![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to prtout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / equel|
Return to prtout.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / equel |
1.1 root 1: # include <stdio.h>
2: # include "constants.h"
3: # include "globals.h"
4: # include <sccs.h>
5:
6: SCCSID(@(#)prtout.c 7.2 10/27/81)
7:
8:
9: /*
10: ** PRTOUT.C -- output routines
11: **
12: ** Output routines for non-specific data structures
13: ** (i.e. w_display is in [display.c])
14: */
15:
16:
17:
18: int Fillcnt = FILLCNT;
19: /*
20: ** W_CON -- write out a constant
21: ** Writes out a constant of type 'type'
22: ** pointed to by 'string'.
23: */
24:
25:
26: w_con(type, string)
27: int type;
28: char *string;
29: {
30: if (type == Tokens.sp_sconst)
31: w_string(string, 1);
32: else
33: w_key(string);
34: }
35: /*
36: ** W_OP -- Writes out a string which doesn't need a blank
37: ** to separate it from a keyword.
38: */
39:
40:
41: w_op(string)
42: char *string;
43: {
44: w_raw(string);
45: Lastc = OPCHAR;
46: }
47: /*
48: ** W_VAR -- writes out code to send the
49: ** value of a C variable down to
50: ** the Quel scanner.
51: **
52: ** Conserves the state of In_quote.
53: */
54:
55:
56: w_var(disp, type)
57: int type;
58: struct display *disp;
59: {
60: register struct disp_node *d;
61: register savestat;
62:
63: savestat = In_quote;
64:
65: /* if was In_quote, then will want a space before the
66: * string written down
67: */
68: if (savestat)
69: w_key("");
70: if (type != opIDSTRING)
71: {
72: w_new("IIcvar(");
73: if (type != opSTRING)
74: w_op("&");
75: }
76: else
77: w_new("IIwrite(");
78: w_display(disp);
79: switch (type)
80: {
81: case opSHORT:
82: w_op(",1,2);");
83:
84: case opFLOAT :
85: w_op(",2,4);");
86: break;
87:
88: case opSTRING :
89: w_op(",3,0);");
90: break;
91:
92: case opDOUBLE :
93: w_op(",4,8);");
94: break;
95:
96: case opCHAR :
97: w_op(",5,1);");
98: break;
99:
100: case opLONG : /* also ints, since this is a VAX */
101: w_op(",6,4);");
102: break;
103:
104: case opIDSTRING :
105: w_op(");");
106: break;
107:
108: default :
109: syserr("invalid type %d in w_var",
110: type);
111: }
112: if (savestat)
113: {
114: begin_quote();
115: /* if was In_quote, then will want a space
116: * before next keyword
117: */
118: w_key("");
119: }
120: }
121: /*
122: ** W_KEY -- write out a string needing a blank to
123: ** separate it from other keywords.
124: */
125:
126:
127: w_key(string)
128: char *string;
129: {
130: if (Lastc == KEYCHAR)
131: w_raw(" ");
132: w_raw(string);
133: Lastc = KEYCHAR;
134: }
135: /*
136: ** W_NEW -- write out a string after getting out of
137: ** any pending IIwrite's.
138: */
139:
140: w_new(string)
141: char *string;
142: {
143: end_quote();
144: w_op(string);
145: }
146: /*
147: ** BEGIN_QUOTE -- Issue an IIwrite("
148: */
149:
150:
151: begin_quote()
152: {
153: In_string = 1;
154: In_quote = 1;
155: Fillmode = 1;
156: w_op("IIwrite(\"");
157: }
158: /*
159: ** END_QUOTE -- End any pending IIwrite("
160: */
161:
162:
163: end_quote()
164: {
165: In_string = 0;
166: if (In_quote)
167: w_op("\");");
168: In_quote = 0;
169: }
170: /*
171: ** EQUATE_LINES -- Make subsequent lines be output on the
172: ** same line they were read (lines of C_CODE only).
173: **
174: ** Note: Because of the algorithm used, it is possible that
175: ** the correct line in the output has already been passed,
176: ** in which case equate_lines does nothing.
177: */
178:
179:
180: equate_lines()
181: {
182: Fillmode = 0;
183: while (Lineout < yyline)
184: w_raw("\n");
185: Lastc = OPCHAR;
186: }
187: /*
188: ** W_SYNC -- Put out an IIsync() call
189: */
190:
191:
192: w_sync()
193: {
194: w_new("IIsync(");
195: w_file();
196: w_op(");");
197: }
198: /*
199: ** W_FLUSH -- Put out an IIflush_tup() call
200: */
201:
202:
203: w_flush()
204: {
205: w_new("IIflushtup(");
206: w_file();
207: w_op(");");
208: }
209: /*
210: ** W_FILE -- Writes out the name and line number of the
211: ** input file if Rtdb is specified, else a 0.
212: */
213:
214:
215: w_file()
216: {
217: char itemp [6];
218:
219: if (Rtdb)
220: {
221: w_string(Input_file_name, 0);
222: itoa(yyline, itemp);
223: w_op(",");
224: w_key(itemp);
225: }
226: else
227: w_key("0");
228: }
229: /*
230: ** W_STRING -- Writes out a string
231: **
232: ** String is output as a string constant if type == 0
233: ** otherwise writes out string inside an IIwrite(
234: */
235:
236:
237: w_string(string, type)
238: char *string;
239: int type;
240: {
241: register char *t;
242: register char *s;
243:
244: if (type)
245: {
246: if (!In_quote)
247: begin_quote();
248: w_raw("\\\"");
249: }
250: else
251: w_raw("\"");
252:
253: s = t = string;
254: In_string += 1;
255: for ( ;*t ; )
256: {
257: if (*t == '\\')
258: {
259:
260: if (t [1] == '\n')
261: {
262: *t = '\0';
263: w_raw(s);
264: s = t = &t [2];
265: w_raw("\\\n");
266: }
267: else
268: {
269: *t++ = '\0';
270: w_raw(s);
271: s = t;
272: /* note that this call must be atomic,
273: * as w_raw would feel free to put newlines
274: * in if not.
275: */
276: if (type)
277: w_raw("\\\\");
278: else
279: w_raw("\\");
280: }
281: }
282: else if (*t == '"')
283: {
284: w_raw("\\\"");
285: s = ++t;
286: }
287: else
288: t++;
289: }
290: w_raw(s);
291: In_string -= 1;
292: if (type)
293: w_raw("\\\"");
294: else
295: w_raw("\"");
296: }
297: /*
298: ** W_RAW -- Lowest level output character routine
299: **
300: ** Outputs string depending on Fillcnt and In_quote
301: ** and In_string and Fillmode.
302: ** When not in Fillmode does straight output.
303: ** When on Fillmode, fills lines to Fillmode.
304: **
305: ** NOTE : w_raw will feel free to output a newline after
306: ** 'string' if the string causes more than Fillcnt
307: ** characters to be output.
308: ** Inside strings (In_string != 0) w_raw will put
309: ** a '\\' before the newline issued.
310: ** When In_quote != 0 when the fillcnt is exceeded,
311: ** the IIwrite( is ended an continued on the next line
312: ** so that the query string won't overflow the C
313: ** pre-processor's line buffer.
314: */
315:
316:
317: w_raw(string)
318: char *string;
319: {
320: register char *s;
321: register charcnt;
322:
323: charcnt = 0;
324: for (s = string; *s; s++)
325: {
326: if (*s != '\n')
327: {
328: putc(*s, Out_file);
329: charcnt++;
330: }
331: else
332: {
333: if (Fillmode == 0 ||
334: Charcnt + charcnt > Fillcnt ||
335: In_string)
336: {
337: putc(*s, Out_file);
338: Lineout++;
339: charcnt = 0;
340: Charcnt = 0;
341: }
342: else
343: {
344: putc(' ', Out_file);
345: charcnt++;
346: }
347: }
348: }
349: if ((Charcnt += charcnt) > Fillcnt && Fillmode == 1)
350: {
351: if (In_string)
352: {
353: if (In_quote)
354: {
355: puts("\");\nIIwrite(\"", Out_file);
356: Charcnt = 9;
357: }
358: else
359: {
360: puts("\\\n", Out_file);
361: Charcnt = 0;
362: }
363: }
364: else
365: {
366: putc('\n', Out_file);
367: Charcnt = 0;
368: }
369: Lineout++;
370: }
371: }
372: /*
373: ** PUTS -- put a string on an output file using putc()
374: */
375:
376: puts(s, file)
377: char *s;
378: FILE *file;
379: {
380: register char *sp;
381: register FILE *f;
382:
383: f = file;
384: for (sp = s; *sp; )
385: putc(*sp++, f);
386: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.