X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/83ccf991a6b09a2f93e97dab936f6d3574e27d68..2e047461253970124582c3b9dca7322fd675e921:/src/output.c diff --git a/src/output.c b/src/output.c index f92b6646..02dfdb68 100644 --- a/src/output.c +++ b/src/output.c @@ -167,50 +167,56 @@ table_grow (size_t desired) } -/*------------------------------------------------------------------. -| Create a function NAME which Format the FIRST and then | -| TABLE_DATA[BEGIN..END[ (of TYPE) into OOUT, and return the number | -| of bits needed for its longuest value. | -`------------------------------------------------------------------*/ +/*-------------------------------------------------------------------. +| Create a function NAME which associates to the muscle NAME the | +| result of formatting the FIRST and then TABLE_DATA[BEGIN..END[ (of | +| TYPE), and to the muscle NAME_max, the max value of the | +| TABLE_DATA. | +`-------------------------------------------------------------------*/ -#define GENERATE_OUTPUT_TABLE(Name, Type) \ +#define GENERATE_MUSCLE_INSERT_TABLE(Name, Type) \ \ -static inline long int \ -Name (struct obstack *oout, \ +static void \ +Name (const char *name, \ Type *table_data, \ Type first, \ int begin, \ int end) \ { \ - long int max = first; \ + Type max = first; \ int i; \ int j = 1; \ \ - obstack_fgrow1 (oout, "%6d", first); \ + obstack_fgrow1 (&format_obstack, "%6d", first); \ for (i = begin; i < end; ++i) \ { \ - obstack_1grow (oout, ','); \ + obstack_1grow (&format_obstack, ','); \ if (j >= 10) \ { \ - obstack_sgrow (oout, "\n "); \ + obstack_sgrow (&format_obstack, "\n "); \ j = 1; \ } \ else \ ++j; \ - obstack_fgrow1 (oout, "%6d", table_data[i]); \ + obstack_fgrow1 (&format_obstack, "%6d", table_data[i]); \ if (table_data[i] > max) \ max = table_data[i]; \ } \ - obstack_1grow (oout, 0); \ + obstack_1grow (&format_obstack, 0); \ + muscle_insert (name, obstack_finish (&format_obstack)); \ \ - return max; \ + /* Build `NAME_max' in the obstack. */ \ + obstack_fgrow1 (&format_obstack, "%s_max", name); \ + obstack_1grow (&format_obstack, 0); \ + MUSCLE_INSERT_LONG_INT (obstack_finish (&format_obstack), \ + (long int) max); \ } -GENERATE_OUTPUT_TABLE(output_int_table, int) -GENERATE_OUTPUT_TABLE(output_short_table, short) -GENERATE_OUTPUT_TABLE(output_token_number_table, token_number_t) -GENERATE_OUTPUT_TABLE(output_item_number_table, item_number_t) +GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_unsigned_int_table, unsigned int) +GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_short_table, short) +GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_symbol_number_table, symbol_number_t) +GENERATE_MUSCLE_INSERT_TABLE(muscle_insert_item_number_table, item_number_t) /*-----------------------------------------------------------------. @@ -221,12 +227,9 @@ GENERATE_OUTPUT_TABLE(output_item_number_table, item_number_t) static void prepare_tokens (void) { - long int max = output_token_number_table (&format_obstack, - token_translations, - 0, 1, max_user_token_number + 1); - muscle_insert ("translate", obstack_finish (&format_obstack)); - MUSCLE_INSERT_LONG_INT ("token_number_max", max); - XFREE (token_translations); + muscle_insert_symbol_number_table ("translate", + token_translations, + 0, 1, max_user_token_number + 1); { int i; @@ -267,9 +270,8 @@ prepare_tokens (void) short *values = XCALLOC (short, ntokens + 1); for (i = 0; i < ntokens + 1; ++i) values[i] = symbols[i]->user_token_number; - output_short_table (&format_obstack, values, - 0, 1, ntokens + 1); - muscle_insert ("toknum", obstack_finish (&format_obstack)); + muscle_insert_short_table ("toknum", values, + 0, 1, ntokens + 1); free (values); } } @@ -283,18 +285,17 @@ prepare_tokens (void) static void prepare_rules (void) { - long int max; - item_number_t *rhsp; int r; - int i = 0; + unsigned int i = 0; item_number_t *rhs = XMALLOC (item_number_t, nritems); - short *prhs = XMALLOC (short, nrules + 1); - token_number_t *r1 = XMALLOC (token_number_t, nrules + 1); - short *r2 = XMALLOC (short, nrules + 1); - short *rline = XMALLOC (short, nrules + 1); + unsigned int *prhs = XMALLOC (unsigned int, nrules + 1); + unsigned int *rline = XMALLOC (unsigned int, nrules + 1); + symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules + 1); + unsigned int *r2 = XMALLOC (unsigned int, nrules + 1); for (r = 1; r < nrules + 1; ++r) { + item_number_t *rhsp; /* Index of rule R in RHS. */ prhs[r] = i; /* RHS of the rule R. */ @@ -311,24 +312,16 @@ prepare_rules (void) } assert (i == nritems); - max = output_int_table (&format_obstack, rhs, ritem[0], 1, nritems); - muscle_insert ("rhs", obstack_finish (&format_obstack)); - MUSCLE_INSERT_LONG_INT ("rhs_number_max", max); - - output_short_table (&format_obstack, prhs, 0, 1, nrules + 1); - muscle_insert ("prhs", obstack_finish (&format_obstack)); - - output_short_table (&format_obstack, rline, 0, 1, nrules + 1); - muscle_insert ("rline", obstack_finish (&format_obstack)); - - output_token_number_table (&format_obstack, r1, 0, 1, nrules + 1); - muscle_insert ("r1", obstack_finish (&format_obstack)); - - output_short_table (&format_obstack, r2, 0, 1, nrules + 1); - muscle_insert ("r2", obstack_finish (&format_obstack)); + muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems); + muscle_insert_unsigned_int_table ("prhs", prhs, 0, 1, nrules + 1); + muscle_insert_unsigned_int_table ("rline", rline, 0, 1, nrules + 1); + muscle_insert_symbol_number_table ("r1", r1, 0, 1, nrules + 1); + muscle_insert_unsigned_int_table ("r2", r2, 0, 1, nrules + 1); free (rhs); free (prhs); + free (rline); + free (r1); free (r2); } @@ -340,13 +333,12 @@ static void prepare_states (void) { size_t i; - token_number_t *values = - (token_number_t *) alloca (sizeof (token_number_t) * nstates); + symbol_number_t *values = + (symbol_number_t *) alloca (sizeof (symbol_number_t) * nstates); for (i = 0; i < nstates; ++i) values[i] = states[i]->accessing_symbol; - output_token_number_table (&format_obstack, values, - 0, 1, nstates); - muscle_insert ("stos", obstack_finish (&format_obstack)); + muscle_insert_symbol_number_table ("stos", values, + 0, 1, nstates); } @@ -398,7 +390,7 @@ action_row (state_t *state) to reduce. */ for (i = 0; i < shiftp->nshifts; i++) { - token_number_t symbol; + symbol_number_t symbol; int shift_state = shiftp->shifts[i]; if (!shift_state) continue; @@ -531,10 +523,8 @@ token_actions (void) save_row (i); } - output_short_table (&format_obstack, yydefact, - yydefact[0], 1, nstates); - muscle_insert ("defact", obstack_finish (&format_obstack)); - + muscle_insert_short_table ("defact", yydefact, + yydefact[0], 1, nstates); XFREE (actrow); XFREE (yydefact); } @@ -582,21 +572,25 @@ token_definitions_output (FILE *out) symbol_t *symbol = symbols[i]; int number = symbol->user_token_number; - if (number == SALIAS) - continue; + /* At this stage, if there are literal aliases, they are part of + SYMBOLS, so we should not find symbols which are the aliases + here. */ + assert (number != USER_NUMBER_ALIAS); + /* Skip error token. */ if (symbol == errtoken) continue; - if (symbol->tag[0] == '\'') - continue; /* skip literal character */ - if (symbol->tag[0] == '\"') - { - /* use literal string only if given a symbol with an alias */ - if (symbol->alias) - symbol = symbol->alias; - else - continue; - } + + /* If this string has an alias, then it is necessarily the alias + which is to be output. */ + if (symbol->alias) + symbol = symbol->alias; + + /* Don't output literal chars or strings (when defined only as a + string). Note that must be done after the alias resolution: + think about `%token 'f' "f"'. */ + if (symbol->tag[0] == '\'' || symbol->tag[0] == '\"') + continue; /* Don't #define nonliteral tokens whose names contain periods or '$' (as does the default value of the EOF token). */ @@ -605,6 +599,7 @@ token_definitions_output (FILE *out) fprintf (out, "%s[[[%s]], [%d]]", first ? "" : ",\n", symbol->tag, number); + first = 0; } } @@ -697,10 +692,8 @@ goto_actions (void) yydefgoto[i - ntokens] = default_state; } - output_short_table (&format_obstack, yydefgoto, - yydefgoto[0], 1, nsyms - ntokens); - muscle_insert ("defgoto", obstack_finish (&format_obstack)); - + muscle_insert_short_table ("defgoto", yydefgoto, + yydefgoto[0], 1, nsyms - ntokens); XFREE (state_count); XFREE (yydefgoto); } @@ -882,15 +875,12 @@ static void output_base (void) { /* Output pact. */ - output_short_table (&format_obstack, base, - base[0], 1, nstates); - muscle_insert ("pact", obstack_finish (&format_obstack)); + muscle_insert_short_table ("pact", base, + base[0], 1, nstates); /* Output pgoto. */ - output_short_table (&format_obstack, base, - base[nstates], nstates + 1, nvectors); - muscle_insert ("pgoto", obstack_finish (&format_obstack)); - + muscle_insert_short_table ("pgoto", base, + base[nstates], nstates + 1, nvectors); XFREE (base); } @@ -898,9 +888,8 @@ output_base (void) static void output_table (void) { - output_short_table (&format_obstack, table, - table[0], 1, high + 1); - muscle_insert ("table", obstack_finish (&format_obstack)); + muscle_insert_short_table ("table", table, + table[0], 1, high + 1); XFREE (table); } @@ -908,9 +897,8 @@ output_table (void) static void output_check (void) { - output_short_table (&format_obstack, check, - check[0], 1, high + 1); - muscle_insert ("check", obstack_finish (&format_obstack)); + muscle_insert_short_table ("check", check, + check[0], 1, high + 1); XFREE (check); } @@ -1006,20 +994,30 @@ output_skeleton (void) { const char *bison_pkgdatadir = getenv ("BISON_PKGDATADIR"); const char *m4 = getenv ("M4"); + int pkg_data_len; + char *full_skeleton; + if (!m4) m4 = M4; if (!bison_pkgdatadir) bison_pkgdatadir = PKGDATADIR; + pkg_data_len = strlen (bison_pkgdatadir); + full_skeleton = XMALLOC (char, pkg_data_len + strlen (skeleton) + 2); + if (bison_pkgdatadir[pkg_data_len-1] == '/') + sprintf (full_skeleton, "%s%s", bison_pkgdatadir, skeleton); + else + sprintf (full_skeleton, "%s/%s", bison_pkgdatadir, skeleton); if (trace_flag) fprintf (stderr, "running: %s -I %s m4sugar/m4sugar.m4 %s %s\n", - m4, bison_pkgdatadir, tempfile, skeleton); + m4, bison_pkgdatadir, tempfile, full_skeleton); skel_in = readpipe (m4, "-I", bison_pkgdatadir, "m4sugar/m4sugar.m4", tempfile, - skeleton, + full_skeleton, NULL); + XFREE (full_skeleton); if (!skel_in) error (EXIT_FAILURE, errno, "cannot run m4"); skel_lex ();