* src/closure.c, src/derives.c, src/gram.h, src/lalr.c,

[bison.git] / src / conflicts.c

diff --git a/src/conflicts.c b/src/conflicts.c
index b03d881d61cf95b6f3b2c724dd20aed86f4feb08..50669cbf1d3c3108a880d0cf25ec92dd40a4a86b 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -35,12 +35,12 @@
 int expected_conflicts = -1;
 static char *conflicts = NULL;
 
 int expected_conflicts = -1;
 static char *conflicts = NULL;
 

-static unsigned *shiftset = NULL;
-static unsigned *lookaheadset = NULL;
+static bitset shiftset;
+static bitset lookaheadset;

 \f
 
 static inline void
 \f
 
 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,
 {
   if (verbose_flag)
     obstack_fgrow4 (&output_obstack,


@@ -63,7 +63,7 @@ flush_shift (state_t *state, int token)
   shifts *shiftp = state->shifts;
   int i;
 
   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);
   for (i = 0; i < shiftp->nshifts; i++)
     if (!SHIFT_IS_DISABLED (shiftp, i) && SHIFT_SYMBOL (shiftp, i) == token)
       SHIFT_DISABLE (shiftp, i);


@@ -101,7 +101,7 @@ resolve_sr_conflict (state_t *state, int lookahead)
 
   for (i = 0; i < ntokens; i++)
     if (bitset_test (LA[lookahead], i)
 
   for (i = 0; i < ntokens; i++)
     if (bitset_test (LA[lookahead], i)

-       && BITISSET (lookaheadset, i)
+       && bitset_test (lookaheadset, i)

        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i
        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i


@@ -155,46 +155,38 @@ resolve_sr_conflict (state_t *state, int lookahead)
 static void
 set_conflicts (state_t *state)
 {
 static void
 set_conflicts (state_t *state)
 {

-  int i, j;
+  int i;

   shifts *shiftp;
 
   if (state->consistent)
     return;
 
   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))
 
   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)
 
   /* 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 (rules[LAruleno[state->lookaheadsp + i]].prec)
-      for (j = 0; j < ntokens; ++j)
-       if (bitset_test (LA[state->lookaheadsp + i], j)
-           && BITISSET (lookaheadset, j))
-         {
-           resolve_sr_conflict (state, state->lookaheadsp + i);
-           break;
-         }
-
+    if (rules[LAruleno[state->lookaheadsp + i]].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)
     {
 
   /* 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 < ntokens; ++j)
-       if (bitset_test (LA[state->lookaheadsp + i], j)
-           && BITISSET (lookaheadset, j))
-         conflicts[state->number] = 1;
-
-      for (j = 0; j < ntokens; ++j)
-       if (bitset_test (LA[state->lookaheadsp + i], j))
-         SETBIT (lookaheadset, j);
+      if (!bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset))
+       conflicts[state->number] = 1;
+
+      bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]);

     }
 }
 
     }
 }
 


@@ -204,8 +196,8 @@ solve_conflicts (void)
   size_t i;
 
   conflicts = XCALLOC (char, nstates);
   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 (states[i]);
 
   for (i = 0; i < nstates; i++)
     set_conflicts (states[i]);


@@ -219,34 +211,26 @@ solve_conflicts (void)
 static int
 count_sr_conflicts (state_t *state)
 {
 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;
 
   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))
 
   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 (i = 0; i < state->nlookaheads; ++i)

-    for (k = 0; k < ntokens; ++k)
-      if (bitset_test (LA[state->lookaheadsp + i], k))
-       SETBIT (lookaheadset, 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;
 }
 
   return src_count;
 }


@@ -408,6 +392,6 @@ void
 free_conflicts (void)
 {
   XFREE (conflicts);
 free_conflicts (void)
 {
   XFREE (conflicts);

-  XFREE (shiftset);
-  XFREE (lookaheadset);
+  bitset_free (shiftset);
+  bitset_free (lookaheadset);

 }
 }