X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ea5607fd01a420fe362d6dfc6f9b75d568f2694b..e89a22bfab22e4d2ee73be49dcb66b51f8d0e892:/src/output.c?ds=inline diff --git a/src/output.c b/src/output.c index a5a0a606..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 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; @@ -150,7 +148,7 @@ output_short_or_char_table (struct obstack *oout, if (j >= 10) { - obstack_grow_string (oout, "\n "); + obstack_sgrow (oout, "\n "); j = 1; } else @@ -161,7 +159,7 @@ output_short_or_char_table (struct obstack *oout, obstack_fgrow1 (oout, "%6d", short_table[i]); } - obstack_grow_string (oout, "\n};\n"); + obstack_sgrow (oout, "\n};\n"); } @@ -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); @@ -223,10 +221,18 @@ register YYLTYPE *yylsp;\n\ void output_headers (void) { - char *attrsfile_quoted = quotearg_style (c_quoting_style, attrsfile); + char *attrsfile_quoted = 0; if (semantic_parser) - obstack_fgrow1 (&guard_obstack, GUARDSTR, attrsfile_quoted); + { + /* FIXME: This is *buggy*. ATTRSFILE is not computed yet, since + we are waiting for the full input file to have been read to + be sure of the output file name. So basically, here, a SEGV + is guaranteed. OTOH, currently semantic parsers are not + supported. */ + attrsfile_quoted = quotearg_style (c_quoting_style, attrsfile); + obstack_fgrow1 (&guard_obstack, GUARDSTR, attrsfile_quoted); + } if (no_parser_flag) return; @@ -234,7 +240,7 @@ output_headers (void) if (semantic_parser) obstack_fgrow1 (&action_obstack, ACTSTR, attrsfile_quoted); else - obstack_grow_string (&action_obstack, ACTSTR_SIMPLE); + obstack_sgrow (&action_obstack, ACTSTR_SIMPLE); /* Rename certain symbols if -p was specified. */ if (spec_name_prefix) @@ -265,7 +271,7 @@ void output_trailers (void) { if (semantic_parser) - obstack_grow_string (&guard_obstack, "\n }\n}\n"); + obstack_sgrow (&guard_obstack, "\n }\n}\n"); obstack_1grow (&action_obstack, '\n'); @@ -273,9 +279,9 @@ output_trailers (void) return; if (semantic_parser) - obstack_grow_string (&action_obstack, " }\n"); + obstack_sgrow (&action_obstack, " }\n"); - obstack_grow_string (&action_obstack, "}\n"); + obstack_sgrow (&action_obstack, "}\n"); } @@ -283,29 +289,23 @@ output_trailers (void) static void output_token_translations (void) { - obstack_grow_string (&table_obstack, "\ + obstack_sgrow (&table_obstack, "\ \n\ -/* YYRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */\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, - "YYRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX", - ntokens < 127 ? "char" : "short", - "yytranslate", token_translations, - 0, 1, max_user_token_number + 1); - } - else - { - obstack_grow_string (&table_obstack, - "\n#define YYTRANSLATE(x) (x)\n"); - } + 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); + + XFREE (token_translations); } @@ -316,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_grow_string (&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; @@ -339,14 +346,20 @@ output_gram (void) } if (!semantic_parser && !no_parser_flag) - obstack_grow_string (&table_obstack, "\n#endif\n"); + obstack_sgrow (&table_obstack, "\n#endif\n"); } 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); } @@ -358,15 +371,21 @@ output_rule_data (void) int j; short *short_tab = NULL; - obstack_grow_string (&table_obstack, "\n\ -#if YYDEBUG != 0\n"); + obstack_sgrow (&table_obstack, "\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_grow_string (&table_obstack, "#endif\n\n"); + obstack_sgrow (&table_obstack, "#endif\n\n"); if (token_table_flag || no_parser_flag) { @@ -380,11 +399,11 @@ output_rule_data (void) /* Output the table of symbol names. */ if (!token_table_flag && !no_parser_flag) - obstack_grow_string (&table_obstack, - "\n#if YYDEBUG != 0 || defined YYERROR_VERBOSE\n\n"); - obstack_grow_string (&table_obstack, "\ + obstack_sgrow (&table_obstack, + "\n#if (YYDEBUG) || defined YYERROR_VERBOSE\n\n"); + obstack_sgrow (&table_obstack, "\ /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */\n"); - obstack_grow_string (&table_obstack, + obstack_sgrow (&table_obstack, "static const char *const yytname[] =\n{\n "); j = 0; @@ -408,7 +427,7 @@ output_rule_data (void) if (j + strsize > 75) { - obstack_grow_string (&table_obstack, "\n "); + obstack_sgrow (&table_obstack, "\n "); j = 2; } @@ -418,25 +437,25 @@ output_rule_data (void) if (*p == '"' || *p == '\\') obstack_fgrow1 (&table_obstack, "\\%c", *p); else if (*p == '\n') - obstack_grow_string (&table_obstack, "\\n"); + obstack_sgrow (&table_obstack, "\\n"); else if (*p == '\t') - obstack_grow_string (&table_obstack, "\\t"); + obstack_sgrow (&table_obstack, "\\t"); else if (*p == '\b') - obstack_grow_string (&table_obstack, "\\b"); + obstack_sgrow (&table_obstack, "\\b"); else if (*p < 040 || *p >= 0177) obstack_fgrow1 (&table_obstack, "\\%03o", *p); else obstack_1grow (&table_obstack, *p); } - obstack_grow_string (&table_obstack, "\", "); + obstack_sgrow (&table_obstack, "\", "); j += strsize; } /* add a NULL entry to list of tokens */ - obstack_grow_string (&table_obstack, "NULL\n};\n"); + obstack_sgrow (&table_obstack, "NULL\n};\n"); if (!token_table_flag && !no_parser_flag) - obstack_grow_string (&table_obstack, "#endif\n\n"); + obstack_sgrow (&table_obstack, "#endif\n\n"); /* Output YYTOKNUM. */ if (token_table_flag) @@ -448,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, @@ -469,7 +493,7 @@ output_rule_data (void) XFREE (short_tab); - XFREE (rrhs + 1); + XFREE (rule_table + 1); } @@ -504,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; @@ -523,7 +543,7 @@ action_row (int state) default_rule = 0; nreds = 0; - redp = reduction_table[state]; + redp = state_table[state].reductions; if (redp) { @@ -533,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 = accessing_symbol[shift_state]; + symbol = state_table[shift_state].accessing_symbol; - 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) { @@ -613,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++) @@ -735,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) { @@ -1012,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; } @@ -1115,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); @@ -1146,17 +1110,20 @@ output_parser (void) int c; FILE *fskel; size_t line; - const char *skeleton = NULL; int actions_dumped = 0; if (pure_parser) - obstack_grow_string (&table_obstack, "#define YYPURE 1\n\n"); + obstack_sgrow (&table_obstack, "#define YYPURE 1\n\n"); /* Loop over lines in the standard parser file. */ - if (semantic_parser) - skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY); - else - skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE); + if (!skeleton) + { + if (semantic_parser) + skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY); + 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 @@ -1187,13 +1154,13 @@ output_parser (void) if ((c = getc (fskel)) == 'e') line_type = sync_line; else - obstack_grow_string (&table_obstack, "#lin"); + obstack_sgrow (&table_obstack, "#lin"); else - obstack_grow_string (&table_obstack, "#li"); + obstack_sgrow (&table_obstack, "#li"); else - obstack_grow_string (&table_obstack, "#l"); + obstack_sgrow (&table_obstack, "#l"); else - obstack_grow_string (&table_obstack, "#"); + obstack_sgrow (&table_obstack, "#"); } else if (c == '%') { @@ -1209,23 +1176,23 @@ output_parser (void) if ((c = getc (fskel)) == 's') line_type = actions_line; else - obstack_grow_string (&table_obstack, "%% action"); + obstack_sgrow (&table_obstack, "%% action"); else - obstack_grow_string (&table_obstack, "%% actio"); + obstack_sgrow (&table_obstack, "%% actio"); else - obstack_grow_string (&table_obstack, "%% acti"); + obstack_sgrow (&table_obstack, "%% acti"); else - obstack_grow_string (&table_obstack, "%% act"); + obstack_sgrow (&table_obstack, "%% act"); else - obstack_grow_string (&table_obstack, "%% ac"); + obstack_sgrow (&table_obstack, "%% ac"); else - obstack_grow_string (&table_obstack, "%% a"); + obstack_sgrow (&table_obstack, "%% a"); else - obstack_grow_string (&table_obstack, "%% "); + obstack_sgrow (&table_obstack, "%% "); else - obstack_grow_string (&table_obstack, "%%"); + obstack_sgrow (&table_obstack, "%%"); else - obstack_grow_string (&table_obstack, "%"); + obstack_sgrow (&table_obstack, "%"); } switch (line_type) @@ -1284,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. | `----------------------------------------------------------*/ @@ -1316,30 +1268,17 @@ output (void) obstack_grow (&table_obstack, obstack_finish (&attrs_obstack), size); } reader_output_yylsp (&table_obstack); - if (debug_flag) - obstack_grow_string (&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_grow_string (&table_obstack, "#include \n\n"); - - /* Make "const" do nothing if not in ANSI C. */ - obstack_grow_string (&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) */ @@ -1350,6 +1289,8 @@ output (void) output_stos (); output_rule_data (); output_actions (); + XFREE (state_table); + if (!no_parser_flag) output_parser (); output_program ();