Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-11 13: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

89
src/gram.c
View File

@@ -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, "<lhs>%s</lhs>", 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)
{
@@ -166,10 +134,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 +141,6 @@ rule_print (rule *r, FILE *out)
rule_rhs_print (r, out);
}
/*------------------------.
| Dump RITEM for traces. |
`------------------------*/
void
ritem_print (FILE *out)
{
@@ -195,11 +154,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 +170,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,11 +196,6 @@ 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_partial_print_xml (FILE *out, int level, bool rtag,
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
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)
{
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
grammar_dump (FILE *out, const char *title)
{
@@ -366,16 +301,8 @@ 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)

29
src/gram.h
View File

@@ -204,15 +204,17 @@ extern rule *rules;
/* A function that selects a rule. */
typedef bool (*rule_filter) (rule *);
/* Return true IFF the rule has a `number' smaller than NRULES. */
bool rule_useful_p (rule *r);
/* Return true IFF the rule has a `number' smaller than NRULES. That is, it is
useful in the grammar. */
bool rule_useful_in_grammar_p (rule *r);
/* Return true IFF the rule has a `number' higher than NRULES. */
bool rule_useless_p (rule *r);
/* Return true IFF the rule has a `number' higher than NRULES. That is, it is
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.
In other words, it was discarded because of conflicts. */
bool rule_never_reduced_p (rule *r);
/* Return true IFF the rule is not flagged as useful but is useful in the
grammar. In other words, it was discarded because of conflicts. */
bool rule_useless_in_parser_p (rule *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
@@ -249,14 +251,13 @@ void ritem_print (FILE *out);
/* Return the size of the longest rule RHS. */
size_t ritem_longest_rhs (void);
/* Print the grammar's rules numbers from BEGIN (inclusive) to END
(exclusive) on OUT under TITLE. */
/* 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);
void grammar_rules_partial_print_xml (FILE *out, int level, bool rtag,
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_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);
/* 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);
MESSAGE (which can be `rule useless in grammar' when invoked after grammar
reduction, or `rule useless in parser due to conflicts' after conflicts
were taken into account). */
void grammar_rules_useless_report (const char *message);
/* Free the packed grammar. */
void grammar_free (void);

4
src/main.c
View File

@@ -132,8 +132,8 @@ main (int argc, char *argv[])
tables_generate ();
timevar_pop (TV_ACTIONS);
grammar_rules_never_reduced_report
(_("rule never reduced because of conflicts"));
grammar_rules_useless_report
(_("rule useless in parser due to conflicts"));
/* 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];
/*----------------------------.
| Print rules never reduced. |
`-----------------------------*/
/*--------------------------------.
| Print rules useless in parser. |
`--------------------------------*/
static void
print_rules_never_reduced (FILE *out, int level)
print_rules_useless_in_parser (FILE *out, int level)
{
rule_number r;
bool count = false;
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;
break;
@@ -71,13 +71,13 @@ print_rules_never_reduced (FILE *out, int level)
}
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,
false, rule_never_reduced_p);
xml_puts (out, level, "</rules-never-reduced>");
false, rule_useless_in_parser_p);
xml_puts (out, level, "</rules-useless-in-parser>");
}
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 */
reduce_xml (out, level + 1);
/* print rules never reduced */
print_rules_never_reduced (out, level + 1);
/* print rules useless in parser */
print_rules_useless_in_parser (out, level + 1);
/* print grammar */
print_grammar (out, level + 1);

3
src/print.c
View File

@@ -492,7 +492,8 @@ print_results (void)
reduce_output (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);
print_grammar (out);

34
src/reduce.c
View File

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