X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ff61dabdbacfc6ea2737395756ea75e61ad1aa5a..e89a22bfab22e4d2ee73be49dcb66b51f8d0e892:/src/output.c diff --git a/src/output.c b/src/output.c index cf01416a..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_literal_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_literal_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) - fprintf (fguard, 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,12 +240,7 @@ output_headers (void) if (semantic_parser) obstack_fgrow1 (&action_obstack, ACTSTR, attrsfile_quoted); else - obstack_grow_literal_string (&action_obstack, ACTSTR_SIMPLE); - -/* if (semantic_parser) JF moved this below - fprintf(ftable, "#include \"%s\"\n", attrsfile); - fprintf(ftable, "#include \n\n"); -*/ + obstack_sgrow (&action_obstack, ACTSTR_SIMPLE); /* Rename certain symbols if -p was specified. */ if (spec_name_prefix) @@ -270,7 +271,7 @@ void output_trailers (void) { if (semantic_parser) - fprintf (fguard, "\n }\n}\n"); + obstack_sgrow (&guard_obstack, "\n }\n}\n"); obstack_1grow (&action_obstack, '\n'); @@ -278,9 +279,9 @@ output_trailers (void) return; if (semantic_parser) - obstack_grow_literal_string (&action_obstack, " }\n"); + obstack_sgrow (&action_obstack, " }\n"); - obstack_grow_literal_string (&action_obstack, "}\n"); + obstack_sgrow (&action_obstack, "}\n"); } @@ -288,29 +289,23 @@ output_trailers (void) static void output_token_translations (void) { - obstack_grow_literal_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_literal_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); } @@ -321,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_literal_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; @@ -344,14 +346,20 @@ output_gram (void) } if (!semantic_parser && !no_parser_flag) - obstack_grow_literal_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); } @@ -363,15 +371,21 @@ output_rule_data (void) int j; short *short_tab = NULL; - obstack_grow_literal_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_literal_string (&table_obstack, "#endif\n\n"); + obstack_sgrow (&table_obstack, "#endif\n\n"); if (token_table_flag || no_parser_flag) { @@ -385,11 +399,11 @@ output_rule_data (void) /* Output the table of symbol names. */ if (!token_table_flag && !no_parser_flag) - obstack_grow_literal_string (&table_obstack, - "\n#if YYDEBUG != 0 || defined YYERROR_VERBOSE\n\n"); - obstack_grow_literal_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_literal_string (&table_obstack, + obstack_sgrow (&table_obstack, "static const char *const yytname[] =\n{\n "); j = 0; @@ -413,7 +427,7 @@ output_rule_data (void) if (j + strsize > 75) { - obstack_grow_literal_string (&table_obstack, "\n "); + obstack_sgrow (&table_obstack, "\n "); j = 2; } @@ -421,39 +435,27 @@ output_rule_data (void) for (p = tags[i]; p && *p; p++) { if (*p == '"' || *p == '\\') - { - obstack_fgrow1 (&table_obstack, "\\%c", *p); - } + obstack_fgrow1 (&table_obstack, "\\%c", *p); else if (*p == '\n') - { - obstack_grow_literal_string (&table_obstack, "\\n"); - } + obstack_sgrow (&table_obstack, "\\n"); else if (*p == '\t') - { - obstack_grow_literal_string (&table_obstack, "\\t"); - } + obstack_sgrow (&table_obstack, "\\t"); else if (*p == '\b') - { - obstack_grow_literal_string (&table_obstack, "\\b"); - } + obstack_sgrow (&table_obstack, "\\b"); else if (*p < 040 || *p >= 0177) - { - obstack_fgrow1 (&table_obstack, "\\%03o", *p); - } + obstack_fgrow1 (&table_obstack, "\\%03o", *p); else - { - obstack_1grow (&table_obstack, *p); - } + obstack_1grow (&table_obstack, *p); } - obstack_grow_literal_string (&table_obstack, "\", "); + obstack_sgrow (&table_obstack, "\", "); j += strsize; } /* add a NULL entry to list of tokens */ - obstack_grow_literal_string (&table_obstack, "NULL\n};\n"); + obstack_sgrow (&table_obstack, "NULL\n};\n"); if (!token_table_flag && !no_parser_flag) - obstack_grow_literal_string (&table_obstack, "#endif\n\n"); + obstack_sgrow (&table_obstack, "#endif\n\n"); /* Output YYTOKNUM. */ if (token_table_flag) @@ -465,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, @@ -486,7 +493,7 @@ output_rule_data (void) XFREE (short_tab); - XFREE (rrhs + 1); + XFREE (rule_table + 1); } @@ -521,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; @@ -540,7 +543,7 @@ action_row (int state) default_rule = 0; nreds = 0; - redp = reduction_table[state]; + redp = state_table[state].reductions; if (redp) { @@ -550,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; - - for (i = 0; i < k; i++) - { - shift_state = shiftp->shifts[i]; - if (!shift_state) - continue; + 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) { @@ -630,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++) @@ -752,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) { @@ -1029,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; } @@ -1132,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); @@ -1161,81 +1108,132 @@ static void output_parser (void) { int c; - static int number_of_dollar_signs = 0; FILE *fskel; + size_t line; + int actions_dumped = 0; if (pure_parser) - obstack_grow_literal_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) - fskel = xfopen (skeleton_find ("BISON_HAIRY", BISON_HAIRY), "r"); - else - fskel = xfopen (skeleton_find ("BISON_SIMPLE", BISON_SIMPLE), "r"); + 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 + decimal integer constant. This specifies that the line number of + the *following* line of input, in its original source file, was + LINENUM. */ + line = 2; while (1) { - int write_line = 1; + enum line_type_e + { + regular_line, + sync_line, /* #line. */ + actions_line /* %% actions. */ + }; + enum line_type_e line_type = regular_line; c = getc (fskel); - /* See if the line starts with `#line. - If so, set write_line to 0. */ - if (no_lines_flag) - if (c == '#') - { - c = getc (fskel); - if (c == 'l') - { - c = getc (fskel); - if (c == 'i') - { - c = getc (fskel); - if (c == 'n') - { - c = getc (fskel); - if (c == 'e') - write_line = 0; + /* Is this line special? */ + if (c == '#') + { + /* See if it's a `#line' line. */ + if ((c = getc (fskel)) == 'l') + if ((c = getc (fskel)) == 'i') + if ((c = getc (fskel)) == 'n') + if ((c = getc (fskel)) == 'e') + line_type = sync_line; + else + obstack_sgrow (&table_obstack, "#lin"); + else + obstack_sgrow (&table_obstack, "#li"); + else + obstack_sgrow (&table_obstack, "#l"); + else + obstack_sgrow (&table_obstack, "#"); + } + else if (c == '%') + { + /* See if it's a `%% actions' line. */ + if ((c = getc (fskel)) == '%') + if ((c = getc (fskel)) == ' ') + if ((c = getc (fskel)) == 'a') + if ((c = getc (fskel)) == 'c') + if ((c = getc (fskel)) == 't') + if ((c = getc (fskel)) == 'i') + if ((c = getc (fskel)) == 'o') + if ((c = getc (fskel)) == 'n') + if ((c = getc (fskel)) == 's') + line_type = actions_line; + else + obstack_sgrow (&table_obstack, "%% action"); else - obstack_grow_literal_string (&table_obstack, "#lin"); - } + obstack_sgrow (&table_obstack, "%% actio"); + else + obstack_sgrow (&table_obstack, "%% acti"); else - obstack_grow_literal_string (&table_obstack, "#li"); - } + obstack_sgrow (&table_obstack, "%% act"); + else + obstack_sgrow (&table_obstack, "%% ac"); else - obstack_grow_literal_string (&table_obstack, "#l"); - } + obstack_sgrow (&table_obstack, "%% a"); + else + obstack_sgrow (&table_obstack, "%% "); else - obstack_grow_literal_string (&table_obstack, "#"); - } + obstack_sgrow (&table_obstack, "%%"); + else + obstack_sgrow (&table_obstack, "%"); + } + + switch (line_type) + { + case sync_line: + if (!no_lines_flag) + obstack_fgrow2 (&table_obstack, "#line %d %s\n", + line, quotearg_style (c_quoting_style, skeleton)); + + /* Skip the end of line. */ + for (; c != '\n' && c != EOF; c = getc (fskel)) + /* nothing */; + break; - /* now write out the line... */ - for (; c != '\n' && c != EOF; c = getc (fskel)) - if (write_line) + case actions_line: { - /* `$' in the parser file indicates where to put the - actions. Copy them in at this point. */ - if (c == '$') - { - size_t size = obstack_object_size (&action_obstack); - - number_of_dollar_signs++; - assert (number_of_dollar_signs == 1); - obstack_grow (&table_obstack, - obstack_finish (&action_obstack), - size); - - /* Skip the end of the line containing `$'. */ - write_line = 0; - } - else - obstack_1grow (&table_obstack, c); + size_t size = obstack_object_size (&action_obstack); + + actions_dumped++; + assert (actions_dumped == 1); + obstack_grow (&table_obstack, + obstack_finish (&action_obstack), + size); } + + /* Skip the end of line. */ + for (; c != '\n' && c != EOF; c = getc (fskel)) + /* nothing */; + break; + + case regular_line: + for (; c != '\n' && c != EOF; c = getc (fskel)) + obstack_1grow (&table_obstack, c); + } + if (c == EOF) break; obstack_1grow (&table_obstack, c); + line++; } - assert (number_of_dollar_signs == 1); + assert (actions_dumped == 1); xfclose (fskel); } @@ -1253,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. | `----------------------------------------------------------*/ @@ -1285,30 +1268,17 @@ output (void) obstack_grow (&table_obstack, obstack_finish (&attrs_obstack), size); } reader_output_yylsp (&table_obstack); - if (debug_flag) - obstack_grow_literal_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_literal_string (&table_obstack, "#include \n\n"); - - /* Make "const" do nothing if not in ANSI C. */ - obstack_grow_literal_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) */ @@ -1319,6 +1289,8 @@ output (void) output_stos (); output_rule_data (); output_actions (); + XFREE (state_table); + if (!no_parser_flag) output_parser (); output_program ();