X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/07a58c1301a1131f7505e74f1d54bfdb31d193f5..782e8187185a009ce698ad294c87e49a0a30c3a1:/src/print.c diff --git a/src/print.c b/src/print.c index bf3fce87..e3795a94 100644 --- a/src/print.c +++ b/src/print.c @@ -1,361 +1,529 @@ /* Print information on generated parser, for bison, - Copyright (C) 1984, 1986, 1989, 2000 Free Software Foundation, Inc. + + Copyright (C) 1984, 1986, 1989, 2000-2005, 2007, 2009-2012 Free + Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. - Bison is free software; you can redistribute it and/or modify + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - Bison is distributed in the hope that it will be useful, + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with Bison; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - + along with this program. If not, see . */ +#include #include "system.h" -#include "alloc.h" + +#include + +#include "LR0.h" +#include "closure.h" +#include "conflicts.h" #include "files.h" +#include "getargs.h" #include "gram.h" -#include "state.h" #include "lalr.h" -#include "conflicts.h" -#include "getargs.h" +#include "muscle-tab.h" +#include "print.h" +#include "reader.h" +#include "reduce.h" #include "state.h" +#include "symtab.h" +#include "tables.h" -extern char **tags; -extern int final_state; +static bitset no_reduce_set; #if 0 static void print_token (int extnum, int token) { - fprintf (foutput, _(" type %d is %s\n"), extnum, tags[token]); + fprintf (out, _(" type %d is %s\n"), extnum, tags[token]); } #endif -/*================================\ + +/*---------------------------------------. +| *WIDTH := max (*WIDTH, strlen (STR)). | +`---------------------------------------*/ + +static void +max_length (size_t *width, const char *str) +{ + size_t len = strlen (str); + if (len > *width) + *width = len; +} + +/*--------------------------------. | Report information on a state. | -\================================*/ +`--------------------------------*/ static void -print_core (int state) +print_core (FILE *out, state *s) { - int i; - int k; - int rule; - core *statep; - short *sp; - short *sp1; + size_t i; + item_number *sitems = s->items; + size_t snritems = s->nitems; + symbol *previous_lhs = NULL; - statep = state_table[state]; - k = statep->nitems; + /* Output all the items of a state, not only its kernel. */ + if (report_flag & report_itemsets) + { + closure (sitems, snritems); + sitems = itemset; + snritems = nitemset; + } - if (k == 0) + if (!snritems) return; - for (i = 0; i < k; i++) + fputc ('\n', out); + + for (i = 0; i < snritems; i++) { - sp1 = sp = ritem + statep->items[i]; + item_number *sp; + item_number *sp1; + rule_number r; - while (*sp > 0) - sp++; + sp1 = sp = ritem + sitems[i]; - rule = -(*sp); - fprintf (foutput, " %s -> ", tags[rlhs[rule]]); + while (*sp >= 0) + sp++; - for (sp = ritem + rrhs[rule]; sp < sp1; sp++) - { - fprintf (foutput, "%s ", tags[*sp]); - } + r = item_number_as_rule_number (*sp); - putc ('.', foutput); + rule_lhs_print (&rules[r], previous_lhs, out); + previous_lhs = rules[r].lhs; - while (*sp > 0) - { - fprintf (foutput, " %s", tags[*sp]); - sp++; - } + for (sp = rules[r].rhs; sp < sp1; sp++) + fprintf (out, " %s", symbols[*sp]->tag); + fputs (" .", out); + for (/* Nothing */; *sp >= 0; ++sp) + fprintf (out, " %s", symbols[*sp]->tag); - fprintf (foutput, _(" (rule %d)"), rule); - putc ('\n', foutput); + /* Display the lookahead tokens? */ + if (report_flag & report_lookahead_tokens + && item_number_is_rule_number (*sp1)) + state_rule_lookahead_tokens_print (s, &rules[r], out); + + fputc ('\n', out); } +} + + +/*------------------------------------------------------------. +| Report the shifts iff DISPLAY_SHIFTS_P or the gotos of S on | +| OUT. | +`------------------------------------------------------------*/ + +static void +print_transitions (state *s, FILE *out, bool display_transitions_p) +{ + transitions *trans = s->transitions; + size_t width = 0; + int i; + + /* Compute the width of the lookahead token column. */ + for (i = 0; i < trans->num; i++) + if (!TRANSITION_IS_DISABLED (trans, i) + && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p) + { + symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)]; + max_length (&width, sym->tag); + } + + /* Nothing to report. */ + if (!width) + return; - putc ('\n', foutput); + fputc ('\n', out); + width += 2; + + /* Report lookahead tokens and shifts. */ + for (i = 0; i < trans->num; i++) + if (!TRANSITION_IS_DISABLED (trans, i) + && TRANSITION_IS_SHIFT (trans, i) == display_transitions_p) + { + symbol *sym = symbols[TRANSITION_SYMBOL (trans, i)]; + const char *tag = sym->tag; + state *s1 = trans->states[i]; + int j; + + fprintf (out, " %s", tag); + for (j = width - strlen (tag); j > 0; --j) + fputc (' ', out); + if (display_transitions_p) + fprintf (out, _("shift, and go to state %d\n"), s1->number); + else + fprintf (out, _("go to state %d\n"), s1->number); + } } + +/*--------------------------------------------------------. +| Report the explicit errors of S raised from %nonassoc. | +`--------------------------------------------------------*/ + static void -print_actions (int state) +print_errs (FILE *out, state *s) { + errs *errp = s->errs; + size_t width = 0; int i; - int k; - int state1; - int symbol; - shifts *shiftp; - errs *errp; - reductions *redp; - int rule; - - shiftp = shift_table[state]; - redp = reduction_table[state]; - errp = err_table[state]; - - if (!shiftp && !redp) - { - if (final_state == state) - fprintf (foutput, _(" $default\taccept\n")); - else - fprintf (foutput, _(" NO ACTIONS\n")); - return; - } - if (shiftp) - { - k = shiftp->nshifts; - - for (i = 0; i < k; i++) - { - if (!shiftp->shifts[i]) - continue; - state1 = shiftp->shifts[i]; - symbol = accessing_symbol[state1]; - /* The following line used to be turned off. */ - if (ISVAR (symbol)) - break; - if (symbol == 0) /* I.e. strcmp(tags[symbol],"$")==0 */ - fprintf (foutput, _(" $ \tgo to state %d\n"), state1); - else - fprintf (foutput, _(" %-4s\tshift, and go to state %d\n"), - tags[symbol], state1); - } - - if (i > 0) - putc ('\n', foutput); - } + /* Compute the width of the lookahead token column. */ + for (i = 0; i < errp->num; ++i) + if (errp->symbols[i]) + max_length (&width, errp->symbols[i]->tag); + + /* Nothing to report. */ + if (!width) + return; + + fputc ('\n', out); + width += 2; + + /* Report lookahead tokens and errors. */ + for (i = 0; i < errp->num; ++i) + if (errp->symbols[i]) + { + const char *tag = errp->symbols[i]->tag; + int j; + fprintf (out, " %s", tag); + for (j = width - strlen (tag); j > 0; --j) + fputc (' ', out); + fputs (_("error (nonassociative)\n"), out); + } +} + + +/*-------------------------------------------------------------------------. +| Report a reduction of RULE on LOOKAHEAD_TOKEN (which can be `default'). | +| If not ENABLED, the rule is masked by a shift or a reduce (S/R and | +| R/R conflicts). | +`-------------------------------------------------------------------------*/ + +static void +print_reduction (FILE *out, size_t width, + const char *lookahead_token, + rule *r, bool enabled) +{ + int j; + fprintf (out, " %s", lookahead_token); + for (j = width - strlen (lookahead_token); j > 0; --j) + fputc (' ', out); + if (!enabled) + fputc ('[', out); + if (r->number) + fprintf (out, _("reduce using rule %d (%s)"), r->number, r->lhs->tag); else - { - i = 0; - k = 0; - } + fprintf (out, _("accept")); + if (!enabled) + fputc (']', out); + fputc ('\n', out); +} - if (errp) - { - int j, nerrs; - nerrs = errp->nerrs; +/*-------------------------------------------. +| Report on OUT the reduction actions of S. | +`-------------------------------------------*/ - for (j = 0; j < nerrs; j++) - { - if (!errp->errs[j]) - continue; - symbol = errp->errs[j]; - fprintf (foutput, _(" %-4s\terror (nonassociative)\n"), - tags[symbol]); - } +static void +print_reductions (FILE *out, state *s) +{ + transitions *trans = s->transitions; + reductions *reds = s->reductions; + rule *default_reduction = NULL; + size_t width = 0; + int i, j; + bool default_reduction_only = true; - if (j > 0) - putc ('\n', foutput); - } + if (reds->num == 0) + return; - if (consistent[state] && redp) - { - rule = redp->rules[0]; - symbol = rlhs[rule]; - fprintf (foutput, _(" $default\treduce using rule %d (%s)\n\n"), - rule, tags[symbol]); - } - else if (redp) - { - print_reductions (state); - } + if (yydefact[s->number] != 0) + default_reduction = &rules[yydefact[s->number] - 1]; + + bitset_zero (no_reduce_set); + FOR_EACH_SHIFT (trans, i) + bitset_set (no_reduce_set, TRANSITION_SYMBOL (trans, i)); + for (i = 0; i < s->errs->num; ++i) + if (s->errs->symbols[i]) + bitset_set (no_reduce_set, s->errs->symbols[i]->number); + + /* Compute the width of the lookahead token column. */ + if (default_reduction) + width = strlen (_("$default")); + + if (reds->lookahead_tokens) + for (i = 0; i < ntokens; i++) + { + bool count = bitset_test (no_reduce_set, i); + + for (j = 0; j < reds->num; ++j) + if (bitset_test (reds->lookahead_tokens[j], i)) + { + if (! count) + { + if (reds->rules[j] != default_reduction) + max_length (&width, symbols[i]->tag); + count = true; + } + else + { + max_length (&width, symbols[i]->tag); + } + } + } + + /* Nothing to report. */ + if (!width) + return; + + fputc ('\n', out); + width += 2; - if (i < k) + /* Report lookahead tokens (or $default) and reductions. */ + if (reds->lookahead_tokens) + for (i = 0; i < ntokens; i++) + { + bool defaulted = false; + bool count = bitset_test (no_reduce_set, i); + if (count) + default_reduction_only = false; + + for (j = 0; j < reds->num; ++j) + if (bitset_test (reds->lookahead_tokens[j], i)) + { + if (! count) + { + if (reds->rules[j] != default_reduction) + { + default_reduction_only = false; + print_reduction (out, width, + symbols[i]->tag, + reds->rules[j], true); + } + else + defaulted = true; + count = true; + } + else + { + default_reduction_only = false; + if (defaulted) + print_reduction (out, width, + symbols[i]->tag, + default_reduction, true); + defaulted = false; + print_reduction (out, width, + symbols[i]->tag, + reds->rules[j], false); + } + } + } + + if (default_reduction) { - for (; i < k; i++) - { - if (!shiftp->shifts[i]) - continue; - state1 = shiftp->shifts[i]; - symbol = accessing_symbol[state1]; - fprintf (foutput, _(" %-4s\tgo to state %d\n"), tags[symbol], - state1); - } - - putc ('\n', foutput); + char *default_reductions = + muscle_percent_define_get ("lr.default-reductions"); + print_reduction (out, width, _("$default"), default_reduction, true); + aver (STREQ (default_reductions, "most") + || (STREQ (default_reductions, "consistent") + && default_reduction_only) + || (reds->num == 1 && reds->rules[0]->number == 0)); + free (default_reductions); } } + +/*--------------------------------------------------------------. +| Report on OUT all the actions (shifts, gotos, reductions, and | +| explicit erros from %nonassoc) of S. | +`--------------------------------------------------------------*/ + +static void +print_actions (FILE *out, state *s) +{ + /* Print shifts. */ + print_transitions (s, out, true); + print_errs (out, s); + print_reductions (out, s); + /* Print gotos. */ + print_transitions (s, out, false); +} + + +/*----------------------------------. +| Report all the data on S on OUT. | +`----------------------------------*/ + static void -print_state (int state) +print_state (FILE *out, state *s) { - fprintf (foutput, _("\n\nstate %d\n\n"), state); - print_core (state); - print_actions (state); + fputs ("\n\n", out); + fprintf (out, _("state %d"), s->number); + fputc ('\n', out); + print_core (out, s); + print_actions (out, s); + if ((report_flag & report_solved_conflicts) && s->solved_conflicts) + { + fputc ('\n', out); + fputs (s->solved_conflicts, out); + } } /*-----------------------------------------. | Print information on the whole grammar. | `-----------------------------------------*/ -#define END_TEST(end) \ - do { \ - if (column + strlen(buffer) > (end)) { \ - fprintf (foutput, "%s\n ", buffer); \ - column = 3; \ - buffer[0] = 0; \ - } \ +#define END_TEST(End) \ + do { \ + if (column + strlen (buffer) > (End)) \ + { \ + fprintf (out, "%s\n ", buffer); \ + column = 3; \ + buffer[0] = 0; \ + } \ } while (0) static void -print_grammar (void) +print_grammar (FILE *out) { - int i, j; - short *rule; + symbol_number i; char buffer[90]; int column = 0; - /* rule # : LHS -> RHS */ - fputs (_("\nGrammar\n"), foutput); - for (i = 1; i <= nrules; i++) - /* Don't print rules disabled in reduce_grammar_tables. */ - if (rlhs[i] >= 0) - { - fprintf (foutput, _("rule %-4d %s ->"), i, tags[rlhs[i]]); - rule = &ritem[rrhs[i]]; - if (*rule > 0) - while (*rule > 0) - fprintf (foutput, " %s", tags[*rule++]); - else - fputs (_(" /* empty */"), foutput); - putc ('\n', foutput); - } + grammar_rules_print (out); /* TERMINAL (type #) : rule #s terminal is on RHS */ - fputs (_("\nTerminals, with rules where they appear\n\n"), foutput); - fprintf (foutput, "%s (-1)\n", tags[0]); - if (translations) - { - for (i = 0; i <= max_user_token_number; i++) - if (token_translations[i] != 2) - { - buffer[0] = 0; - column = strlen (tags[token_translations[i]]); - fprintf (foutput, "%s", tags[token_translations[i]]); - END_TEST (50); - sprintf (buffer, " (%d)", i); - - for (j = 1; j <= nrules; j++) - { - for (rule = &ritem[rrhs[j]]; *rule > 0; rule++) - if (*rule == token_translations[i]) - { - END_TEST (65); - sprintf (buffer + strlen (buffer), " %d", j); - break; - } - } - fprintf (foutput, "%s\n", buffer); - } - } - else - for (i = 1; i < ntokens; i++) + fprintf (out, "%s\n\n", _("Terminals, with rules where they appear")); + for (i = 0; i < max_user_token_number + 1; i++) + if (token_translations[i] != undeftoken->number) { - buffer[0] = 0; - column = strlen (tags[i]); - fprintf (foutput, "%s", tags[i]); - END_TEST (50); - sprintf (buffer, " (%d)", i); - - for (j = 1; j <= nrules; j++) - { - for (rule = &ritem[rrhs[j]]; *rule > 0; rule++) - if (*rule == i) - { - END_TEST (65); - sprintf (buffer + strlen (buffer), " %d", j); - break; - } - } - fprintf (foutput, "%s\n", buffer); + const char *tag = symbols[token_translations[i]]->tag; + rule_number r; + item_number *rhsp; + + buffer[0] = 0; + column = strlen (tag); + fputs (tag, out); + END_TEST (65); + sprintf (buffer, " (%d)", i); + + for (r = 0; r < nrules; r++) + for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++) + if (item_number_as_symbol_number (*rhsp) == token_translations[i]) + { + END_TEST (65); + sprintf (buffer + strlen (buffer), " %d", r); + break; + } + fprintf (out, "%s\n", buffer); } + fputs ("\n\n", out); - fputs (_("\nNonterminals, with rules where they appear\n\n"), foutput); - for (i = ntokens; i <= nsyms - 1; i++) + + fprintf (out, "%s\n\n", _("Nonterminals, with rules where they appear")); + for (i = ntokens; i < nsyms; i++) { int left_count = 0, right_count = 0; - - for (j = 1; j <= nrules; j++) - { - if (rlhs[j] == i) - left_count++; - for (rule = &ritem[rrhs[j]]; *rule > 0; rule++) - if (*rule == i) - { - right_count++; - break; - } - } + rule_number r; + const char *tag = symbols[i]->tag; + + for (r = 0; r < nrules; r++) + { + item_number *rhsp; + if (rules[r].lhs->number == i) + left_count++; + for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++) + if (item_number_as_symbol_number (*rhsp) == i) + { + right_count++; + break; + } + } buffer[0] = 0; - fprintf (foutput, "%s", tags[i]); - column = strlen (tags[i]); + fputs (tag, out); + column = strlen (tag); sprintf (buffer, " (%d)", i); END_TEST (0); if (left_count > 0) - { - END_TEST (50); - sprintf (buffer + strlen (buffer), _(" on left:")); - - for (j = 1; j <= nrules; j++) - { - END_TEST (65); - if (rlhs[j] == i) - sprintf (buffer + strlen (buffer), " %d", j); - } - } + { + END_TEST (65); + sprintf (buffer + strlen (buffer), _(" on left:")); + + for (r = 0; r < nrules; r++) + { + if (rules[r].lhs->number == i) + { + END_TEST (65); + sprintf (buffer + strlen (buffer), " %d", r); + } + } + } if (right_count > 0) - { - if (left_count > 0) - sprintf (buffer + strlen (buffer), ","); - END_TEST (50); - sprintf (buffer + strlen (buffer), _(" on right:")); - for (j = 1; j <= nrules; j++) - { - for (rule = &ritem[rrhs[j]]; *rule > 0; rule++) - if (*rule == i) - { - END_TEST (65); - sprintf (buffer + strlen (buffer), " %d", j); - break; - } - } - } - fprintf (foutput, "%s\n", buffer); + { + if (left_count > 0) + sprintf (buffer + strlen (buffer), ","); + END_TEST (65); + sprintf (buffer + strlen (buffer), _(" on right:")); + for (r = 0; r < nrules; r++) + { + item_number *rhsp; + for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++) + if (item_number_as_symbol_number (*rhsp) == i) + { + END_TEST (65); + sprintf (buffer + strlen (buffer), " %d", r); + break; + } + } + } + fprintf (out, "%s\n", buffer); } } void print_results (void) { - int i; - - if (any_conflicts) - print_conflicts (); - - if (verboseflag) - print_grammar (); - - if (verboseflag) - for (i = 0; i < nstates; i++) - print_state (i); + state_number 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"); + + reduce_output (out); + grammar_rules_partial_print (out, + _("Rules useless in parser due to conflicts"), + rule_useless_in_parser_p); + conflicts_output (out); + + print_grammar (out); + + /* 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. */ + no_reduce_set = bitset_create (ntokens, BITSET_FIXED); + for (i = 0; i < nstates; i++) + print_state (out, states[i]); + bitset_free (no_reduce_set); + if (report_flag & report_itemsets) + free_closure (); + + xfclose (out); }