X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/9222837b2743308e4971fc0ad299ca2f73fb20ae..4b7a4c1b1c8c18e9ad2517c117442b9b7d7e671a:/src/gram.c diff --git a/src/gram.c b/src/gram.c index 708922d5..e28b64da 100644 --- a/src/gram.c +++ b/src/gram.c @@ -1,79 +1,110 @@ -/* 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, 2005, 2006, + 2007, 2008, 2009 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 "quotearg.h" -#include "symtab.h" + +#include + #include "gram.h" -#include "reduce.h" #include "reader.h" +#include "reduce.h" +#include "symtab.h" +#include "print-xml.h" /* Comments for these variables are in gram.h. */ -item_number_t *ritem = NULL; +item_number *ritem = NULL; unsigned int nritems = 0; -rule_t *rules = NULL; -rule_number_t 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; -symbol_number_t *token_translations = NULL; +symbol_number *token_translations = NULL; int max_user_token_number = 256; -int glr_parser = 0; -int pure_parser = 0; +bool +rule_useful_in_grammar_p (rule *r) +{ + return r->number < nrules; +} + +bool +rule_useless_in_grammar_p (rule *r) +{ + return !rule_useful_in_grammar_p (r); +} + +bool +rule_useless_in_parser_p (rule *r) +{ + return !r->useful && rule_useful_in_grammar_p (r); +} +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); + } +} -/*--------------------------------------. -| Return the number of symbols in RHS. | -`--------------------------------------*/ +void +rule_lhs_print_xml (rule *r, FILE *out, int level) +{ + xml_printf (out, level, "%s", r->lhs->tag); +} 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_t *rule, FILE *out) +rule_rhs_print (rule *r, FILE *out) { - if (*rule->rhs >= 0) + if (*r->rhs >= 0) { - item_number_t *r; - for (r = rule->rhs; *r >= 0; r++) - fprintf (out, " %s", symbol_tag_get (symbols[*r])); + item_number *rp; + for (rp = r->rhs; *rp >= 0; rp++) + fprintf (out, " %s", symbols[*rp]->tag); fputc ('\n', out); } else @@ -82,23 +113,33 @@ rule_rhs_print (rule_t *rule, FILE *out) } } - -/*-------------------------. -| Print this RULE on OUT. | -`-------------------------*/ +static void +rule_rhs_print_xml (rule *r, FILE *out, int level) +{ + if (*r->rhs >= 0) + { + item_number *rp; + xml_puts (out, level, ""); + for (rp = r->rhs; *rp >= 0; rp++) + xml_printf (out, level + 1, "%s", + xml_escape (symbols[*rp]->tag)); + xml_puts (out, level, ""); + } + else + { + xml_puts (out, level, ""); + xml_puts (out, level + 1, ""); + xml_puts (out, level, ""); + } +} void -rule_print (rule_t *rule, FILE *out) +rule_print (rule *r, FILE *out) { - fprintf (out, "%s:", symbol_tag_get (rule->lhs)); - rule_rhs_print (rule, out); + fprintf (out, "%s:", r->lhs->tag); + rule_rhs_print (r, out); } - -/*------------------------. -| Dump RITEM for traces. | -`------------------------*/ - void ritem_print (FILE *out) { @@ -106,24 +147,19 @@ ritem_print (FILE *out) fputs ("RITEM\n", out); for (i = 0; i < nritems; ++i) if (ritem[i] >= 0) - fprintf (out, " %s", symbol_tag_get (symbols[ritem[i]])); + 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); } - -/*------------------------------------------. -| Return the size of the longest rule RHS. | -`------------------------------------------*/ - size_t ritem_longest_rhs (void) { int max = 0; - rule_number_t r; + rule_number r; - for (r = 1; r < nrules + 1; ++r) + for (r = 0; r < nrules; ++r) { int length = rule_rhs_length (&rules[r]); if (length > max) @@ -133,64 +169,74 @@ ritem_longest_rhs (void) return max; } - -/*----------------------------------------------------------------. -| Print the grammar's rules numbers from BEGIN (inclusive) to END | -| (exclusive) on OUT under TITLE. | -`----------------------------------------------------------------*/ - -static inline void -blanks_print (unsigned n, FILE *out) -{ - for (/* Nothing*/; n > 0; --n) - fputc (' ', out); -} - void grammar_rules_partial_print (FILE *out, const char *title, - rule_number_t begin, rule_number_t end) + rule_filter filter) { - int r; - symbol_t *last_lhs = NULL; + rule_number r; + bool first = true; + symbol *previous_lhs = NULL; /* rule # : LHS -> RHS */ - fprintf (out, "%s\n\n", title); - for (r = begin; r < end; r++) + for (r = 0; r < nrules + nuseless_productions; r++) { - if (last_lhs && last_lhs != rules[r].lhs) + 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); - - fprintf (out, " %3d ", r - 1); - if (last_lhs != rules[r].lhs) - { - last_lhs = rules[r].lhs; - fprintf (out, "%s:", symbol_tag_get (last_lhs)); - } - else - { - blanks_print (strlen (symbol_tag_get (last_lhs)), out); - fputc ('|', out); - } + first = false; + rule_lhs_print (&rules[r], previous_lhs, out); rule_rhs_print (&rules[r], out); + previous_lhs = rules[r].lhs; } - fputs ("\n\n", out); + 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"), 1, nrules + 1); + grammar_rules_partial_print (out, _("Grammar"), rule_useful_in_grammar_p); } +void +grammar_rules_print_xml (FILE *out, int level) +{ + rule_number r; + bool first = true; -/*-------------------. -| Dump the grammar. | -`-------------------*/ + for (r = 0; r < nrules + nuseless_productions; r++) + { + if (first) + xml_puts (out, level + 1, ""); + first = false; + { + char const *usefulness; + if (rule_useless_in_grammar_p (&rules[r])) + usefulness = "useless-in-grammar"; + else if (rule_useless_in_parser_p (&rules[r])) + usefulness = "useless-in-parser"; + else + usefulness = "useful"; + xml_indent (out, level + 2); + fprintf (out, "tag)); + fputs (">\n", out); + } + rule_lhs_print_xml (&rules[r], out, level + 3); + rule_rhs_print_xml (&rules[r], out, level + 3); + xml_puts (out, level + 2, ""); + } + if (!first) + xml_puts (out, level + 1, ""); + else + xml_puts (out, level + 1, ""); +} void grammar_dump (FILE *out, const char *title) @@ -203,49 +249,50 @@ grammar_dump (FILE *out, const char *title) fprintf (out, "Variables\n---------\n\n"); { - symbol_number_t i; + 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, - symbol_tag_get (symbols[i])); + symbols[i]->tag); fprintf (out, "\n\n"); } fprintf (out, "Rules\n-----\n\n"); { - rule_number_t i; + rule_number i; fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n"); - for (i = 1; i < nrules + nuseless_productions + 1; i++) + for (i = 0; i < nrules + nuseless_productions; i++) { - rule_t *rule = &rules[i]; - item_number_t *r = NULL; - int rhs_count = 0; + 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 (r = rule->rhs; *r >= 0; ++r) + for (rp = rule_i->rhs; *rp >= 0; ++rp) ++rhs_count; - fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d) %2d ->", - i - 1, - rule->prec ? rule->prec->prec : 0, - rule->prec ? rule->prec->assoc : 0, - rule->useful, - rule->rhs - ritem, - rule->rhs - ritem + rhs_count - 1, - rule->lhs->number); + 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 (r = rule->rhs; *r >= 0; r++) - fprintf (out, " %3d", *r); - fprintf (out, " [%d]\n", -(*r) - 1); + 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"); { - rule_number_t r; - for (r = 1; r < nrules + nuseless_productions + 1; r++) + rule_number r; + for (r = 0; r < nrules + nuseless_productions; r++) { fprintf (out, "%-5d ", r); rule_print (&rules[r], out); @@ -254,13 +301,26 @@ grammar_dump (FILE *out, const char *title) fprintf (out, "\n\n"); } +void +grammar_rules_useless_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); + if (ritem) + free (ritem - 1); + free (rules); + free (token_translations); /* Free the symbol table data structure. */ symbols_free (); free_merger_functions ();