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