X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/26f609ffc36f35dd84da3d1df8ff716a6c01581c..78af9bbcd3cc7904cf304a3da91b45fe9528dd3c:/src/output.c diff --git a/src/output.c b/src/output.c index 72e4048a..17b4d914 100644 --- a/src/output.c +++ b/src/output.c @@ -94,7 +94,6 @@ #include "obstack.h" #include "quotearg.h" #include "getargs.h" -#include "xalloc.h" #include "files.h" #include "gram.h" #include "LR0.h" @@ -103,41 +102,42 @@ #include "lalr.h" #include "reader.h" #include "conflicts.h" -#include "macrotab.h" +#include "muscle_tab.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; -struct obstack macro_obstack; +struct obstack muscle_obstack; struct obstack output_obstack; +int error_verbose = 0; + /* FIXME. */ static inline void -output_table_data (struct obstack* oout, - short* table, - short first, - short begin, +output_table_data (struct obstack *oout, + short *table_data, + short first, + short begin, short end) { int i; int j = 1; - + obstack_fgrow1 (oout, "%6d", first); for (i = begin; i < end; ++i) { @@ -149,7 +149,7 @@ output_table_data (struct obstack* oout, } else ++j; - obstack_fgrow1 (oout, "%6d", table[i]); + obstack_fgrow1 (oout, "%6d", table_data[i]); } obstack_1grow (oout, 0); } @@ -158,19 +158,28 @@ output_table_data (struct obstack* oout, static void output_token_translations (void) { - output_table_data (&output_obstack, token_translations, + output_table_data (&output_obstack, token_translations, 0, 1, max_user_token_number + 1); - macro_insert ("translate", obstack_finish (&output_obstack)); + muscle_insert ("translate", obstack_finish (&output_obstack)); + XFREE (token_translations); } static void output_gram (void) { - output_table_data (&output_obstack, rrhs, - 0, 1, nrules + 1); - macro_insert ("prhs", obstack_finish (&output_obstack)); - + { + int i; + short *values = XCALLOC (short, nrules + 1); + for (i = 0; i < nrules + 1; ++i) + values[i] = rule_table[i].rhs; + output_table_data (&output_obstack, values, + 0, 1, nrules + 1); + XFREE (values); + } + + muscle_insert ("prhs", obstack_finish (&output_obstack)); + { size_t yyrhs_size = 1; short *yyrhs, *sp; @@ -183,24 +192,30 @@ output_gram (void) for (sp = ritem + 1, i = 1; *sp; ++sp, ++i) yyrhs[i] = *sp > 0 ? *sp : 0; - output_table_data (&output_obstack, yyrhs, + output_table_data (&output_obstack, yyrhs, ritem[0], 1, yyrhs_size); - macro_insert ("rhs", obstack_finish (&output_obstack)); + muscle_insert ("rhs", obstack_finish (&output_obstack)); XFREE (yyrhs); } - /* if (!semantic_parser && !no_parser_flag) - obstack_sgrow (&table_obstack, "\n#endif\n"); */ +#if 0 + if (!semantic_parser && !no_parser_flag) + obstack_sgrow (&table_obstack, "\n#endif\n"); +#endif } static void output_stos (void) { - output_table_data (&output_obstack, 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_table_data (&output_obstack, values, 0, 1, nstates); - macro_insert ("stos", obstack_finish (&output_obstack)); + muscle_insert ("stos", obstack_finish (&output_obstack)); } @@ -211,9 +226,16 @@ output_rule_data (void) int j; short *short_tab = NULL; - output_table_data (&output_obstack, rline, - 0, 1, nrules + 1); - macro_insert ("rline", obstack_finish (&output_obstack)); + { + short *values = XCALLOC (short, nrules + 1); + for (i = 0; i < nrules + 1; ++i) + values[i] = rule_table[i].line; + output_table_data (&output_obstack, values, + 0, 1, nrules + 1); + muscle_insert ("rline", obstack_finish (&output_obstack)); + XFREE (values); + } + j = 0; for (i = 0; i < nsyms; i++) @@ -265,30 +287,35 @@ output_rule_data (void) /* Finish table and store. */ obstack_1grow (&output_obstack, 0); - macro_insert ("tname", obstack_finish (&output_obstack)); + muscle_insert ("tname", obstack_finish (&output_obstack)); /* Output YYTOKNUM. */ output_table_data (&output_obstack, user_toknums, 0, 1, ntokens + 1); - macro_insert ("toknum", obstack_finish (&output_obstack)); + muscle_insert ("toknum", obstack_finish (&output_obstack)); /* Output YYR1. */ - output_table_data (&output_obstack, rlhs, - 0, 1, nrules + 1); - macro_insert ("r1", obstack_finish (&output_obstack)); - XFREE (rlhs + 1); + { + short *values = XCALLOC (short, nrules + 1); + for (i = 0; i < nrules + 1; ++i) + values[i] = rule_table[i].lhs; + output_table_data (&output_obstack, values, + 0, 1, nrules + 1); + muscle_insert ("r1", obstack_finish (&output_obstack)); + XFREE (values); + } /* 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; - output_table_data (&output_obstack, short_tab, + short_tab[i] = rule_table[i + 1].rhs - rule_table[i].rhs - 1; + short_tab[nrules] = nitems - rule_table[nrules].rhs - 1; + output_table_data (&output_obstack, short_tab, 0, 1, nrules + 1); - macro_insert ("r2", obstack_finish (&output_obstack)); + muscle_insert ("r2", obstack_finish (&output_obstack)); XFREE (short_tab); - XFREE (rrhs + 1); + XFREE (rule_table + 1); } /*------------------------------------------------------------------. @@ -313,15 +340,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; @@ -332,7 +355,7 @@ action_row (int state) default_rule = 0; nreds = 0; - redp = reduction_table[state]; + redp = state_table[state]->reductions; if (redp) { @@ -342,69 +365,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) { @@ -422,14 +422,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++) @@ -532,46 +532,15 @@ token_actions (void) save_row (i); } - output_table_data (&output_obstack, yydefact, + output_table_data (&output_obstack, yydefact, yydefact[0], 1, nstates); - macro_insert ("defact", obstack_finish (&output_obstack)); - + muscle_insert ("defact", obstack_finish (&output_obstack)); + XFREE (actrow); XFREE (yydefact); } -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) { @@ -673,9 +642,9 @@ goto_actions (void) yydefgoto[i - ntokens] = default_state; } - output_table_data (&output_obstack, yydefgoto, + output_table_data (&output_obstack, yydefgoto, yydefgoto[0], 1, nsyms - ntokens); - macro_insert ("defgoto", obstack_finish (&output_obstack)); + muscle_insert ("defgoto", obstack_finish (&output_obstack)); XFREE (state_count); XFREE (yydefgoto); @@ -819,8 +788,8 @@ pack_vector (int vector) } } - berror ("pack_vector"); - return 0; /* JF keep lint happy */ + assert (!"pack_vector"); + return 0; } @@ -878,14 +847,14 @@ static void output_base (void) { /* Output pact. */ - output_table_data (&output_obstack, base, + output_table_data (&output_obstack, base, base[0], 1, nstates); - macro_insert ("pact", obstack_finish (&output_obstack)); + muscle_insert ("pact", obstack_finish (&output_obstack)); /* Output pgoto. */ - output_table_data (&output_obstack, base, + output_table_data (&output_obstack, base, base[nstates], nstates + 1, nvectors); - macro_insert ("pgoto", obstack_finish (&output_obstack)); + muscle_insert ("pgoto", obstack_finish (&output_obstack)); XFREE (base); } @@ -894,9 +863,9 @@ output_base (void) static void output_table (void) { - output_table_data (&output_obstack, table, + output_table_data (&output_obstack, table, table[0], 1, high + 1); - macro_insert ("table", obstack_finish (&output_obstack)); + muscle_insert ("table", obstack_finish (&output_obstack)); XFREE (table); } @@ -904,9 +873,9 @@ output_table (void) static void output_check (void) { - output_table_data (&output_obstack, check, + output_table_data (&output_obstack, check, check[0], 1, high + 1); - macro_insert ("check", obstack_finish (&output_obstack)); + muscle_insert ("check", obstack_finish (&output_obstack)); XFREE (check); } @@ -916,6 +885,7 @@ output_check (void) static void output_actions (void) { + int i; nvectors = nstates + nvars; froms = XCALLOC (short *, nvectors); @@ -924,12 +894,8 @@ output_actions (void) width = XCALLOC (short, nvectors); token_actions (); - free_shifts (); - free_reductions (); - XFREE (lookaheads); XFREE (LA); XFREE (LAruleno); - XFREE (accessing_symbol); goto_actions (); XFREE (goto_map + ntokens); @@ -938,38 +904,38 @@ output_actions (void) sort_actions (); pack_table (); - /* FIXME: See if this is useful. */ - /* obstack_1grow (&table_obstack, '\n'); */ + output_base (); output_table (); - /* FIXME: See if this is useful. */ - /* obstack_1grow (&table_obstack, '\n'); */ + output_check (); + + for (i = 0; i < nstates; ++i) + { + XFREE (state_table[i]->shifts); + XFREE (state_table[i]->reductions); + XFREE (state_table[i]->errs); + free (state_table[i]); + } + XFREE (state_table); } -/*------------------------------------------. -| Copy the parser code into TABLE_OBSTACK. | -`------------------------------------------*/ + +/*------------------------------------------------------------. +| Copy the parser code from SKEL_FILENAME into OOUT obstack. | +| and do the muscle substitution. | +`------------------------------------------------------------*/ static void -output_parser (void) +output_parser (const char *skel_filename, struct obstack *oout) { int c; FILE *fskel; size_t line; - int actions_dumped = 0; - /* Loop over lines in the standard parser file. */ - if (!skeleton) - { - if (semantic_parser) - skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY); - else - skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE); - } - fskel = xfopen (skeleton, "r"); + fskel = xfopen (skel_filename, "r"); - /* New output code. */ + /* New output code. */ line = 1; c = getc (fskel); while (c != EOF) @@ -978,120 +944,109 @@ output_parser (void) { if (c == '\n') ++line; - obstack_1grow (&table_obstack, c); + obstack_1grow (oout, c); c = getc (fskel); } else if ((c = getc (fskel)) == '%') { - /* Read the macro. */ - char* macro_key = 0; - char* macro_value = 0; - while (isalnum (c = getc (fskel)) || c == '_') - obstack_1grow (¯o_obstack, c); - obstack_1grow (¯o_obstack, 0); - - /* Output the right value, or see if it's something special. */ - macro_key = obstack_finish (¯o_obstack); - macro_value = macro_find (macro_key); - if (macro_value) - obstack_sgrow (&table_obstack, macro_value); - else if (!strcmp (macro_key, "line")) - obstack_fgrow1 (&table_obstack, "%d", line + 1); - else if (!strcmp (macro_key, "action")) - { - size_t size = obstack_object_size (&action_obstack); - obstack_grow (&table_obstack, - obstack_finish (&action_obstack), size); - } + /* Read the muscle. */ + const char *muscle_key = 0; + const char *muscle_value = 0; + + while (isalnum (c = getc (fskel)) || c == '-') + obstack_1grow (&muscle_obstack, c); + obstack_1grow (&muscle_obstack, 0); + + /* Output the right value, or see if it's something special. */ + muscle_key = obstack_finish (&muscle_obstack); + muscle_value = muscle_find (muscle_key); + if (muscle_value) + obstack_sgrow (oout, muscle_value); + else if (!strcmp (muscle_key, "line")) + obstack_fgrow1 (oout, "%d", line + 1); + else if (!strcmp (muscle_key, "input-line")) + obstack_fgrow1 (oout, "%d", lineno); else { - obstack_sgrow (&table_obstack, "%%"); - obstack_sgrow (&table_obstack, macro_key); + obstack_sgrow (oout, "%%"); + obstack_sgrow (oout, muscle_key); } } + else + obstack_1grow (oout, '%'); } - /* End. */ + /* End. */ xfclose (fskel); } -static void -output_program (void) -{ - int c; - - while ((c = getc (finput)) != EOF) - obstack_1grow (&table_obstack, c); -} - +/*----------------------------------------. +| Prepare the master parser to be output | +`----------------------------------------*/ static void -free_itemsets (void) +output_master_parser (void) { - core *cp, *cptmp; - - XFREE (state_table); - - for (cp = first_state; cp; cp = cptmp) + if (!skeleton) { - cptmp = cp->next; - XFREE (cp); + if (semantic_parser) + skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY); + else + skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE); } + muscle_insert ("skeleton", skeleton); + output_parser (skeleton, &table_obstack); } + /* FIXME. */ -#define MACRO_INSERT_INT(Key, Value) \ -{ \ - obstack_fgrow1 (¯o_obstack, "%d", Value); \ - obstack_1grow (¯o_obstack, 0); \ - macro_insert (Key, obstack_finish (¯o_obstack)); \ +#define MUSCLE_INSERT_INT(Key, Value) \ +{ \ + obstack_fgrow1 (&muscle_obstack, "%d", Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ } -#define MACRO_INSERT_STRING(Key, Value) \ -{ \ - obstack_sgrow (¯o_obstack, Value); \ - obstack_1grow (¯o_obstack, 0); \ - macro_insert (Key, obstack_finish (¯o_obstack)); \ +#define MUSCLE_INSERT_STRING(Key, Value) \ +{ \ + obstack_sgrow (&muscle_obstack, Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ } -#define MACRO_INSERT_PREFIX(Key, Value) \ +#define MUSCLE_INSERT_PREFIX(Key, Value) \ { \ - obstack_fgrow2 (¯o_obstack, "%s%s", spec_name_prefix, Value); \ - obstack_1grow (¯o_obstack, 0); \ - macro_insert (Key, obstack_finish (¯o_obstack)); \ + obstack_fgrow2 (&muscle_obstack, "%s%s", spec_name_prefix, Value); \ + obstack_1grow (&muscle_obstack, 0); \ + muscle_insert (Key, obstack_finish (&muscle_obstack)); \ } static void prepare (void) { - MACRO_INSERT_INT ("last", high); - MACRO_INSERT_INT ("flag", MINSHORT); - MACRO_INSERT_INT ("pure", pure_parser); - MACRO_INSERT_INT ("nsym", nsyms); - MACRO_INSERT_INT ("debug", debug_flag); - MACRO_INSERT_INT ("final", final_state); - MACRO_INSERT_INT ("maxtok", max_user_token_number); - MACRO_INSERT_INT ("ntbase", ntokens); - MACRO_INSERT_INT ("verbose", 0); - - MACRO_INSERT_STRING ("filename", infile); - - MACRO_INSERT_INT ("nnts", nvars); - MACRO_INSERT_INT ("nrules", nrules); - MACRO_INSERT_INT ("nstates", nstates); - MACRO_INSERT_INT ("ntokens", ntokens); - - if (spec_name_prefix) - { - MACRO_INSERT_PREFIX ("yylex", "lex"); - MACRO_INSERT_PREFIX ("yychar", "char"); - MACRO_INSERT_PREFIX ("yylval", "lval"); - MACRO_INSERT_PREFIX ("yydebug", "debug"); - MACRO_INSERT_PREFIX ("yyerror", "error"); - MACRO_INSERT_PREFIX ("yynerrs", "nerrs"); - MACRO_INSERT_PREFIX ("yyparse", "parse"); - } + MUSCLE_INSERT_INT ("last", high); + MUSCLE_INSERT_INT ("flag", MINSHORT); + MUSCLE_INSERT_INT ("pure", pure_parser); + MUSCLE_INSERT_INT ("nsym", nsyms); + 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); + + MUSCLE_INSERT_INT ("nnts", nvars); + MUSCLE_INSERT_INT ("nrules", nrules); + MUSCLE_INSERT_INT ("nstates", nstates); + MUSCLE_INSERT_INT ("ntokens", ntokens); + + MUSCLE_INSERT_INT ("locations-flag", locations_flag); + + /* We need to save the actions in the muscle %%action. */ + obstack_1grow (&action_obstack, 0); + muscle_insert ("action", obstack_finish (&action_obstack)); + } /*----------------------------------------------------------. @@ -1101,22 +1056,8 @@ prepare (void) void output (void) { - obstack_init (¯o_obstack); obstack_init (&output_obstack); -#if 0 - /* If using a simple parser the definition of YYSTYPE are put into - TABLE_OBSTACK. */ - if (!semantic_parser) - { - size_t size = obstack_object_size (&attrs_obstack); - obstack_grow (&table_obstack, obstack_finish (&attrs_obstack), size); - } -#endif - - /* reader_output_yylsp (&table_obstack); */ - free_itemsets (); - output_token_translations (); output_gram (); @@ -1124,13 +1065,20 @@ output (void) if (semantic_parser) output_stos (); output_rule_data (); + XFREE (user_toknums); output_actions (); - /* if (!no_parser_flag) */ +#if 0 + if (!no_parser_flag) */ +#endif prepare (); - output_parser (); - output_program (); + /* Copy definitions in directive. */ + obstack_1grow (&attrs_obstack, 0); + muscle_insert ("prologue", obstack_finish (&attrs_obstack)); + + output_master_parser (); - obstack_free (¯o_obstack, 0); + obstack_free (&muscle_obstack, 0); obstack_free (&output_obstack, 0); + obstack_free (&action_obstack, 0); }