X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/8adfa272f72683102c45cc6eaba00aaa5db2497a..366eea36d3a9aaccf80a78c2fcd8c3cd6b563e25:/src/print.c?ds=sidebyside diff --git a/src/print.c b/src/print.c index 648e3e6c..b0ff76ed 100644 --- a/src/print.c +++ b/src/print.c @@ -1,5 +1,6 @@ /* Print information on generated parser, for bison, - Copyright 1984, 1986, 1989, 2000, 2001 Free Software Foundation, Inc. + Copyright (C) 1984, 1986, 1989, 2000, 2001, 2002 + Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -22,6 +23,7 @@ #include "system.h" #include "quotearg.h" #include "files.h" +#include "symtab.h" #include "gram.h" #include "LR0.h" #include "lalr.h" @@ -32,9 +34,10 @@ #include "print.h" #include "reduce.h" #include "closure.h" +#include "bitset.h" -static unsigned *shiftset = NULL; -static unsigned *lookaheadset = NULL; +static bitset shiftset; +static bitset lookaheadset; #if 0 static void @@ -44,19 +47,6 @@ print_token (int extnum, int token) } #endif -static inline const char * -escape (const char *s) -{ - return quotearg_n_style (1, escape_quoting_style, s); -} - -/* Be cautious not to use twice the same slot in a single expression. */ -static inline const char * -escape2 (const char *s) -{ - return quotearg_n_style (2, escape_quoting_style, s); -} - /*--------------------------------. | Report information on a state. | @@ -66,43 +56,46 @@ static void print_core (FILE *out, state_t *state) { int i; - short *sitems = state->items; - int snitems = state->nitems; + item_number_t *sitems = state->items; + int snritems = state->nitems; - /* New experimental feature: if TRACE_FLAGS output all the items of - a state, not only its kernel. */ - if (trace_flag) + /* Output all the items of a state, not only its kernel. */ + if (report_flag & report_itemsets) { - closure (sitems, snitems); + closure (sitems, snritems); sitems = itemset; - snitems = nitemset; + snritems = nritemset; } - if (snitems) + if (snritems) { - for (i = 0; i < snitems; i++) + for (i = 0; i < snritems; i++) { - short *sp; - short *sp1; + item_number_t *sp; + item_number_t *sp1; int rule; sp1 = sp = ritem + sitems[i]; - while (*sp > 0) + while (*sp >= 0) sp++; rule = -(*sp); - fprintf (out, " %s -> ", escape (tags[rule_table[rule].lhs])); + fprintf (out, " %s -> ", symbol_tag_get (rules[rule].lhs)); - for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++) - fprintf (out, "%s ", escape (tags[*sp])); + for (sp = rules[rule].rhs; sp < sp1; sp++) + fprintf (out, "%s ", symbol_tag_get (symbols[*sp])); fputc ('.', out); - for (/* Nothing */; *sp > 0; ++sp) - fprintf (out, " %s", escape (tags[*sp])); + for (/* Nothing */; *sp >= 0; ++sp) + fprintf (out, " %s", symbol_tag_get (symbols[*sp])); - fprintf (out, _(" (rule %d)"), rule); + /* Display the lookaheads? */ + if (report_flag & report_lookaheads) + state_rule_lookaheads_print (state, &rules[rule], out); + + fprintf (out, _(" (rule %d)"), rule - 1); fputc ('\n', out); } @@ -121,10 +114,10 @@ print_shifts (FILE *out, state_t *state) if (!SHIFT_IS_DISABLED (shiftp, i)) { int state1 = shiftp->shifts[i]; - int symbol = state_table[state1]->accessing_symbol; + symbol_number_t symbol = states[state1]->accessing_symbol; fprintf (out, _(" %-4s\tshift, and go to state %d\n"), - escape (tags[symbol]), state1); + symbol_tag_get (symbols[symbol]), state1); } if (i > 0) @@ -141,7 +134,7 @@ print_errs (FILE *out, state_t *state) for (i = 0; i < errp->nerrs; ++i) if (errp->errs[i]) fprintf (out, _(" %-4s\terror (nonassociative)\n"), - escape (tags[errp->errs[i]])); + symbol_tag_get (symbols[errp->errs[i]])); if (i > 0) fputc ('\n', out); @@ -163,9 +156,9 @@ print_gotos (FILE *out, state_t *state) if (!SHIFT_IS_DISABLED (shiftp, i)) { int state1 = shiftp->shifts[i]; - int symbol = state_table[state1]->accessing_symbol; + symbol_number_t symbol = states[state1]->accessing_symbol; fprintf (out, _(" %-4s\tgo to state %d\n"), - escape (tags[symbol]), state1); + symbol_tag_get (symbols[symbol]), state1); } fputc ('\n', out); @@ -187,14 +180,13 @@ print_reductions (FILE *out, state_t *state) if (state->consistent) { int rule = redp->rules[0]; - int symbol = rule_table[rule].lhs; + symbol_number_t symbol = rules[rule].lhs->number; fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"), - rule, escape (tags[symbol])); + rule - 1, symbol_tag_get (symbols[symbol])); return; } - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; + bitset_zero (shiftset); for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) if (!SHIFT_IS_DISABLED (shiftp, i)) @@ -203,112 +195,108 @@ print_reductions (FILE *out, state_t *state) default rule. */ if (SHIFT_IS_ERROR (shiftp, i)) nodefault = 1; - SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); + bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i)); } for (i = 0; i < errp->nerrs; i++) if (errp->errs[i]) - SETBIT (shiftset, errp->errs[i]); + bitset_set (shiftset, errp->errs[i]); if (state->nlookaheads == 1 && !nodefault) { - int k; - int default_rule = LAruleno[state->lookaheadsp]; + rule_t *default_rule = state->lookaheads_rule[0]; - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] = LA (state->lookaheadsp)[k] & shiftset[k]; + bitset_and (lookaheadset, state->lookaheads[0], shiftset); for (i = 0; i < ntokens; i++) - if (BITISSET (lookaheadset, i)) + if (bitset_test (lookaheadset, i)) fprintf (out, _(" %-4s\t[reduce using rule %d (%s)]\n"), - escape (tags[i]), default_rule, - escape2 (tags[rule_table[default_rule].lhs])); + symbol_tag_get (symbols[i]), + default_rule->number - 1, + symbol_tag_get_n (default_rule->lhs, 1)); fprintf (out, _(" $default\treduce using rule %d (%s)\n\n"), - default_rule, escape (tags[rule_table[default_rule].lhs])); + default_rule->number - 1, + symbol_tag_get (default_rule->lhs)); } else if (state->nlookaheads >= 1) { int cmax = 0; int default_LA = -1; - int default_rule = 0; + rule_t *default_rule = NULL; if (!nodefault) for (i = 0; i < state->nlookaheads; ++i) { int count = 0; - int j, k; + int j; - for (k = 0; k < tokensetsize; ++k) - lookaheadset[k] = LA (state->lookaheadsp + i)[k] & ~shiftset[k]; + bitset_andn (lookaheadset, state->lookaheads[i], shiftset); for (j = 0; j < ntokens; j++) - if (BITISSET (lookaheadset, j)) + if (bitset_test (lookaheadset, j)) count++; if (count > cmax) { cmax = count; - default_LA = state->lookaheadsp + i; - default_rule = LAruleno[state->lookaheadsp + i]; + default_LA = i; + default_rule = state->lookaheads_rule[i]; } - for (k = 0; k < tokensetsize; ++k) - shiftset[k] |= lookaheadset[k]; + bitset_or (shiftset, shiftset, lookaheadset); } - for (i = 0; i < tokensetsize; i++) - shiftset[i] = 0; + bitset_zero (shiftset); for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++) if (!SHIFT_IS_DISABLED (shiftp, i)) - SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i)); + bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i)); for (i = 0; i < ntokens; i++) { int j; int defaulted = 0; - int count = BITISSET (shiftset, i); + int count = bitset_test (shiftset, i); for (j = 0; j < state->nlookaheads; ++j) - { - if (BITISSET (LA (state->lookaheadsp + j), i)) - { - if (count == 0) - { - if (state->lookaheadsp + j != default_LA) - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - escape (tags[i]), - LAruleno[state->lookaheadsp + j], - escape2 (tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs])); - else - defaulted = 1; - - count++; - } - else - { - if (defaulted) - fprintf (out, - _(" %-4s\treduce using rule %d (%s)\n"), - escape (tags[i]), - LAruleno[default_LA], - escape2 (tags[rule_table[LAruleno[default_LA]].lhs])); - defaulted = 0; + if (bitset_test (state->lookaheads[j], i)) + { + if (count == 0) + { + if (j != default_LA) fprintf (out, - _(" %-4s\t[reduce using rule %d (%s)]\n"), - escape (tags[i]), - LAruleno[state->lookaheadsp + j], - escape2 (tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs])); - } - } - } + _(" %-4s\treduce using rule %d (%s)\n"), + symbol_tag_get (symbols[i]), + state->lookaheads_rule[j]->number - 1, + symbol_tag_get_n (state->lookaheads_rule[j]->lhs, 1)); + else + defaulted = 1; + + count++; + } + else + { + if (defaulted) + fprintf (out, + _(" %-4s\treduce using rule %d (%s)\n"), + symbol_tag_get (symbols[i]), + state->lookaheads_rule[default_LA]->number - 1, + symbol_tag_get_n (state->lookaheads_rule[default_LA]->lhs, 1)); + defaulted = 0; + fprintf (out, + _(" %-4s\t[reduce using rule %d (%s)]\n"), + symbol_tag_get (symbols[i]), + state->lookaheads_rule[j]->number - 1, + symbol_tag_get_n (state->lookaheads_rule[j]->lhs, 1)); + } + } } if (default_LA >= 0) fprintf (out, _(" $default\treduce using rule %d (%s)\n"), - default_rule, escape (tags[rule_table[default_rule].lhs])); + default_rule->number - 1, + symbol_tag_get (default_rule->lhs)); } } @@ -322,9 +310,9 @@ print_actions (FILE *out, state_t *state) if (shiftp->nshifts == 0 && redp->nreds == 0) { if (final_state == state->number) - fprintf (out, _(" $default\taccept\n")); + fprintf (out, _(" $default\taccept\n")); else - fprintf (out, _(" NO ACTIONS\n")); + fprintf (out, _(" NO ACTIONS\n")); return; } @@ -341,6 +329,9 @@ print_state (FILE *out, state_t *state) fputs ("\n\n", out); print_core (out, state); print_actions (out, state); + if ((report_flag & report_solved_conflicts) + && state->solved_conflicts) + fputs (state->solved_conflicts, out); fputs ("\n\n", out); } @@ -362,50 +353,32 @@ do { \ static void print_grammar (FILE *out) { - int i, j; - short *rule; + symbol_number_t i; + item_number_t *rule; char buffer[90]; int column = 0; - /* rule # : LHS -> RHS */ - fprintf (out, "%s\n\n", _("Grammar")); - fprintf (out, " %s\n", _("Number, Line, Rule")); - for (i = 1; i <= nrules; i++) - /* Don't print rules disabled in reduce_grammar_tables. */ - if (rule_table[i].useful) - { - fprintf (out, _(" %3d %3d %s ->"), - i, rule_table[i].line, escape (tags[rule_table[i].lhs])); - rule = &ritem[rule_table[i].rhs]; - if (*rule > 0) - while (*rule > 0) - fprintf (out, " %s", escape (tags[*rule++])); - else - fprintf (out, " /* %s */", _("empty")); - fputc ('\n', out); - } - fputs ("\n\n", out); - + grammar_rules_print (out); /* TERMINAL (type #) : rule #s terminal is on RHS */ fprintf (out, "%s\n\n", _("Terminals, with rules where they appear")); - fprintf (out, "%s (-1)\n", escape (tags[0])); - - for (i = 0; i <= max_user_token_number; i++) - if (token_translations[i] != 2) + for (i = 0; i < max_user_token_number + 1; i++) + if (token_translations[i] != undeftoken->number) { + const char *tag = symbol_tag_get (symbols[token_translations[i]]); + int r; buffer[0] = 0; - column = strlen (escape (tags[token_translations[i]])); - fputs (escape (tags[token_translations[i]]), out); + column = strlen (tag); + fputs (tag, out); END_TEST (50); sprintf (buffer, " (%d)", i); - for (j = 1; j <= nrules; j++) - for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++) - if (*rule == token_translations[i]) + for (r = 1; r < nrules + 1; r++) + for (rule = rules[r].rhs; *rule >= 0; rule++) + if (item_number_as_symbol_number (*rule) == token_translations[i]) { END_TEST (65); - sprintf (buffer + strlen (buffer), " %d", j); + sprintf (buffer + strlen (buffer), " %d", r - 1); break; } fprintf (out, "%s\n", buffer); @@ -414,16 +387,18 @@ print_grammar (FILE *out) fprintf (out, "%s\n\n", _("Nonterminals, with rules where they appear")); - for (i = ntokens; i <= nsyms - 1; i++) + for (i = ntokens; i < nsyms; i++) { int left_count = 0, right_count = 0; + int r; + const char *tag = symbol_tag_get (symbols[i]); - for (j = 1; j <= nrules; j++) + for (r = 1; r < nrules + 1; r++) { - if (rule_table[j].lhs == i) + if (rules[r].lhs->number == i) left_count++; - for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++) - if (*rule == i) + for (rule = rules[r].rhs; *rule >= 0; rule++) + if (item_number_as_symbol_number (*rule) == i) { right_count++; break; @@ -431,8 +406,8 @@ print_grammar (FILE *out) } buffer[0] = 0; - fputs (escape (tags[i]), out); - column = strlen (escape (tags[i])); + fputs (tag, out); + column = strlen (tag); sprintf (buffer, " (%d)", i); END_TEST (0); @@ -441,11 +416,11 @@ print_grammar (FILE *out) END_TEST (50); sprintf (buffer + strlen (buffer), _(" on left:")); - for (j = 1; j <= nrules; j++) + for (r = 1; r < nrules + 1; r++) { END_TEST (65); - if (rule_table[j].lhs == i) - sprintf (buffer + strlen (buffer), " %d", j); + if (rules[r].lhs->number == i) + sprintf (buffer + strlen (buffer), " %d", r - 1); } } @@ -455,13 +430,13 @@ print_grammar (FILE *out) sprintf (buffer + strlen (buffer), ","); END_TEST (50); sprintf (buffer + strlen (buffer), _(" on right:")); - for (j = 1; j <= nrules; j++) + for (r = 1; r < nrules + 1; r++) { - for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++) - if (*rule == i) + for (rule = rules[r].rhs; *rule >= 0; rule++) + if (item_number_as_symbol_number (*rule) == i) { END_TEST (65); - sprintf (buffer + strlen (buffer), " %d", j); + sprintf (buffer + strlen (buffer), " %d", r - 1); break; } } @@ -474,37 +449,29 @@ print_grammar (FILE *out) void print_results (void) { - int i; + size_t i; /* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but that conflicts with Posix. */ FILE *out = xfopen (spec_verbose_file, "w"); - size_t size = obstack_object_size (&output_obstack); - fwrite (obstack_finish (&output_obstack), 1, size, out); - obstack_free (&output_obstack, NULL); - - if (size) - fputs ("\n\n", out); - reduce_output (out); conflicts_output (out); print_grammar (out); - /* New experimental feature: output all the items of a state, not - only its kernel. Requires to run closure, which need memory - allocation/deallocation. */ - if (trace_flag) - new_closure (nitems); + /* If the whole state item sets, not only the kernels, are wanted, + `closure' will be run, which needs memory allocation/deallocation. */ + if (report_flag & report_itemsets) + new_closure (nritems); /* Storage for print_reductions. */ - shiftset = XCALLOC (unsigned, tokensetsize); - lookaheadset = XCALLOC (unsigned, tokensetsize); + shiftset = bitset_create (ntokens, BITSET_FIXED); + lookaheadset = bitset_create (ntokens, BITSET_FIXED); for (i = 0; i < nstates; i++) - print_state (out, state_table[i]); - free (shiftset); - free (lookaheadset); - if (trace_flag) + print_state (out, states[i]); + bitset_free (shiftset); + bitset_free (lookaheadset); + if (report_flag & report_itemsets) free_closure (); xfclose (out);