X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/760b53a84bfc0c79bac266414136936400769e33..74ffbcb6bf2b471ef16c485830a3084978fa29f7:/src/reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index 7e164c50..d8ea5ed6 100644
--- 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;
 
 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,30 +307,21 @@ 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;
 
-    }
-#endif /* 0 */
-  /* Disable useless productions,
-     since they may contain useless nonterms
-     that would get mapped below to -1 and confuse everyone.  */
+	/* Is it worth it to reduce the amount of memory for the
+	   grammar? Probably not.  */
+      }
+
+  /* Disable useless productions. */
   if (nuseless_productions > 0)
     {
       int pn;
-
       for (pn = 1; pn <= nrules; pn++)
-	{
-	  if (!BITISSET (P, pn))
-	    {
-	      rule_table[pn].lhs = -1;
-	    }
-	}
+	rule_table[pn].useful = BITISSET (P, pn);
     }
 }
 
@@ -338,8 +336,8 @@ nonterminals_reduce (void)
   int i, n;
   rule r;
 
-  /* Create a map of nonterminal number to new nonterminal number. -1
-     in the map means it was useless and is being eliminated.  */
+  /* Map the nonterminals to their new index: useful first, useless
+     afterwards.  Kept for later report.  */
 
   short *nontermmap = XCALLOC (short, nvars) - ntokens;
   n = ntokens;
@@ -379,9 +377,7 @@ nonterminals_reduce (void)
 
   for (i = 1; i <= nrules; i++)
     {
-      /* Ignore the rules disabled above.  */
-      if (rule_table[i].lhs >= 0)
-	rule_table[i].lhs = nontermmap[rule_table[i].lhs];
+      rule_table[i].lhs = nontermmap[rule_table[i].lhs];
       if (ISVAR (rule_table[i].precsym))
 	/* Can this happen?  */
 	rule_table[i].precsym = nontermmap[rule_table[i].precsym];
@@ -396,7 +392,7 @@ nonterminals_reduce (void)
   nsyms -= nuseless_nonterminals;
   nvars -= nuseless_nonterminals;
 
-  free (&nontermmap[ntokens]);
+  free (nontermmap + ntokens);
 }
 
 
@@ -407,50 +403,46 @@ nonterminals_reduce (void)
 void
 reduce_output (FILE *out)
 {
-  int i;
-  rule r;
-  bool b;
-
   if (nuseless_nonterminals > 0)
     {
-      fprintf (out, _("Useless nonterminals:"));
-      fprintf (out, "\n\n");
+      int i;
+      fprintf (out, "%s\n\n", _("Useless nonterminals:"));
       for (i = 0; i < nuseless_nonterminals; ++i)
 	fprintf (out, "   %s\n", tags[nsyms + i]);
+      fputs ("\n\n", out);
     }
-  b = FALSE;
-  for (i = 0; i < ntokens; i++)
-    {
+
+  {
+    bool b = FALSE;
+    int i;
+    for (i = 0; i < ntokens; i++)
       if (!BITISSET (V, i) && !BITISSET (V1, i))
 	{
 	  if (!b)
-	    {
-	      fprintf (out, "\n\n");
-	      fprintf (out, _("Terminals which are not used:"));
-	      fprintf (out, "\n\n");
-	      b = TRUE;
-	    }
+	    fprintf (out, "%s\n\n", _("Terminals which are not used:"));
+	  b = TRUE;
 	  fprintf (out, "   %s\n", tags[i]);
 	}
-    }
+    if (b)
+      fputs ("\n\n", out);
+  }
 
   if (nuseless_productions > 0)
     {
-      fprintf (out, "\n\n");
-      fprintf (out, _("Useless rules:"));
-      fprintf (out, "\n\n");
+      int i;
+      fprintf (out, "%s\n\n", _("Useless rules:"));
       for (i = 1; i <= nrules; i++)
-	if (!BITISSET (P, i))
+	if (!rule_table[i].useful)
 	  {
+	    rule r;
 	    fprintf (out, "#%-4d  ", i);
-	    fprintf (out, "%s :\t", tags[rule_table[i].lhs]);
+	    fprintf (out, "%s:", tags[rule_table[i].lhs]);
 	    for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
 	      fprintf (out, " %s", tags[*r]);
-	    fprintf (out, ";\n");
+	    fputs (";\n", out);
 	  }
+      fputs ("\n\n", out);
     }
-  if (nuseless_nonterminals > 0 || nuseless_productions > 0 || b)
-    fprintf (out, "\n\n");
 }
 
 static void
@@ -469,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");