* src/conflicts.c (conflicts_output): Don't output rules never

reduced here, since anyway that computation doesn't work.
* src/gram.h, src/gram.h (rule_filter_t, rule_useful_p)
(rule_useless_p, rule_never_reduced_p): New.
(grammar_rules_partial_print): Use a filter instead of a range.
Display the title only if needed.
(grammar_rules_print): Adjust.
(grammar_rules_never_reduced_report): New.
* src/tables.c (action_row): Move the computation of rules never
reduced to...
(token_actions): here.
* src/main.c (main): Make the parser before making the report, so
that rules never reduced are computed.
Call grammar_rules_never_reduced_report.
* src/print.c (print_results): Report rules never reduced.
* tests/conflicts.at, tests/reduce.at: Adjust.

diff --git a/ChangeLog b/ChangeLog
index b50e350301802473727e822a714ce42f7b931137..d9e3482aa28e04d4ce60ac976d12fa6a2dd0edbf 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,22 @@
+2002-08-02  Akim Demaille  <akim@epita.fr>
+
+       * src/conflicts.c (conflicts_output): Don't output rules never
+       reduced here, since anyway that computation doesn't work.
+       * src/gram.h, src/gram.h (rule_filter_t, rule_useful_p)
+       (rule_useless_p, rule_never_reduced_p): New.
+       (grammar_rules_partial_print): Use a filter instead of a range.
+       Display the title only if needed.
+       (grammar_rules_print): Adjust.
+       (grammar_rules_never_reduced_report): New.
+       * src/tables.c (action_row): Move the computation of rules never
+       reduced to...
+       (token_actions): here.
+       * src/main.c (main): Make the parser before making the report, so
+       that rules never reduced are computed.
+       Call grammar_rules_never_reduced_report.
+       * src/print.c (print_results): Report rules never reduced.
+       * tests/conflicts.at, tests/reduce.at: Adjust.
+
 2002-08-01  Akim Demaille  <akim@epita.fr>
 
        Instead of attaching lookaheads and duplicating the rules being

diff --git a/src/conflicts.c b/src/conflicts.c
index 1c24d7e23ebee0234754487f4fa1f386d76c165f..24f27cc8a37df8aad94bd6d20e83852be013e0b4 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -451,15 +451,10 @@ void
 conflicts_output (FILE *out)
 {
   bool printed_sth = FALSE;
-  bool *used_rules = XCALLOC (bool, nrules);
   state_number_t i;
   for (i = 0; i < nstates; i++)
     {
       state_t *s = states[i];
-      reductions_t *reds = s->reductions;
-      int j;
-      for (j = 0; j < reds->num; ++j)
-       used_rules[reds->rules[j]->number] = TRUE;
       if (conflicts[i])
        {
          fprintf (out, _("State %d contains "), i);
@@ -471,23 +466,6 @@ conflicts_output (FILE *out)
     }
   if (printed_sth)
     fputs ("\n\n", out);
-
-  for (i = 0; i < nstates; i++)
-    {
-      state_t *s = states[i];
-      reductions_t *r = s->reductions;
-      int j;
-      for (j = 0; j < r->num; ++j)
-       if (!used_rules[r->rules[j]->number])
-         {
-           LOCATION_PRINT (stderr, r->rules[j]->location);
-           fprintf (stderr, ": %s: %s: ",
-                    _("warning"),
-                    _("rule never reduced because of conflicts"));
-           rule_print (r->rules[j], stderr);
-         }
-    }
-  free (used_rules);
 }
 
 /*--------------------------------------------------------.

diff --git a/src/gram.c b/src/gram.c
index c28f5b5ed2d1abbb319837f9278035d1d2e8a29f..263411a4ab30f8c10a26fd60df2e24dcc28e91fc 100644 (file)
--- a/src/gram.c
+++ b/src/gram.c
@@ -47,6 +47,40 @@ int glr_parser = 0;
 int pure_parser = 0;
 
 
+/*--------------------------------------------------------------.
+| Return true IFF the rule has a `number' smaller than NRULES.  |
+`--------------------------------------------------------------*/
+
+bool
+rule_useful_p (rule_t *r)
+{
+  return r->number < nrules;
+}
+
+
+/*-------------------------------------------------------------.
+| Return true IFF the rule has a `number' higher than NRULES.  |
+`-------------------------------------------------------------*/
+
+bool
+rule_useless_p (rule_t *r)
+{
+  return r->number >= nrules;
+}
+
+
+/*--------------------------------------------------------------------.
+| 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_t *r)
+{
+  return !r->useful && r->number < nrules;
+}
+
+
 /*----------------------------------------------------------------.
 | Print this RULE's number and lhs on OUT.  If a PREVIOUS_LHS was |
 | already displayed (by a previous call for another rule), avoid  |
@@ -158,29 +192,34 @@ 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_number_t begin, rule_number_t end)
+                            rule_filter_t filter)
 {
   int r;
+  bool first = TRUE;
   symbol_t *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 (previous_lhs && previous_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);
+      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);
 }
 
 
@@ -191,7 +230,7 @@ grammar_rules_partial_print (FILE *out, const char *title,
 void
 grammar_rules_print (FILE *out)
 {
-  grammar_rules_partial_print (out, _("Grammar"), 0, nrules);
+  grammar_rules_partial_print (out, _("Grammar"), rule_useful_p);
 }
 
 
@@ -262,6 +301,27 @@ 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)
+{
+  rule_number_t 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)
 {

diff --git a/src/gram.h b/src/gram.h
index dd5a45f886a41b8bfa59d5b0ebb00afd23fe81c3..de782f7d646ef570f628230f767cb1d0ddbb8fa7 100644 (file)
--- a/src/gram.h
+++ b/src/gram.h
@@ -175,6 +175,36 @@ typedef struct rule_s
 
 extern struct rule_s *rules;
 
+/* A function that selects a rule.  */
+typedef bool (*rule_filter_t) PARAMS ((rule_t *r));
+
+/* Return true IFF the rule has a `number' smaller than NRULES.  */
+bool rule_useful_p PARAMS ((rule_t *r));
+
+/* Return true IFF the rule has a `number' higher than NRULES.  */
+bool rule_useless_p PARAMS ((rule_t *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 PARAMS ((rule_t *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 PARAMS ((rule_t *rule, symbol_t *previous_lhs, FILE *out));
+
+/* Return the length of the RHS.  */
+int rule_rhs_length PARAMS ((rule_t *rule));
+
+/* Print this RULE's RHS on OUT.  */
+void rule_rhs_print PARAMS ((rule_t *rule, FILE *out));
+
+/* Print this RULE on OUT.  */
+void rule_print PARAMS ((rule_t *rule, FILE *out));
+
+
+
+
 /* Table of the symbols, indexed by the symbol number. */
 extern symbol_t **symbols;
 
@@ -185,6 +215,7 @@ extern symbol_number_t *token_translations;
 extern int max_user_token_number;
 
 
+
 /* GLR_PARSER is nonzero if the input file says to use the GLR
    (Generalized LR) parser, and to output some additional
    information used by the GLR algorithm. */
@@ -196,20 +227,6 @@ extern int glr_parser;
 
 extern int pure_parser;
 
-/* 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 PARAMS ((rule_t *rule, symbol_t *previous_lhs, FILE *out));
-
-/* Return the length of the RHS.  */
-int rule_rhs_length PARAMS ((rule_t *rule));
-
-/* Print this RULE's RHS on OUT.  */
-void rule_rhs_print PARAMS ((rule_t *rule, FILE *out));
-
-/* Print this RULE on OUT.  */
-void rule_print PARAMS ((rule_t *rule, FILE *out));
-
 /* Dump RITEM for traces. */
 void ritem_print PARAMS ((FILE *out));
 
@@ -219,8 +236,7 @@ size_t ritem_longest_rhs PARAMS ((void));
 /* Print the grammar's rules numbers from BEGIN (inclusive) to END
    (exclusive) on OUT under TITLE.  */
 void grammar_rules_partial_print PARAMS ((FILE *out, const char *title,
-                                         rule_number_t begin,
-                                         rule_number_t end));
+                                         rule_filter_t filter));
 
 /* Print the grammar's rules on OUT.  */
 void grammar_rules_print PARAMS ((FILE *out));
@@ -228,6 +244,12 @@ void grammar_rules_print PARAMS ((FILE *out));
 /* Dump the grammar. */
 void grammar_dump PARAMS ((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 PARAMS ((const char *message));
+
 /* Free the packed grammar. */
 void grammar_free PARAMS ((void));
 

diff --git a/src/main.c b/src/main.c
index e634f310fd69b02ca93dd2f94c88c3ee38938621..602d4db6b72e9f94ac8699fc8b296333aa4c0ed7 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -108,6 +108,14 @@ main (int argc, char *argv[])
   conflicts_print ();
   timevar_pop (TV_CONFLICTS);
 
+  /* Compute the parser tables.  */
+  timevar_push (TV_ACTIONS);
+  tables_generate ();
+  timevar_pop (TV_ACTIONS);
+
+  grammar_rules_never_reduced_report
+    (_("rule never reduced because of conflicts"));
+
   /* Output file names. */
   compute_output_file_names ();
 
@@ -119,11 +127,6 @@ main (int argc, char *argv[])
       timevar_pop (TV_REPORT);
     }
 
-  /* Stop if there were errors, to avoid trashing previous output
-     files.  */
-  if (complain_message_count)
-    exit (1);
-
   /* Output the VCG graph.  */
   if (graph_flag)
     {
@@ -132,10 +135,10 @@ main (int argc, char *argv[])
       timevar_pop (TV_GRAPH);
     }
 
-  /* Compute the parser tables.  */
-  timevar_push (TV_ACTIONS);
-  tables_generate ();
-  timevar_pop (TV_ACTIONS);
+  /* Stop if there were errors, to avoid trashing previous output
+     files.  */
+  if (complain_message_count)
+    exit (1);
 
   /* Lookaheads are no longer needed. */
   timevar_push (TV_FREE);

diff --git a/src/print.c b/src/print.c
index 12466c905e4c4de54f55aba2a7fb9c9ae9e35c19..6fbe2c9a1ac31934ed24e6e3df63a445935d4d23 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -548,6 +548,8 @@ print_results (void)
   FILE *out = xfopen (spec_verbose_file, "w");
 
   reduce_output (out);
+  grammar_rules_partial_print (out,
+                              _("Rules never reduced"), rule_never_reduced_p);
   conflicts_output (out);
 
   print_grammar (out);

diff --git a/src/reduce.c b/src/reduce.c
index 986aecd045dbd618cdddb0f5391650cd2a907f6b..7bbd89542ad13abf67a767a970f3c20a21a4bbc6 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -235,15 +235,8 @@ reduce_grammar_tables (void)
   {
     rule_number_t r;
     for (r = 0; r < nrules; r++)
-      {
-       rules[r].useful = bitset_test (P, r);
-       if (!rules[r].useful)
-         {
-           LOCATION_PRINT (stderr, rules[r].location);
-           fprintf (stderr, ": %s: %s: ", _("warning"), _("useless rule"));
-           rule_print (&rules[r], stderr);
-         }
-      }
+      rules[r].useful = bitset_test (P, r);
+    grammar_rules_never_reduced_report (_("useless rule"));
   }
 
   /* Map the nonterminals to their new index: useful first, useless
@@ -353,7 +346,7 @@ reduce_output (FILE *out)
   if (nuseless_nonterminals > 0)
     {
       int i;
-      fprintf (out, "%s\n\n", _("Useless nonterminals:"));
+      fprintf (out, "%s\n\n", _("Useless nonterminals"));
       for (i = 0; i < nuseless_nonterminals; ++i)
        fprintf (out, "   %s\n", symbols[nsyms + i]->tag);
       fputs ("\n\n", out);
@@ -366,7 +359,7 @@ reduce_output (FILE *out)
       if (!bitset_test (V, i) && !bitset_test (V1, i))
        {
          if (!b)
-           fprintf (out, "%s\n\n", _("Terminals which are not used:"));
+           fprintf (out, "%s\n\n", _("Terminals which are not used"));
          b = TRUE;
          fprintf (out, "   %s\n", symbols[i]->tag);
        }
@@ -376,8 +369,7 @@ reduce_output (FILE *out)
 
   if (nuseless_productions > 0)
     grammar_rules_partial_print (out, _("Useless rules"),
-                                nrules,
-                                nrules + nuseless_productions);
+                                rule_useless_p);
 }
 \f
 

diff --git a/src/tables.c b/src/tables.c
index 75502759162d3a412c25b31c2a70e208c756a05a..47d9d6af2e97f49492191f8fb3fb0a7a68e1473f 100644 (file)
--- a/src/tables.c
+++ b/src/tables.c
@@ -394,16 +394,6 @@ action_row (state_t *state)
        }
     }
 
-  /* Find the rules which are reduced.  */
-  if (!glr_parser)
-    {
-      for (i = 0; i < ntokens; i++)
-       if (actrow[i] < 0 && actrow[i] != ACTION_MIN)
-         rules[item_number_as_rule_number (actrow[i])].useful = TRUE;
-      if (default_rule)
-       default_rule->useful = TRUE;
-    }
-
   /* If have no default rule, the default is an error.
      So replace any action which says "error" with "use default".  */
 
@@ -477,7 +467,9 @@ static void
 token_actions (void)
 {
   state_number_t i;
+  symbol_number_t j;
   rule_number_t r;
+
   int nconflict = conflicts_total_count ();
 
   yydefact = XCALLOC (rule_number_t, nstates);
@@ -485,9 +477,7 @@ token_actions (void)
   actrow = XCALLOC (action_t, ntokens);
   conflrow = XCALLOC (unsigned int, ntokens);
 
-  /* Now that the parser was computed, we can find which rules are
-     really reduced, and which are not because of SR or RR conflicts.
-     */
+  /* Find the rules which are reduced.  */
   if (!glr_parser)
     for (r = 0; r < nrules; ++r)
       rules[r].useful = FALSE;
@@ -506,17 +496,19 @@ token_actions (void)
       rule_t *default_rule = action_row (states[i]);
       yydefact[i] = default_rule ? default_rule->number + 1 : 0;
       save_row (i);
-    }
 
-  if (!glr_parser)
-    for (r = 0; r < nrules ; ++r)
-      if (!rules[r].useful)
+      /* Now that the parser was computed, we can find which rules are
+        really reduced, and which are not because of SR or RR
+        conflicts.  */
+      if (!glr_parser)
        {
-         LOCATION_PRINT (stderr, rules[r].location);
-         fprintf (stderr, ": %s: %s: ",
-                  _("warning"), _("rule never reduced because of conflicts"));
-         rule_print (&rules[r], stderr);
+         for (j = 0; j < ntokens; ++j)
+           if (actrow[j] < 0 && actrow[j] != ACTION_MIN)
+             rules[item_number_as_rule_number (actrow[j])].useful = TRUE;
+         if (yydefact[i])
+           rules[yydefact[i] - 1].useful = TRUE;
        }
+    }
 
   free (actrow);
   free (conflrow);

diff --git a/tests/conflicts.at b/tests/conflicts.at
index 6a9ef9bd454ff8f5d727d66194bfc2095b5cbfb9..6f0a971f3ff66623a59db975228d861f3b4795bf 100644 (file)
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -377,7 +377,12 @@ input.y:4.4-8: warning: rule never reduced because of conflicts: id: '0'
 
 # Check the contents of the report.
 AT_CHECK([cat input.output], [],
-[[State 1 contains 1 reduce/reduce conflict.
+[[Rules never reduced
+
+    4 id: '0'
+
+
+State 1 contains 1 reduce/reduce conflict.
 
 
 Grammar

diff --git a/tests/reduce.at b/tests/reduce.at
index 4c8da723898cc719bab2105918899cc9250b34db..e475cb04a8d2ffa3cd9cf70988b9d4a2336888e4 100644 (file)
--- a/tests/reduce.at
+++ b/tests/reduce.at
@@ -47,7 +47,7 @@ exp: useful;
 AT_CHECK([[bison input.y]])
 
 AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
-[[Terminals which are not used:
+[[Terminals which are not used
    useless1
    useless2
    useless3
@@ -102,7 +102,7 @@ input.y:12.8-15: warning: useless nonterminal: useless9
 ]])
 
 AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
-[[Useless nonterminals:
+[[Useless nonterminals
    useless1
    useless2
    useless3
@@ -166,7 +166,7 @@ input.y:14.9-13: warning: useless rule: useless9: '9'
 ]])
 
 AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
-[[Useless nonterminals:
+[[Useless nonterminals
    useless1
    useless2
    useless3
@@ -176,7 +176,7 @@ AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
    useless7
    useless8
    useless9
-Terminals which are not used:
+Terminals which are not used
    '1'
    '2'
    '3'
@@ -248,10 +248,10 @@ not-reduced.y:17.15-18.63: warning: useless rule: non_productive: non_productive
 ]])
 
 AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' not-reduced.output]], 0,
-[[Useless nonterminals:
+[[Useless nonterminals
    not_reachable
    non_productive
-Terminals which are not used:
+Terminals which are not used
    useless_token
 Useless rules
     2 exp: non_productive
@@ -322,7 +322,7 @@ input.y:7.12-24: warning: useless rule: indirection: underivable
 ]])
 
 AT_CHECK([[sed -n '/^Grammar/q;/^$/!p' input.output]], 0,
-[[Useless nonterminals:
+[[Useless nonterminals
    underivable
    indirection
 Useless rules