* src/LR0.c (augment_automaton): Better variable locality.

[bison.git] / src / reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index 190f357746a43f9165e380302ab82efb89ae395c..d8ea5ed60ba1f95327219cdc8cf51db90e6f10a1 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -54,7 +54,7 @@ static BSet V1;
 static int nuseful_productions;
 static int nuseless_productions;
 static int nuseful_nonterminals;
-static int nuseless_nonterminals;
+int nuseless_nonterminals;
 \f
 static bool
 bits_equal (BSet L, BSet R, int n)
@@ -264,28 +264,35 @@ inaccessable_symbols (void)
 static void
 reduce_grammar_tables (void)
 {
-/* This is turned off because we would need to change the numbers
-   in the case statements in the actions file.  */
-#if 0
-  /* remove useless productions */
-  if (nuseless_productions > 0)
-    {
-      short np, pn, ni, pi;
+  /* This is turned off because we would need to change the numbers in
+     the case statements in the actions file.
 
-      np = 0;
-      ni = 0;
-      for (pn = 1; pn <= nrules; pn++)
-       {
+     We don't disable it via CPP so that it is still checked with the
+     rest of the code, to avoid its becoming completely obsolete.
+
+     FIXME: I think the comment above demonstrates this code must be
+     turned off for *semantic* parser, not in the general case.  Try
+     to understand this better --akim.  */
+
+  if (0)
+    /* remove useless productions */
+    if (nuseless_productions > 0)
+      {
+       short np, pn, ni, pi;
+
+       np = 0;
+       ni = 0;
+       for (pn = 1; pn <= nrules; pn++)
          if (BITISSET (P, pn))
            {
              np++;
              if (pn != np)
                {
-                 rule_table[np].lhs = rule_table[pn].lhs;
-                 rline[np] = rline[pn];
-                 rule_table[np].prec = rule_table[pn].prec;
+                 rule_table[np].lhs   = rule_table[pn].lhs;
+                 rule_table[np].line  = rule_table[pn].line;
+                 rule_table[np].prec  = rule_table[pn].prec;
                  rule_table[np].assoc = rule_table[pn].assoc;
-                 rule_table[np].rhs = rule_table[pn].rhs;
+                 rule_table[np].rhs   = rule_table[pn].rhs;
                  if (rule_table[np].rhs != ni)
                    {
                      pi = rule_table[np].rhs;
@@ -300,16 +307,15 @@ reduce_grammar_tables (void)
                  while (ritem[ni++] >= 0);
                }
            }
-       }
-      ritem[ni] = 0;
-      nrules -= nuseless_productions;
-      nitems = ni;
 
-      /* Is it worth it to reduce the amount of memory for the
-         grammar? Probably not.  */
+       ritem[ni] = 0;
+       nrules -= nuseless_productions;
+       nitems = ni;
+
+       /* Is it worth it to reduce the amount of memory for the
+          grammar? Probably not.  */
+      }
 
-    }
-#endif /* 0 */
   /* Disable useless productions. */
   if (nuseless_productions > 0)
     {
@@ -455,18 +461,22 @@ dump_grammar (FILE *out)
     fprintf (out, "%5d  %5d   %5d  %s\n", i, sprec[i], sassoc[i], tags[i]);
   fprintf (out, "\n\n");
   fprintf (out, "Rules\n-----\n\n");
-  fprintf (out, "Num (Prec, Assoc) Lhs : (@Rhs) Ritems [Num?]\n");
+  fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
   for (i = 1; i <= nrules; i++)
     {
-      fprintf (out, "%-5d(%5d%5d)%5d : (@%-5d)",
+      int rhs_count = 0;
+      /* Find the last RHS index in ritems. */
+      for (r = &ritem[rule_table[i].rhs]; *r > 0; ++r)
+       ++rhs_count;
+      fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
               i,
-              rule_table[i].prec,
-              rule_table[i].assoc,
-              rule_table[i].lhs,
-              rule_table[i].rhs);
+              rule_table[i].prec, rule_table[i].assoc, rule_table[i].useful,
+              rule_table[i].rhs, rule_table[i].rhs + rhs_count - 1,
+              rule_table[i].lhs);
+      /* Dumped the RHS. */
       for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
-       fprintf (out, "%5d", *r);
-      fprintf (out, " [%d]\n", -(*r));
+       fprintf (out, "%3d", *r);
+      fprintf (out, "  [%d]\n", -(*r));
     }
   fprintf (out, "\n\n");
   fprintf (out, "Rules interpreted\n-----------------\n\n");