X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/fb9c0b3360928887038a296c338025ced68e2d8c..9ca7f077a0a5ecdd00c5945c7a7bd3cf46e23c13:/src/gram.c diff --git a/src/gram.c b/src/gram.c index dd77a766..6b9eda13 100644 --- a/src/gram.c +++ b/src/gram.c @@ -1,26 +1,24 @@ /* Allocate input grammar variables for Bison. - Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003 Free Software - Foundation, Inc. + Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003, 2005, 2006 + 2007 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - + along with this program. If not, see . */ +#include #include "system.h" #include @@ -29,6 +27,7 @@ #include "reader.h" #include "reduce.h" #include "symtab.h" +#include "print-xml.h" /* Comments for these variables are in gram.h. */ @@ -47,46 +46,24 @@ symbol_number *token_translations = NULL; int max_user_token_number = 256; -/*--------------------------------------------------------------. -| Return true IFF the rule has a `number' smaller than NRULES. | -`--------------------------------------------------------------*/ - bool -rule_useful_p (rule *r) +rule_useful_in_grammar_p (rule *r) { return r->number < nrules; } - -/*-------------------------------------------------------------. -| Return true IFF the rule has a `number' higher than NRULES. | -`-------------------------------------------------------------*/ - bool -rule_useless_p (rule *r) +rule_useless_in_grammar_p (rule *r) { - return r->number >= nrules; + return !rule_useful_in_grammar_p (r); } - -/*--------------------------------------------------------------------. -| 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) +rule_useless_in_parser_p (rule *r) { - return !r->useful && r->number < nrules; + return !r->useful && rule_useful_in_grammar_p (r); } - -/*----------------------------------------------------------------. -| 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) { @@ -104,10 +81,11 @@ rule_lhs_print (rule *r, symbol *previous_lhs, FILE *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 *r) @@ -119,11 +97,6 @@ rule_rhs_length (rule *r) return res; } - -/*-------------------------------. -| Print this rule's RHS on OUT. | -`-------------------------------*/ - void rule_rhs_print (rule *r, FILE *out) { @@ -140,10 +113,25 @@ rule_rhs_print (rule *r, 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 *r, FILE *out) @@ -152,11 +140,6 @@ rule_print (rule *r, FILE *out) rule_rhs_print (r, out); } - -/*------------------------. -| Dump RITEM for traces. | -`------------------------*/ - void ritem_print (FILE *out) { @@ -170,11 +153,6 @@ ritem_print (FILE *out) fputs ("\n\n", out); } - -/*------------------------------------------. -| Return the size of the longest rule RHS. | -`------------------------------------------*/ - size_t ritem_longest_rhs (void) { @@ -191,11 +169,6 @@ ritem_longest_rhs (void) return max; } - -/*-----------------------------------------------------------------. -| 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) @@ -222,21 +195,47 @@ grammar_rules_partial_print (FILE *out, const char *title, 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); + 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) @@ -247,24 +246,23 @@ grammar_dump (FILE *out, const char *title) ntokens, nvars, nsyms, nrules, nritems); - fputs (("Variables\n---------\n\n" - "Value Sprec Sassoc Tag\n"), - out); + fprintf (out, "Variables\n---------\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"); } - fputs ("\n\n", out); - fputs (("Rules\n-----\n\n" - "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n"), - out); + fprintf (out, "Rules\n-----\n\n"); { 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]; @@ -288,9 +286,9 @@ grammar_dump (FILE *out, const char *title) fprintf (out, " [%d]\n", item_number_as_rule_number (*rp)); } } - fputs ("\n\n", out); + fprintf (out, "\n\n"); - fputs ("Rules interpreted\n-----------------\n\n", out); + fprintf (out, "Rules interpreted\n-----------------\n\n"); { rule_number r; for (r = 0; r < nrules + nuseless_productions; r++) @@ -299,27 +297,18 @@ grammar_dump (FILE *out, const char *title) rule_print (&rules[r], out); } } - fputs ("\n\n", 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) +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); + fprintf (stderr, ": %s: %s: ", _("warning"), message); rule_print (&rules[r], stderr); } } @@ -327,7 +316,8 @@ grammar_rules_never_reduced_report (const char *message) void grammar_free (void) { - free (ritem); + if (ritem) + free (ritem - 1); free (rules); free (token_translations); /* Free the symbol table data structure. */