* 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 a0c0986d88cb06cff1c4ff4b04411876c19b1cac..02b843b31fd12e6425dfced65b71af6099806deb 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -90,11 +90,11 @@ resolve_sr_conflict (int state, int lookaheadnum)
   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  */
-  redprec = rprec[LAruleno[lookaheadnum]];
+  redprec = rule_table[LAruleno[lookaheadnum]].prec;
 
   mask = 1;
   fp1 = LA (lookaheadnum);
@@ -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;
-      err_table[state] = (errs *) xcalloc ((unsigned int) i, 1);
+      err_table[state] = ERRS_ALLOC (i + 1);
       bcopy (errp, err_table[state], i);
     }
   else
@@ -182,13 +182,8 @@ resolve_sr_conflict (int state, int lookaheadnum)
 static void
 set_conflicts (int state)
 {
-  int i;
-  int k;
+  int i, j;
   shifts *shiftp;
-  unsigned *fp2;
-  unsigned *fp3;
-  unsigned *fp4;
-  unsigned *fp1;
   int symbol;
 
   if (state_table[state].consistent)
@@ -199,58 +194,41 @@ set_conflicts (int state)
 
   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 */
-  for (i = state_table[state].lookaheads; i < k; i++)
-    if (rprec[LAruleno[i]])
-      {
-       fp1 = LA (i);
-       fp2 = fp1;
-       fp3 = lookaheadset;
-
-       while (fp3 < fp4)
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)
+    if (rule_table[LAruleno[i]].prec)
+      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.  */
-  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;
 
-      fp2 = fp1;
-      fp3 = lookaheadset;
-
-      while (fp3 < fp4)
-       *fp3++ |= *fp2++;
+      for (j = 0; j < tokensetsize; ++j)
+       lookaheadset[j] |= LA (i)[j];
     }
 }
 
@@ -587,7 +565,8 @@ print_reductions (FILE *out, int state)
        {
          if (mask & *fp3)
            fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                    tags[i], default_rule, tags[rlhs[default_rule]]);
+                    tags[i], default_rule,
+                    tags[rule_table[default_rule].lhs]);
 
          mask <<= 1;
          if (mask == 0)
@@ -598,7 +577,7 @@ print_reductions (FILE *out, int state)
        }
 
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
-              default_rule, tags[rlhs[default_rule]]);
+              default_rule, tags[rule_table[default_rule].lhs]);
     }
   else if (n - m >= 1)
     {
@@ -687,7 +666,7 @@ print_reductions (FILE *out, int state)
                          rule = LAruleno[j];
                          fprintf (out,
                                   _("    %-4s\treduce using rule %d (%s)\n"),
-                                  tags[i], rule, tags[rlhs[rule]]);
+                                  tags[i], rule, tags[rule_table[rule].lhs]);
                        }
                      else
                        defaulted = 1;
@@ -701,13 +680,13 @@ print_reductions (FILE *out, int state)
                          rule = LAruleno[default_LA];
                          fprintf (out,
                                   _("    %-4s\treduce using rule %d (%s)\n"),
-                                  tags[i], rule, tags[rlhs[rule]]);
+                                  tags[i], rule, tags[rule_table[rule].lhs]);
                          defaulted = 0;
                        }
                      rule = LAruleno[j];
                      fprintf (out,
                               _("    %-4s\t[reduce using rule %d (%s)]\n"),
-                              tags[i], rule, tags[rlhs[rule]]);
+                              tags[i], rule, tags[rule_table[rule].lhs]);
                    }
                }
 
@@ -727,7 +706,7 @@ print_reductions (FILE *out, int state)
 
       if (default_LA >= 0)
        fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
-                default_rule, tags[rlhs[default_rule]]);
+                default_rule, tags[rule_table[default_rule].lhs]);
     }
 }