1 /* $Id: output.c,v 1.94 2020/09/10 20:24:30 tom Exp $ */
5 #define StaticOrR (rflag ? "" : "static ")
6 #define CountLine(fp) (!rflag || ((fp) == code_file))
16 static Value_t **froms;
19 static Value_t *conflicts = NULL;
20 static Value_t nconflicts = 0;
22 static Value_t *tally;
23 static Value_t *width;
24 static Value_t *state_count;
25 static Value_t *order;
29 static Value_t *table;
30 static Value_t *check;
35 putc_code(FILE * fp, int c)
37 if ((c == '\n') && (fp == code_file))
43 putl_code(FILE * fp, const char *s)
51 puts_code(FILE * fp, const char *s)
57 puts_param_types(FILE * fp, param *list, int more)
63 for (p = list; p; p = p->next)
65 size_t len_type = strlen(p->type);
66 fprintf(fp, "%s%s%s%s%s", p->type,
67 (((len_type != 0) && (p->type[len_type - 1] == '*'))
71 ((more || p->next) ? ", " : ""));
82 puts_param_names(FILE * fp, param *list, int more)
86 for (p = list; p; p = p->next)
88 fprintf(fp, "%s%s", p->name,
89 ((more || p->next) ? ", " : ""));
94 write_code_lineno(FILE * fp)
96 if (!lflag && (fp == code_file))
99 fprintf(fp, line_format, outline + 1, code_file_name);
104 write_input_lineno(void)
109 fprintf(code_file, line_format, lineno, input_file_name);
114 define_prefixed(FILE * fp, const char *name)
116 int bump_line = CountLine(fp);
123 fprintf(fp, "#ifndef %s\n", name);
127 fprintf(fp, "#define %-10s %s%s\n", name, symbol_prefix, name + 2);
131 fprintf(fp, "#endif /* %s */\n", name);
135 output_prefix(FILE * fp)
137 if (symbol_prefix == NULL)
139 symbol_prefix = "yy";
143 define_prefixed(fp, "yyparse");
144 define_prefixed(fp, "yylex");
145 define_prefixed(fp, "yyerror");
146 define_prefixed(fp, "yychar");
147 define_prefixed(fp, "yyval");
148 define_prefixed(fp, "yylval");
149 define_prefixed(fp, "yydebug");
150 define_prefixed(fp, "yynerrs");
151 define_prefixed(fp, "yyerrflag");
152 define_prefixed(fp, "yylhs");
153 define_prefixed(fp, "yylen");
154 define_prefixed(fp, "yydefred");
155 #if defined(YYBTYACC)
156 define_prefixed(fp, "yystos");
158 define_prefixed(fp, "yydgoto");
159 define_prefixed(fp, "yysindex");
160 define_prefixed(fp, "yyrindex");
161 define_prefixed(fp, "yygindex");
162 define_prefixed(fp, "yytable");
163 define_prefixed(fp, "yycheck");
164 define_prefixed(fp, "yyname");
165 define_prefixed(fp, "yyrule");
166 #if defined(YYBTYACC)
169 define_prefixed(fp, "yyloc");
170 define_prefixed(fp, "yylloc");
173 putl_code(fp, "#if YYBTYACC\n");
175 define_prefixed(fp, "yycindex");
176 define_prefixed(fp, "yyctable");
179 putl_code(fp, "#endif /* YYBTYACC */\n");
185 fprintf(fp, "#define YYPREFIX \"%s\"\n", symbol_prefix);
189 output_code_lines(FILE * fp, int cl)
191 if (code_lines[cl].lines != NULL)
195 outline += (int)code_lines[cl].num;
199 fprintf(fp, "/* %%code \"%s\" block start */\n", code_lines[cl].name);
200 fputs(code_lines[cl].lines, fp);
201 fprintf(fp, "/* %%code \"%s\" block end */\n", code_lines[cl].name);
204 write_code_lineno(fp);
214 putc('\n', output_file);
218 output_line(const char *value)
220 fputs(value, output_file);
225 output_int(int value)
227 fprintf(output_file, "%5d,", value);
231 start_int_table(const char *name, int value)
233 int need = 34 - (int)(strlen(symbol_prefix) + strlen(name));
238 "%sconst YYINT %s%s[] = {%*d,",
239 StaticOrR, symbol_prefix, name, need, value);
243 start_str_table(const char *name)
246 "%sconst char *const %s%s[] = {",
247 StaticOrR, symbol_prefix, name);
259 output_stype(FILE * fp)
261 if (!unionized && ntags == 0)
265 "! defined(YYSTYPE) && "
266 "! defined(YYSTYPE_IS_DECLARED)\n");
267 putl_code(fp, "/* Default: YYSTYPE is the semantic value type. */\n");
268 putl_code(fp, "typedef int YYSTYPE;\n");
269 putl_code(fp, "# define YYSTYPE_IS_DECLARED 1\n");
270 putl_code(fp, "#endif\n");
274 #if defined(YYBTYACC)
276 output_ltype(FILE * fp)
279 putl_code(fp, "#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED\n");
280 putl_code(fp, "/* Default: YYLTYPE is the text position type. */\n");
281 putl_code(fp, "typedef struct YYLTYPE\n");
282 putl_code(fp, "{\n");
283 putl_code(fp, " int first_line;\n");
284 putl_code(fp, " int first_column;\n");
285 putl_code(fp, " int last_line;\n");
286 putl_code(fp, " int last_column;\n");
287 putl_code(fp, " unsigned source;\n");
288 putl_code(fp, "} YYLTYPE;\n");
289 putl_code(fp, "#define YYLTYPE_IS_DECLARED 1\n");
290 putl_code(fp, "#endif\n");
291 putl_code(fp, "#define YYRHSLOC(rhs, k) ((rhs)[k])\n");
296 output_YYINT_typedef(FILE * fp)
298 /* generate the type used to index the various parser tables */
301 fprintf(fp, "typedef %s YYINT;\n", CONCAT1("", YYINT));
305 output_rule_data(void)
310 output_YYINT_typedef(output_file);
312 start_int_table("lhs", symbol_value[start_symbol]);
315 for (i = 3; i < nrules; i++)
325 output_int(symbol_value[rlhs[i]]);
329 start_int_table("len", 2);
332 for (i = 3; i < nrules; i++)
342 output_int(rrhs[i + 1] - rrhs[i] - 1);
348 output_yydefred(void)
352 start_int_table("defred", (defred[0] ? defred[0] - 2 : 0));
355 for (i = 1; i < nstates; i++)
365 output_int((defred[i] ? defred[i] - 2 : 0));
371 #if defined(YYBTYACC)
373 output_accessing_symbols(void)
380 translate = TMALLOC(int, nstates);
383 for (i = 0; i < nstates; ++i)
385 int gsymb = accessing_symbol[i];
387 translate[i] = symbol_pval[gsymb];
390 putl_code(output_file,
391 "#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)\n");
392 /* yystos[] may be unused, depending on compile-time defines */
393 start_int_table("stos", translate[0]);
396 for (i = 1; i < nstates; ++i)
406 output_int(translate[i]);
411 putl_code(output_file,
412 "#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */\n");
417 find_conflict_base(int cbase)
421 for (i = 0; i < cbase; i++)
423 for (j = 0; j + cbase < nconflicts; j++)
425 if (conflicts[i + j] != conflicts[cbase + j])
428 if (j + cbase >= nconflicts)
439 Value_t shiftcount, reducecount;
440 #if defined(YYBTYACC)
441 Value_t conflictcount = 0;
446 Value_t *actionrow, *r, *s;
449 actionrow = NEW2(PER_STATE * ntokens, Value_t);
450 for (i = 0; i < nstates; ++i)
454 for (j = 0; j < PER_STATE * ntokens; ++j)
459 #if defined(YYBTYACC)
467 for (p = parser[i]; p; p = p->next)
469 #if defined(YYBTYACC)
472 if (csym != -1 && csym != p->symbol)
475 conflicts[nconflicts++] = -1;
476 j = find_conflict_base(cbase);
477 actionrow[csym + 2 * ntokens] = (Value_t)(j + 1);
484 if (conflicts[cbase] == -1)
492 if (p->suppressed == 0)
494 if (p->action_code == SHIFT)
497 actionrow[p->symbol] = p->number;
499 else if (p->action_code == REDUCE && p->number != defred[i])
502 actionrow[p->symbol + ntokens] = p->number;
505 #if defined(YYBTYACC)
506 else if (backtrack && p->suppressed == 1)
509 if (p->action_code == SHIFT)
511 conflicts[nconflicts++] = p->number;
513 else if (p->action_code == REDUCE && p->number != defred[i])
515 if (cbase == nconflicts)
520 conflicts[nconflicts++] = -1;
522 conflicts[nconflicts++] = (Value_t)(p->number - 2);
527 #if defined(YYBTYACC)
528 if (backtrack && csym != -1)
531 conflicts[nconflicts++] = -1;
532 j = find_conflict_base(cbase);
533 actionrow[csym + 2 * ntokens] = (Value_t)(j + 1);
540 if (conflicts[cbase] == -1)
547 tally[i] = shiftcount;
548 tally[nstates + i] = reducecount;
549 #if defined(YYBTYACC)
551 tally[2 * nstates + i] = conflictcount;
554 width[nstates + i] = 0;
555 #if defined(YYBTYACC)
557 width[2 * nstates + i] = 0;
561 froms[i] = r = NEW2(shiftcount, Value_t);
562 tos[i] = s = NEW2(shiftcount, Value_t);
565 for (j = 0; j < ntokens; ++j)
569 if (min > symbol_value[j])
570 min = symbol_value[j];
571 if (max < symbol_value[j])
572 max = symbol_value[j];
573 *r++ = symbol_value[j];
577 width[i] = (Value_t)(max - min + 1);
581 froms[nstates + i] = r = NEW2(reducecount, Value_t);
582 tos[nstates + i] = s = NEW2(reducecount, Value_t);
585 for (j = 0; j < ntokens; ++j)
587 if (actionrow[ntokens + j])
589 if (min > symbol_value[j])
590 min = symbol_value[j];
591 if (max < symbol_value[j])
592 max = symbol_value[j];
593 *r++ = symbol_value[j];
594 *s++ = (Value_t)(actionrow[ntokens + j] - 2);
597 width[nstates + i] = (Value_t)(max - min + 1);
599 #if defined(YYBTYACC)
600 if (backtrack && conflictcount > 0)
602 froms[2 * nstates + i] = r = NEW2(conflictcount, Value_t);
603 tos[2 * nstates + i] = s = NEW2(conflictcount, Value_t);
606 for (j = 0; j < ntokens; ++j)
608 if (actionrow[2 * ntokens + j])
610 if (min > symbol_value[j])
611 min = symbol_value[j];
612 if (max < symbol_value[j])
613 max = symbol_value[j];
614 *r++ = symbol_value[j];
615 *s++ = (Value_t)(actionrow[2 * ntokens + j] - 1);
618 width[2 * nstates + i] = (Value_t)(max - min + 1);
627 default_goto(int symbol)
635 m = goto_map[symbol];
636 n = goto_map[symbol + 1];
641 for (i = 0; i < nstates; i++)
644 for (i = m; i < n; i++)
645 state_count[to_state[i]]++;
649 for (i = 0; i < nstates; i++)
651 if (state_count[i] > max)
653 max = state_count[i];
658 return (default_state);
662 save_column(int symbol, int default_state)
673 m = goto_map[symbol];
674 n = goto_map[symbol + 1];
677 for (i = m; i < n; i++)
679 if (to_state[i] != default_state)
685 symno = symbol_value[symbol] + PER_STATE * nstates;
687 froms[symno] = sp1 = sp = NEW2(count, Value_t);
688 tos[symno] = sp2 = NEW2(count, Value_t);
690 for (i = m; i < n; i++)
692 if (to_state[i] != default_state)
694 *sp1++ = from_state[i];
695 *sp2++ = to_state[i];
699 tally[symno] = count;
700 width[symno] = (Value_t)(sp1[-1] - sp[0] + 1);
708 state_count = NEW2(nstates, Value_t);
710 k = default_goto(start_symbol + 1);
711 start_int_table("dgoto", k);
712 save_column(start_symbol + 1, k);
715 for (i = start_symbol + 2; i < nsyms; i++)
743 order = NEW2(nvectors, Value_t);
746 for (i = 0; i < nvectors; i++)
754 while (j >= 0 && (width[order[j]] < w))
757 while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t))
760 for (k = nentries - 1; k > j; k--)
761 order[k + 1] = order[k];
769 /* The function matching_vector determines if the vector specified by */
770 /* the input parameter matches a previously considered vector. The */
771 /* test at the start of the function checks if the vector represents */
772 /* a row of shifts over terminal symbols or a row of reductions, or a */
773 /* column of shifts over a nonterminal symbol. Berkeley Yacc does not */
774 /* check if a column of shifts over a nonterminal symbols matches a */
775 /* previously considered vector. Because of the nature of LR parsing */
776 /* tables, no two columns can match. Therefore, the only possible */
777 /* match would be between a row and a column. Such matches are */
778 /* unlikely. Therefore, to save time, no attempt is made to see if a */
779 /* column matches a previously considered vector. */
781 /* Matching_vector is poorly designed. The test could easily be made */
782 /* faster. Also, it depends on the vectors being in a specific */
784 #if defined(YYBTYACC)
786 /* Not really any point in checking for matching conflicts -- it is */
787 /* extremely unlikely to occur, and conflicts are (hopefully) rare. */
791 matching_vector(int vector)
800 if (i >= 2 * nstates)
806 for (prev = vector - 1; prev >= 0; prev--)
810 if (width[j] != w || tally[j] != t)
818 for (k = 0; match && k < t; k++)
820 if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k])
833 pack_vector(int vector)
850 j = lowzero - from[0];
851 for (k = 1; k < t; ++k)
852 if (lowzero - from[k] > j)
853 j = lowzero - from[k];
859 for (k = 0; ok && k < t; k++)
862 if (loc >= maxtable - 1)
864 if (loc >= MAXTABLE - 1)
865 fatal("maximum table size exceeded");
872 while (newmax <= loc);
874 table = TREALLOC(Value_t, table, newmax);
877 check = TREALLOC(Value_t, check, newmax);
880 for (l = maxtable; l < newmax; ++l)
888 if (check[loc] != -1)
891 for (k = 0; ok && k < vector; k++)
898 for (k = 0; k < t; k++)
902 check[loc] = from[k];
907 while (check[lowzero] != -1)
921 base = NEW2(nvectors, Value_t);
922 pos = NEW2(nentries, Value_t);
925 table = NEW2(maxtable, Value_t);
926 check = NEW2(maxtable, Value_t);
931 for (i = 0; i < maxtable; i++)
934 for (i = 0; i < nentries; i++)
936 int state = matching_vector(i);
939 place = (Value_t)pack_vector(i);
944 base[order[i]] = place;
947 for (i = 0; i < nvectors; i++)
967 start_int_table("sindex", base[0]);
970 for (i = 1; i < nstates; i++)
985 start_int_table("rindex", base[nstates]);
988 for (i = nstates + 1; i < 2 * nstates; i++)
1003 #if defined(YYBTYACC)
1004 output_line("#if YYBTYACC");
1005 start_int_table("cindex", base[2 * nstates]);
1008 for (i = 2 * nstates + 1; i < 3 * nstates; i++)
1018 output_int(base[i]);
1022 output_line("#endif");
1025 start_int_table("gindex", base[PER_STATE * nstates]);
1028 for (i = PER_STATE * nstates + 1; i < nvectors - 1; i++)
1038 output_int(base[i]);
1051 if (high >= MAXYYINT)
1053 fprintf(stderr, "YYTABLESIZE: %ld\n", high);
1054 fprintf(stderr, "Table is longer than %d elements.\n", MAXYYINT);
1059 fprintf(code_file, "#define YYTABLESIZE %ld\n", high);
1060 start_int_table("table", table[0]);
1063 for (i = 1; i <= high; i++)
1073 output_int(table[i]);
1086 start_int_table("check", check[0]);
1089 for (i = 1; i <= high; i++)
1099 output_int(check[i]);
1106 #if defined(YYBTYACC)
1112 int limit = (conflicts != 0) ? nconflicts : 0;
1117 output_line("#if YYBTYACC");
1118 start_int_table("ctable", conflicts ? conflicts[0] : -1);
1121 for (i = 1; i < limit; i++)
1131 output_int((conflicts != 0 && i < nconflicts) ? conflicts[i] : -1);
1138 output_line("#endif");
1143 output_actions(void)
1145 nvectors = PER_STATE * nstates + nvars;
1147 froms = NEW2(nvectors, Value_t *);
1148 tos = NEW2(nvectors, Value_t *);
1149 tally = NEW2(nvectors, Value_t);
1150 width = NEW2(nvectors, Value_t);
1152 #if defined(YYBTYACC)
1153 if (backtrack && (SRtotal + RRtotal) != 0)
1154 conflicts = NEW2(4 * (SRtotal + RRtotal), Value_t);
1161 FREE(accessing_symbol);
1173 #if defined(YYBTYACC)
1179 is_C_identifier(char *name)
1191 while ((c = *++s) != '"')
1201 while ((c = *++s) != 0)
1209 #if USE_HEADER_GUARDS
1211 start_defines_file(void)
1213 fprintf(defines_file, "#ifndef _%s_defines_h_\n", symbol_prefix);
1214 fprintf(defines_file, "#define _%s_defines_h_\n\n", symbol_prefix);
1218 end_defines_file(void)
1220 fprintf(defines_file, "\n#endif /* _%s_defines_h_ */\n", symbol_prefix);
1223 #define start_defines_file() /* nothing */
1224 #define end_defines_file() /* nothing */
1228 output_defines(FILE * fp)
1232 if (fp == defines_file)
1234 output_code_lines(fp, CODE_REQUIRES);
1237 for (i = 2; i < ntokens; ++i)
1239 char *s = symbol_name[i];
1241 if (is_C_identifier(s) && (!sflag || *s != '"'))
1243 fprintf(fp, "#define ");
1247 while ((c = *++s) != '"')
1258 while ((c = *++s) != 0);
1260 if (fp == code_file)
1262 fprintf(fp, " %d\n", symbol_value[i]);
1266 if (fp == code_file)
1268 if (fp != defines_file || iflag)
1269 fprintf(fp, "#define YYERRCODE %d\n", symbol_value[1]);
1271 if (fp == defines_file)
1273 output_code_lines(fp, CODE_PROVIDES);
1276 if (token_table && rflag && fp != externs_file)
1278 if (fp == code_file)
1280 fputs("#undef yytname\n", fp);
1281 if (fp == code_file)
1283 fputs("#define yytname yyname\n", fp);
1286 if (fp == defines_file || (iflag && !dflag))
1290 if (union_file != 0)
1293 while ((c = getc(union_file)) != EOF)
1297 fprintf(fp, "extern YYSTYPE %slval;\n", symbol_prefix);
1299 #if defined(YYBTYACC)
1303 fprintf(fp, "extern YYLTYPE %slloc;\n", symbol_prefix);
1310 output_stored_text(FILE * fp)
1315 if (text_file == NULL)
1316 open_error("text_file");
1319 if ((c = getc(in)) == EOF)
1322 while ((c = getc(in)) != EOF)
1326 write_code_lineno(fp);
1330 output_yydebug(FILE * fp)
1332 fprintf(fp, "#ifndef YYDEBUG\n");
1333 fprintf(fp, "#define YYDEBUG %d\n", tflag);
1334 fprintf(fp, "#endif\n");
1341 int i, j, k, max, maxtok;
1342 const char **symnam;
1346 fprintf(code_file, "#define YYFINAL %d\n", final_state);
1348 outline += output_yydebug(code_file);
1352 output_yydebug(output_file);
1356 for (i = 0; i < ntokens; ++i)
1357 if (symbol_value[i] > maxtok)
1358 maxtok = symbol_value[i];
1360 /* symbol_value[$accept] = -1 */
1361 /* symbol_value[<goal>] = 0 */
1362 /* remaining non-terminals start at 1 */
1364 for (i = ntokens; i < nsyms; ++i)
1365 if (((maxtok + 1) + (symbol_value[i] + 1)) > max)
1366 max = (maxtok + 1) + (symbol_value[i] + 1);
1369 fprintf(code_file, "#define YYMAXTOKEN %d\n", maxtok);
1372 fprintf(code_file, "#define YYUNDFTOKEN %d\n", max + 1);
1375 fprintf(code_file, "#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? "
1376 "YYUNDFTOKEN : (a))\n");
1378 symnam = TMALLOC(const char *, max + 2);
1381 /* Note that it is not necessary to initialize the element */
1383 #if defined(YYBTYACC)
1384 for (i = 0; i < max; ++i)
1386 for (i = nsyms - 1; i >= 0; --i)
1387 symnam[symbol_pval[i]] = symbol_name[i];
1388 symnam[max + 1] = "illegal-symbol";
1390 for (i = 0; i <= max; ++i)
1392 for (i = ntokens - 1; i >= 2; --i)
1393 symnam[symbol_value[i]] = symbol_name[i];
1394 symnam[0] = "end-of-file";
1395 symnam[max + 1] = "illegal-symbol";
1399 * bison's yytname[] array is roughly the same as byacc's yyname[] array.
1400 * The difference is that byacc does not predefine "$undefined".
1402 * If the grammar declares "%token-table", define symbol "yytname" so
1403 * an application such as ntpd can build.
1409 output_line("#undef yytname");
1410 output_line("#define yytname yyname");
1415 output_line("#if YYDEBUG");
1418 start_str_table("name");
1420 for (i = 0; i <= max + 1; ++i)
1422 if ((s = symnam[i]) != 0)
1443 fprintf(output_file, "\"\\\"");
1449 fprintf(output_file, "\\\\");
1451 fprintf(output_file, "\\\\");
1453 putc(*s, output_file);
1456 putc(*s, output_file);
1458 fprintf(output_file, "\\\"\",");
1460 else if (s[0] == '\'')
1470 fprintf(output_file, "\"'\\\"'\",");
1475 while (*++s != '\'')
1491 fprintf(output_file, "\"'");
1493 while (*++s != '\'')
1497 fprintf(output_file, "\\\\");
1499 fprintf(output_file, "\\\\");
1501 putc(*s, output_file);
1504 putc(*s, output_file);
1506 fprintf(output_file, "'\",");
1511 k = (int)strlen(s) + 3;
1518 putc('"', output_file);
1521 putc(*s, output_file);
1524 fprintf(output_file, "\",");
1535 fprintf(output_file, "0,");
1542 output_line("#if YYDEBUG");
1543 start_str_table("rule");
1544 for (i = 2; i < nrules; ++i)
1546 fprintf(output_file, "\"%s :", symbol_name[rlhs[i]]);
1547 for (j = rrhs[i]; ritem[j] > 0; ++j)
1549 s = symbol_name[ritem[j]];
1552 fprintf(output_file, " \\\"");
1558 fprintf(output_file, "\\\\\\\\");
1560 fprintf(output_file, "\\\\%c", s[1]);
1564 putc(*s, output_file);
1566 fprintf(output_file, "\\\"");
1568 else if (s[0] == '\'')
1571 fprintf(output_file, " '\\\"'");
1572 else if (s[1] == '\\')
1575 fprintf(output_file, " '\\\\\\\\");
1577 fprintf(output_file, " '\\\\%c", s[2]);
1579 while (*++s != '\'')
1580 putc(*s, output_file);
1581 putc('\'', output_file);
1584 fprintf(output_file, " '%c'", s[1]);
1587 fprintf(output_file, " %s", s);
1589 fprintf(output_file, "\",");
1594 output_line("#endif");
1597 #if defined(YYBTYACC)
1599 output_backtracking_parser(FILE * fp)
1601 putl_code(fp, "#undef YYBTYACC\n");
1602 #if defined(YYBTYACC)
1605 putl_code(fp, "#define YYBTYACC 1\n");
1607 "#define YYDEBUGSTR (yytrial ? YYPREFIX \"debug(trial)\" : YYPREFIX \"debug\")\n");
1612 putl_code(fp, "#define YYBTYACC 0\n");
1613 putl_code(fp, "#define YYDEBUGSTR YYPREFIX \"debug\"\n");
1619 output_pure_parser(FILE * fp)
1621 putc_code(fp, '\n');
1623 if (fp == code_file)
1625 fprintf(fp, "#define YYPURE %d\n", pure_parser);
1626 putc_code(fp, '\n');
1629 #if defined(YY_NO_LEAKS)
1631 output_no_leaks(FILE * fp)
1633 putc_code(fp, '\n');
1635 if (fp == code_file)
1637 fputs("#define YY_NO_LEAKS 1\n", fp);
1638 putc_code(fp, '\n');
1643 output_trailing_text(void)
1656 if ((c = getc(in)) == EOF)
1658 write_input_lineno();
1659 putc_code(code_file, c);
1664 write_input_lineno();
1667 putc_code(code_file, c);
1669 while ((c = *++cptr) != '\n');
1670 putc_code(code_file, c);
1674 while ((c = getc(in)) != EOF)
1676 putc_code(code_file, c);
1682 putc_code(code_file, '\n');
1684 write_code_lineno(code_file);
1688 output_semantic_actions(void)
1692 rewind(action_file);
1693 if ((c = getc(action_file)) == EOF)
1697 putc_code(code_file, c);
1698 while ((c = getc(action_file)) != EOF)
1700 putc_code(code_file, c);
1706 putc_code(code_file, '\n');
1709 write_code_lineno(code_file);
1713 output_parse_decl(FILE * fp)
1715 putc_code(fp, '\n');
1716 putl_code(fp, "/* compatibility with bison */\n");
1717 putl_code(fp, "#ifdef YYPARSE_PARAM\n");
1718 putl_code(fp, "/* compatibility with FreeBSD */\n");
1719 putl_code(fp, "# ifdef YYPARSE_PARAM_TYPE\n");
1721 "# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)\n");
1722 putl_code(fp, "# else\n");
1723 putl_code(fp, "# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)\n");
1724 putl_code(fp, "# endif\n");
1725 putl_code(fp, "#else\n");
1727 puts_code(fp, "# define YYPARSE_DECL() yyparse(");
1728 puts_param_types(fp, parse_param, 0);
1729 putl_code(fp, ")\n");
1731 putl_code(fp, "#endif\n");
1735 output_lex_decl(FILE * fp)
1737 putc_code(fp, '\n');
1738 putl_code(fp, "/* Parameters sent to lex. */\n");
1739 putl_code(fp, "#ifdef YYLEX_PARAM\n");
1742 putl_code(fp, "# ifdef YYLEX_PARAM_TYPE\n");
1743 #if defined(YYBTYACC)
1746 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval,"
1748 " YYLEX_PARAM_TYPE YYLEX_PARAM)\n");
1753 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval,"
1754 " YYLEX_PARAM_TYPE YYLEX_PARAM)\n");
1756 putl_code(fp, "# else\n");
1757 #if defined(YYBTYACC)
1760 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval,"
1762 " void * YYLEX_PARAM)\n");
1767 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval,"
1768 " void * YYLEX_PARAM)\n");
1770 putl_code(fp, "# endif\n");
1771 #if defined(YYBTYACC)
1774 "# define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)\n");
1777 putl_code(fp, "# define YYLEX yylex(&yylval, YYLEX_PARAM)\n");
1781 putl_code(fp, "# define YYLEX_DECL() yylex(void *YYLEX_PARAM)\n");
1782 putl_code(fp, "# define YYLEX yylex(YYLEX_PARAM)\n");
1784 putl_code(fp, "#else\n");
1785 if (pure_parser && lex_param)
1787 #if defined(YYBTYACC)
1790 "# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLTYPE *yylloc, ");
1793 puts_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval, ");
1794 puts_param_types(fp, lex_param, 0);
1795 putl_code(fp, ")\n");
1797 #if defined(YYBTYACC)
1799 puts_code(fp, "# define YYLEX yylex(&yylval, &yylloc, ");
1802 puts_code(fp, "# define YYLEX yylex(&yylval, ");
1803 puts_param_names(fp, lex_param, 0);
1804 putl_code(fp, ")\n");
1806 else if (pure_parser)
1808 #if defined(YYBTYACC)
1812 "# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLTYPE *yylloc)\n");
1813 putl_code(fp, "# define YYLEX yylex(&yylval, &yylloc)\n");
1818 putl_code(fp, "# define YYLEX_DECL() yylex(YYSTYPE *yylval)\n");
1819 putl_code(fp, "# define YYLEX yylex(&yylval)\n");
1824 puts_code(fp, "# define YYLEX_DECL() yylex(");
1825 puts_param_types(fp, lex_param, 0);
1826 putl_code(fp, ")\n");
1828 puts_code(fp, "# define YYLEX yylex(");
1829 puts_param_names(fp, lex_param, 0);
1830 putl_code(fp, ")\n");
1834 putl_code(fp, "# define YYLEX_DECL() yylex(void)\n");
1835 putl_code(fp, "# define YYLEX yylex()\n");
1837 putl_code(fp, "#endif\n");
1840 * Provide a prototype for yylex for the simplest case. This is done for
1841 * better compatibility with older yacc's, but can be a problem if someone
1842 * uses "static int yylex(void);"
1845 #if defined(YYBTYACC)
1848 && !strcmp(symbol_prefix, "yy"))
1850 putl_code(fp, "\n");
1851 putl_code(fp, "#if !(defined(yylex) || defined(YYSTATE))\n");
1852 putl_code(fp, "int YYLEX_DECL();\n");
1853 putl_code(fp, "#endif\n");
1858 output_error_decl(FILE * fp)
1860 putc_code(fp, '\n');
1861 putl_code(fp, "/* Parameters sent to yyerror. */\n");
1862 putl_code(fp, "#ifndef YYERROR_DECL\n");
1863 puts_code(fp, "#define YYERROR_DECL() yyerror(");
1864 #if defined(YYBTYACC)
1866 puts_code(fp, "YYLTYPE *loc, ");
1868 puts_param_types(fp, parse_param, 1);
1869 putl_code(fp, "const char *s)\n");
1870 putl_code(fp, "#endif\n");
1872 putl_code(fp, "#ifndef YYERROR_CALL\n");
1874 puts_code(fp, "#define YYERROR_CALL(msg) yyerror(");
1875 #if defined(YYBTYACC)
1877 puts_code(fp, "&yylloc, ");
1879 puts_param_names(fp, parse_param, 1);
1880 putl_code(fp, "msg)\n");
1882 putl_code(fp, "#endif\n");
1885 #if defined(YYBTYACC)
1887 output_yydestruct_decl(FILE * fp)
1889 putc_code(fp, '\n');
1890 putl_code(fp, "#ifndef YYDESTRUCT_DECL\n");
1893 "#define YYDESTRUCT_DECL() "
1894 "yydestruct(const char *msg, int psymb, YYSTYPE *val");
1895 #if defined(YYBTYACC)
1897 puts_code(fp, ", YYLTYPE *loc");
1901 puts_code(fp, ", ");
1902 puts_param_types(fp, parse_param, 0);
1904 putl_code(fp, ")\n");
1906 putl_code(fp, "#endif\n");
1908 putl_code(fp, "#ifndef YYDESTRUCT_CALL\n");
1910 puts_code(fp, "#define YYDESTRUCT_CALL(msg, psymb, val");
1911 #if defined(YYBTYACC)
1913 puts_code(fp, ", loc");
1915 puts_code(fp, ") yydestruct(msg, psymb, val");
1916 #if defined(YYBTYACC)
1918 puts_code(fp, ", loc");
1922 puts_code(fp, ", ");
1923 puts_param_names(fp, parse_param, 0);
1925 putl_code(fp, ")\n");
1927 putl_code(fp, "#endif\n");
1931 output_initial_action(void)
1934 fprintf(code_file, "%s\n", initial_action);
1938 output_yydestruct_impl(void)
1941 char *s, *destructor_code;
1943 putc_code(code_file, '\n');
1944 putl_code(code_file, "/* Release memory associated with symbol. */\n");
1945 putl_code(code_file, "#if ! defined YYDESTRUCT_IS_DECLARED\n");
1946 putl_code(code_file, "static void\n");
1947 putl_code(code_file, "YYDESTRUCT_DECL()\n");
1948 putl_code(code_file, "{\n");
1949 putl_code(code_file, " switch (psymb)\n");
1950 putl_code(code_file, " {\n");
1951 for (i = 2; i < nsyms; ++i)
1953 if ((destructor_code = symbol_destructor[i]) != NULL)
1956 fprintf(code_file, "\tcase %d:\n", symbol_pval[i]);
1957 /* comprehend the number of lines in the destructor code */
1958 for (s = destructor_code; (s = strchr(s, '\n')) != NULL; s++)
1960 puts_code(code_file, destructor_code);
1961 putc_code(code_file, '\n');
1962 putl_code(code_file, "\tbreak;\n");
1963 write_code_lineno(code_file);
1964 FREE(destructor_code);
1967 putl_code(code_file, " }\n");
1968 putl_code(code_file, "}\n");
1969 putl_code(code_file, "#define YYDESTRUCT_IS_DECLARED 1\n");
1970 putl_code(code_file, "#endif\n");
1972 DO_FREE(symbol_destructor);
1982 for (cp = first_state; cp; cp = next)
1995 for (sp = first_shift; sp; sp = next)
2003 free_reductions(void)
2005 reductions *rp, *next;
2007 FREE(reduction_table);
2008 for (rp = first_reduction; rp; rp = next)
2016 output_externs(FILE * fp, const char *const section[])
2021 for (i = 0; (s = section[i]) != 0; ++i)
2023 /* prefix non-blank lines that don't start with
2024 C pre-processor directives with 'extern ' */
2025 if (*s && (*s != '#'))
2026 fputs("extern\t", fp);
2027 if (fp == code_file)
2029 fprintf(fp, "%s\n", s);
2042 output_code_lines(code_file, CODE_TOP);
2043 #if defined(YYBTYACC)
2044 output_backtracking_parser(output_file);
2046 output_backtracking_parser(code_file);
2051 write_code_lineno(code_file);
2053 fprintf(code_file, "#include \"%s\"\n", externs_file_name);
2060 output_pure_parser(fp);
2061 #if defined(YY_NO_LEAKS)
2062 output_no_leaks(fp);
2064 output_stored_text(fp);
2066 #if defined(YYBTYACC)
2070 output_parse_decl(fp);
2071 output_lex_decl(fp);
2072 output_error_decl(fp);
2073 #if defined(YYBTYACC)
2075 output_yydestruct_decl(fp);
2077 if (iflag || !rflag)
2079 write_section(fp, xdecls);
2084 fprintf(externs_file, "\n");
2085 output_yydebug(externs_file);
2086 output_externs(externs_file, global_vars);
2088 output_externs(externs_file, impure_vars);
2092 fprintf(code_file, "#include \"%s\"\n", defines_file_name);
2095 output_defines(externs_file);
2099 putc_code(code_file, '\n');
2100 output_defines(code_file);
2105 start_defines_file();
2106 output_defines(defines_file);
2112 #if defined(YYBTYACC)
2113 output_accessing_symbols();
2121 write_section(code_file, xdecls);
2122 output_YYINT_typedef(code_file);
2123 write_section(code_file, tables);
2126 write_section(code_file, global_vars);
2129 write_section(code_file, impure_vars);
2131 output_code_lines(code_file, CODE_REQUIRES);
2133 write_section(code_file, hdr_defs);
2136 write_section(code_file, hdr_vars);
2139 output_code_lines(code_file, CODE_PROVIDES);
2140 output_code_lines(code_file, CODE_HEADER);
2142 output_trailing_text();
2143 #if defined(YYBTYACC)
2145 output_yydestruct_impl();
2147 write_section(code_file, body_1);
2150 write_section(code_file, body_vars);
2152 write_section(code_file, body_2);
2155 write_section(code_file, init_vars);
2157 #if defined(YYBTYACC)
2159 output_initial_action();
2161 write_section(code_file, body_3);
2162 output_semantic_actions();
2163 write_section(code_file, trailer);