* src/closure.c (set_firsts): De-obfuscate.

[bison.git] / src / closure.c

diff --git a/src/closure.c b/src/closure.c
index 09d835002645d855dc801728866291ca26e6cdf5..849b0b6288a5d13c3e167fb2be45f38064053d9f 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -26,8 +26,10 @@
 #include "derives.h"
 #include "warshall.h"
 
+/* ITEMSETSIZE is the size of the array ITEMSET.  */
 short *itemset;
-short *itemsetend;
+int itemsetsize;
+
 static unsigned *ruleset;
 
 /* internal data.  See comments before set_fderives and set_firsts.  */
@@ -51,11 +53,10 @@ static int varsetsize;
 static void
 print_closure (int n)
 {
-  short *isp;
-
+  int i;
   fprintf (stderr, "n = %d\n", n);
-  for (isp = itemset; isp < itemsetend; isp++)
-    fprintf (stderr, "   %d\n", *isp);
+  for (i = 0; i < itemsetsize; ++i)
+    fprintf (stderr, "   %d\n", itemset[i]);
   fprintf (stderr, "\n\n");
 }
 
@@ -99,7 +100,13 @@ print_fderives (void)
 
       for (j = 0; j <= nrules; j++)
        if (BITISSET (rp, j))
-         fprintf (stderr, "\t\t%d (%s)\n", j, tags[j]);
+         {
+           short *rhsp;
+           fprintf (stderr, "\t\t%d:", j);
+           for (rhsp = ritem + rule_table[j].rhs; *rhsp > 0; ++rhsp)
+             fprintf (stderr, " %s", tags[*rhsp]);
+           fputc ('\n', stderr);
+         }
     }
   fprintf (stderr, "\n\n");
 }
@@ -117,33 +124,24 @@ print_fderives (void)
 static void
 set_firsts (void)
 {
-  unsigned *row;
-  int symbol;
-  short *sp;
   int rowsize;
 
-  int i;
+  int i, j;
 
   varsetsize = rowsize = WORDSIZE (nvars);
 
   firsts = XCALLOC (unsigned, nvars * rowsize);
 
-  row = firsts;
   for (i = ntokens; i < nsyms; i++)
-    {
-      sp = derives[i];
-      while (*sp >= 0)
-       {
-         symbol = ritem[rule_table[*sp++].rhs];
-         if (ISVAR (symbol))
-           {
-             symbol -= ntokens;
-             SETBIT (row, symbol);
-           }
-       }
-
-      row += rowsize;
-    }
+    for (j = 0; derives[i][j] >= 0; ++j)
+      {
+       int symbol = ritem[rule_table[derives[i][j]].rhs];
+       if (ISVAR (symbol))
+         {
+           symbol -= ntokens;
+           SETBIT (FIRSTS (i - ntokens), symbol);
+         }
+      }
 
   RTC (firsts, nvars);
 
@@ -228,74 +226,62 @@ new_closure (int n)
 void
 closure (short *core, int n)
 {
-  int ruleno;
-  short *csp;
+  /* Index over CORE. */
+  int c;
 
-  int itemno;
-  int i;
+  /* Index over RULESET. */
+  int r;
+
+  /* A bit index over RULESET. */
+  int ruleno;
 
   if (trace_flag)
     {
       fprintf (stderr, "Entering closure (items = {");
-      for (i = 0; i < n; ++i)
-       fprintf (stderr, " %d ", core[i]);
-      fprintf (stderr, "}, nitems = %d)\n", n);
+      for (c = 0; c < n; ++c)
+       fprintf (stderr, " %d ", core[c]);
+      fprintf (stderr, "})\n");
     }
 
   if (n == 0)
     {
-      for (i = 0; i < rulesetsize; ++i)
-       ruleset[i] = FDERIVES (start_symbol)[i];
+      for (r = 0; r < rulesetsize; ++r)
+       ruleset[r] = FDERIVES (start_symbol)[r];
     }
   else
     {
-      for (i = 0; i < rulesetsize; ++i)
-       ruleset[i] = 0;
+      for (r = 0; r < rulesetsize; ++r)
+       ruleset[r] = 0;
 
-      for (i = 0; i < n; ++i)
-       {
-         int symbol = ritem[core[i]];
-         if (ISVAR (symbol))
-           {
-             int j;
-             for (j = 0; j < rulesetsize; ++j)
-               ruleset[j] |= FDERIVES (symbol)[j];
-           }
-       }
+      for (c = 0; c < n; ++c)
+       if (ISVAR (ritem[core[c]]))
+         for (r = 0; r < rulesetsize; ++r)
+           ruleset[r] |= FDERIVES (ritem[core[c]])[r];
     }
 
-  ruleno = 0;
-  itemsetend = itemset;
-  csp = core;
-  for (i= 0; i < rulesetsize; ++i)
+  itemsetsize = 0;
+  c = 0;
+  for (ruleno = 0; ruleno < rulesetsize * BITS_PER_WORD; ++ruleno)
+    if (BITISSET (ruleset, ruleno))
+      {
+       int itemno = rule_table[ruleno].rhs;
+       while (c < n && core[c] < itemno)
+         {
+           itemset[itemsetsize] = core[c];
+           itemsetsize++;
+           c++;
+         }
+       itemset[itemsetsize] = itemno;
+       itemsetsize++;
+      }
+
+  while (c < n)
     {
-      int word = ruleset[i];
-      if (word == 0)
-       {
-         ruleno += BITS_PER_WORD;
-       }
-      else
-       {
-         int b;
-
-         for (b = 0; b < BITS_PER_WORD; b++)
-           {
-             if (word & (1 << b))
-               {
-                 itemno = rule_table[ruleno].rhs;
-                 while (csp < (core + n ) && *csp < itemno)
-                   *itemsetend++ = *csp++;
-                 *itemsetend++ = itemno;
-               }
-
-             ruleno++;
-           }
-       }
+      itemset[itemsetsize] = core[c];
+      itemsetsize++;
+      c++;
     }
 
-  while (csp < (core + n))
-    *itemsetend++ = *csp++;
-
   if (trace_flag)
     print_closure (n);
 }