Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 12:23:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

* src/gram.c: Remove comments that duplicate comments in gram.h.

Browse Source 
When reporting useless rules and nonterminals, say "useless in grammar"
instead of "useless", and say "useless in parser" instead of "never
reduced".  Discussed starting at
<http://lists.gnu.org/archive/html/bison-patches/2007-10/msg00033.html>.
* NEWS (2.3a+): Mention this change.
* data/xslt/xml2text.xsl: Update output text and expected input XML
element names to match changes below.
* data/xslt/xml2xhtml.xsl: Likewise.
(xsl:template match="bison-xml-report"): Add missing entry in Table of
Contents: "Rules useless in parser due to conflicts".
* doc/bison.texinfo (Decl Summary): Reword a little.
(Understanding): Update example output for changes below.
* src/gram.c: (rule_useful_p): Rename to...
(rule_useful_in_grammar_p): ... this.
(rule_useless_p): Rename to...
(rule_useless_in_grammar_p): ... this.
(rule_never_reduced_p): Rename to...
(rule_useless_in_parser_p): ... this.
(grammar_rules_print): Update for renames.
(grammar_rules_print_xml): Update for renames.
(grammar_rules_never_reduced_report): Rename to...
(grammar_rules_useless_report): ... this since it is used for either
kind of useless rule.
* src/gram.h: Reword comments and update function names in prototypes.
* src/main.c (main): Say "rule useless in parser due to conflicts".
* src/print-xml.c (print_rules_never_reduced): Rename to...
(print_rules_useless_in_parser): ... this, and rename output XML
element "rules-never-reduced" to "rules-useless-in-parser".
(print_xml): Update for rename.
* src/print.c (print_results): Say "Rules useless in parser due to
conflicts".
* src/reduce.c (reduce_grammar_tables): Say "rule useless in grammar".
(nonterminals_reduce): Say "nonterminal useless in grammar".
(reduce_output): Say "Nonterminals useless in grammar".
Say "Rules useless in grammar".
(reduce_xml): Rename output XML element "useless" to
"useless-in-grammar".
(reduce_print): Don't report the count of grammatically useless rules
as "rules never reduced" just because %yacc is specified.
In the correct report of this count, say nonterminal(s) and rule(s)
"useless in grammar".
* tests/conflicts.at (S/R in initial): Update expected output.
(Defaulted Conflicted Reduction): Likewise.
(Unreachable States After Conflict Resolution): Likewise.
* tests/existing.at (GNU pic Grammar): Likewise.
* tests/reduce.at (Useless Nonterminals): Likewise.
(Useless Rules): Likewise.
(Reduced Automaton): Likewise.
(Underivable Rules): Likewise.
(Empty Language): Likewise.
This commit is contained in:
Joel E. Denny
2007-11-10 03:42:37 +00:00
parent 66f0441da3
commit cff03fb2b9
14 changed files with 214 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
ChangeLog
View File

@@ -1,3 +1,58 @@
2007-11-10 Joel E. Denny <jdenny@ces.clemson.edu>
* src/gram.c: Remove comments that duplicate comments in gram.h.
When reporting useless rules and nonterminals, say "useless in grammar"
instead of "useless", and say "useless in parser" instead of "never
reduced". Discussed starting at
<http://lists.gnu.org/archive/html/bison-patches/2007-10/msg00033.html>.
* NEWS (2.3a+): Mention this change.
* data/xslt/xml2text.xsl: Update output text and expected input XML
element names to match changes below.
* data/xslt/xml2xhtml.xsl: Likewise.
(xsl:template match="bison-xml-report"): Add missing entry in Table of
Contents: "Rules useless in parser due to conflicts".
* doc/bison.texinfo (Decl Summary): Reword a little.
(Understanding): Update example output for changes below.
* src/gram.c: (rule_useful_p): Rename to...
(rule_useful_in_grammar_p): ... this.
(rule_useless_p): Rename to...
(rule_useless_in_grammar_p): ... this.
(rule_never_reduced_p): Rename to...
(rule_useless_in_parser_p): ... this.
(grammar_rules_print): Update for renames.
(grammar_rules_print_xml): Update for renames.
(grammar_rules_never_reduced_report): Rename to...
(grammar_rules_useless_report): ... this since it is used for either
kind of useless rule.
* src/gram.h: Reword comments and update function names in prototypes.
* src/main.c (main): Say "rule useless in parser due to conflicts".
* src/print-xml.c (print_rules_never_reduced): Rename to...
(print_rules_useless_in_parser): ... this, and rename output XML
element "rules-never-reduced" to "rules-useless-in-parser".
(print_xml): Update for rename.
* src/print.c (print_results): Say "Rules useless in parser due to
conflicts".
* src/reduce.c (reduce_grammar_tables): Say "rule useless in grammar".
(nonterminals_reduce): Say "nonterminal useless in grammar".
(reduce_output): Say "Nonterminals useless in grammar".
Say "Rules useless in grammar".
(reduce_xml): Rename output XML element "useless" to
"useless-in-grammar".
(reduce_print): Don't report the count of grammatically useless rules
as "rules never reduced" just because %yacc is specified.
In the correct report of this count, say nonterminal(s) and rule(s)
"useless in grammar".
* tests/conflicts.at (S/R in initial): Update expected output.
(Defaulted Conflicted Reduction): Likewise.
(Unreachable States After Conflict Resolution): Likewise.
* tests/existing.at (GNU pic Grammar): Likewise.
* tests/reduce.at (Useless Nonterminals): Likewise.
(Useless Rules): Likewise.
(Reduced Automaton): Likewise.
(Underivable Rules): Likewise.
(Empty Language): Likewise.
2007-11-09 Joel E. Denny <jdenny@ces.clemson.edu> 2007-11-09 Joel E. Denny <jdenny@ces.clemson.edu>
* data/bison.m4 (b4_cat): Put a newline after the end delimiter of the * data/bison.m4 (b4_cat): Put a newline after the end delimiter of the

6
NEWS
View File

@@ -41,6 +41,10 @@ Changes in version 2.3a+ (????-??-??):
%defines "parser.h" %defines "parser.h"
* When reporting useless rules and nonterminals, Bison now employs the term
"useless in grammar" instead of "useless" and employs the term "useless in
parser" instead of "never reduced".
* Unreachable State Removal * Unreachable State Removal
Previously, Bison sometimes generated parser tables containing unreachable Previously, Bison sometimes generated parser tables containing unreachable
@@ -54,7 +58,7 @@ Changes in version 2.3a+ (????-??-??):
directives in existing grammar files. directives in existing grammar files.
3. For any rule used only in such states, Bison now reports the rule as 3. For any rule used only in such states, Bison now reports the rule as
"never reduced because of conflicts". "useless in parser due to conflicts".
This feature can be disabled with the following directive: This feature can be disabled with the following directive:

18
data/xslt/xml2text.xsl
View File

@@ -37,15 +37,15 @@
<xsl:template match="bison-xml-report"> <xsl:template match="bison-xml-report">
<xsl:apply-templates select="reductions"/> <xsl:apply-templates select="reductions"/>
<xsl:apply-templates select="rules-never-reduced"/> <xsl:apply-templates select="rules-useless-in-parser"/>
<xsl:apply-templates select="automaton" mode="conflicts"/> <xsl:apply-templates select="automaton" mode="conflicts"/>
<xsl:apply-templates select="grammar"/> <xsl:apply-templates select="grammar"/>
<xsl:apply-templates select="automaton"/> <xsl:apply-templates select="automaton"/>
</xsl:template> </xsl:template>
<xsl:template match="rules-never-reduced"> <xsl:template match="rules-useless-in-parser">
<xsl:if test="rule"> <xsl:if test="rule">
<xsl:text>Rules never reduced&#10;</xsl:text> <xsl:text>Rules useless in parser due to conflicts&#10;</xsl:text>
<xsl:apply-templates select="rule"> <xsl:apply-templates select="rule">
<xsl:with-param name="pad" select="'3'"/> <xsl:with-param name="pad" select="'3'"/>
</xsl:apply-templates> </xsl:apply-templates>
@@ -54,14 +54,14 @@
</xsl:template> </xsl:template>
<xsl:template match="reductions"> <xsl:template match="reductions">
<xsl:apply-templates select="useless/nonterminals"/> <xsl:apply-templates select="useless-in-grammar/nonterminals"/>
<xsl:apply-templates select="unused/terminals"/> <xsl:apply-templates select="unused/terminals"/>
<xsl:apply-templates select="useless/rules"/> <xsl:apply-templates select="useless-in-grammar/rules"/>
</xsl:template> </xsl:template>
<xsl:template match="useless/nonterminals"> <xsl:template match="useless-in-grammar/nonterminals">
<xsl:if test="nonterminal"> <xsl:if test="nonterminal">
<xsl:text>Useless nonterminals&#10;&#10;</xsl:text> <xsl:text>Nonterminals useless in grammar&#10;&#10;</xsl:text>
<xsl:for-each select="nonterminal"> <xsl:for-each select="nonterminal">
<xsl:text> </xsl:text> <xsl:text> </xsl:text>
<xsl:value-of select="."/> <xsl:value-of select="."/>
@@ -71,9 +71,9 @@
</xsl:if> </xsl:if>
</xsl:template> </xsl:template>
<xsl:template match="useless/rules"> <xsl:template match="useless-in-grammar/rules">
<xsl:if test="rule"> <xsl:if test="rule">
<xsl:text>Useless rules&#10;</xsl:text> <xsl:text>Rules useless in grammar&#10;</xsl:text>
<xsl:apply-templates select="rule"> <xsl:apply-templates select="rule">
<xsl:with-param name="pad" select="'3'"/> <xsl:with-param name="pad" select="'3'"/>
</xsl:apply-templates> </xsl:apply-templates>

33
data/xslt/xml2xhtml.xsl
View File

@@ -108,9 +108,12 @@
<li> <li>
<a href="#reductions">Reductions</a> <a href="#reductions">Reductions</a>
<ul class="lower-alpha"> <ul class="lower-alpha">
<li><a href="#useless_nonterminals">Useless nonterminal symbols</a></li> <li><a href="#nonterminals_useless_in_grammar">Nonterminals useless in grammar</a></li>
<li><a href="#unused_terminals">Unused terminal symbols</a></li> <li><a href="#unused_terminals">Unused terminals</a></li>
<li><a href="#useless_rules">Useless rules</a></li> <li><a href="#rules_useless_in_grammar">Rules useless in grammar</a></li>
<xsl:if test="rules-useless-in-parser/rule">
<li><a href="#rules_useless_in_parser">Rules useless in parser due to conflicts</a></li>
</xsl:if>
</ul> </ul>
</li> </li>
<li><a href="#conflicts">Conflicts</a></li> <li><a href="#conflicts">Conflicts</a></li>
@@ -125,17 +128,17 @@
<li><a href="#automaton">Automaton</a></li> <li><a href="#automaton">Automaton</a></li>
</ul> </ul>
<xsl:apply-templates select="reductions"/> <xsl:apply-templates select="reductions"/>
<xsl:apply-templates select="rules-never-reduced"/> <xsl:apply-templates select="rules-useless-in-parser"/>
<xsl:apply-templates select="automaton" mode="conflicts"/> <xsl:apply-templates select="automaton" mode="conflicts"/>
<xsl:apply-templates select="grammar"/> <xsl:apply-templates select="grammar"/>
<xsl:apply-templates select="automaton"/> <xsl:apply-templates select="automaton"/>
</xsl:template> </xsl:template>
<xsl:template match="rules-never-reduced"> <xsl:template match="rules-useless-in-parser">
<xsl:if test="rule"> <xsl:if test="rule">
<h2> <h2>
<a name="rules_never_reduced"/> <a name="rules_useless_in_parser"/>
<xsl:text> Rules never reduced</xsl:text> <xsl:text> Rules useless in parser due to conflicts</xsl:text>
</h2> </h2>
<xsl:text>&#10;</xsl:text> <xsl:text>&#10;</xsl:text>
<p class="pre"> <p class="pre">
@@ -152,15 +155,15 @@
<a name="reductions"/> <a name="reductions"/>
<xsl:text> Reductions</xsl:text> <xsl:text> Reductions</xsl:text>
</h2> </h2>
<xsl:apply-templates select="useless/nonterminals"/> <xsl:apply-templates select="useless-in-grammar/nonterminals"/>
<xsl:apply-templates select="unused/terminals"/> <xsl:apply-templates select="unused/terminals"/>
<xsl:apply-templates select="useless/rules"/> <xsl:apply-templates select="useless-in-grammar/rules"/>
</xsl:template> </xsl:template>
<xsl:template match="useless/nonterminals"> <xsl:template match="useless-in-grammar/nonterminals">
<h3> <h3>
<a name="useless_nonterminals"/> <a name="nonterminals_useless_in_grammar"/>
<xsl:text> Useless nonterminals</xsl:text> <xsl:text> Nonterminals useless in grammar</xsl:text>
</h3> </h3>
<xsl:text>&#10;&#10;</xsl:text> <xsl:text>&#10;&#10;</xsl:text>
<xsl:if test="nonterminal"> <xsl:if test="nonterminal">
@@ -175,10 +178,10 @@
</xsl:if> </xsl:if>
</xsl:template> </xsl:template>
<xsl:template match="useless/rules"> <xsl:template match="useless-in-grammar/rules">
<h3> <h3>
<a name="useless_rules"/> <a name="rules_useless_in_grammar"/>
<xsl:text> Useless rules</xsl:text> <xsl:text> Rules useless in grammar</xsl:text>
</h3> </h3>
<xsl:text>&#10;</xsl:text> <xsl:text>&#10;</xsl:text>
<xsl:if test="rule"> <xsl:if test="rule">

13
doc/bison.texinfo
View File

@@ -4887,8 +4887,9 @@ are useless in the generated parser.
@item Caveats: @item Caveats:
@itemize @bullet @itemize @bullet
@item Unreachable states may contain conflicts and may reduce rules not
reduced in any other state. @item Unreachable states may contain conflicts and may use rules not used in
any other state.
Thus, keeping unreachable states may induce warnings that are irrelevant to Thus, keeping unreachable states may induce warnings that are irrelevant to
your parser's behavior, and it may eliminate warnings that are relevant. your parser's behavior, and it may eliminate warnings that are relevant.
Of course, the change in warnings may actually be relevant to a parser table Of course, the change in warnings may actually be relevant to a parser table
@@ -7155,9 +7156,9 @@ useless: STR;
@command{bison} reports: @command{bison} reports:
@example @example
calc.y: warning: 1 useless nonterminal and 1 useless rule calc.y: warning: 1 nonterminal and 1 rule useless in grammar
calc.y:11.1-7: warning: useless nonterminal: useless calc.y:11.1-7: warning: nonterminal useless in grammar: useless
calc.y:11.10-12: warning: useless rule: useless: STR calc.y:11.10-12: warning: rule useless in grammar: useless: STR
calc.y: conflicts: 7 shift/reduce calc.y: conflicts: 7 shift/reduce
@end example @end example
@@ -7206,7 +7207,7 @@ Useless nonterminals:
Terminals which are not used: Terminals which are not used:
STR STR
Useless rules: Rules useless in grammar:
#6 useless: STR; #6 useless: STR;
@end example @end example

89
src/gram.c
View File

@@ -46,46 +46,24 @@ symbol_number *token_translations = NULL;
int max_user_token_number = 256; int max_user_token_number = 256;
/*--------------------------------------------------------------.
| Return true IFF the rule has a `number' smaller than NRULES. |
`--------------------------------------------------------------*/
bool bool
rule_useful_p (rule *r) rule_useful_in_grammar_p (rule *r)
{ {
return r->number < nrules; return r->number < nrules;
} }
/*-------------------------------------------------------------.
| Return true IFF the rule has a `number' higher than NRULES. |
`-------------------------------------------------------------*/
bool 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 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 void
rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out) 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, "<lhs>%s</lhs>", r->lhs->tag); xml_printf (out, level, "<lhs>%s</lhs>", r->lhs->tag);
} }
/*--------------------------------------.
| Return the number of symbols in RHS. |
`--------------------------------------*/
int int
rule_rhs_length (rule *r) rule_rhs_length (rule *r)
{ {
@@ -124,11 +97,6 @@ rule_rhs_length (rule *r)
return res; return res;
} }
/*-------------------------------.
| Print this rule's RHS on OUT. |
`-------------------------------*/
void void
rule_rhs_print (rule *r, FILE *out) rule_rhs_print (rule *r, FILE *out)
{ {
@@ -166,10 +134,6 @@ rule_rhs_print_xml (rule *r, FILE *out, int level)
} }
} }
/*-------------------------.
| Print this rule on OUT. |
`-------------------------*/
void void
rule_print (rule *r, FILE *out) rule_print (rule *r, FILE *out)
{ {
@@ -177,11 +141,6 @@ rule_print (rule *r, FILE *out)
rule_rhs_print (r, out); rule_rhs_print (r, out);
} }
/*------------------------.
| Dump RITEM for traces. |
`------------------------*/
void void
ritem_print (FILE *out) ritem_print (FILE *out)
{ {
@@ -195,11 +154,6 @@ ritem_print (FILE *out)
fputs ("\n\n", out); fputs ("\n\n", out);
} }
/*------------------------------------------.
| Return the size of the longest rule RHS. |
`------------------------------------------*/
size_t size_t
ritem_longest_rhs (void) ritem_longest_rhs (void)
{ {
@@ -216,11 +170,6 @@ ritem_longest_rhs (void)
return max; return max;
} }
/*-----------------------------------------------------------------.
| Print the grammar's rules that match FILTER on OUT under TITLE. |
`-----------------------------------------------------------------*/
void void
grammar_rules_partial_print (FILE *out, const char *title, grammar_rules_partial_print (FILE *out, const char *title,
rule_filter filter) rule_filter filter)
@@ -247,11 +196,6 @@ grammar_rules_partial_print (FILE *out, const char *title,
fputs ("\n\n", out); fputs ("\n\n", out);
} }
/*----------------------------------------------------------.
| Print the grammar's rules that match FILTER on OUT (XML). |
`-----------------------------------------------------------*/
void void
grammar_rules_partial_print_xml (FILE *out, int level, bool rtag, grammar_rules_partial_print_xml (FILE *out, int level, bool rtag,
rule_filter filter) rule_filter filter)
@@ -282,27 +226,18 @@ grammar_rules_partial_print_xml (FILE *out, int level, bool rtag,
} }
} }
/*------------------------------------------.
| Print the grammar's useful rules on OUT. |
`------------------------------------------*/
void void
grammar_rules_print (FILE *out) 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 void
grammar_rules_print_xml (FILE *out, int level) grammar_rules_print_xml (FILE *out, int level)
{ {
grammar_rules_partial_print_xml (out, level, true, rule_useful_p); grammar_rules_partial_print_xml (out, level, true, rule_useful_in_grammar_p);
} }
/*-------------------.
| Dump the grammar. |
`-------------------*/
void void
grammar_dump (FILE *out, const char *title) grammar_dump (FILE *out, const char *title)
{ {
@@ -366,16 +301,8 @@ grammar_dump (FILE *out, const char *title)
fprintf (out, "\n\n"); 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 void
grammar_rules_never_reduced_report (const char *message) grammar_rules_useless_report (const char *message)
{ {
rule_number r; rule_number r;
for (r = 0; r < nrules ; ++r) for (r = 0; r < nrules ; ++r)

29
src/gram.h
View File

@@ -204,15 +204,17 @@ extern rule *rules;
/* A function that selects a rule. */ /* A function that selects a rule. */
typedef bool (*rule_filter) (rule *); typedef bool (*rule_filter) (rule *);
/* Return true IFF the rule has a `number' smaller than NRULES. */ /* Return true IFF the rule has a `number' smaller than NRULES. That is, it is
bool rule_useful_p (rule *r); useful in the grammar. */
bool rule_useful_in_grammar_p (rule *r);
/* Return true IFF the rule has a `number' higher than NRULES. */ /* Return true IFF the rule has a `number' higher than NRULES. That is, it is
bool rule_useless_p (rule *r); useless in the grammar. */
bool rule_useless_in_grammar_p (rule *r);
/* Return true IFF the rule is not flagged as useful *and* is useful. /* Return true IFF the rule is not flagged as useful but is useful in the
In other words, it was discarded because of conflicts. */ grammar. In other words, it was discarded because of conflicts. */
bool rule_never_reduced_p (rule *r); bool rule_useless_in_parser_p (rule *r);
/* Print this rule's number and lhs on OUT. If a PREVIOUS_LHS was /* Print this rule's number and lhs on OUT. If a PREVIOUS_LHS was
already displayed (by a previous call for another rule), avoid already displayed (by a previous call for another rule), avoid
@@ -249,14 +251,13 @@ void ritem_print (FILE *out);
/* Return the size of the longest rule RHS. */ /* Return the size of the longest rule RHS. */
size_t ritem_longest_rhs (void); size_t ritem_longest_rhs (void);
/* Print the grammar's rules numbers from BEGIN (inclusive) to END /* Print the grammar's rules that match FILTER on OUT under TITLE. */
(exclusive) on OUT under TITLE. */
void grammar_rules_partial_print (FILE *out, const char *title, void grammar_rules_partial_print (FILE *out, const char *title,
rule_filter filter); rule_filter filter);
void grammar_rules_partial_print_xml (FILE *out, int level, bool rtag, void grammar_rules_partial_print_xml (FILE *out, int level, bool rtag,
rule_filter filter); rule_filter filter);
/* Print the grammar's rules on OUT. */ /* Print the grammar's useful rules on OUT. */
void grammar_rules_print (FILE *out); void grammar_rules_print (FILE *out);
void grammar_rules_print_xml (FILE *out, int level); void grammar_rules_print_xml (FILE *out, int level);
@@ -264,10 +265,10 @@ void grammar_rules_print_xml (FILE *out, int level);
void grammar_dump (FILE *out, const char *title); void grammar_dump (FILE *out, const char *title);
/* Report on STDERR the rules that are not flagged USEFUL, using the /* Report on STDERR the rules that are not flagged USEFUL, using the
MESSAGE (which can be `useless rule' when invoked after grammar MESSAGE (which can be `rule useless in grammar' when invoked after grammar
reduction, or `never reduced' after conflicts were taken into reduction, or `rule useless in parser due to conflicts' after conflicts
account). */ were taken into account). */
void grammar_rules_never_reduced_report (const char *message); void grammar_rules_useless_report (const char *message);
/* Free the packed grammar. */ /* Free the packed grammar. */
void grammar_free (void); void grammar_free (void);

4
src/main.c
View File

@@ -132,8 +132,8 @@ main (int argc, char *argv[])
tables_generate (); tables_generate ();
timevar_pop (TV_ACTIONS); timevar_pop (TV_ACTIONS);
grammar_rules_never_reduced_report grammar_rules_useless_report
(_("rule never reduced because of conflicts")); (_("rule useless in parser due to conflicts"));
/* Output file names. */ /* Output file names. */
compute_output_file_names (); compute_output_file_names ();

22
src/print-xml.c
View File

@@ -51,19 +51,19 @@ struct escape_buf
static struct escape_buf escape_bufs[2]; static struct escape_buf escape_bufs[2];
/*----------------------------. /*--------------------------------.
| Print rules never reduced. | | Print rules useless in parser. |
`-----------------------------*/ `--------------------------------*/
static void static void
print_rules_never_reduced (FILE *out, int level) print_rules_useless_in_parser (FILE *out, int level)
{ {
rule_number r; rule_number r;
bool count = false; bool count = false;
for (r = 0; r < nrules + nuseless_productions; r++) for (r = 0; r < nrules + nuseless_productions; r++)
{ {
if (rule_never_reduced_p (&rules[r])) if (rule_useless_in_parser_p (&rules[r]))
{ {
count = true; count = true;
break; break;
@@ -71,13 +71,13 @@ print_rules_never_reduced (FILE *out, int level)
} }
if (count) { if (count) {
xml_puts (out, level, "<rules-never-reduced>"); xml_puts (out, level, "<rules-useless-in-parser>");
grammar_rules_partial_print_xml (out, level - 1, grammar_rules_partial_print_xml (out, level - 1,
false, rule_never_reduced_p); false, rule_useless_in_parser_p);
xml_puts (out, level, "</rules-never-reduced>"); xml_puts (out, level, "</rules-useless-in-parser>");
} }
else else
xml_puts (out, level, "<rules-never-reduced/>"); xml_puts (out, level, "<rules-useless-in-parser/>");
} }
/*--------------------------------. /*--------------------------------.
@@ -587,8 +587,8 @@ print_xml (void)
/* print reductions */ /* print reductions */
reduce_xml (out, level + 1); reduce_xml (out, level + 1);
/* print rules never reduced */ /* print rules useless in parser */
print_rules_never_reduced (out, level + 1); print_rules_useless_in_parser (out, level + 1);
/* print grammar */ /* print grammar */
print_grammar (out, level + 1); print_grammar (out, level + 1);

3
src/print.c
View File

@@ -492,7 +492,8 @@ print_results (void)
reduce_output (out); reduce_output (out);
grammar_rules_partial_print (out, grammar_rules_partial_print (out,
_("Rules never reduced"), rule_never_reduced_p); _("Rules useless in parser due to conflicts"),
rule_useless_in_parser_p);
conflicts_output (out); conflicts_output (out);
print_grammar (out); print_grammar (out);

34
src/reduce.c
View File

@@ -239,7 +239,7 @@ reduce_grammar_tables (void)
rule_number r; rule_number r;
for (r = 0; r < nrules; r++) for (r = 0; r < nrules; r++)
rules[r].useful = bitset_test (P, 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 /* Map the nonterminals to their new index: useful first, useless
@@ -300,7 +300,7 @@ nonterminals_reduce (void)
if (!bitset_test (V, i)) if (!bitset_test (V, i))
{ {
nontermmap[i - ntokens] = n++; nontermmap[i - ntokens] = n++;
warn_at (symbols[i]->location, _("useless nonterminal: %s"), warn_at (symbols[i]->location, _("nonterminal useless in grammar: %s"),
symbols[i]->tag); symbols[i]->tag);
} }
@@ -348,7 +348,7 @@ reduce_output (FILE *out)
if (nuseless_nonterminals > 0) if (nuseless_nonterminals > 0)
{ {
int i; 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) 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); fputs ("\n\n", out);
@@ -370,8 +370,8 @@ reduce_output (FILE *out)
} }
if (nuseless_productions > 0) if (nuseless_productions > 0)
grammar_rules_partial_print (out, _("Useless rules"), grammar_rules_partial_print (out, _("Rules useless in grammar"),
rule_useless_p); rule_useless_in_grammar_p);
} }
@@ -384,7 +384,7 @@ reduce_xml (FILE *out, int level)
{ {
fputc ('\n', out); fputc ('\n', out);
xml_puts (out, level, "<reductions>"); xml_puts (out, level, "<reductions>");
xml_puts (out, level + 1, "<useless>"); xml_puts (out, level + 1, "<useless-in-grammar>");
if (nuseless_nonterminals > 0) if (nuseless_nonterminals > 0)
{ {
@@ -400,11 +400,12 @@ reduce_xml (FILE *out, int level)
xml_puts (out, level + 2, "<nonterminals/>"); xml_puts (out, level + 2, "<nonterminals/>");
if (nuseless_productions > 0) if (nuseless_productions > 0)
grammar_rules_partial_print_xml (out, level + 1, true, rule_useless_p); grammar_rules_partial_print_xml (out, level + 1, true,
rule_useless_in_grammar_p);
else else
xml_puts (out, level + 2, "<rules/>"); xml_puts (out, level + 2, "<rules/>");
xml_puts (out, level + 1, "</useless>"); xml_puts (out, level + 1, "</useless-in-grammar>");
xml_puts (out, level + 1, "<unused>"); xml_puts (out, level + 1, "<unused>");
{ {
@@ -439,17 +440,11 @@ reduce_xml (FILE *out, int level)
static void static void
reduce_print (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")); fprintf (stderr, "%s: %s: ", grammar_file, _("warning"));
if (nuseless_nonterminals > 0) if (nuseless_nonterminals > 0)
fprintf (stderr, ngettext ("%d useless nonterminal", fprintf (stderr, ngettext ("%d nonterminal",
"%d useless nonterminals", "%d nonterminals",
nuseless_nonterminals), nuseless_nonterminals),
nuseless_nonterminals); nuseless_nonterminals);
@@ -457,10 +452,13 @@ reduce_print (void)
fprintf (stderr, _(" and ")); fprintf (stderr, _(" and "));
if (nuseless_productions > 0) if (nuseless_productions > 0)
fprintf (stderr, ngettext ("%d useless rule", fprintf (stderr, ngettext ("%d rule",
"%d useless rules", "%d rules",
nuseless_productions), nuseless_productions),
nuseless_productions); nuseless_productions);
if (nuseless_nonterminals > 0 || nuseless_productions > 0)
fprintf (stderr, _(" useless in grammar"));
fprintf (stderr, "\n"); fprintf (stderr, "\n");
} }

30
tests/conflicts.at
View File

@@ -37,7 +37,7 @@ e: 'e' | /* Nothing. */;
]]) ]])
AT_CHECK([bison -o input.c input.y], 0, [], AT_CHECK([bison -o input.c input.y], 0, [],
[[input.y:4.9: warning: rule never reduced because of conflicts: e: /* empty */ [[input.y:4.9: warning: rule useless in parser due to conflicts: e: /* empty */
]]) ]])
AT_CLEANUP AT_CLEANUP
@@ -364,12 +364,12 @@ id : '0';
AT_CHECK([bison -o input.c --report=all input.y], 0, [], AT_CHECK([bison -o input.c --report=all input.y], 0, [],
[[input.y: conflicts: 1 reduce/reduce [[input.y: conflicts: 1 reduce/reduce
input.y:4.6-8: warning: rule never reduced because of conflicts: id: '0' input.y:4.6-8: warning: rule useless in parser due to conflicts: id: '0'
]]) ]])
# Check the contents of the report. # Check the contents of the report.
AT_CHECK([cat input.output], [], AT_CHECK([cat input.output], [],
[[Rules never reduced [[Rules useless in parser due to conflicts
4 id: '0' 4 id: '0'
@@ -667,17 +667,17 @@ reported_conflicts:
AT_CHECK([[bison --report=all input.y]], 0, [], AT_CHECK([[bison --report=all input.y]], 0, [],
[[input.y: conflicts: 1 shift/reduce, 1 reduce/reduce [[input.y: conflicts: 1 shift/reduce, 1 reduce/reduce
input.y:12.5-20: warning: rule never reduced because of conflicts: resolved_conflict: 'a' unreachable1 input.y:12.5-20: warning: rule useless in parser due to conflicts: resolved_conflict: 'a' unreachable1
input.y:20.5-20: warning: rule never reduced because of conflicts: unreachable1: 'a' unreachable2 input.y:20.5-20: warning: rule useless in parser due to conflicts: unreachable1: 'a' unreachable2
input.y:21.4: warning: rule never reduced because of conflicts: unreachable1: /* empty */ input.y:21.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */
input.y:25.13: warning: rule never reduced because of conflicts: unreachable2: /* empty */ input.y:25.13: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
input.y:25.16: warning: rule never reduced because of conflicts: unreachable2: /* empty */ input.y:25.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
input.y:31.5-7: warning: rule never reduced because of conflicts: reported_conflicts: 'a' input.y:31.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a'
input.y:32.4: warning: rule never reduced because of conflicts: reported_conflicts: /* empty */ input.y:32.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */
]]) ]])
AT_CHECK([[cat input.output]], 0, AT_CHECK([[cat input.output]], 0,
[[Rules never reduced [[Rules useless in parser due to conflicts
2 resolved_conflict: 'a' unreachable1 2 resolved_conflict: 'a' unreachable1
@@ -819,10 +819,10 @@ AT_CHECK([[cat input.y >> input-keep.y]])
AT_CHECK([[bison input-keep.y]], 0, [], AT_CHECK([[bison input-keep.y]], 0, [],
[[input-keep.y: conflicts: 2 shift/reduce, 2 reduce/reduce [[input-keep.y: conflicts: 2 shift/reduce, 2 reduce/reduce
input-keep.y:22.4: warning: rule never reduced because of conflicts: unreachable1: /* empty */ input-keep.y:22.4: warning: rule useless in parser due to conflicts: unreachable1: /* empty */
input-keep.y:26.16: warning: rule never reduced because of conflicts: unreachable2: /* empty */ input-keep.y:26.16: warning: rule useless in parser due to conflicts: unreachable2: /* empty */
input-keep.y:32.5-7: warning: rule never reduced because of conflicts: reported_conflicts: 'a' input-keep.y:32.5-7: warning: rule useless in parser due to conflicts: reported_conflicts: 'a'
input-keep.y:33.4: warning: rule never reduced because of conflicts: reported_conflicts: /* empty */ input-keep.y:33.4: warning: rule useless in parser due to conflicts: reported_conflicts: /* empty */
]]) ]])
AT_CLEANUP AT_CLEANUP

2
tests/existing.at
View File

@@ -1519,7 +1519,7 @@ expr:
# don't actually check the output. But SEGV is watching us, and # don't actually check the output. But SEGV is watching us, and
# so might do dmalloc. # so might do dmalloc.
AT_CHECK([[bison --verbose --defines input.y]], 0, [], AT_CHECK([[bison --verbose --defines input.y]], 0, [],
[[input.y:453.11-48: warning: rule never reduced because of conflicts: path: ORDINAL LAST object_type relative_path [[input.y:453.11-48: warning: rule useless in parser due to conflicts: path: ORDINAL LAST object_type relative_path
]]) ]])
AT_CLEANUP AT_CLEANUP

100
tests/reduce.at
View File

@@ -1,5 +1,5 @@
# Exercising Bison Grammar Reduction. -*- Autotest -*- # Exercising Bison Grammar Reduction. -*- Autotest -*-
# Copyright (C) 2001, 2002 Free Software Foundation, Inc. # Copyright (C) 2001, 2002, 2007 Free Software Foundation, Inc.
# This program 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 # it under the terms of the GNU General Public License as published by
@@ -87,20 +87,20 @@ exp: useful;
]]) ]])
AT_CHECK([[bison input.y]], 0, [], AT_CHECK([[bison input.y]], 0, [],
[[input.y: warning: 9 useless nonterminals [[input.y: warning: 9 nonterminals useless in grammar
input.y:4.8-15: warning: useless nonterminal: useless1 input.y:4.8-15: warning: nonterminal useless in grammar: useless1
input.y:5.8-15: warning: useless nonterminal: useless2 input.y:5.8-15: warning: nonterminal useless in grammar: useless2
input.y:6.8-15: warning: useless nonterminal: useless3 input.y:6.8-15: warning: nonterminal useless in grammar: useless3
input.y:7.8-15: warning: useless nonterminal: useless4 input.y:7.8-15: warning: nonterminal useless in grammar: useless4
input.y:8.8-15: warning: useless nonterminal: useless5 input.y:8.8-15: warning: nonterminal useless in grammar: useless5
input.y:9.8-15: warning: useless nonterminal: useless6 input.y:9.8-15: warning: nonterminal useless in grammar: useless6
input.y:10.8-15: warning: useless nonterminal: useless7 input.y:10.8-15: warning: nonterminal useless in grammar: useless7
input.y:11.8-15: warning: useless nonterminal: useless8 input.y:11.8-15: warning: nonterminal useless in grammar: useless8
input.y:12.8-15: warning: useless nonterminal: useless9 input.y:12.8-15: warning: nonterminal useless in grammar: useless9
]]) ]])
AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0, AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
[[Useless nonterminals [[Nonterminals useless in grammar
useless1 useless1
useless2 useless2
useless3 useless3
@@ -142,29 +142,29 @@ useless9: '9';
]]) ]])
AT_CHECK([[bison input.y]], 0, [], AT_CHECK([[bison input.y]], 0, [],
[[input.y: warning: 9 useless nonterminals and 9 useless rules [[input.y: warning: 9 nonterminals and 9 rules useless in grammar
input.y:6.1-8: warning: useless nonterminal: useless1 input.y:6.1-8: warning: nonterminal useless in grammar: useless1
input.y:7.1-8: warning: useless nonterminal: useless2 input.y:7.1-8: warning: nonterminal useless in grammar: useless2
input.y:8.1-8: warning: useless nonterminal: useless3 input.y:8.1-8: warning: nonterminal useless in grammar: useless3
input.y:9.1-8: warning: useless nonterminal: useless4 input.y:9.1-8: warning: nonterminal useless in grammar: useless4
input.y:10.1-8: warning: useless nonterminal: useless5 input.y:10.1-8: warning: nonterminal useless in grammar: useless5
input.y:11.1-8: warning: useless nonterminal: useless6 input.y:11.1-8: warning: nonterminal useless in grammar: useless6
input.y:12.1-8: warning: useless nonterminal: useless7 input.y:12.1-8: warning: nonterminal useless in grammar: useless7
input.y:13.1-8: warning: useless nonterminal: useless8 input.y:13.1-8: warning: nonterminal useless in grammar: useless8
input.y:14.1-8: warning: useless nonterminal: useless9 input.y:14.1-8: warning: nonterminal useless in grammar: useless9
input.y:6.11-13: warning: useless rule: useless1: '1' input.y:6.11-13: warning: rule useless in grammar: useless1: '1'
input.y:7.11-13: warning: useless rule: useless2: '2' input.y:7.11-13: warning: rule useless in grammar: useless2: '2'
input.y:8.11-13: warning: useless rule: useless3: '3' input.y:8.11-13: warning: rule useless in grammar: useless3: '3'
input.y:9.11-13: warning: useless rule: useless4: '4' input.y:9.11-13: warning: rule useless in grammar: useless4: '4'
input.y:10.11-13: warning: useless rule: useless5: '5' input.y:10.11-13: warning: rule useless in grammar: useless5: '5'
input.y:11.11-13: warning: useless rule: useless6: '6' input.y:11.11-13: warning: rule useless in grammar: useless6: '6'
input.y:12.11-13: warning: useless rule: useless7: '7' input.y:12.11-13: warning: rule useless in grammar: useless7: '7'
input.y:13.11-13: warning: useless rule: useless8: '8' input.y:13.11-13: warning: rule useless in grammar: useless8: '8'
input.y:14.11-13: warning: useless rule: useless9: '9' input.y:14.11-13: warning: rule useless in grammar: useless9: '9'
]]) ]])
AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0, AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
[[Useless nonterminals [[Nonterminals useless in grammar
useless1 useless1
useless2 useless2
useless3 useless3
@@ -184,7 +184,7 @@ Terminals which are not used
'7' '7'
'8' '8'
'9' '9'
Useless rules Rules useless in grammar
2 useless1: '1' 2 useless1: '1'
3 useless2: '2' 3 useless2: '2'
4 useless3: '3' 4 useless3: '3'
@@ -237,21 +237,21 @@ non_productive: non_productive useless_token
]]) ]])
AT_CHECK([[bison not-reduced.y]], 0, [], AT_CHECK([[bison not-reduced.y]], 0, [],
[[not-reduced.y: warning: 2 useless nonterminals and 3 useless rules [[not-reduced.y: warning: 2 nonterminals and 3 rules useless in grammar
not-reduced.y:14.1-13: warning: useless nonterminal: not_reachable not-reduced.y:14.1-13: warning: nonterminal useless in grammar: not_reachable
not-reduced.y:11.6-19: warning: useless nonterminal: non_productive not-reduced.y:11.6-19: warning: nonterminal useless in grammar: non_productive
not-reduced.y:11.6-57: warning: useless rule: exp: non_productive not-reduced.y:11.6-57: warning: rule useless in grammar: exp: non_productive
not-reduced.y:14.16-56: warning: useless rule: not_reachable: useful not-reduced.y:14.16-56: warning: rule useless in grammar: not_reachable: useful
not-reduced.y:17.17-18.63: warning: useless rule: non_productive: non_productive useless_token not-reduced.y:17.17-18.63: warning: rule useless in grammar: non_productive: non_productive useless_token
]]) ]])
AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' not-reduced.output]], 0, AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' not-reduced.output]], 0,
[[Useless nonterminals [[Nonterminals useless in grammar
not_reachable not_reachable
non_productive non_productive
Terminals which are not used Terminals which are not used
useless_token useless_token
Useless rules Rules useless in grammar
2 exp: non_productive 2 exp: non_productive
3 not_reachable: useful 3 not_reachable: useful
4 non_productive: non_productive useless_token 4 non_productive: non_productive useless_token
@@ -311,19 +311,19 @@ indirection: underivable;
]]) ]])
AT_CHECK([[bison input.y]], 0, [], AT_CHECK([[bison input.y]], 0, [],
[[input.y: warning: 2 useless nonterminals and 3 useless rules [[input.y: warning: 2 nonterminals and 3 rules useless in grammar
input.y:5.15-25: warning: useless nonterminal: underivable input.y:5.15-25: warning: nonterminal useless in grammar: underivable
input.y:6.14-24: warning: useless nonterminal: indirection input.y:6.14-24: warning: nonterminal useless in grammar: indirection
input.y:5.15-25: warning: useless rule: exp: underivable input.y:5.15-25: warning: rule useless in grammar: exp: underivable
input.y:6.14-24: warning: useless rule: underivable: indirection input.y:6.14-24: warning: rule useless in grammar: underivable: indirection
input.y:7.14-24: warning: useless rule: indirection: underivable input.y:7.14-24: warning: rule useless in grammar: indirection: underivable
]]) ]])
AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0, AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
[[Useless nonterminals [[Nonterminals useless in grammar
underivable underivable
indirection indirection
Useless rules Rules useless in grammar
2 exp: underivable 2 exp: underivable
3 underivable: indirection 3 underivable: indirection
4 indirection: underivable 4 indirection: underivable
@@ -346,7 +346,7 @@ exp: exp;
]]) ]])
AT_CHECK([[bison input.y]], 1, [], AT_CHECK([[bison input.y]], 1, [],
[[input.y: warning: 2 useless nonterminals and 2 useless rules [[input.y: warning: 2 nonterminals and 2 rules useless in grammar
input.y:3.1-3: fatal error: start symbol exp does not derive any sentence input.y:3.1-3: fatal error: start symbol exp does not derive any sentence
]]) ]])