* src/conflicts.c (set_conflicts): Use arrays instead of pointers

[bison.git] / src / conflicts.c

diff --git a/src/conflicts.c b/src/conflicts.c
index fd7af88c189516af907a3551196aa686de76ec8b..02b843b31fd12e6425dfced65b71af6099806deb 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -90,7 +90,7 @@ resolve_sr_conflict (int state, int lookaheadnum)
   unsigned *fp1;
   unsigned *fp2;
   int redprec;
   unsigned *fp1;
   unsigned *fp2;
   int redprec;

-  errs *errp = (errs *) xcalloc (sizeof (errs) + ntokens * sizeof (short), 1);
+  errs *errp = ERRS_ALLOC (ntokens + 1);

   short *errtokens = errp->errs;
 
   /* find the rule to reduce by to get precedence of reduction  */
   short *errtokens = errp->errs;
 
   /* find the rule to reduce by to get precedence of reduction  */


@@ -170,7 +170,7 @@ resolve_sr_conflict (int state, int lookaheadnum)
       /* Some tokens have been explicitly made errors.  Allocate
          a permanent errs structure for this state, to record them.  */
       i = (char *) errtokens - (char *) errp;
       /* Some tokens have been explicitly made errors.  Allocate
          a permanent errs structure for this state, to record them.  */
       i = (char *) errtokens - (char *) errp;

-      err_table[state] = (errs *) xcalloc ((unsigned int) i, 1);
+      err_table[state] = ERRS_ALLOC (i + 1);

       bcopy (errp, err_table[state], i);
     }
   else
       bcopy (errp, err_table[state], i);
     }
   else


@@ -182,13 +182,8 @@ resolve_sr_conflict (int state, int lookaheadnum)
 static void
 set_conflicts (int state)
 {
 static void
 set_conflicts (int state)
 {

-  int i;
-  int k;
+  int i, j;

   shifts *shiftp;
   shifts *shiftp;

-  unsigned *fp2;
-  unsigned *fp3;
-  unsigned *fp4;
-  unsigned *fp1;

   int symbol;
 
   if (state_table[state].consistent)
   int symbol;
 
   if (state_table[state].consistent)


@@ -199,58 +194,41 @@ set_conflicts (int state)
 
   shiftp = state_table[state].shift_table;
   if (shiftp)
 
   shiftp = state_table[state].shift_table;
   if (shiftp)

-    {
-      k = shiftp->nshifts;
-      for (i = 0; i < k; i++)
-       {
-         symbol = state_table[shiftp->shifts[i]].accessing_symbol;
-         if (ISVAR (symbol))
-           break;
-         SETBIT (lookaheadset, symbol);
-       }
-    }
-
-  k = state_table[state + 1].lookaheads;
-  fp4 = lookaheadset + tokensetsize;
+    for (i = 0; i < shiftp->nshifts; i++)
+      {
+       symbol = state_table[shiftp->shifts[i]].accessing_symbol;
+       if (ISVAR (symbol))
+         break;
+       SETBIT (lookaheadset, symbol);
+      }

 
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */
 
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
      precedence */

-  for (i = state_table[state].lookaheads; i < k; i++)
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)

     if (rule_table[LAruleno[i]].prec)
     if (rule_table[LAruleno[i]].prec)

-      {
-       fp1 = LA (i);
-       fp2 = fp1;
-       fp3 = lookaheadset;
-
-       while (fp3 < fp4)
+      for (j = 0; j < tokensetsize; ++j)
+       if (LA (i)[j] & lookaheadset[j])

          {
          {

-           if (*fp2++ & *fp3++)
-             {
-               resolve_sr_conflict (state, i);
-               break;
-             }
+           resolve_sr_conflict (state, i);
+           break;

          }
          }

-      }

 
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */
 
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */

-  for (i = state_table[state].lookaheads; i < k; i++)
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)

     {
     {

-      fp1 = LA (i);
-      fp2 = fp1;
-      fp3 = lookaheadset;
-
-      while (fp3 < fp4)
-       if (*fp2++ & *fp3++)
+      for (j = 0; j < tokensetsize; ++j)
+       if (LA (i)[j] & lookaheadset[j])

          conflicts[state] = 1;
 
          conflicts[state] = 1;
 

-      fp2 = fp1;
-      fp3 = lookaheadset;
-
-      while (fp3 < fp4)
-       *fp3++ |= *fp2++;
+      for (j = 0; j < tokensetsize; ++j)
+       lookaheadset[j] |= LA (i)[j];

     }
 }
 
     }
 }