X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/a04bc341806e1e423b2475eece725e7835af2b12..b608206ecab1f6b4b23c93be3dcfac86eeef55ee:/src/conflicts.c

diff --git a/src/conflicts.c b/src/conflicts.c
index ae5c79e4..3aa4ad14 100644
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -184,7 +184,6 @@ set_conflicts (int state)
 {
   int i, j;
   shifts *shiftp;
-  int symbol;
 
   if (state_table[state].consistent)
     return;
@@ -194,13 +193,8 @@ set_conflicts (int state)
 
   shiftp = state_table[state].shift_table;
   if (shiftp)
-    for (i = 0; i < shiftp->nshifts; i++)
-      {
-	symbol = state_table[shiftp->shifts[i]].accessing_symbol;
-	if (ISVAR (symbol))
-	  break;
-	SETBIT (lookaheadset, symbol);
-      }
+    for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
+      SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
 
   /* Loop over all rules which require lookahead in this state.  First
      check for shift-reduce conflict, and try to resolve using
@@ -255,18 +249,10 @@ solve_conflicts (void)
 static int
 count_sr_conflicts (int state)
 {
-  int i;
-  int k;
-  int mask;
-  shifts *shiftp;
-  unsigned *fp1;
-  unsigned *fp2;
-  unsigned *fp3;
-  int symbol;
-
+  int i, k;
   int src_count = 0;
+  shifts *shiftp = state_table[state].shift_table;
 
-  shiftp = state_table[state].shift_table;
   if (!shiftp)
     return 0;
 
@@ -276,49 +262,21 @@ count_sr_conflicts (int state)
       lookaheadset[i] = 0;
     }
 
-  k = shiftp->nshifts;
-  for (i = 0; i < k; i++)
-    {
-      if (!shiftp->shifts[i])
-	continue;
-      symbol = state_table[shiftp->shifts[i]].accessing_symbol;
-      if (ISVAR (symbol))
-	break;
-      SETBIT (shiftset, symbol);
-    }
-
-  k = state_table[state + 1].lookaheads;
-  fp3 = lookaheadset + tokensetsize;
-
-  for (i = state_table[state].lookaheads; i < k; i++)
-    {
-      fp1 = LA (i);
-      fp2 = lookaheadset;
-
-      while (fp2 < fp3)
-	*fp2++ |= *fp1++;
-    }
+  for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
+    SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 
-  fp1 = shiftset;
-  fp2 = lookaheadset;
+  for (i = state_table[state].lookaheads;
+       i < state_table[state + 1].lookaheads;
+       ++i)
+    for (k = 0; k < tokensetsize; ++k)
+      lookaheadset[k] |= LA (i)[k];
 
-  while (fp2 < fp3)
-    *fp2++ &= *fp1++;
+  for (k = 0; k < tokensetsize; ++k)
+    lookaheadset[k] &= shiftset[k];
 
-  mask = 1;
-  fp2 = lookaheadset;
   for (i = 0; i < ntokens; i++)
-    {
-      if (mask & *fp2)
-	src_count++;
-
-      mask <<= 1;
-      if (mask == 0)
-	{
-	  mask = 1;
-	  fp2++;
-	}
-    }
+    if (BITISSET (lookaheadset, i))
+      src_count++;
 
   return src_count;
 }
@@ -332,9 +290,6 @@ static int
 count_rr_conflicts (int state)
 {
   int i;
-  unsigned mask;
-  unsigned *baseword;
-
   int rrc_count = 0;
 
   int m = state_table[state].lookaheads;
@@ -343,31 +298,16 @@ count_rr_conflicts (int state)
   if (n - m < 2)
     return 0;
 
-  mask = 1;
-  baseword = LA (m);
   for (i = 0; i < ntokens; i++)
     {
-      unsigned *wordp = baseword;
-
       int count = 0;
       int j;
       for (j = m; j < n; j++)
-	{
-	  if (mask & *wordp)
-	    count++;
-
-	  wordp += tokensetsize;
-	}
+	if (BITISSET (LA (m), j))
+	  count++;
 
       if (count >= 2)
 	rrc_count++;
-
-      mask <<= 1;
-      if (mask == 0)
-	{
-	  mask = 1;
-	  baseword++;
-	}
     }
 
   return rrc_count;
@@ -502,15 +442,8 @@ print_reductions (FILE *out, int state)
 {
   int i;
   int j;
-  int rule;
-  int symbol;
-  unsigned mask;
   int m;
   int n;
-  int default_LA;
-  int default_rule = 0;
-  int cmax;
-  int count;
   shifts *shiftp;
   errs *errp;
   int nodefault = 0;
@@ -520,31 +453,20 @@ print_reductions (FILE *out, int state)
 
   shiftp = state_table[state].shift_table;
   if (shiftp)
-    for (i = 0; i < shiftp->nshifts; i++)
+    for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
       {
-	if (!shiftp->shifts[i])
-	  continue;
-	symbol = state_table[shiftp->shifts[i]].accessing_symbol;
-	if (ISVAR (symbol))
-	  break;
-	/* if this state has a shift for the error token,
-	   don't use a default rule.  */
-	if (symbol == error_token_number)
+	/* if this state has a shift for the error token, don't use a
+	   default rule.  */
+	if (SHIFT_IS_ERROR (shiftp, i))
 	  nodefault = 1;
-	SETBIT (shiftset, symbol);
+	SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
       }
 
   errp = err_table[state];
   if (errp)
-    {
-      for (i = 0; i < errp->nerrs; i++)
-	{
-	  if (!errp->errs[i])
-	    continue;
-	  symbol = errp->errs[i];
-	  SETBIT (shiftset, symbol);
-	}
-    }
+    for (i = 0; i < errp->nerrs; i++)
+      if (errp->errs[i])
+	SETBIT (shiftset, errp->errs[i]);
 
   m = state_table[state].lookaheads;
   n = state_table[state + 1].lookaheads;
@@ -552,7 +474,7 @@ print_reductions (FILE *out, int state)
   if (n - m == 1 && !nodefault)
     {
       int k;
-      default_rule = LAruleno[m];
+      int default_rule = LAruleno[m];
 
       for (k = 0; k < tokensetsize; ++k)
 	lookaheadset[k] = LA (m)[k] & shiftset[k];
@@ -568,37 +490,23 @@ print_reductions (FILE *out, int state)
     }
   else if (n - m >= 1)
     {
-      unsigned *fp1, *fp2, *fp3, *fp4;
+      int k;
 
-      cmax = 0;
-      default_LA = -1;
-      fp4 = lookaheadset + tokensetsize;
+      int cmax = 0;
+      int default_LA = -1;
+      int default_rule = 0;
 
       if (!nodefault)
 	for (i = m; i < n; i++)
 	  {
-	    fp1 = LA (i);
-	    fp2 = shiftset;
-	    fp3 = lookaheadset;
+	    int count = 0;
 
-	    while (fp3 < fp4)
-	      *fp3++ = *fp1++ & (~(*fp2++));
+	    for (k = 0; k < tokensetsize; ++k)
+	      lookaheadset[k] = LA (i)[k] & ~shiftset[k];
 
-	    count = 0;
-	    mask = 1;
-	    fp3 = lookaheadset;
 	    for (j = 0; j < ntokens; j++)
-	      {
-		if (mask & *fp3)
-		  count++;
-
-		mask <<= 1;
-		if (mask == 0)
-		  {
-		    mask = 1;
-		    fp3++;
-		  }
-	      }
+	      if (BITISSET (lookaheadset, j))
+		count++;
 
 	    if (count > cmax)
 	      {
@@ -607,55 +515,34 @@ print_reductions (FILE *out, int state)
 		default_rule = LAruleno[i];
 	      }
 
-	    fp2 = shiftset;
-	    fp3 = lookaheadset;
-
-	    while (fp3 < fp4)
-	      *fp2++ |= *fp3++;
+	    for (k = 0; k < tokensetsize; ++k)
+	      shiftset[k] |= lookaheadset[k];
 	  }
 
       for (i = 0; i < tokensetsize; i++)
 	shiftset[i] = 0;
 
       if (shiftp)
-	{
-	  for (i = 0; i < shiftp->nshifts; i++)
-	    {
-	      if (!shiftp->shifts[i])
-		continue;
-	      symbol = state_table[shiftp->shifts[i]].accessing_symbol;
-	      if (ISVAR (symbol))
-		break;
-	      SETBIT (shiftset, symbol);
-	    }
-	}
+	for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
+	  SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 
-      mask = 1;
-      fp1 = LA (m);
-      fp2 = shiftset;
       for (i = 0; i < ntokens; i++)
 	{
 	  int defaulted = 0;
+	  int count = BITISSET (shiftset, i);
 
-	  if (mask & *fp2)
-	    count = 1;
-	  else
-	    count = 0;
-
-	  fp3 = fp1;
 	  for (j = m; j < n; j++)
 	    {
-	      if (mask & *fp3)
+	      if (BITISSET (LA (m), j))
 		{
 		  if (count == 0)
 		    {
 		      if (j != default_LA)
-			{
-			  rule = LAruleno[j];
-			  fprintf (out,
-				   _("    %-4s\treduce using rule %d (%s)\n"),
-				   tags[i], rule, tags[rule_table[rule].lhs]);
-			}
+			fprintf (out,
+				 _("    %-4s\treduce using rule %d (%s)\n"),
+				 tags[i],
+				 LAruleno[j],
+				 tags[rule_table[LAruleno[j]].lhs]);
 		      else
 			defaulted = 1;
 
@@ -664,31 +551,19 @@ print_reductions (FILE *out, int state)
 		  else
 		    {
 		      if (defaulted)
-			{
-			  rule = LAruleno[default_LA];
-			  fprintf (out,
-				   _("    %-4s\treduce using rule %d (%s)\n"),
-				   tags[i], rule, tags[rule_table[rule].lhs]);
-			  defaulted = 0;
-			}
-		      rule = LAruleno[j];
+			fprintf (out,
+				 _("    %-4s\treduce using rule %d (%s)\n"),
+				 tags[i],
+				 LAruleno[default_LA],
+				 tags[rule_table[LAruleno[default_LA]].lhs]);
+		      defaulted = 0;
 		      fprintf (out,
 			       _("    %-4s\t[reduce using rule %d (%s)]\n"),
-			       tags[i], rule, tags[rule_table[rule].lhs]);
+			       tags[i],
+			       LAruleno[j],
+			       tags[rule_table[LAruleno[j]].lhs]);
 		    }
 		}
-
-	      fp3 += tokensetsize;
-	    }
-
-	  mask <<= 1;
-	  if (mask == 0)
-	    {
-	      mask = 1;
-	      /* We tried incrementing just fp1, and just fp2; both seem wrong.
-	         It seems necessary to increment both in sync.  */
-	      fp1++;
-	      fp2++;
 	    }
 	}