X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/41d7a5f24d5e69bdf6ce10c012d50b89ce1e3957..5d614dfa8c3b98804a88239d1c80f3b20e56b7df:/src/gram.c diff --git a/src/gram.c b/src/gram.c index 84f79244..d1b38043 100644 --- a/src/gram.c +++ b/src/gram.c @@ -1,7 +1,7 @@ /* Allocate input grammar variables for Bison. - Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003, 2005, 2006 - 2007 Free Software Foundation, Inc. + Copyright (C) 1984, 1986, 1989, 2001-2003, 2005-2012 Free Software + Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -21,13 +21,13 @@ #include #include "system.h" -#include - +#include "complain.h" +#include "getargs.h" #include "gram.h" +#include "print-xml.h" #include "reader.h" #include "reduce.h" #include "symtab.h" -#include "print-xml.h" /* Comments for these variables are in gram.h. */ @@ -46,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 !rule_useful_p (r); + 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 && rule_useful_p (r); + 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) { @@ -109,11 +87,6 @@ rule_lhs_print_xml (rule *r, FILE *out, int level) xml_printf (out, level, "%s", r->lhs->tag); } - -/*--------------------------------------. -| Return the number of symbols in RHS. | -`--------------------------------------*/ - int rule_rhs_length (rule *r) { @@ -124,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) { @@ -153,8 +121,7 @@ rule_rhs_print_xml (rule *r, FILE *out, int level) item_number *rp; xml_puts (out, level, ""); for (rp = r->rhs; *rp >= 0; rp++) - xml_printf (out, level + 1, "%s", - symbol_class_get_string (symbols[*rp]), + xml_printf (out, level + 1, "%s", xml_escape (symbols[*rp]->tag)); xml_puts (out, level, ""); } @@ -166,10 +133,6 @@ rule_rhs_print_xml (rule *r, FILE *out, int level) } } -/*-------------------------. -| Print this rule on OUT. | -`-------------------------*/ - void rule_print (rule *r, FILE *out) { @@ -177,11 +140,6 @@ rule_print (rule *r, FILE *out) rule_rhs_print (r, out); } - -/*------------------------. -| Dump RITEM for traces. | -`------------------------*/ - void ritem_print (FILE *out) { @@ -195,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) { @@ -216,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) @@ -247,62 +195,49 @@ grammar_rules_partial_print (FILE *out, const char *title, fputs ("\n\n", out); } - -/*----------------------------------------------------------. -| Print the grammar's rules that match FILTER on OUT (XML). | -`-----------------------------------------------------------*/ +void +grammar_rules_print (FILE *out) +{ + grammar_rules_partial_print (out, _("Grammar"), rule_useful_in_grammar_p); +} void -grammar_rules_partial_print_xml (FILE *out, int level, bool rtag, - rule_filter filter) +grammar_rules_print_xml (FILE *out, int level) { rule_number r; bool first = true; for (r = 0; r < nrules + nuseless_productions; r++) { - if (filter && !filter (&rules[r])) - continue; - if (rtag && first) + if (first) xml_puts (out, level + 1, ""); first = false; - - xml_printf (out, level + 2, "", - rules[r].number); + { + 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 (rtag) - { - if (!first) - xml_puts (out, level + 1, ""); - else - xml_puts (out, level + 1, ""); - } -} - -/*------------------------------------------. -| Print the grammar's useful rules on OUT. | -`------------------------------------------*/ - -void -grammar_rules_print (FILE *out) -{ - grammar_rules_partial_print (out, _("Grammar"), rule_useful_p); -} - -void -grammar_rules_print_xml (FILE *out, int level) -{ - grammar_rules_partial_print_xml (out, level, true, rule_useful_p); + if (!first) + xml_puts (out, level + 1, ""); + else + xml_puts (out, level + 1, ""); } - -/*-------------------. -| Dump the grammar. | -`-------------------*/ - void grammar_dump (FILE *out, const char *title) { @@ -366,24 +301,19 @@ grammar_dump (FILE *out, const char *title) 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); - rule_print (&rules[r], stderr); + warn_at (rules[r].location, "%s: ", message); + if (warnings_flag & warnings_other) + { + rule_print (&rules[r], stderr); + fflush (stderr); + } } }