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

[bison.git] / src / nullable.c

diff --git a/src/nullable.c b/src/nullable.c
index 4568114f9f84b3f64f92c8c50f8895f5746327c3..8e8809e20b993f6f865aade2202fefe4f5c5e6bf 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -24,32 +24,40 @@
    do so.  */
 
 #include "system.h"
+#include "getargs.h"
+#include "reader.h"
 #include "types.h"
 #include "gram.h"
+#include "reduce.h"
 #include "nullable.h"
 
 char *nullable = NULL;
 
+static void
+nullable_print (FILE *out)
+{
+  int i;
+  fputs ("NULLABLE\n", out);
+  for (i = ntokens; i < nsyms; i++)
+    fprintf (out, "\t%s: %s\n", tags[i], nullable[i] ? "yes" : "no");
+  fputs ("\n\n", out);
+}
+
 void
 set_nullable (void)
 {
   short *r;
   short *s1;
   short *s2;
-  int ruleno;
-  int symbol;
   shorts *p;
 
   short *squeue;
   short *rcount;
   shorts **rsets;
   shorts *relts;
-  char any_tokens;
-  short *r1;
 
-#ifdef TRACE
-  fprintf (stderr, "Entering set_nullable\n");
-#endif
+  if (trace_flag)
+    fprintf (stderr, "Entering set_nullable\n");
 
   nullable = XCALLOC (char, nvars) - ntokens;
 
@@ -57,74 +65,66 @@ 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])
        {
-         symbol = rule_table[-(*r++)].lhs;
-         if (symbol >= 0 && !nullable[symbol])
-           {
-             nullable[symbol] = 1;
-             *s2++ = symbol;
-           }
-       }
-      else
-       {
-         r1 = r;
-         any_tokens = 0;
-         for (symbol = *r++; symbol > 0; symbol = *r++)
-           {
-             if (ISTOKEN (symbol))
-               any_tokens = 1;
-           }
-
-         if (!any_tokens)
-           {
-             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)
-       {
-         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])
            {
-             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);
   XFREE (rsets + ntokens);
   XFREE (relts);
+
+  if (trace_flag)
+    nullable_print (stderr);
 }