X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/d6ea8200af27933cac4ca91df7cf2693154cd2b9..22b081deb7ab1d0ec7a279e5213fa7fdc2c85207:/src/reduce.c?ds=sidebyside diff --git a/src/reduce.c b/src/reduce.c index e3ed6f61..736cbb6a 100644 --- a/src/reduce.c +++ b/src/reduce.c @@ -1,22 +1,22 @@ /* Grammar reduction for Bison. - Copyright (C) 1988, 1989, 2000, 2001, 2002 Free Software Foundation, Inc. + + Copyright (C) 1988-1989, 2000-2003, 2005-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 . */ /* Reduce the grammar: Find and eliminate unreachable terminals, @@ -25,17 +25,19 @@ /* Don't eliminate unreachable terminals: They may be used by the user's parser. */ +#include #include "system.h" -#include "quotearg.h" -#include "getargs.h" + +#include + +#include "complain.h" #include "files.h" -#include "symtab.h" +#include "getargs.h" #include "gram.h" -#include "complain.h" -#include "reduce.h" +#include "print-xml.h" #include "reader.h" -#include "getargs.h" -#include "bitset.h" +#include "reduce.h" +#include "symtab.h" /* Set of all nonterminals which are not useless. */ static bitset N; @@ -50,10 +52,10 @@ static bitset V; `useless', but no warning should be issued). */ static bitset V1; -static rule_number_t nuseful_productions; -rule_number_t nuseless_productions; +static rule_number nuseful_productions; +rule_number nuseless_productions; static int nuseful_nonterminals; -symbol_number_t nuseless_nonterminals; +symbol_number nuseless_nonterminals; /*-------------------------------------------------------------------. | Another way to do this would be with a set for each production and | @@ -62,9 +64,9 @@ symbol_number_t nuseless_nonterminals; `-------------------------------------------------------------------*/ static bool -useful_production (rule_number_t r, bitset N0) +useful_production (rule_number r, bitset N0) { - item_number_t *rhsp; + item_number *rhsp; /* A production is useful if all of the nonterminals in its appear in the set of useful nonterminals. */ @@ -84,7 +86,7 @@ static void useless_nonterminals (void) { bitset Np, Ns; - rule_number_t r; + rule_number r; /* N is set as built. Np is set being built this iteration. P is set of all productions which have a RHS all in N. */ @@ -112,14 +114,14 @@ useless_nonterminals (void) { bitset_copy (Np, N); for (r = 0; r < nrules; r++) - if (!bitset_test (P, r) - && useful_production (r, N)) - { - bitset_set (Np, rules[r].lhs->number - ntokens); - bitset_set (P, r); - } + if (!bitset_test (P, r) + && useful_production (r, N)) + { + bitset_set (Np, rules[r].lhs->number - ntokens); + bitset_set (P, r); + } if (bitset_equal_p (N, Np)) - break; + break; Ns = Np; Np = N; N = Ns; @@ -166,37 +168,37 @@ inaccessable_symbols (void) bitset_set (V, accept->number); while (1) - { - rule_number_t r; - bitset_copy (Vp, V); - for (r = 0; r < nrules; r++) - { - if (!bitset_test (Pp, r) - && bitset_test (P, r) - && bitset_test (V, rules[r].lhs->number)) - { - item_number_t *rhsp; - for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++) - if (ISTOKEN (*rhsp) || bitset_test (N, *rhsp - ntokens)) - bitset_set (Vp, *rhsp); - bitset_set (Pp, r); - } - } - if (bitset_equal_p (V, Vp)) - break; - Vs = Vp; - Vp = V; - V = Vs; - } + { + rule_number r; + bitset_copy (Vp, V); + for (r = 0; r < nrules; r++) + { + if (!bitset_test (Pp, r) + && bitset_test (P, r) + && bitset_test (V, rules[r].lhs->number)) + { + item_number *rhsp; + for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++) + if (ISTOKEN (*rhsp) || bitset_test (N, *rhsp - ntokens)) + bitset_set (Vp, *rhsp); + bitset_set (Pp, r); + } + } + if (bitset_equal_p (V, Vp)) + break; + Vs = Vp; + Vp = V; + V = Vs; + } } bitset_free (V); V = Vp; /* Tokens 0, 1, and 2 are internal to Bison. Consider them useful. */ - bitset_set (V, endtoken->number); /* end-of-input token */ - bitset_set (V, errtoken->number); /* error token */ - bitset_set (V, undeftoken->number); /* some undefined token */ + bitset_set (V, endtoken->number); /* end-of-input token */ + bitset_set (V, errtoken->number); /* error token */ + bitset_set (V, undeftoken->number); /* some undefined token */ bitset_free (P); P = Pp; @@ -206,19 +208,19 @@ inaccessable_symbols (void) nuseful_nonterminals = 0; { - symbol_number_t i; + symbol_number i; for (i = ntokens; i < nsyms; i++) if (bitset_test (V, i)) - nuseful_nonterminals++; + nuseful_nonterminals++; } nuseless_nonterminals = nvars - nuseful_nonterminals; /* A token that was used in %prec should not be warned about. */ { - rule_number_t r; + rule_number r; for (r = 0; r < nrules; ++r) if (rules[r].precsym != 0) - bitset_set (V1, rules[r].precsym->number); + bitset_set (V1, rules[r].precsym->number); } } @@ -233,10 +235,10 @@ reduce_grammar_tables (void) { /* Report and flag useless productions. */ { - rule_number_t r; + rule_number r; for (r = 0; r < nrules; r++) rules[r].useful = bitset_test (P, r); - grammar_rules_never_reduced_report (_("useless rule")); + grammar_rules_useless_report (_("rule useless in grammar")); } /* Map the nonterminals to their new index: useful first, useless @@ -244,8 +246,8 @@ reduce_grammar_tables (void) { int useful = 0; int useless = nrules - nuseless_productions; - rule_t *rules_sorted = XMALLOC (rule_t, nrules); - rule_number_t r; + rule *rules_sorted = xnmalloc (nrules, sizeof *rules_sorted); + rule_number r; for (r = 0; r < nrules; ++r) rules_sorted[rules[r].useful ? useful++ : useless++] = rules[r]; free (rules); @@ -254,23 +256,23 @@ reduce_grammar_tables (void) /* Renumber the rules markers in RITEMS. */ for (r = 0; r < nrules; ++r) { - item_number_t *rhsp = rules[r].rhs; - for (/* Nothing. */; *rhsp >= 0; ++rhsp) - /* Nothing. */; - *rhsp = rule_number_as_item_number (r); - rules[r].number = r; + item_number *rhsp = rules[r].rhs; + for (/* Nothing. */; *rhsp >= 0; ++rhsp) + /* Nothing. */; + *rhsp = rule_number_as_item_number (r); + rules[r].number = r; } nrules -= nuseless_productions; } /* Adjust NRITEMS. */ { - int r; + rule_number r; int length; for (r = nrules; r < nrules + nuseless_productions; ++r) { - length = rule_rhs_length (&rules[r]); - nritems -= length + 1; + length = rule_rhs_length (&rules[r]); + nritems -= length + 1; } } } @@ -283,54 +285,56 @@ reduce_grammar_tables (void) static void nonterminals_reduce (void) { - symbol_number_t i, n; - /* Map the nonterminals to their new index: useful first, useless afterwards. Kept for later report. */ - symbol_number_t *nontermmap = XCALLOC (symbol_number_t, nvars) - ntokens; - n = ntokens; + symbol_number *nontermmap = xnmalloc (nvars, sizeof *nontermmap); + symbol_number n = ntokens; + symbol_number i; for (i = ntokens; i < nsyms; i++) if (bitset_test (V, i)) - nontermmap[i] = n++; + nontermmap[i - ntokens] = n++; for (i = ntokens; i < nsyms; i++) if (!bitset_test (V, i)) { - nontermmap[i] = n++; - warn_at (symbols[i]->location, _("useless nonterminal: %s"), - symbols[i]->tag); + nontermmap[i - ntokens] = n++; + if (symbols[i]->status != used) + warn_at (symbols[i]->location, + _("nonterminal useless in grammar: %s"), + symbols[i]->tag); } /* Shuffle elements of tables indexed by symbol number. */ { - symbol_t **symbols_sorted = XMALLOC (symbol_t *, nvars) - ntokens; + symbol **symbols_sorted = xnmalloc (nvars, sizeof *symbols_sorted); for (i = ntokens; i < nsyms; i++) - symbols[i]->number = nontermmap[i]; + symbols[i]->number = nontermmap[i - ntokens]; for (i = ntokens; i < nsyms; i++) - symbols_sorted[nontermmap[i]] = symbols[i]; + symbols_sorted[nontermmap[i - ntokens] - ntokens] = symbols[i]; for (i = ntokens; i < nsyms; i++) - symbols[i] = symbols_sorted[i]; - free (symbols_sorted + ntokens); + symbols[i] = symbols_sorted[i - ntokens]; + free (symbols_sorted); } { - rule_number_t r; + rule_number r; for (r = 0; r < nrules; ++r) { - item_number_t *rhsp; - for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp) - if (ISVAR (*rhsp)) - *rhsp = symbol_number_as_item_number (nontermmap[*rhsp]); + item_number *rhsp; + for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp) + if (ISVAR (*rhsp)) + *rhsp = symbol_number_as_item_number (nontermmap[*rhsp + - ntokens]); } - accept->number = nontermmap[accept->number]; + accept->number = nontermmap[accept->number - ntokens]; } nsyms -= nuseless_nonterminals; nvars -= nuseless_nonterminals; - free (nontermmap + ntokens); + free (nontermmap); } @@ -344,9 +348,9 @@ reduce_output (FILE *out) if (nuseless_nonterminals > 0) { int i; - fprintf (out, "%s\n\n", _("Useless nonterminals")); + fprintf (out, "%s\n\n", _("Nonterminals useless in grammar")); for (i = 0; i < nuseless_nonterminals; ++i) - fprintf (out, " %s\n", symbols[nsyms + i]->tag); + fprintf (out, " %s\n", symbols[nsyms + i]->tag); fputs ("\n\n", out); } @@ -354,26 +358,23 @@ reduce_output (FILE *out) bool b = false; int i; for (i = 0; i < ntokens; i++) - if (!bitset_test (V, i) && !bitset_test (V1, i)) - { - if (!b) - fprintf (out, "%s\n\n", _("Terminals which are not used")); - b = true; - fprintf (out, " %s\n", symbols[i]->tag); - } + if (reduce_token_unused_in_grammar (i)) + { + if (!b) + fprintf (out, "%s\n\n", _("Terminals unused in grammar")); + b = true; + fprintf (out, " %s\n", symbols[i]->tag); + } if (b) fputs ("\n\n", out); } if (nuseless_productions > 0) - grammar_rules_partial_print (out, _("Useless rules"), - rule_useless_p); + grammar_rules_partial_print (out, _("Rules useless in grammar"), + rule_useless_in_grammar_p); } - - - /*-------------------------------. | Report the results to STDERR. | `-------------------------------*/ @@ -381,30 +382,16 @@ reduce_output (FILE *out) static void reduce_print (void) { - if (yacc_flag && nuseless_productions) - fprintf (stderr, ngettext ("%d rule never reduced\n", - "%d rules never reduced\n", - nuseless_productions), - nuseless_productions); - - fprintf (stderr, "%s: %s: ", grammar_file, _("warning")); - if (nuseless_nonterminals > 0) - fprintf (stderr, ngettext ("%d useless nonterminal", - "%d useless nonterminals", - nuseless_nonterminals), - nuseless_nonterminals); - - if (nuseless_nonterminals > 0 && nuseless_productions > 0) - fprintf (stderr, _(" and ")); - + warn (ngettext ("%d nonterminal useless in grammar", + "%d nonterminals useless in grammar", + nuseless_nonterminals), + nuseless_nonterminals); if (nuseless_productions > 0) - fprintf (stderr, ngettext ("%d useless rule", - "%d useless rules", - nuseless_productions), - nuseless_productions); - fprintf (stderr, "\n"); - fflush (stderr); + warn (ngettext ("%d rule useless in grammar", + "%d rules useless in grammar", + nuseless_productions), + nuseless_productions); } void @@ -422,7 +409,7 @@ reduce_grammar (void) useless_nonterminals (); inaccessable_symbols (); - reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0); + reduced = (nuseless_nonterminals + nuseless_productions > 0); if (!reduced) return; @@ -430,8 +417,8 @@ reduce_grammar (void) if (!bitset_test (N, accept->number - ntokens)) fatal_at (startsymbol_location, - _("start symbol %s does not derive any sentence"), - startsymbol->tag); + _("start symbol %s does not derive any sentence"), + startsymbol->tag); /* First reduce the nonterminals, as they renumber themselves in the whole grammar. If you change the order, nonterms would be @@ -447,10 +434,23 @@ reduce_grammar (void) fprintf (stderr, "reduced %s defines %d terminals, %d nonterminals\ , and %d productions.\n", - grammar_file, ntokens, nvars, nrules); + grammar_file, ntokens, nvars, nrules); } } +bool +reduce_token_unused_in_grammar (symbol_number i) +{ + aver (i < ntokens); + return !bitset_test (V, i) && !bitset_test (V1, i); +} + +bool +reduce_nonterminal_useless_in_grammar (symbol_number i) +{ + aver (ntokens <= i && i < nsyms + nuseless_nonterminals); + return nsyms <= i; +} /*-----------------------------------------------------------. | Free the global sets used to compute the reduced grammar. |