* src/LR0.c: Attach shifts to states as soon as they are

[bison.git] / src / nullable.c

diff --git a/src/nullable.c b/src/nullable.c
index c207924dc8328a9770263d2313451c8e38b66748..8e8809e20b993f6f865aade2202fefe4f5c5e6bf 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -28,6 +28,7 @@
 #include "reader.h"
 #include "types.h"
 #include "gram.h"
+#include "reduce.h"
 #include "nullable.h"
 
 char *nullable = NULL;
@@ -64,68 +65,58 @@ set_nullable (void)
   s1 = s2 = squeue;
 
   rcount = XCALLOC (short, nrules + 1);
-  rsets = XCALLOC (shorts *, nvars) - ntokens;
+
+  /* RITEM contains all the rules, including useless productions.
+     Hence we must allocate room for useless nonterminals too.  */
+  rsets = XCALLOC (shorts *, nvars + nuseless_nonterminals) - ntokens;
   /* This is said to be more elements than we actually use.
      Supposedly nitems - nrules is enough.
      But why take the risk?  */
-  relts = XCALLOC (shorts, nitems + nvars + 1);
+  relts = XCALLOC (shorts, nitems + nvars + nuseless_nonterminals + 1);
   p = relts;
 
-  r = ritem;
-  while (*r)
+  for (r = ritem; *r; ++r)
     {
-      if (*r < 0)
+      /* Walk RITEM to find (i), if there are any tokens in the
+        RHS, and (ii), to find RULENO. */
+      int ruleno;
+      int any_tokens = 0;
+      short *r1;
+      for (r1 = r; *r1 > 0; ++r1)
+       if (ISTOKEN (*r1))
+         any_tokens = 1;
+      ruleno = -*r1;
+
+      /* Examine the RHS of the rule.  */
+      if (!any_tokens)
+       for (/* Nothing. */; *r > 0; ++r)
+         {
+           rcount[ruleno]++;
+           p->next = rsets[*r];
+           p->value = ruleno;
+           rsets[*r] = p;
+           p++;
+         }
+
+      /* Examine its LHS. */
+      if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
        {
-         int symbol = rule_table[-(*r++)].lhs;
-         if (symbol >= 0 && !nullable[symbol])
-           {
-             nullable[symbol] = 1;
-             *s2++ = symbol;
-           }
-       }
-      else
-       {
-         int any_tokens = 0;
-         int symbol;
-         short *r1 = r;
-         for (symbol = *r++; symbol > 0; symbol = *r++)
-           if (ISTOKEN (symbol))
-             any_tokens = 1;
-
-         if (!any_tokens)
-           {
-             int ruleno = -symbol;
-             r = r1;
-             for (symbol = *r++; symbol > 0; symbol = *r++)
-               {
-                 rcount[ruleno]++;
-                 p->next = rsets[symbol];
-                 p->value = ruleno;
-                 rsets[symbol] = p;
-                 p++;
-               }
-           }
-       }
+         nullable[rule_table[ruleno].lhs] = 1;
+         *s2++ = rule_table[ruleno].lhs;
+        }
     }
 
   while (s1 < s2)
-    {
-      p = rsets[*s1++];
-      while (p)
-       {
-         int ruleno = p->value;
-         p = p->next;
-         if (--rcount[ruleno] == 0)
+    for (p = rsets[*s1++]; p; p = p->next)
+      {
+       int ruleno = p->value;
+       if (--rcount[ruleno] == 0)
+         if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
            {
-             int symbol = rule_table[ruleno].lhs;
-             if (symbol >= 0 && !nullable[symbol])
-               {
-                 nullable[symbol] = 1;
-                 *s2++ = symbol;
-               }
+             nullable[rule_table[ruleno].lhs] = 1;
+             *s2++ = rule_table[ruleno].lhs;
            }
-       }
-    }
+      }
 
   XFREE (squeue);
   XFREE (rcount);