![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / yacc|
Return to output.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / yacc |
1.1 root 1: /*
2: * Copyright (c) 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Robert Paul Corbett.
7: *
8: * Redistribution and use in source and binary forms are permitted provided
9: * that: (1) source distributions retain this entire copyright notice and
10: * comment, and (2) distributions including binaries display the following
11: * acknowledgement: ``This product includes software developed by the
12: * University of California, Berkeley and its contributors'' in the
13: * documentation or other materials provided with the distribution and in
14: * all advertising materials mentioning features or use of this software.
15: * Neither the name of the University nor the names of its contributors may
16: * be used to endorse or promote products derived from this software without
17: * specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: static char sccsid[] = "@(#)output.c 5.5 (Berkeley) 6/1/90";
25: #endif /* not lint */
26:
27: #include "defs.h"
28:
29: static int nvectors;
30: static int nentries;
31: static short **froms;
32: static short **tos;
33: static short *tally;
34: static short *width;
35: static short *state_count;
36: static short *order;
37: static short *base;
38: static short *pos;
39: static int maxtable;
40: static short *table;
41: static short *check;
42: static int lowzero;
43: static int high;
44:
45:
46: output()
47: {
48: free_itemsets();
49: free_shifts();
50: free_reductions();
51: output_stored_text();
52: output_defines();
53: output_rule_data();
54: output_yydefred();
55: output_actions();
56: free_parser();
57: output_debug();
58: output_stype();
59: write_section(header);
60: output_trailing_text();
61: write_section(body);
62: output_semantic_actions();
63: write_section(trailer);
64: }
65:
66:
67: output_rule_data()
68: {
69: register int i;
70: register int j;
71:
72:
73: fprintf(output_file, "short yylhs[] = {%42d,",
74: symbol_value[start_symbol]);
75:
76: j = 10;
77: for (i = 3; i < nrules; i++)
78: {
79: if (j >= 10)
80: {
81: ++outline;
82: putc('\n', output_file);
83: j = 1;
84: }
85: else
86: ++j;
87:
88: fprintf(output_file, "%5d,", symbol_value[rlhs[i]]);
89: }
90: outline += 2;
91: fprintf(output_file, "\n};\n");
92:
93: fprintf(output_file, "short yylen[] = {%42d,", 2);
94:
95: j = 10;
96: for (i = 3; i < nrules; i++)
97: {
98: if (j >= 10)
99: {
100: ++outline;
101: putc('\n', output_file);
102: j = 1;
103: }
104: else
105: j++;
106:
107: fprintf(output_file, "%5d,", rrhs[i + 1] - rrhs[i] - 1);
108: }
109: outline += 2;
110: fprintf(output_file, "\n};\n");
111: }
112:
113:
114: output_yydefred()
115: {
116: register int i, j;
117:
118: fprintf(output_file, "short yydefred[] = {%39d,",
119: (defred[0] ? defred[0] - 2 : 0));
120:
121: j = 10;
122: for (i = 1; i < nstates; i++)
123: {
124: if (j < 10)
125: ++j;
126: else
127: {
128: ++outline;
129: putc('\n', output_file);
130: j = 1;
131: }
132:
133: fprintf(output_file, "%5d,", (defred[i] ? defred[i] - 2 : 0));
134: }
135:
136: outline += 2;
137: fprintf(output_file, "\n};\n");
138: }
139:
140:
141: output_actions()
142: {
143: nvectors = 2*nstates + nvars;
144:
145: froms = NEW2(nvectors, short *);
146: tos = NEW2(nvectors, short *);
147: tally = NEW2(nvectors, short);
148: width = NEW2(nvectors, short);
149:
150: token_actions();
151: FREE(lookaheads);
152: FREE(LA);
153: FREE(LAruleno);
154: FREE(accessing_symbol);
155:
156: goto_actions();
157: FREE(goto_map + ntokens);
158: FREE(from_state);
159: FREE(to_state);
160:
161: sort_actions();
162: pack_table();
163: output_base();
164: output_table();
165: output_check();
166: }
167:
168:
169: token_actions()
170: {
171: register int i, j;
172: register int shiftcount, reducecount;
173: register int max, min;
174: register short *actionrow, *r, *s;
175: register action *p;
176:
177: actionrow = NEW2(2*ntokens, short);
178: for (i = 0; i < nstates; ++i)
179: {
180: if (parser[i])
181: {
182: for (j = 0; j < 2*ntokens; ++j)
183: actionrow[j] = 0;
184:
185: shiftcount = 0;
186: reducecount = 0;
187: for (p = parser[i]; p; p = p->next)
188: {
189: if (p->suppressed == 0)
190: {
191: if (p->action_code == SHIFT)
192: {
193: ++shiftcount;
194: actionrow[p->symbol] = p->number;
195: }
196: else if (p->action_code == REDUCE && p->number != defred[i])
197: {
198: ++reducecount;
199: actionrow[p->symbol + ntokens] = p->number;
200: }
201: }
202: }
203:
204: tally[i] = shiftcount;
205: tally[nstates+i] = reducecount;
206: width[i] = 0;
207: width[nstates+i] = 0;
208: if (shiftcount > 0)
209: {
210: froms[i] = r = NEW2(shiftcount, short);
211: tos[i] = s = NEW2(shiftcount, short);
212: min = MAXSHORT;
213: max = 0;
214: for (j = 0; j < ntokens; ++j)
215: {
216: if (actionrow[j])
217: {
218: if (min > symbol_value[j])
219: min = symbol_value[j];
220: if (max < symbol_value[j])
221: max = symbol_value[j];
222: *r++ = symbol_value[j];
223: *s++ = actionrow[j];
224: }
225: }
226: width[i] = max - min + 1;
227: }
228: if (reducecount > 0)
229: {
230: froms[nstates+i] = r = NEW2(reducecount, short);
231: tos[nstates+i] = s = NEW2(reducecount, short);
232: min = MAXSHORT;
233: max = 0;
234: for (j = 0; j < ntokens; ++j)
235: {
236: if (actionrow[ntokens+j])
237: {
238: if (min > symbol_value[j])
239: min = symbol_value[j];
240: if (max < symbol_value[j])
241: max = symbol_value[j];
242: *r++ = symbol_value[j];
243: *s++ = actionrow[ntokens+j] - 2;
244: }
245: }
246: width[nstates+i] = max - min + 1;
247: }
248: }
249: }
250: FREE(actionrow);
251: }
252:
253: goto_actions()
254: {
255: register int i, j, k;
256:
257: state_count = NEW2(nstates, short);
258:
259: k = default_goto(start_symbol + 1);
260: fprintf(output_file, "short yydgoto[] = {%40d,", k);
261: save_column(start_symbol + 1, k);
262:
263: j = 10;
264: for (i = start_symbol + 2; i < nsyms; i++)
265: {
266: if (j >= 10)
267: {
268: ++outline;
269: putc('\n', output_file);
270: j = 1;
271: }
272: else
273: ++j;
274:
275: k = default_goto(i);
276: fprintf(output_file, "%5d,", k);
277: save_column(i, k);
278: }
279:
280: outline += 2;
281: fprintf(output_file, "\n};\n");
282: FREE(state_count);
283: }
284:
285: int
286: default_goto(symbol)
287: int symbol;
288: {
289: register int i;
290: register int m;
291: register int n;
292: register int default_state;
293: register int max;
294:
295: m = goto_map[symbol];
296: n = goto_map[symbol + 1];
297:
298: if (m == n) return (0);
299:
300: for (i = 0; i < nstates; i++)
301: state_count[i] = 0;
302:
303: for (i = m; i < n; i++)
304: state_count[to_state[i]]++;
305:
306: max = 0;
307: default_state = 0;
308: for (i = 0; i < nstates; i++)
309: {
310: if (state_count[i] > max)
311: {
312: max = state_count[i];
313: default_state = i;
314: }
315: }
316:
317: return (default_state);
318: }
319:
320:
321:
322: save_column(symbol, default_state)
323: int symbol;
324: int default_state;
325: {
326: register int i;
327: register int m;
328: register int n;
329: register short *sp;
330: register short *sp1;
331: register short *sp2;
332: register int count;
333: register int symno;
334:
335: m = goto_map[symbol];
336: n = goto_map[symbol + 1];
337:
338: count = 0;
339: for (i = m; i < n; i++)
340: {
341: if (to_state[i] != default_state)
342: ++count;
343: }
344: if (count == 0) return;
345:
346: symno = symbol_value[symbol] + 2*nstates;
347:
348: froms[symno] = sp1 = sp = NEW2(count, short);
349: tos[symno] = sp2 = NEW2(count, short);
350:
351: for (i = m; i < n; i++)
352: {
353: if (to_state[i] != default_state)
354: {
355: *sp1++ = from_state[i];
356: *sp2++ = to_state[i];
357: }
358: }
359:
360: tally[symno] = count;
361: width[symno] = sp1[-1] - sp[0] + 1;
362: }
363:
364: sort_actions()
365: {
366: register int i;
367: register int j;
368: register int k;
369: register int t;
370: register int w;
371:
372: order = NEW2(nvectors, short);
373: nentries = 0;
374:
375: for (i = 0; i < nvectors; i++)
376: {
377: if (tally[i] > 0)
378: {
379: t = tally[i];
380: w = width[i];
381: j = nentries - 1;
382:
383: while (j >= 0 && (width[order[j]] < w))
384: j--;
385:
386: while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t))
387: j--;
388:
389: for (k = nentries - 1; k > j; k--)
390: order[k + 1] = order[k];
391:
392: order[j + 1] = i;
393: nentries++;
394: }
395: }
396: }
397:
398:
399: pack_table()
400: {
401: register int i;
402: register int place;
403: register int state;
404:
405: base = NEW2(nvectors, short);
406: pos = NEW2(nentries, short);
407:
408: maxtable = 1000;
409: table = NEW2(maxtable, short);
410: check = NEW2(maxtable, short);
411:
412: lowzero = 0;
413: high = 0;
414:
415: for (i = 0; i < maxtable; i++)
416: check[i] = -1;
417:
418: for (i = 0; i < nentries; i++)
419: {
420: state = matching_vector(i);
421:
422: if (state < 0)
423: place = pack_vector(i);
424: else
425: place = base[state];
426:
427: pos[i] = place;
428: base[order[i]] = place;
429: }
430:
431: for (i = 0; i < nvectors; i++)
432: {
433: if (froms[i])
434: FREE(froms[i]);
435: if (tos[i])
436: FREE(tos[i]);
437: }
438:
439: FREE(froms);
440: FREE(tos);
441: FREE(pos);
442: }
443:
444:
445: /* The function matching_vector determines if the vector specified by */
446: /* the input parameter matches a previously considered vector. The */
447: /* test at the start of the function checks if the vector represents */
448: /* a row of shifts over terminal symbols or a row of reductions, or a */
449: /* column of shifts over a nonterminal symbol. Berkeley Yacc does not */
450: /* check if a column of shifts over a nonterminal symbols matches a */
451: /* previously considered vector. Because of the nature of LR parsing */
452: /* tables, no two columns can match. Therefore, the only possible */
453: /* match would be between a row and a column. Such matches are */
454: /* unlikely. Therefore, to save time, no attempt is made to see if a */
455: /* column matches a previously considered vector. */
456: /* */
457: /* Matching_vector is poorly designed. The test could easily be made */
458: /* faster. Also, it depends on the vectors being in a specific */
459: /* order. */
460:
461: int
462: matching_vector(vector)
463: int vector;
464: {
465: register int i;
466: register int j;
467: register int k;
468: register int t;
469: register int w;
470: register int match;
471: register int prev;
472:
473: i = order[vector];
474: if (i >= 2*nstates)
475: return (-1);
476:
477: t = tally[i];
478: w = width[i];
479:
480: for (prev = vector - 1; prev >= 0; prev--)
481: {
482: j = order[prev];
483: if (width[j] != w || tally[j] != t)
484: return (-1);
485:
486: match = 1;
487: for (k = 0; match && k < t; k++)
488: {
489: if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
490: match = 0;
491: }
492:
493: if (match)
494: return (j);
495: }
496:
497: return (-1);
498: }
499:
500:
501:
502: int
503: pack_vector(vector)
504: int vector;
505: {
506: register int i, j, k, l;
507: register int t;
508: register int loc;
509: register int ok;
510: register short *from;
511: register short *to;
512: int newmax;
513:
514: i = order[vector];
515: t = tally[i];
516: assert(t);
517:
518: from = froms[i];
519: to = tos[i];
520:
521: j = lowzero - from[0];
522: for (k = 1; k < t; ++k)
523: if (lowzero - from[k] > j)
524: j = lowzero - from[k];
525: for (;; ++j)
526: {
527: if (j == 0)
528: continue;
529: ok = 1;
530: for (k = 0; ok && k < t; k++)
531: {
532: loc = j + from[k];
533: if (loc >= maxtable)
534: {
535: if (loc >= MAXTABLE)
536: fatal("maximum table size exceeded");
537:
538: newmax = maxtable;
539: do { newmax += 200; } while (newmax <= loc);
540: table = (short *) realloc(table, newmax*sizeof(short));
541: if (table == 0) no_space();
542: check = (short *) realloc(check, newmax*sizeof(short));
543: if (check == 0) no_space();
544: for (l = maxtable; l < newmax; ++l)
545: {
546: table[l] = 0;
547: check[l] = -1;
548: }
549: maxtable = newmax;
550: }
551:
552: if (check[loc] != -1)
553: ok = 0;
554: }
555: for (k = 0; ok && k < vector; k++)
556: {
557: if (pos[k] == j)
558: ok = 0;
559: }
560: if (ok)
561: {
562: for (k = 0; k < t; k++)
563: {
564: loc = j + from[k];
565: table[loc] = to[k];
566: check[loc] = from[k];
567: if (loc > high) high = loc;
568: }
569:
570: while (check[lowzero] != -1)
571: ++lowzero;
572:
573: return (j);
574: }
575: }
576: }
577:
578:
579:
580: output_base()
581: {
582: register int i, j;
583:
584: fprintf(output_file, "short yysindex[] = {%39d,", base[0]);
585:
586: j = 10;
587: for (i = 1; i < nstates; i++)
588: {
589: if (j >= 10)
590: {
591: ++outline;
592: putc('\n', output_file);
593: j = 1;
594: }
595: else
596: ++j;
597:
598: fprintf(output_file, "%5d,", base[i]);
599: }
600:
601: outline += 2;
602: fprintf(output_file, "\n};\nshort yyrindex[] = {%39d,",
603: base[nstates]);
604:
605: j = 10;
606: for (i = nstates + 1; i < 2*nstates; i++)
607: {
608: if (j >= 10)
609: {
610: ++outline;
611: putc('\n', output_file);
612: j = 1;
613: }
614: else
615: ++j;
616:
617: fprintf(output_file, "%5d,", base[i]);
618: }
619:
620: outline += 2;
621: fprintf(output_file, "\n};\nshort yygindex[] = {%39d,",
622: base[2*nstates]);
623:
624: j = 10;
625: for (i = 2*nstates + 1; i < nvectors - 1; i++)
626: {
627: if (j >= 10)
628: {
629: ++outline;
630: putc('\n', output_file);
631: j = 1;
632: }
633: else
634: ++j;
635:
636: fprintf(output_file, "%5d,", base[i]);
637: }
638:
639: outline += 2;
640: fprintf(output_file, "\n};\n");
641: FREE(base);
642: }
643:
644:
645:
646: output_table()
647: {
648: register int i;
649: register int j;
650:
651: ++outline;
652: fprintf(output_file, "#define YYTABLESIZE %d\n", high);
653: fprintf(output_file, "short yytable[] = {%40d,", table[0]);
654:
655: j = 10;
656: for (i = 1; i <= high; i++)
657: {
658: if (j >= 10)
659: {
660: ++outline;
661: putc('\n', output_file);
662: j = 1;
663: }
664: else
665: ++j;
666:
667: fprintf(output_file, "%5d,", table[i]);
668: }
669:
670: outline += 2;
671: fprintf(output_file, "\n};\n");
672: FREE(table);
673: }
674:
675:
676:
677: output_check()
678: {
679: register int i;
680: register int j;
681:
682: fprintf(output_file, "short yycheck[] = {%40d,", check[0]);
683:
684: j = 10;
685: for (i = 1; i <= high; i++)
686: {
687: if (j >= 10)
688: {
689: ++outline;
690: putc('\n', output_file);
691: j = 1;
692: }
693: else
694: ++j;
695:
696: fprintf(output_file, "%5d,", check[i]);
697: }
698:
699: outline += 2;
700: fprintf(output_file, "\n};\n");
701: FREE(check);
702: }
703:
704:
705: int
706: is_C_identifier(name)
707: char *name;
708: {
709: register char *s;
710: register int c;
711:
712: s = name;
713: c = *s;
714: if (c == '"')
715: {
716: c = *++s;
717: if (!isalpha(c) && c != '_' && c != '$')
718: return (0);
719: while ((c = *++s) != '"')
720: {
721: if (!isalnum(c) && c != '_' && c != '$')
722: return (0);
723: }
724: return (1);
725: }
726:
727: if (!isalpha(c) && c != '_' && c != '$')
728: return (0);
729: while (c = *++s)
730: {
731: if (!isalnum(c) && c != '_' && c != '$')
732: return (0);
733: }
734: return (1);
735: }
736:
737:
738: output_defines()
739: {
740: register int c, i;
741: register char *s;
742:
743: for (i = 2; i < ntokens; ++i)
744: {
745: s = symbol_name[i];
746: if (is_C_identifier(s))
747: {
748: fprintf(output_file, "#define ");
749: if (dflag) fprintf(defines_file, "#define ");
750: c = *s;
751: if (c == '"')
752: {
753: while ((c = *++s) != '"')
754: {
755: putc(c, output_file);
756: if (dflag) putc(c, defines_file);
757: }
758: }
759: else
760: {
761: do
762: {
763: putc(c, output_file);
764: if (dflag) putc(c, defines_file);
765: }
766: while (c = *++s);
767: }
768: ++outline;
769: fprintf(output_file, " %d\n", symbol_value[i]);
770: if (dflag) fprintf(defines_file, " %d\n", symbol_value[i]);
771: }
772: }
773:
774: ++outline;
775: fprintf(output_file, "#define YYERRCODE %d\n", symbol_value[1]);
776:
777: if (dflag && unionized)
778: {
779: fclose(union_file);
780: union_file = fopen(union_file_name, "r");
781: if (union_file == NULL) open_error(union_file_name);
782: while ((c = getc(union_file)) != EOF)
783: putc(c, defines_file);
784: fprintf(defines_file, " YYSTYPE;\nextern YYSTYPE yylval;\n");
785: }
786: }
787:
788:
789: output_stored_text()
790: {
791: register int c;
792: register FILE *in, *out;
793:
794: fclose(text_file);
795: text_file = fopen(text_file_name, "r");
796: if (text_file == NULL) open_error(text_file_name);
797: in = text_file;
798: out = output_file;
799: if ((c = getc(in)) == EOF)
800: return;
801: if (c == '\n') ++outline;
802: putc(c, out);
803: while ((c = getc(in)) != EOF)
804: {
805: if (c == '\n') ++outline;
806: putc(c, out);
807: }
808: if (!lflag)
809: {
810: ++outline;
811: fprintf(out, line_format, outline + 1, output_file_name);
812: }
813: }
814:
815:
816: output_debug()
817: {
818: register int i, j, k, max;
819: char **symnam, *s;
820:
821: ++outline;
822: fprintf(output_file, "#define YYFINAL %d\n", final_state);
823: outline += 3;
824: fprintf(output_file, "#ifndef YYDEBUG\n#define YYDEBUG %d\n#endif\n",
825: tflag);
826:
827: max = 0;
828: for (i = 2; i < ntokens; ++i)
829: if (symbol_value[i] > max)
830: max = symbol_value[i];
831: ++outline;
832: fprintf(output_file, "#define YYMAXTOKEN %d\n", max);
833:
834: symnam = (char **) MALLOC((max+1)*sizeof(char *));
835: if (symnam == 0) no_space();
836: for (i = 0; i < max; ++i)
837: symnam[i] = 0;
838: for (i = ntokens - 1; i >= 2; --i)
839: symnam[symbol_value[i]] = symbol_name[i];
840: symnam[0] = "end-of-file";
841:
842: ++outline;
843: fprintf(output_file, "#if YYDEBUG\nchar *yyname[] = {");
844: j = 80;
845: for (i = 0; i <= max; ++i)
846: {
847: if (s = symnam[i])
848: {
849: if (s[0] == '"')
850: {
851: k = 7;
852: while (*++s != '"')
853: {
854: if (*s == '\\')
855: {
856: k += 2;
857: if (*++s == '\\')
858: k += 2;
859: else
860: ++k;
861: }
862: else
863: ++k;
864: }
865: j += k;
866: if (j > 80)
867: {
868: ++outline;
869: putc('\n', output_file);
870: j = k;
871: }
872: fprintf(output_file, "\"\\\"");
873: s = symnam[i];
874: while (*++s != '"')
875: {
876: if (*s == '\\')
877: {
878: fprintf(output_file, "\\\\");
879: if (*++s == '\\')
880: fprintf(output_file, "\\\\");
881: else
882: putc(*s, output_file);
883: }
884: else
885: putc(*s, output_file);
886: }
887: fprintf(output_file, "\\\"\",");
888: }
889: else if (s[0] == '\'')
890: {
891: if (s[1] == '"')
892: {
893: j += 7;
894: if (j > 80)
895: {
896: ++outline;
897: putc('\n', output_file);
898: j = 7;
899: }
900: fprintf(output_file, "\"'\\\"'\",");
901: }
902: else
903: {
904: k = 5;
905: while (*++s != '\'')
906: {
907: if (*s == '\\')
908: {
909: k += 2;
910: ++s;
911: if (*++s == '\\')
912: k += 2;
913: else
914: ++k;
915: }
916: else
917: ++k;
918: }
919: j += k;
920: if (j > 80)
921: {
922: ++outline;
923: putc('\n', output_file);
924: j = k;
925: }
926: fprintf(output_file, "\"'");
927: s = symnam[i];
928: while (*++s != '\'')
929: {
930: if (*s == '\\')
931: {
932: fprintf(output_file, "\\\\");
933: if (*++s == '\\')
934: fprintf(output_file, "\\\\");
935: else
936: putc(*s, output_file);
937: }
938: else
939: putc(*s, output_file);
940: }
941: fprintf(output_file, "'\",");
942: }
943: }
944: else
945: {
946: k = strlen(s) + 3;
947: j += k;
948: if (j > 80)
949: {
950: ++outline;
951: putc('\n', output_file);
952: j = k;
953: }
954: putc('"', output_file);
955: do { putc(*s, output_file); } while (*++s);
956: fprintf(output_file, "\",");
957: }
958: }
959: else
960: {
961: j += 2;
962: if (j > 80)
963: {
964: ++outline;
965: putc('\n', output_file);
966: j = 2;
967: }
968: fprintf(output_file, "0,");
969: }
970: }
971: outline += 2;
972: fprintf(output_file, "\n};\n");
973: FREE(symnam);
974:
975: ++outline;
976: fprintf(output_file, "char *yyrule[] = {\n");
977: for (i = 2; i < nrules; ++i)
978: {
979: fprintf(output_file, "\"%s :", symbol_name[rlhs[i]]);
980: for (j = rrhs[i]; ritem[j] > 0; ++j)
981: {
982: s = symbol_name[ritem[j]];
983: if (s[0] == '"')
984: {
985: fprintf(output_file, " \\\"");
986: while (*++s != '"')
987: {
988: if (*s == '\\')
989: {
990: if (s[1] == '\\')
991: fprintf(output_file, "\\\\\\\\");
992: else
993: fprintf(output_file, "\\\\%c", s[1]);
994: ++s;
995: }
996: else
997: putc(*s, output_file);
998: }
999: fprintf(output_file, "\\\"");
1000: }
1001: else if (s[0] == '\'')
1002: {
1003: if (s[1] == '"')
1004: fprintf(output_file, " '\\\"'");
1005: else if (s[1] == '\\')
1006: {
1007: if (s[2] == '\\')
1008: fprintf(output_file, " '\\\\\\\\");
1009: else
1010: fprintf(output_file, " '\\\\%c", s[2]);
1011: s += 2;
1012: while (*++s != '\'')
1013: putc(*s, output_file);
1014: putc('\'', output_file);
1015: }
1016: else
1017: fprintf(output_file, " '%c'", s[1]);
1018: }
1019: else
1020: fprintf(output_file, " %s", s);
1021: }
1022: ++outline;
1023: fprintf(output_file, "\",\n");
1024: }
1025:
1026: outline += 2;
1027: fprintf(output_file, "};\n#endif\n");
1028: }
1029:
1030:
1031: output_stype()
1032: {
1033: if (!unionized && ntags == 0)
1034: {
1035: outline += 3;
1036: fprintf(output_file, "#ifndef YYSTYPE\ntypedef int YYSTYPE;\n#endif\n");
1037: }
1038: }
1039:
1040:
1041: output_trailing_text()
1042: {
1043: register int c, last;
1044:
1045: if (line == 0)
1046: return;
1047:
1048: c = *cptr;
1049: if (c == '\n')
1050: {
1051: ++lineno;
1052: if ((c = getc(input_file)) == EOF)
1053: return;
1054: if (!lflag)
1055: {
1056: ++outline;
1057: fprintf(output_file, line_format, lineno, input_file_name);
1058: }
1059: if (c == '\n') ++outline;
1060: putc(c, output_file);
1061: last = c;
1062: }
1063: else
1064: {
1065: if (!lflag)
1066: {
1067: ++outline;
1068: fprintf(output_file, line_format, lineno, input_file_name);
1069: }
1070: do { putc(c, output_file); } while ((c = *++cptr) != '\n');
1071: ++outline;
1072: putc('\n', output_file);
1073: last = '\n';
1074: }
1075:
1076: while ((c = getc(input_file)) != EOF)
1077: {
1078: if (c == '\n') ++outline;
1079: putc(c, output_file);
1080: last = c;
1081: }
1082:
1083: if (last != '\n')
1084: {
1085: ++outline;
1086: putc('\n', output_file);
1087: }
1088: if (!lflag)
1089: {
1090: ++outline;
1091: fprintf(output_file, line_format, outline + 1, output_file_name);
1092: }
1093: }
1094:
1095:
1096: output_semantic_actions()
1097: {
1098: register int c, last;
1099:
1100: fclose(action_file);
1101: action_file = fopen(action_file_name, "r");
1102: if (action_file == NULL) open_error(action_file_name);
1103:
1104: if ((c = getc(action_file)) == EOF)
1105: return;
1106: last = c;
1107: if (c == '\n') ++outline;
1108: putc(c, output_file);
1109: while ((c = getc(action_file)) != EOF)
1110: {
1111: if (c == '\n') ++outline;
1112: putc(c, output_file);
1113: last = c;
1114: }
1115:
1116: if (last != '\n')
1117: {
1118: ++outline;
1119: putc('\n', output_file);
1120: }
1121: if (!lflag)
1122: {
1123: ++outline;
1124: fprintf(output_file, line_format, outline + 1, output_file_name);
1125: }
1126: }
1127:
1128:
1129: free_itemsets()
1130: {
1131: register core *cp, *next;
1132:
1133: FREE(state_table);
1134: for (cp = first_state; cp; cp = next)
1135: {
1136: next = cp->next;
1137: FREE(cp);
1138: }
1139: }
1140:
1141:
1142: free_shifts()
1143: {
1144: register shifts *sp, *next;
1145:
1146: FREE(shift_table);
1147: for (sp = first_shift; sp; sp = next)
1148: {
1149: next = sp->next;
1150: FREE(sp);
1151: }
1152: }
1153:
1154:
1155:
1156: free_reductions()
1157: {
1158: register reductions *rp, *next;
1159:
1160: FREE(reduction_table);
1161: for (rp = first_reduction; rp; rp = next)
1162: {
1163: next = rp->next;
1164: FREE(rp);
1165: }
1166: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.