* src/lalr.c (traverse): Use arrays instead of pointers.

diff --git a/ChangeLog b/ChangeLog
index f59d0292711d46a42844e1187ec351666799fc41..3729fa94efa90d6de38f0668cee094ccd0365e67 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2001-12-05  Akim Demaille  <akim@epita.fr>
+
+       * src/lalr.c (traverse): Use arrays instead of pointers.
+
 2001-12-05  Akim Demaille  <akim@epita.fr>
 
        * src/nullable.c (set_nullable): Use a for loop to de-obfuscate

diff --git a/src/lalr.c b/src/lalr.c
index 42cd05ef938f287ae97866fccd98c1c7a02eb29d..d59170e7f15941f28784d7879620680436d71a6f 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -50,7 +50,7 @@ extern void berror PARAMS ((const char *));
 static int infinity;
 static int ngotos;
 
-/* And for the famous F variable, which named is so descriptive that a
+/* And for the famous F variable, which name is so descriptive that a
    comment is hardly needed.  <grin>.  */
 static unsigned *F = NULL;
 #define F(Rule)  (F + (Rule) * tokensetsize)
@@ -66,57 +66,39 @@ static int top;
 static void
 traverse (int i)
 {
-  unsigned *fp1;
-  unsigned *fp2;
-  unsigned *fp3;
   int j;
-  short *rp;
-
+  size_t k;
   int height;
-  unsigned *base;
+  size_t size = F (i + 1) - F(i);
 
   VERTICES[++top] = i;
   INDEX[i] = height = top;
 
-  base = F (i);
-  fp3 = F (i + 1);
-
-  rp = R[i];
-  if (rp)
-    {
-      while ((j = *rp++) >= 0)
-       {
-         if (INDEX[j] == 0)
-           traverse (j);
-
-         if (INDEX[i] > INDEX[j])
-           INDEX[i] = INDEX[j];
+  if (R[i])
+    for (j = 0; R[i][j] >= 0; ++j)
+      {
+       if (INDEX[R[i][j]] == 0)
+         traverse (R[i][j]);
 
-         fp1 = base;
-         fp2 = F (j);
+       if (INDEX[i] > INDEX[R[i][j]])
+         INDEX[i] = INDEX[R[i][j]];
 
-         while (fp1 < fp3)
-           *fp1++ |= *fp2++;
-       }
-    }
+       for (k = 0; k < size; ++k)
+         F (i)[k] |= F (R[i][j])[k];
+      }
 
   if (INDEX[i] == height)
-    {
-      for (;;)
-       {
-         j = VERTICES[top--];
-         INDEX[j] = infinity;
-
-         if (i == j)
-           break;
+    for (;;)
+      {
+       j = VERTICES[top--];
+       INDEX[j] = infinity;
 
-         fp1 = base;
-         fp2 = F (j);
+       if (i == j)
+         break;
 
-         while (fp1 < fp3)
-           *fp2++ = *fp1++;
-       }
-    }
+       for (k = 0; k < size; ++k)
+         F (i)[k] = F (j)[k];
+      }
 }
 
 
@@ -212,7 +194,10 @@ set_state_table (void)
 }
 
 
-/* Return the size of the longest ride hand side of the rules. */
+/*------------------------------------------.
+| Return the size of the longest rule RHS.  |
+`------------------------------------------*/
+
 static size_t
 maxrhs (void)
 {