* 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 1497dd1b46e638586fc1e004d30b1629f30b9f3d..02b843b31fd12e6425dfced65b71af6099806deb 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -60,7 +60,7 @@ flush_shift (int state, int token)
   shifts *shiftp;
   int k, i;
 
-  shiftp = shift_table[state];
+  shiftp = state_table[state].shift_table;
 
   if (shiftp)
     {
@@ -68,7 +68,7 @@ flush_shift (int state, int token)
       for (i = 0; i < k; i++)
        {
          if (shiftp->shifts[i]
-             && token == accessing_symbol[shiftp->shifts[i]])
+             && token == state_table[shiftp->shifts[i]].accessing_symbol)
            (shiftp->shifts[i]) = 0;
        }
     }
@@ -90,14 +90,14 @@ 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 * tokensetsize;
+  fp1 = LA (lookaheadnum);
   fp2 = lookaheadset;
   for (i = 0; i < ntokens; i++)
     {
@@ -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,75 +182,53 @@ 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 (consistent[state])
+  if (state_table[state].consistent)
     return;
 
   for (i = 0; i < tokensetsize; i++)
     lookaheadset[i] = 0;
 
-  shiftp = shift_table[state];
+  shiftp = state_table[state].shift_table;
   if (shiftp)
-    {
-      k = shiftp->nshifts;
-      for (i = 0; i < k; i++)
-       {
-         symbol = accessing_symbol[shiftp->shifts[i]];
-         if (ISVAR (symbol))
-           break;
-         SETBIT (lookaheadset, symbol);
-       }
-    }
-
-  k = lookaheads[state + 1];
-  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 = lookaheads[state]; i < k; i++)
-    if (rprec[LAruleno[i]])
-      {
-       fp1 = LA + i * tokensetsize;
-       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 = lookaheads[state]; i < k; i++)
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)
     {
-      fp1 = LA + i * tokensetsize;
-      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];
     }
 }
 
@@ -288,7 +266,7 @@ count_sr_conflicts (int state)
 
   int src_count = 0;
 
-  shiftp = shift_table[state];
+  shiftp = state_table[state].shift_table;
   if (!shiftp)
     return 0;
 
@@ -303,18 +281,18 @@ count_sr_conflicts (int state)
     {
       if (!shiftp->shifts[i])
        continue;
-      symbol = accessing_symbol[shiftp->shifts[i]];
+      symbol = state_table[shiftp->shifts[i]].accessing_symbol;
       if (ISVAR (symbol))
        break;
       SETBIT (shiftset, symbol);
     }
 
-  k = lookaheads[state + 1];
+  k = state_table[state + 1].lookaheads;
   fp3 = lookaheadset + tokensetsize;
 
-  for (i = lookaheads[state]; i < k; i++)
+  for (i = state_table[state].lookaheads; i < k; i++)
     {
-      fp1 = LA + i * tokensetsize;
+      fp1 = LA (i);
       fp2 = lookaheadset;
 
       while (fp2 < fp3)
@@ -359,14 +337,14 @@ count_rr_conflicts (int state)
 
   int rrc_count = 0;
 
-  int m = lookaheads[state];
-  int n = lookaheads[state + 1];
+  int m = state_table[state].lookaheads;
+  int n = state_table[state + 1].lookaheads;
 
   if (n - m < 2)
     return 0;
 
   mask = 1;
-  baseword = LA + m * tokensetsize;
+  baseword = LA (m);
   for (i = 0; i < ntokens; i++)
     {
       unsigned *wordp = baseword;
@@ -533,7 +511,7 @@ print_reductions (FILE *out, int state)
   for (i = 0; i < tokensetsize; i++)
     shiftset[i] = 0;
 
-  shiftp = shift_table[state];
+  shiftp = state_table[state].shift_table;
   if (shiftp)
     {
       k = shiftp->nshifts;
@@ -541,7 +519,7 @@ print_reductions (FILE *out, int state)
        {
          if (!shiftp->shifts[i])
            continue;
-         symbol = accessing_symbol[shiftp->shifts[i]];
+         symbol = state_table[shiftp->shifts[i]].accessing_symbol;
          if (ISVAR (symbol))
            break;
          /* if this state has a shift for the error token,
@@ -565,14 +543,14 @@ print_reductions (FILE *out, int state)
        }
     }
 
-  m = lookaheads[state];
-  n = lookaheads[state + 1];
+  m = state_table[state].lookaheads;
+  n = state_table[state + 1].lookaheads;
 
   if (n - m == 1 && !nodefault)
     {
       default_rule = LAruleno[m];
 
-      fp1 = LA + m * tokensetsize;
+      fp1 = LA (m);
       fp2 = shiftset;
       fp3 = lookaheadset;
       fp4 = lookaheadset + tokensetsize;
@@ -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)
     {
@@ -609,7 +588,7 @@ print_reductions (FILE *out, int state)
       if (!nodefault)
        for (i = m; i < n; i++)
          {
-           fp1 = LA + i * tokensetsize;
+           fp1 = LA (i);
            fp2 = shiftset;
            fp3 = lookaheadset;
 
@@ -656,7 +635,7 @@ print_reductions (FILE *out, int state)
            {
              if (!shiftp->shifts[i])
                continue;
-             symbol = accessing_symbol[shiftp->shifts[i]];
+             symbol = state_table[shiftp->shifts[i]].accessing_symbol;
              if (ISVAR (symbol))
                break;
              SETBIT (shiftset, symbol);
@@ -664,7 +643,7 @@ print_reductions (FILE *out, int state)
        }
 
       mask = 1;
-      fp1 = LA + m * tokensetsize;
+      fp1 = LA (m);
       fp2 = shiftset;
       for (i = 0; i < ntokens; i++)
        {
@@ -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]);
     }
 }