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