X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/5372019fabc593faad353349d41dea7e79dae509..3dc4aa8c362af2ffeabd2d3cb15a5816d4584ed6:/src/gram.c?ds=sidebyside diff --git a/src/gram.c b/src/gram.c index 3fc03d0e..4636f4e1 100644 --- a/src/gram.c +++ b/src/gram.c @@ -1,5 +1,7 @@ -/* Allocate input grammar variables for bison, - Copyright (C) 1984, 1986, 1989, 2001, 2002 Free Software Foundation, Inc. +/* Allocate input grammar variables for Bison. + + Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003 Free Software + Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -15,37 +17,92 @@ 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. */ + the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "system.h" -#include "quotearg.h" -#include "symtab.h" + +#include + #include "gram.h" -#include "reduce.h" #include "reader.h" +#include "reduce.h" +#include "symtab.h" -/* comments for these variables are in gram.h */ +/* Comments for these variables are in gram.h. */ -item_number_t *ritem = NULL; -int nritems = 0; +item_number *ritem = NULL; +unsigned int nritems = 0; -rule_t *rules = NULL; -int nrules = 0; +rule *rules = NULL; +rule_number nrules = 0; -symbol_t **symbols = NULL; +symbol **symbols = NULL; int nsyms = 0; int ntokens = 1; int nvars = 0; -token_number_t *token_translations = NULL; - -token_number_t start_symbol = 0; +symbol_number *token_translations = NULL; int max_user_token_number = 256; -int pure_parser = 0; +/*--------------------------------------------------------------. +| Return true IFF the rule has a `number' smaller than NRULES. | +`--------------------------------------------------------------*/ + +bool +rule_useful_p (rule *r) +{ + return r->number < nrules; +} + + +/*-------------------------------------------------------------. +| Return true IFF the rule has a `number' higher than NRULES. | +`-------------------------------------------------------------*/ + +bool +rule_useless_p (rule *r) +{ + return r->number >= nrules; +} + + +/*--------------------------------------------------------------------. +| Return true IFF the rule is not flagged as useful *and* is useful. | +| In other words, it was discarded because of conflicts. | +`--------------------------------------------------------------------*/ + +bool +rule_never_reduced_p (rule *r) +{ + return !r->useful && r->number < nrules; +} + + +/*----------------------------------------------------------------. +| Print this RULE's number and lhs on OUT. If a PREVIOUS_LHS was | +| already displayed (by a previous call for another rule), avoid | +| useless repetitions. | +`----------------------------------------------------------------*/ + +void +rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out) +{ + fprintf (out, " %3d ", r->number); + if (previous_lhs != r->lhs) + { + fprintf (out, "%s:", r->lhs->tag); + } + else + { + int n; + for (n = strlen (previous_lhs->tag); n > 0; --n) + fputc (' ', out); + fputc ('|', out); + } +} /*--------------------------------------. @@ -53,16 +110,49 @@ int pure_parser = 0; `--------------------------------------*/ int -rule_rhs_length (rule_t *rule) +rule_rhs_length (rule *r) { int res = 0; - item_number_t *rhsp; - for (rhsp = rule->rhs; *rhsp >= 0; ++rhsp) + item_number *rhsp; + for (rhsp = r->rhs; *rhsp >= 0; ++rhsp) ++res; return res; } +/*-------------------------------. +| Print this rule's RHS on OUT. | +`-------------------------------*/ + +void +rule_rhs_print (rule *r, FILE *out) +{ + if (*r->rhs >= 0) + { + item_number *rp; + for (rp = r->rhs; *rp >= 0; rp++) + fprintf (out, " %s", symbols[*rp]->tag); + fputc ('\n', out); + } + else + { + fprintf (out, " /* %s */\n", _("empty")); + } +} + + +/*-------------------------. +| Print this rule on OUT. | +`-------------------------*/ + +void +rule_print (rule *r, FILE *out) +{ + fprintf (out, "%s:", r->lhs->tag); + rule_rhs_print (r, out); +} + + /*------------------------. | Dump RITEM for traces. | `------------------------*/ @@ -70,14 +160,13 @@ rule_rhs_length (rule_t *rule) void ritem_print (FILE *out) { - int i; + unsigned int i; fputs ("RITEM\n", out); for (i = 0; i < nritems; ++i) if (ritem[i] >= 0) - fprintf (out, " %s", quotearg_style (escape_quoting_style, - symbols[ritem[i]]->tag)); + fprintf (out, " %s", symbols[ritem[i]]->tag); else - fprintf (out, " (rule %d)\n", -ritem[i] - 1); + fprintf (out, " (rule %d)\n", item_number_as_rule_number (ritem[i])); fputs ("\n\n", out); } @@ -90,11 +179,11 @@ size_t ritem_longest_rhs (void) { int max = 0; - int i; + rule_number r; - for (i = 1; i < nrules + 1; ++i) + for (r = 0; r < nrules; ++r) { - int length = rule_rhs_length (&rules[i]); + int length = rule_rhs_length (&rules[r]); if (length > max) max = length; } @@ -103,6 +192,48 @@ ritem_longest_rhs (void) } +/*-----------------------------------------------------------------. +| Print the grammar's rules that match FILTER on OUT under TITLE. | +`-----------------------------------------------------------------*/ + +void +grammar_rules_partial_print (FILE *out, const char *title, + rule_filter filter) +{ + rule_number r; + bool first = true; + symbol *previous_lhs = NULL; + + /* rule # : LHS -> RHS */ + for (r = 0; r < nrules + nuseless_productions; r++) + { + if (filter && !filter (&rules[r])) + continue; + if (first) + fprintf (out, "%s\n\n", title); + else if (previous_lhs && previous_lhs != rules[r].lhs) + fputc ('\n', out); + first = false; + rule_lhs_print (&rules[r], previous_lhs, out); + rule_rhs_print (&rules[r], out); + previous_lhs = rules[r].lhs; + } + if (!first) + fputs ("\n\n", out); +} + + +/*------------------------------------------. +| Print the grammar's useful rules on OUT. | +`------------------------------------------*/ + +void +grammar_rules_print (FILE *out) +{ + grammar_rules_partial_print (out, _("Grammar"), rule_useful_p); +} + + /*-------------------. | Dump the grammar. | `-------------------*/ @@ -110,63 +241,95 @@ ritem_longest_rhs (void) void grammar_dump (FILE *out, const char *title) { - int i; - item_number_t *r; - fprintf (out, "%s\n\n", title); fprintf (out, "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n", ntokens, nvars, nsyms, nrules, nritems); + + fprintf (out, "Variables\n---------\n\n"); - fprintf (out, "Value Sprec Sassoc Tag\n"); - for (i = ntokens; i < nsyms; i++) - fprintf (out, "%5d %5d %5d %s\n", - i, - symbols[i]->prec, symbols[i]->assoc, - quotearg_style (escape_quoting_style, symbols[i]->tag)); - fprintf (out, "\n\n"); + { + symbol_number i; + fprintf (out, "Value Sprec Sassoc Tag\n"); + + for (i = ntokens; i < nsyms; i++) + fprintf (out, "%5d %5d %5d %s\n", + i, + symbols[i]->prec, symbols[i]->assoc, + symbols[i]->tag); + fprintf (out, "\n\n"); + } + fprintf (out, "Rules\n-----\n\n"); - fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n"); - for (i = 1; i < nrules + nuseless_productions + 1; i++) - { - int rhs_count = 0; - /* Find the last RHS index in ritems. */ - for (r = rules[i].rhs; *r >= 0; ++r) - ++rhs_count; - fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d) %2d ->", - i - 1, - rules[i].prec ? rules[i].prec->prec : 0, - rules[i].prec ? rules[i].prec->assoc : 0, - rules[i].useful, - rules[i].rhs - ritem, - rules[i].rhs - ritem + rhs_count - 1, - rules[i].lhs->number); - /* Dumped the RHS. */ - for (r = rules[i].rhs; *r >= 0; r++) - fprintf (out, " %3d", *r); - fprintf (out, " [%d]\n", -(*r) - 1); - } + { + rule_number i; + fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n"); + for (i = 0; i < nrules + nuseless_productions; i++) + { + rule *rule_i = &rules[i]; + item_number *rp = NULL; + unsigned int rhs_itemno = rule_i->rhs - ritem; + unsigned int rhs_count = 0; + /* Find the last RHS index in ritems. */ + for (rp = rule_i->rhs; *rp >= 0; ++rp) + ++rhs_count; + fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u) %2d ->", + i, + rule_i->prec ? rule_i->prec->prec : 0, + rule_i->prec ? rule_i->prec->assoc : 0, + rule_i->useful, + rhs_itemno, + rhs_itemno + rhs_count - 1, + rule_i->lhs->number); + /* Dumped the RHS. */ + for (rp = rule_i->rhs; *rp >= 0; rp++) + fprintf (out, " %3d", *rp); + fprintf (out, " [%d]\n", item_number_as_rule_number (*rp)); + } + } fprintf (out, "\n\n"); + fprintf (out, "Rules interpreted\n-----------------\n\n"); - for (i = 1; i < nrules + nuseless_productions + 1; i++) - { - fprintf (out, "%-5d %s :", - i, quotearg_style (escape_quoting_style, rules[i].lhs->tag)); - for (r = rules[i].rhs; *r >= 0; r++) - fprintf (out, " %s", - quotearg_style (escape_quoting_style, symbols[*r]->tag)); - fputc ('\n', out); - } + { + rule_number r; + for (r = 0; r < nrules + nuseless_productions; r++) + { + fprintf (out, "%-5d ", r); + rule_print (&rules[r], out); + } + } fprintf (out, "\n\n"); } +/*------------------------------------------------------------------. +| Report on STDERR the rules that are not flagged USEFUL, using the | +| MESSAGE (which can be `useless rule' when invoked after grammar | +| reduction, or `never reduced' after conflicts were taken into | +| account). | +`------------------------------------------------------------------*/ + +void +grammar_rules_never_reduced_report (const char *message) +{ + rule_number r; + for (r = 0; r < nrules ; ++r) + if (!rules[r].useful) + { + location_print (stderr, rules[r].location); + fprintf (stderr, ": %s: %s: ", + _("warning"), message); + rule_print (&rules[r], stderr); + } +} + void grammar_free (void) { - XFREE (ritem); - free (rules + 1); - XFREE (token_translations); + free (ritem); + free (rules); + free (token_translations); /* Free the symbol table data structure. */ symbols_free (); + free_merger_functions (); }