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

[bison.git] / src / closure.c

diff --git a/src/closure.c b/src/closure.c
index ab086342dc67c4140b586098740f970efb398617..849b0b6288a5d13c3e167fb2be45f38064053d9f 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -28,7 +28,7 @@
 
 /* ITEMSETSIZE is the size of the array ITEMSET.  */
 short *itemset;
-size_t itemsetsize;
+int itemsetsize;
 
 static unsigned *ruleset;
 
@@ -124,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);
 
@@ -235,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;
   itemsetsize = 0;
-  csp = core;
-  for (i = 0; i < rulesetsize; ++i)
-    {
-      int word = ruleset[i];
-      if (word == 0)
-       {
-         ruleno += BITS_PER_WORD;
-       }
-      else
-       {
-         int b;
+  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++;
+      }
 
-         for (b = 0; b < BITS_PER_WORD; b++)
-           {
-             if (word & (1 << b))
-               {
-                 itemno = rule_table[ruleno].rhs;
-                 while (csp < (core + n) && *csp < itemno)
-                   itemset[itemsetsize++] = *csp++;
-                 itemset[itemsetsize++] = itemno;
-               }
-
-             ruleno++;
-           }
-       }
+  while (c < n)
+    {
+      itemset[itemsetsize] = core[c];
+      itemsetsize++;
+      c++;
     }
 
-  while (csp < (core + n))
-    itemset[itemsetsize++] = *csp++;
-
   if (trace_flag)
     print_closure (n);
 }