X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/630e182b7ba2257805c49424c96b9dc03a113668..bec30531f782a6f4fe1466fb62b61352d873cb58:/src/reduce.c

diff --git a/src/reduce.c b/src/reduce.c
index 87a2a1a9..0beff91a 100644
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -28,6 +28,7 @@
 #include "system.h"
 #include "getargs.h"
 #include "files.h"
+#include "symtab.h"
 #include "gram.h"
 #include "complain.h"
 #include "reduce.h"
@@ -107,7 +108,7 @@ useful_production (int i, BSet N0)
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 
-  for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
+  for (r = &ritem[rules[i].rhs]; *r >= 0; r++)
     if (ISVAR (n = *r))
       if (!BITISSET (N0, n - ntokens))
 	return FALSE;
@@ -156,7 +157,7 @@ useless_nonterminals (void)
 	    {
 	      if (useful_production (i, N))
 		{
-		  SETBIT (Np, rule_table[i].lhs - ntokens);
+		  SETBIT (Np, rules[i].lhs - ntokens);
 		  SETBIT (P, i);
 		}
 	    }
@@ -219,9 +220,9 @@ inaccessable_symbols (void)
 	    {
 	      if (!BITISSET (Pp, i)
 		  && BITISSET (P, i)
-		  && BITISSET (V, rule_table[i].lhs))
+		  && BITISSET (V, rules[i].lhs))
 		{
-		  for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
+		  for (r = &ritem[rules[i].rhs]; *r >= 0; r++)
 		    if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
 		      SETBIT (Vp, t);
 		  SETBIT (Pp, i);
@@ -257,39 +258,46 @@ inaccessable_symbols (void)
 
   /* A token that was used in %prec should not be warned about.  */
   for (i = 1; i < nrules; i++)
-    if (rule_table[i].precsym != 0)
-      SETBIT (V1, rule_table[i].precsym);
+    if (rules[i].precsym != 0)
+      SETBIT (V1, rules[i].precsym);
 }
 
 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].assoc = rule_table[pn].assoc;
-		  rule_table[np].rhs = rule_table[pn].rhs;
-		  if (rule_table[np].rhs != ni)
+		  rules[np].lhs   = rules[pn].lhs;
+		  rules[np].line  = rules[pn].line;
+		  rules[np].prec  = rules[pn].prec;
+		  rules[np].assoc = rules[pn].assoc;
+		  rules[np].rhs   = rules[pn].rhs;
+		  if (rules[np].rhs != ni)
 		    {
-		      pi = rule_table[np].rhs;
-		      rule_table[np].rhs = ni;
+		      pi = rules[np].rhs;
+		      rules[np].rhs = ni;
 		      while (ritem[pi] >= 0)
 			ritem[ni++] = ritem[pi++];
 		      ritem[ni++] = -np;
@@ -297,25 +305,26 @@ reduce_grammar_tables (void)
 		}
 	      else
 		{
-		  while (ritem[ni++] >= 0);
+		  while (ritem[ni++] >= 0)
+		    /* Nothing. */;
 		}
 	    }
-	}
-      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;
+	nritems = 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)
     {
       int pn;
       for (pn = 1; pn <= nrules; pn++)
-	rule_table[pn].useful = BITISSET (P, pn);
+	rules[pn].useful = BITISSET (P, pn);
     }
 }
 
@@ -328,7 +337,6 @@ static void
 nonterminals_reduce (void)
 {
   int i, n;
-  rule r;
 
   /* Map the nonterminals to their new index: useful first, useless
      afterwards.  Kept for later report.  */
@@ -345,41 +353,28 @@ nonterminals_reduce (void)
 
   /* Shuffle elements of tables indexed by symbol number.  */
   {
-    short *sassoc_sorted = XMALLOC (short, nvars) - ntokens;
-    short *sprec_sorted  = XMALLOC (short, nvars) - ntokens;
-    char **tags_sorted   = XMALLOC (char *, nvars) - ntokens;
+    bucket **symbols_sorted = XMALLOC (bucket *, nvars) - ntokens;
 
     for (i = ntokens; i < nsyms; i++)
-      {
-	n = nontermmap[i];
-	sassoc_sorted[n] = sassoc[i];
-	sprec_sorted[n]  = sprec[i];
-	tags_sorted[n]   = tags[i];
-      }
+      symbols_sorted[nontermmap[i]] = symbols[i];
     for (i = ntokens; i < nsyms; i++)
-      {
-	sassoc[i] = sassoc_sorted[i];
-	sprec[i]  = sprec_sorted[i];
-	tags[i]   = tags_sorted[i];
-      }
-    free (sassoc_sorted + ntokens);
-    free (sprec_sorted + ntokens);
-    free (tags_sorted + ntokens);
+      symbols[i] = symbols_sorted[i];
+    free (symbols_sorted + ntokens);
   }
 
   /* Replace all symbol numbers in valid data structures.  */
 
   for (i = 1; i <= nrules; i++)
     {
-      rule_table[i].lhs = nontermmap[rule_table[i].lhs];
-      if (ISVAR (rule_table[i].precsym))
+      rules[i].lhs = nontermmap[rules[i].lhs];
+      if (ISVAR (rules[i].precsym))
 	/* Can this happen?  */
-	rule_table[i].precsym = nontermmap[rule_table[i].precsym];
+	rules[i].precsym = nontermmap[rules[i].precsym];
     }
 
-  for (r = ritem; *r; r++)
-    if (ISVAR (*r))
-      *r = nontermmap[*r];
+  for (i = 0; i < nritems; ++i)
+    if (ISVAR (ritem[i]))
+      ritem[i] = nontermmap[ritem[i]];
 
   start_symbol = nontermmap[start_symbol];
 
@@ -402,7 +397,7 @@ reduce_output (FILE *out)
       int i;
       fprintf (out, "%s\n\n", _("Useless nonterminals:"));
       for (i = 0; i < nuseless_nonterminals; ++i)
-	fprintf (out, "   %s\n", tags[nsyms + i]);
+	fprintf (out, "   %s\n", symbols[nsyms + i]->tag);
       fputs ("\n\n", out);
     }
 
@@ -415,7 +410,7 @@ reduce_output (FILE *out)
 	  if (!b)
 	    fprintf (out, "%s\n\n", _("Terminals which are not used:"));
 	  b = TRUE;
-	  fprintf (out, "   %s\n", tags[i]);
+	  fprintf (out, "   %s\n", symbols[i]->tag);
 	}
     if (b)
       fputs ("\n\n", out);
@@ -426,13 +421,13 @@ reduce_output (FILE *out)
       int i;
       fprintf (out, "%s\n\n", _("Useless rules:"));
       for (i = 1; i <= nrules; i++)
-	if (!rule_table[i].useful)
+	if (!rules[i].useful)
 	  {
 	    rule r;
-	    fprintf (out, "#%-4d  ", i);
-	    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, "#%-4d  ", i - 1);
+	    fprintf (out, "%s:", symbols[rules[i].lhs]->tag);
+	    for (r = &ritem[rules[i].rhs]; *r >= 0; r++)
+	      fprintf (out, " %s", symbols[*r]->tag);
 	    fputs (";\n", out);
 	  }
       fputs ("\n\n", out);
@@ -452,7 +447,9 @@ dump_grammar (FILE *out)
   fprintf (out, "Variables\n---------\n\n");
   fprintf (out, "Value  Sprec  Sassoc  Tag\n");
   for (i = ntokens; i < nsyms; i++)
-    fprintf (out, "%5d  %5d   %5d  %s\n", i, sprec[i], sassoc[i], tags[i]);
+    fprintf (out, "%5d  %5d   %5d  %s\n",
+	     i,
+	     symbols[i]->prec, symbols[i]->assoc, symbols[i]->tag);
   fprintf (out, "\n\n");
   fprintf (out, "Rules\n-----\n\n");
   fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
@@ -460,25 +457,25 @@ dump_grammar (FILE *out)
     {
       int rhs_count = 0;
       /* Find the last RHS index in ritems. */
-      for (r = &ritem[rule_table[i].rhs]; *r > 0; ++r)
+      for (r = &ritem[rules[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].useful,
-	       rule_table[i].rhs, rule_table[i].rhs + rhs_count - 1,
-	       rule_table[i].lhs);
+	       i - 1,
+	       rules[i].prec, rules[i].assoc, rules[i].useful,
+	       rules[i].rhs, rules[i].rhs + rhs_count - 1,
+	       rules[i].lhs);
       /* Dumped the RHS. */
-      for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
+      for (r = &ritem[rules[i].rhs]; *r >= 0; r++)
 	fprintf (out, "%3d", *r);
-      fprintf (out, "  [%d]\n", -(*r));
+      fprintf (out, "  [%d]\n", -(*r) - 1);
     }
   fprintf (out, "\n\n");
   fprintf (out, "Rules interpreted\n-----------------\n\n");
   for (i = 1; i <= nrules; i++)
     {
-      fprintf (out, "%-5d  %s :", i, tags[rule_table[i].lhs]);
-      for (r = &ritem[rule_table[i].rhs]; *r > 0; r++)
-	fprintf (out, " %s", tags[*r]);
+      fprintf (out, "%-5d  %s :", i, symbols[rules[i].lhs]->tag);
+      for (r = &ritem[rules[i].rhs]; *r >= 0; r++)
+	fprintf (out, " %s", symbols[*r]->tag);
       fputc ('\n', out);
     }
   fprintf (out, "\n\n");
@@ -543,7 +540,7 @@ reduce_grammar (void)
 
   if (!BITISSET (N, start_symbol - ntokens))
     fatal (_("Start symbol %s does not derive any sentence"),
-	   tags[start_symbol]);
+	   symbols[start_symbol]->tag);
 
   reduce_grammar_tables ();
   if (nuseless_nonterminals > 0)