X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ad949da96bf5621185a28f354c08f4595bc42952..20c37f213a14c112251907734402cbf80f44d780:/src/conflicts.c?ds=sidebyside

diff --git a/src/conflicts.c b/src/conflicts.c
index 05f37bd1..22e7d8a3 100644
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -1,5 +1,6 @@
 /* Find and resolve or report look-ahead conflicts for bison,
-   Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 1992, 2000, 2001, 2002
+   Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -19,6 +20,7 @@
    02111-1307, USA.  */
 
 #include "system.h"
+#include "bitset.h"
 #include "complain.h"
 #include "getargs.h"
 #include "symtab.h"
@@ -34,18 +36,20 @@
 int expected_conflicts = -1;
 static char *conflicts = NULL;
 
-static unsigned *shiftset = NULL;
-static unsigned *lookaheadset = NULL;
+static bitset shiftset;
+static bitset lookaheadset;
 
 
 static inline void
-log_resolution (state_t *state, int LAno, int token, char *resolution)
+log_resolution (state_t *state, int LAno, int token, const char *resolution)
 {
   if (verbose_flag)
     obstack_fgrow4 (&output_obstack,
 		    _("\
 Conflict in state %d between rule %d and token %s resolved as %s.\n"),
-		    state->number, LAruleno[LAno], symbols[token]->tag,
+		    state->number,
+		    LArule[LAno]->number,
+		    symbols[token]->tag,
 		    resolution);
 }
 
@@ -62,7 +66,7 @@ flush_shift (state_t *state, int token)
   shifts *shiftp = state->shifts;
   int i;
 
-  RESETBIT (lookaheadset, token);
+  bitset_reset (lookaheadset, token);
   for (i = 0; i < shiftp->nshifts; i++)
     if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token)
       SHIFT_DISABLE (shiftp, i);
@@ -78,7 +82,7 @@ flush_shift (state_t *state, int token)
 static void
 flush_reduce (int lookahead, int token)
 {
-  RESETBIT (LA (lookahead), token);
+  bitset_reset (LA[lookahead], token);
 }
 
 
@@ -94,13 +98,13 @@ resolve_sr_conflict (state_t *state, int lookahead)
 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */
-  int redprec = rule_table[LAruleno[lookahead]].prec;
+  int redprec = LArule[lookahead]->prec->prec;
   errs *errp = errs_new (ntokens + 1);
   errp->nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
-    if (BITISSET (LA (lookahead), i)
-	&& BITISSET (lookaheadset, i)
+    if (bitset_test (LA[lookahead], i)
+	&& bitset_test (lookaheadset, i)
 	&& symbols[i]->prec)
       {
 	/* Shift-reduce conflict occurs for token number i
@@ -122,7 +126,7 @@ resolve_sr_conflict (state_t *state, int lookahead)
 	     For right association, keep only the shift.
 	     For nonassociation, keep neither.  */
 
-	  switch (sassoc[i])
+	  switch (symbols[i]->assoc)
 	    {
 	    case right_assoc:
 	      log_resolution (state, lookahead, i, _("shift"));
@@ -154,57 +158,53 @@ resolve_sr_conflict (state_t *state, int lookahead)
 static void
 set_conflicts (state_t *state)
 {
-  int i, j;
+  int i;
   shifts *shiftp;
 
   if (state->consistent)
     return;
 
-  for (i = 0; i < tokensetsize; i++)
-    lookaheadset[i] = 0;
+  bitset_zero (lookaheadset);
 
   shiftp = state->shifts;
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
-      SETBIT (lookaheadset, SHIFT_SYMBOL (shiftp, i));
+      bitset_set (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
      precedence */
   for (i = 0; i < state->nlookaheads; ++i)
-    if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
-      for (j = 0; j < tokensetsize; ++j)
-	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
-	  {
-	    resolve_sr_conflict (state, state->lookaheadsp + i);
-	    break;
-	  }
-
+    if (LArule[state->lookaheadsp + i]->prec
+	&& LArule[state->lookaheadsp + i]->prec->prec
+	&& !bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset))
+      {
+	resolve_sr_conflict (state, state->lookaheadsp + i);
+	break;
+      }
 
   /* Loop over all rules which require lookahead in this state.  Check
      for conflicts not resolved above.  */
   for (i = 0; i < state->nlookaheads; ++i)
     {
-      for (j = 0; j < tokensetsize; ++j)
-	if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
-	  conflicts[state->number] = 1;
+      if (!bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset))
+	conflicts[state->number] = 1;
 
-      for (j = 0; j < tokensetsize; ++j)
-	lookaheadset[j] |= LA (state->lookaheadsp + i)[j];
+      bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]);
     }
 }
 
 void
 solve_conflicts (void)
 {
-  int i;
+  size_t i;
 
   conflicts = XCALLOC (char, nstates);
-  shiftset = XCALLOC (unsigned, tokensetsize);
-  lookaheadset = XCALLOC (unsigned, tokensetsize);
+  shiftset = bitset_create (ntokens, BITSET_FIXED);
+  lookaheadset = bitset_create (ntokens, BITSET_FIXED);
 
   for (i = 0; i < nstates; i++)
-    set_conflicts (state_table[i]);
+    set_conflicts (states[i]);
 }
 
 
@@ -215,33 +215,26 @@ solve_conflicts (void)
 static int
 count_sr_conflicts (state_t *state)
 {
-  int i, k;
+  int i;
   int src_count = 0;
   shifts *shiftp = state->shifts;
 
   if (!shiftp)
     return 0;
 
-  for (i = 0; i < tokensetsize; i++)
-    {
-      shiftset[i] = 0;
-      lookaheadset[i] = 0;
-    }
+  bitset_zero (lookaheadset);
+  bitset_zero (shiftset);
 
   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
     if (!SHIFT_IS_DISABLED (shiftp, i))
-      SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
+      bitset_set (shiftset, SHIFT_SYMBOL (shiftp, i));
 
   for (i = 0; i < state->nlookaheads; ++i)
-    for (k = 0; k < tokensetsize; ++k)
-      lookaheadset[k] |= LA (state->lookaheadsp + i)[k];
+    bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]);
 
-  for (k = 0; k < tokensetsize; ++k)
-    lookaheadset[k] &= shiftset[k];
+  bitset_and (lookaheadset, lookaheadset, shiftset);
 
-  for (i = 0; i < ntokens; i++)
-    if (BITISSET (lookaheadset, i))
-      src_count++;
+  src_count = bitset_count (lookaheadset);
 
   return src_count;
 }
@@ -265,7 +258,7 @@ count_rr_conflicts (state_t *state)
       int count = 0;
       int j;
       for (j = 0; j < state->nlookaheads; ++j)
-	if (BITISSET (LA (state->lookaheadsp), state->lookaheadsp + j))
+	if (bitset_test (LA[state->lookaheadsp + j], i))
 	  count++;
 
       if (count >= 2)
@@ -322,13 +315,13 @@ void
 conflicts_output (FILE *out)
 {
   bool printed_sth = FALSE;
-  int i;
+  size_t i;
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
 	fprintf (out, _("State %d contains "), i);
-	fputs (conflict_report (count_sr_conflicts (state_table[i]),
-				count_rr_conflicts (state_table[i])), out);
+	fputs (conflict_report (count_sr_conflicts (states[i]),
+				count_rr_conflicts (states[i])), out);
 	printed_sth = TRUE;
       }
   if (printed_sth)
@@ -343,7 +336,7 @@ conflicts_output (FILE *out)
 void
 conflicts_print (void)
 {
-  int i;
+  size_t i;
 
   /* Is the number of SR conflicts OK?  Either EXPECTED_CONFLICTS is
      not set, and then we want 0 SR, or else it is specified, in which
@@ -357,8 +350,8 @@ conflicts_print (void)
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
-	src_total += count_sr_conflicts (state_table[i]);
-	rrc_total += count_rr_conflicts (state_table[i]);
+	src_total += count_sr_conflicts (states[i]);
+	rrc_total += count_rr_conflicts (states[i]);
       }
 
   src_ok = src_total == (expected_conflicts == -1 ? 0 : expected_conflicts);
@@ -403,6 +396,6 @@ void
 free_conflicts (void)
 {
   XFREE (conflicts);
-  XFREE (shiftset);
-  XFREE (lookaheadset);
+  bitset_free (shiftset);
+  bitset_free (lookaheadset);
 }