X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/1fa140687eb4ae093904366f4cb1563bbb47e63a..b9f71f19cc20de68101ba1a9ae60753558247eca:/src/output.c diff --git a/src/output.c b/src/output.c index afb9881d..3a8bc994 100644 --- a/src/output.c +++ b/src/output.c @@ -1,5 +1,6 @@ /* Output the generated parsing program for bison, - Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc. + Copyright 1984, 1986, 1989, 1992, 2000, 2001 + Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -19,76 +20,73 @@ 02111-1307, USA. */ -/* The parser tables consist of these tables. - Starred ones needed only for the semantic parser. - Double starred are output only if switches are set. +/* The parser tables consist of these tables. Marked ones needed only + for the semantic parser. Double marked are output only if switches + are set. - yytranslate = vector mapping yylex's token numbers into bison's token - numbers. + YYTRANSLATE = vector mapping yylex's token numbers into bison's + token numbers. - ** yytname = vector of string-names indexed by bison token number + ++ YYTNAME = vector of string-names indexed by bison token number. - ** yytoknum = vector of yylex token numbers corresponding to entries - in yytname + ++ YYTOKNUM = vector of yylex token numbers corresponding to + entries in YYTNAME. - yyrline = vector of line-numbers of all rules. For yydebug printouts. + YYRLINE = vector of line-numbers of all rules. For yydebug + printouts. - yyrhs = vector of items of all rules. - This is exactly what ritems contains. For yydebug and for semantic - parser. + YYRHS = vector of items of all rules. This is exactly what RITEMS + contains. For yydebug and for semantic parser. - yyprhs[r] = index in yyrhs of first item for rule r. + YYPRHS[R] = index in YYRHS of first item for rule R. - yyr1[r] = symbol number of symbol that rule r derives. + YYR1[R] = symbol number of symbol that rule R derives. - yyr2[r] = number of symbols composing right hand side of rule r. + YYR2[R] = number of symbols composing right hand side of rule R. - * yystos[s] = the symbol number of the symbol that leads to state s. + + YYSTOS[S] = the symbol number of the symbol that leads to state + S. - yydefact[s] = default rule to reduce with in state s, - when yytable doesn't specify something else to do. - Zero means the default is an error. + YYDEFACT[S] = default rule to reduce with in state s, when YYTABLE + doesn't specify something else to do. Zero means the default is an + error. - yydefgoto[i] = default state to go to after a reduction of a rule that - generates variable ntokens + i, except when yytable - specifies something else to do. + YYDEFGOTO[I] = default state to go to after a reduction of a rule + that generates variable NTOKENS + I, except when YYTABLE specifies + something else to do. - yypact[s] = index in yytable of the portion describing state s. - The lookahead token's type is used to index that portion - to find out what to do. + YYPACT[S] = index in YYTABLE of the portion describing state S. + The lookahead token's type is used to index that portion to find + out what to do. - If the value in yytable is positive, - we shift the token and go to that state. + If the value in YYTABLE is positive, we shift the token and go to + that state. If the value is negative, it is minus a rule number to reduce by. - If the value is zero, the default action from yydefact[s] is used. + If the value is zero, the default action from YYDEFACT[S] is used. - yypgoto[i] = the index in yytable of the portion describing - what to do after reducing a rule that derives variable i + ntokens. - This portion is indexed by the parser state number, s, - as of before the text for this nonterminal was read. - The value from yytable is the state to go to if - the corresponding value in yycheck is s. + YYPGOTO[I] = the index in YYTABLE of the portion describing what to + do after reducing a rule that derives variable I + NTOKENS. This + portion is indexed by the parser state number, S, as of before the + text for this nonterminal was read. The value from YYTABLE is the + state to go to if the corresponding value in YYCHECK is S. - yytable = a vector filled with portions for different uses, - found via yypact and yypgoto. + YYTABLE = a vector filled with portions for different uses, found + via YYPACT and YYPGOTO. - yycheck = a vector indexed in parallel with yytable. - It indicates, in a roundabout way, the bounds of the - portion you are trying to examine. + YYCHECK = a vector indexed in parallel with YYTABLE. It indicates, + in a roundabout way, the bounds of the portion you are trying to + examine. - Suppose that the portion of yytable starts at index p - and the index to be examined within the portion is i. - Then if yycheck[p+i] != i, i is outside the bounds - of what is actually allocated, and the default - (from yydefact or yydefgoto) should be used. - Otherwise, yytable[p+i] should be used. + Suppose that the portion of yytable starts at index P and the index + to be examined within the portion is I. Then if YYCHECK[P+I] != I, + I is outside the bounds of what is actually allocated, and the + default (from YYDEFACT or YYDEFGOTO) should be used. Otherwise, + YYTABLE[P+I] should be used. - YYFINAL = the state number of the termination state. - YYFLAG = most negative short int. Used to flag ?? - YYNTBASE = ntokens. -*/ + YYFINAL = the state number of the termination state. YYFLAG = most + negative short int. Used to flag ?? */ #include "system.h" #include "quotearg.h" @@ -100,6 +98,7 @@ #include "output.h" #include "lalr.h" #include "reader.h" +#include "symtab.h" #include "conflicts.h" #include "muscle_tab.h" @@ -133,10 +132,8 @@ get_lines_number (const char *s) size_t i; for (i = 0; s[i]; ++i) - { - if (s[i] == '\n') - ++lines; - } + if (s[i] == '\n') + ++lines; return lines; } @@ -188,7 +185,7 @@ output_gram (void) int i; short *values = XCALLOC (short, nrules + 1); for (i = 0; i < nrules + 1; ++i) - values[i] = rule_table[i].rhs; + values[i] = rules[i].rhs; output_table_data (&format_obstack, values, 0, 1, nrules + 1); XFREE (values); @@ -197,19 +194,16 @@ output_gram (void) muscle_insert ("prhs", obstack_finish (&format_obstack)); { - size_t yyrhs_size = 1; - short *yyrhs, *sp; + short *yyrhs; int i; - for (sp = ritem + 1; *sp; sp++) - ++yyrhs_size; - yyrhs = XMALLOC (short, yyrhs_size); + yyrhs = XMALLOC (short, nritems); - for (sp = ritem + 1, i = 1; *sp; ++sp, ++i) - yyrhs[i] = *sp > 0 ? *sp : 0; + for (i = 1; i < nritems; ++i) + yyrhs[i] = ritem[i] >= 0 ? ritem[i] : -1; output_table_data (&format_obstack, yyrhs, - ritem[0], 1, yyrhs_size); + ritem[0], 1, nritems); muscle_insert ("rhs", obstack_finish (&format_obstack)); XFREE (yyrhs); @@ -245,7 +239,7 @@ output_rule_data (void) { short *values = XCALLOC (short, nrules + 1); for (i = 0; i < nrules + 1; ++i) - values[i] = rule_table[i].line; + values[i] = rules[i].line; output_table_data (&format_obstack, values, 0, 1, nrules + 1); muscle_insert ("rline", obstack_finish (&format_obstack)); @@ -259,7 +253,7 @@ output_rule_data (void) /* Be sure not to use twice the same quotearg slot. */ const char *cp = quotearg_n_style (1, c_quoting_style, - quotearg_style (escape_quoting_style, tags[i])); + quotearg_style (escape_quoting_style, symbols[i]->tag)); /* Width of the next token, including the two quotes, the coma and the space. */ int strsize = strlen (cp) + 2; @@ -282,15 +276,22 @@ output_rule_data (void) muscle_insert ("tname", obstack_finish (&format_obstack)); /* Output YYTOKNUM. */ - output_table_data (&format_obstack, user_toknums, - 0, 1, ntokens + 1); - muscle_insert ("toknum", obstack_finish (&format_obstack)); + { + short *values = XCALLOC (short, ntokens + 1); + for (i = 0; i < ntokens + 1; ++i) + values[i] = symbols[i]->user_token_number; + output_table_data (&format_obstack, values, + 0, 1, ntokens + 1); + muscle_insert ("toknum", obstack_finish (&format_obstack)); + XFREE (values); + } + /* Output YYR1. */ { short *values = XCALLOC (short, nrules + 1); for (i = 0; i < nrules + 1; ++i) - values[i] = rule_table[i].lhs; + values[i] = rules[i].lhs; output_table_data (&format_obstack, values, 0, 1, nrules + 1); muscle_insert ("r1", obstack_finish (&format_obstack)); @@ -300,8 +301,8 @@ output_rule_data (void) /* Output YYR2. */ short_tab = XMALLOC (short, nrules + 1); for (i = 1; i < nrules; i++) - short_tab[i] = rule_table[i + 1].rhs - rule_table[i].rhs - 1; - short_tab[nrules] = nitems - rule_table[nrules].rhs - 1; + short_tab[i] = rules[i + 1].rhs - rules[i].rhs - 1; + short_tab[nrules] = nritems - rules[nrules].rhs - 1; output_table_data (&format_obstack, short_tab, 0, 1, nrules + 1); muscle_insert ("r2", obstack_finish (&format_obstack)); @@ -323,38 +324,32 @@ output_rule_data (void) `------------------------------------------------------------------*/ static int -action_row (int state) +action_row (state_t *state) { int i; - int m = 0; - int n = 0; int default_rule = 0; - reductions *redp = state_table[state]->reductions; - int nreds = redp ? redp->nreds : 0; - shifts *shiftp = state_table[state]->shifts; - errs *errp = state_table[state]->errs; + reductions *redp = state->reductions; + shifts *shiftp = state->shifts; + errs *errp = state->errs; /* set nonzero to inhibit having any default reduction */ int nodefault = 0; for (i = 0; i < ntokens; i++) actrow[i] = 0; - if (nreds >= 1) + if (redp->nreds >= 1) { int j; /* loop over all the rules available here which require lookahead */ - m = state_table[state]->lookaheadsp; - n = state_table[state + 1]->lookaheadsp; - - for (i = n - 1; i >= m; i--) + for (i = state->nlookaheads - 1; i >= 0; --i) /* and find each token which the rule finds acceptable to come next */ for (j = 0; j < ntokens; j++) /* and record this rule as the rule to use if that token follows. */ - if (BITISSET (LA (i), j)) - actrow[j] = -LAruleno[i]; + if (BITISSET (LA (state->lookaheadsp + i), j)) + actrow[j] = -LAruleno[state->lookaheadsp + i]; } /* Now see which tokens are allowed for shifts in this state. For @@ -382,27 +377,26 @@ action_row (int state) /* See which tokens are an explicit error in this state (due to %nonassoc). For them, record MINSHORT as the action. */ - if (errp) - for (i = 0; i < errp->nerrs; i++) - { - int symbol = errp->errs[i]; - actrow[symbol] = MINSHORT; - } + for (i = 0; i < errp->nerrs; i++) + { + int symbol = errp->errs[i]; + actrow[symbol] = MINSHORT; + } /* Now find the most common reduction and make it the default action for this state. */ - if (nreds >= 1 && !nodefault) + if (redp->nreds >= 1 && !nodefault) { - if (state_table[state]->consistent) + if (state->consistent) default_rule = redp->rules[0]; else { int max = 0; - for (i = m; i < n; i++) + for (i = 0; i < state->nlookaheads; i++) { int count = 0; - int rule = -LAruleno[i]; + int rule = -LAruleno[state->lookaheadsp + i]; int j; for (j = 0; j < ntokens; j++) @@ -492,7 +486,7 @@ token_actions (void) actrow = XCALLOC (short, ntokens); for (i = 0; i < nstates; ++i) { - yydefact[i] = action_row (i); + yydefact[i] = action_row (state_table[i]); save_row (i); } @@ -514,20 +508,20 @@ actions_output (FILE *out, size_t *line) { int rule; for (rule = 1; rule < nrules + 1; ++rule) - if (rule_table[rule].action) + if (rules[rule].action) { fprintf (out, " case %d:\n", rule); if (!no_lines_flag) fprintf (out, muscle_find ("linef"), - rule_table[rule].action_line, + rules[rule].action_line, quotearg_style (c_quoting_style, muscle_find ("filename"))); /* As a Bison extension, add the ending semicolon. Since some Yacc don't do that, help people using bison as a Yacc finding their missing semicolons. */ fprintf (out, "{ %s%s }\n break;\n\n", - rule_table[rule].action, + rules[rule].action, yacc_flag ? ";" : ""); /* We always output 4 '\n' per action. */ @@ -536,7 +530,39 @@ actions_output (FILE *out, size_t *line) if (!no_lines_flag) ++*line; /* Get the number of lines written by the user. */ - *line += get_lines_number (rule_table[rule].action); + *line += get_lines_number (rules[rule].action); + } +} + + +/*----------------------------. +| Output the guards to OOUT. | +`----------------------------*/ + +static void +guards_output (FILE *out, size_t *line) +{ + int rule; + for (rule = 1; rule < nrules + 1; ++rule) + if (rules[rule].action) + { + fprintf (out, " case %d:\n", rule); + + if (!no_lines_flag) + fprintf (out, muscle_find ("linef"), + rules[rule].guard_line, + quotearg_style (c_quoting_style, + muscle_find ("filename"))); + fprintf (out, "{ %s; }\n break;\n\n", + rules[rule].guard); + + /* We always output 4 '\n' per action. */ + *line += 4; + /* Plus one if !no_lines_flag. */ + if (!no_lines_flag) + ++*line; + /* Get the number of lines written by the user. */ + *line += get_lines_number (rules[rule].guard); } } @@ -878,9 +904,9 @@ output_actions (void) for (i = 0; i < nstates; ++i) { - XFREE (state_table[i]->shifts); + free (state_table[i]->shifts); XFREE (state_table[i]->reductions); - XFREE (state_table[i]->errs); + free (state_table[i]->errs); free (state_table[i]); } XFREE (state_table); @@ -933,6 +959,8 @@ output_parser (const char *skel_filename, FILE *out) muscle_value = muscle_find (muscle_key); if (!strcmp (muscle_key, "actions")) actions_output (out, &output_line); + else if (!strcmp (muscle_key, "guards")) + guards_output (out, &output_line); else if (!strcmp (muscle_key, "line")) fprintf (out, "%d", output_line); else if (!strcmp (muscle_key, "skeleton-line")) @@ -1012,7 +1040,6 @@ prepare (void) MUSCLE_INSERT_INT ("debug", debug_flag); MUSCLE_INSERT_INT ("final", final_state); MUSCLE_INSERT_INT ("maxtok", max_user_token_number); - MUSCLE_INSERT_INT ("ntbase", ntokens); MUSCLE_INSERT_INT ("error-verbose", error_verbose); MUSCLE_INSERT_STRING ("prefix", spec_name_prefix); @@ -1056,8 +1083,8 @@ yystype;\n\ for (i = ntokens; i < nsyms; i++) /* don't make these for dummy nonterminals made by gensym. */ - if (*tags[i] != '@') - fprintf (out, "# define\tNT%s\t%d\n", tags[i], i); + if (*symbols[i]->tag != '@') + fprintf (out, "# define NT%s\t%d\n", symbols[i]->tag, i); } fprintf (out, "\n#endif /* not %s */\n", macro_name); @@ -1082,7 +1109,6 @@ output (void) if (semantic_parser) output_stos (); output_rule_data (); - XFREE (user_toknums); output_actions (); prepare (); @@ -1096,8 +1122,9 @@ output (void) if (defines_flag) header_output (); - free (rule_table + 1); - obstack_free (&muscle_obstack, 0); - obstack_free (&format_obstack, 0); - obstack_free (&action_obstack, 0); + free (rules + 1); + obstack_free (&muscle_obstack, NULL); + obstack_free (&format_obstack, NULL); + obstack_free (&action_obstack, NULL); + obstack_free (&attrs_obstack, NULL); }