X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/fabd3b431d984f277f0838053a281b19015b15c7..e89a22bfab22e4d2ee73be49dcb66b51f8d0e892:/src/output.c diff --git a/src/output.c b/src/output.c index d5c3b990..2daac6c3 100644 --- a/src/output.c +++ b/src/output.c @@ -1,5 +1,7 @@ /* Output the generated parsing program for bison, - Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc. + + Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001 Free Software + Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -94,7 +96,6 @@ #include "obstack.h" #include "quotearg.h" #include "getargs.h" -#include "xalloc.h" #include "files.h" #include "gram.h" #include "LR0.h" @@ -104,23 +105,20 @@ #include "reader.h" #include "conflicts.h" -extern void berror PARAMS((const char *)); - - static int nvectors; static int nentries; -static short **froms; -static short **tos; -static short *tally; -static short *width; -static short *actrow; -static short *state_count; -static short *order; -static short *base; -static short *pos; -static short *table; -static short *check; +static short **froms = NULL; +static short **tos = NULL; +static short *tally = NULL; +static short *width = NULL; +static short *actrow = NULL; +static short *state_count = NULL; +static short *order = NULL; +static short *base = NULL; +static short *pos = NULL; +static short *table = NULL; +static short *check = NULL; static int lowzero; static int high; @@ -133,7 +131,7 @@ output_short_or_char_table (struct obstack *oout, const char *table_name, short *short_table, short first_value, - short begin, short end) + int begin, int end) { int i, j; @@ -171,7 +169,7 @@ output_short_table (struct obstack *oout, const char *table_name, short *short_table, short first_value, - short begin, short end) + int begin, int end) { output_short_or_char_table (oout, comment, "short", table_name, short_table, first_value, begin, end); @@ -295,25 +293,19 @@ output_token_translations (void) \n\ /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */\n"); - if (translations) - { - obstack_fgrow2 (&table_obstack, + obstack_fgrow2 (&table_obstack, "#define YYTRANSLATE(x) ((unsigned)(x) <= %d ? yytranslate[x] : %d)\ \n\ \n", - max_user_token_number, nsyms); + max_user_token_number, nsyms); - output_short_or_char_table (&table_obstack, + output_short_or_char_table (&table_obstack, "YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX", - ntokens < 127 ? "char" : "short", - "yytranslate", token_translations, - 0, 1, max_user_token_number + 1); - } - else - { - obstack_sgrow (&table_obstack, - "\n#define YYTRANSLATE(x) (x)\n"); - } + ntokens < 127 ? "char" : "short", + "yytranslate", token_translations, + 0, 1, max_user_token_number + 1); + + XFREE (token_translations); } @@ -324,10 +316,17 @@ output_gram (void) yyprhs and yyrhs are needed only for yydebug. */ /* With the no_parser option, all tables are generated */ if (!semantic_parser && !no_parser_flag) - obstack_sgrow (&table_obstack, "\n#if YYDEBUG != 0\n"); + obstack_sgrow (&table_obstack, "\n#if YYDEBUG\n"); - output_short_table (&table_obstack, NULL, "yyprhs", rrhs, - 0, 1, nrules + 1); + { + int i; + short *values = XCALLOC (short, nrules + 1); + for (i = 0; i < nrules + 1; ++i) + values[i] = rule_table[i].rhs; + output_short_table (&table_obstack, NULL, "yyprhs", values, + 0, 1, nrules + 1); + XFREE (values); + } { size_t yyrhs_size = 1; @@ -354,7 +353,13 @@ output_gram (void) static void output_stos (void) { - output_short_table (&table_obstack, NULL, "yystos", accessing_symbol, + int i; + short *values = (short *) alloca (sizeof (short) * nstates); + for (i = 0; i < nstates; ++i) + values[i] = state_table[i].accessing_symbol; + output_short_table (&table_obstack, + "YYSTOS[STATE] -- Accessing symbol to the STATE", + "yystos", values, 0, 1, nstates); } @@ -367,12 +372,18 @@ output_rule_data (void) short *short_tab = NULL; obstack_sgrow (&table_obstack, "\n\ -#if YYDEBUG != 0\n"); +#if YYDEBUG\n"); - output_short_table (&table_obstack, - "YYRLINE[YYN] -- source line where rule number YYN was defined", - "yyrline", rline, - 0, 1, nrules + 1); + { + short *values = XCALLOC (short, nrules + 1); + for (i = 0; i < nrules + 1; ++i) + values[i] = rule_table[i].line; + output_short_table (&table_obstack, + "YYRLINE[YYN] -- source line where rule number YYN was defined", + "yyrline", values, + 0, 1, nrules + 1); + XFREE (values); + } obstack_sgrow (&table_obstack, "#endif\n\n"); @@ -389,7 +400,7 @@ output_rule_data (void) /* Output the table of symbol names. */ if (!token_table_flag && !no_parser_flag) obstack_sgrow (&table_obstack, - "\n#if YYDEBUG != 0 || defined YYERROR_VERBOSE\n\n"); + "\n#if (YYDEBUG) || defined YYERROR_VERBOSE\n\n"); obstack_sgrow (&table_obstack, "\ /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */\n"); obstack_sgrow (&table_obstack, @@ -456,19 +467,24 @@ output_rule_data (void) } /* Output YYR1. */ - output_short_table (&table_obstack, + { + short *values = XCALLOC (short, nrules + 1); + for (i = 0; i < nrules + 1; ++i) + values[i] = rule_table[i].lhs; + output_short_table (&table_obstack, "YYR1[YYN] -- Symbol number of symbol that rule YYN derives", - "yyr1", rlhs, - 0, 1, nrules + 1); - XFREE (rlhs + 1); + "yyr1", values, + 0, 1, nrules + 1); + XFREE (values); + } obstack_1grow (&table_obstack, '\n'); /* Output YYR2. */ short_tab = XMALLOC (short, nrules + 1); for (i = 1; i < nrules; i++) - short_tab[i] = rrhs[i + 1] - rrhs[i] - 1; - short_tab[nrules] = nitems - rrhs[nrules] - 1; + short_tab[i] = rule_table[i + 1].rhs - rule_table[i].rhs - 1; + short_tab[nrules] = nitems - rule_table[nrules].rhs - 1; output_short_table (&table_obstack, "YYR2[YYN] -- Number of symbols composing right hand side of rule YYN", "yyr2", short_tab, @@ -477,7 +493,7 @@ output_rule_data (void) XFREE (short_tab); - XFREE (rrhs + 1); + XFREE (rule_table + 1); } @@ -512,15 +528,11 @@ action_row (int state) int k; int m = 0; int n = 0; - int count; int default_rule; int nreds; - int max; int rule; int shift_state; int symbol; - unsigned mask; - unsigned *wordp; reductions *redp; shifts *shiftp; errs *errp; @@ -531,7 +543,7 @@ action_row (int state) default_rule = 0; nreds = 0; - redp = reduction_table[state]; + redp = state_table[state].reductions; if (redp) { @@ -541,69 +553,46 @@ action_row (int state) { /* loop over all the rules available here which require lookahead */ - m = lookaheads[state]; - n = lookaheads[state + 1]; + m = state_table[state].lookaheads; + n = state_table[state + 1].lookaheads; for (i = n - 1; i >= m; i--) - { - rule = -LAruleno[i]; - wordp = LA + i * tokensetsize; - mask = 1; - - /* 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 (mask & *wordp) - actrow[j] = rule; - - mask <<= 1; - if (mask == 0) - { - mask = 1; - wordp++; - } - } - } + /* 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]; } } - shiftp = shift_table[state]; - /* Now see which tokens are allowed for shifts in this state. For them, record the shift as the thing to do. So shift is preferred to reduce. */ - - if (shiftp) + shiftp = state_table[state].shifts; + for (i = 0; i < shiftp->nshifts; i++) { - k = shiftp->nshifts; + shift_state = shiftp->shifts[i]; + if (!shift_state) + continue; - for (i = 0; i < k; i++) - { - shift_state = shiftp->shifts[i]; - if (!shift_state) - continue; + symbol = state_table[shift_state].accessing_symbol; - symbol = accessing_symbol[shift_state]; - - if (ISVAR (symbol)) - break; + if (ISVAR (symbol)) + break; - actrow[symbol] = shift_state; + actrow[symbol] = shift_state; - /* Do not use any default reduction if there is a shift for - error */ - if (symbol == error_token_number) - nodefault = 1; - } + /* Do not use any default reduction if there is a shift for + error */ + if (symbol == error_token_number) + nodefault = 1; } - errp = err_table[state]; - /* See which tokens are an explicit error in this state (due to %nonassoc). For them, record MINSHORT as the action. */ + errp = state_table[state].errs; if (errp) { @@ -621,14 +610,14 @@ action_row (int state) if (nreds >= 1 && !nodefault) { - if (consistent[state]) + if (state_table[state].consistent) default_rule = redp->rules[0]; else { - max = 0; + int max = 0; for (i = m; i < n; i++) { - count = 0; + int count = 0; rule = -LAruleno[i]; for (j = 0; j < ntokens; j++) @@ -743,37 +732,6 @@ token_actions (void) } -static void -free_shifts (void) -{ - shifts *sp, *sptmp; /* JF derefrenced freed ptr */ - - XFREE (shift_table); - - for (sp = first_shift; sp; sp = sptmp) - { - sptmp = sp->next; - XFREE (sp); - } -} - - -static void -free_reductions (void) -{ - reductions *rp, *rptmp; /* JF fixed freed ptr */ - - XFREE (reduction_table); - - for (rp = first_reduction; rp; rp = rptmp) - { - rptmp = rp->next; - XFREE (rp); - } -} - - - static void save_column (int symbol, int default_state) { @@ -1020,9 +978,9 @@ pack_vector (int vector) return j; } } - - berror ("pack_vector"); - return 0; /* JF keep lint happy */ +#define pack_vector_succeeded 0 + assert (pack_vector_succeeded); + return 0; } @@ -1123,12 +1081,10 @@ output_actions (void) width = XCALLOC (short, nvectors); token_actions (); - free_shifts (); - free_reductions (); - XFREE (lookaheads); + LIST_FREE (shifts, first_shift); + LIST_FREE (reductions, first_reduction); XFREE (LA); XFREE (LAruleno); - XFREE (accessing_symbol); goto_actions (); XFREE (goto_map + ntokens); @@ -1167,6 +1123,7 @@ output_parser (void) else skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE); } + assert (skeleton); fskel = xfopen (skeleton, "r"); /* Set LINE to 2, not 1: `#line LINENUM' -- Here LINENUM is a @@ -1294,21 +1251,6 @@ output_program (void) } -static void -free_itemsets (void) -{ - core *cp, *cptmp; - - XFREE (state_table); - - for (cp = first_state; cp; cp = cptmp) - { - cptmp = cp->next; - XFREE (cp); - } -} - - /*----------------------------------------------------------. | Output the parsing tables and the parser code to ftable. | `----------------------------------------------------------*/ @@ -1326,30 +1268,17 @@ output (void) obstack_grow (&table_obstack, obstack_finish (&attrs_obstack), size); } reader_output_yylsp (&table_obstack); - if (debug_flag) - obstack_sgrow (&table_obstack, "\ + obstack_fgrow1 (&table_obstack, "\ #ifndef YYDEBUG\n\ -# define YYDEBUG 1\n\ +# define YYDEBUG %d\n\ #endif\n\ -\n"); +\n", debug_flag); if (semantic_parser) obstack_fgrow1 (&table_obstack, "#include %s\n", quotearg_style (c_quoting_style, attrsfile)); - if (!no_parser_flag) - obstack_sgrow (&table_obstack, "#include \n\n"); - - /* Make "const" do nothing if not in ANSI C. */ - obstack_sgrow (&table_obstack, "\ -#ifndef __cplusplus\n\ -# ifndef __STDC__\n\ -# define const\n\ -# endif\n\ -#endif\n\ -\n"); - - free_itemsets (); + LIST_FREE (core, first_state); output_defines (); output_token_translations (); /* if (semantic_parser) */ @@ -1360,6 +1289,8 @@ output (void) output_stos (); output_rule_data (); output_actions (); + XFREE (state_table); + if (!no_parser_flag) output_parser (); output_program ();