(AUTOMAKE_OPTIONS): Remove.

[bison.git] / src / conflicts.c

diff --git a/src/conflicts.c b/src/conflicts.c
index bd29bf9717fb730649923328880e0f9c77853be0..d90b380aa4ef87b5fb8b1cdc6f3d5157b81a4e4b 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -1,5 +1,5 @@
 /* Find and resolve or report look-ahead conflicts for bison,
 /* Find and resolve or report look-ahead conflicts for bison,

-   Copyright 1984, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
+   Copyright 1984, 1989, 1992, 2000, 2001, 2002 Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -19,6 +19,7 @@
    02111-1307, USA.  */
 
 #include "system.h"
    02111-1307, USA.  */
 
 #include "system.h"

+#include "bitset.h"

 #include "complain.h"
 #include "getargs.h"
 #include "symtab.h"
 #include "complain.h"
 #include "getargs.h"
 #include "symtab.h"


@@ -34,8 +35,8 @@
 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


@@ -62,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);


@@ -78,7 +79,7 @@ flush_shift (state_t *state, int token)
 static void
 flush_reduce (int lookahead, int token)
 {
 static void
 flush_reduce (int lookahead, int token)
 {

-  RESETBIT (LA (lookahead), token);
+  bitset_reset (LA[lookahead], token);

 }
 
 
 }
 
 


@@ -99,8 +100,8 @@ resolve_sr_conflict (state_t *state, int lookahead)
   errp->nerrs = 0;
 
   for (i = 0; i < ntokens; i++)
   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
        && symbols[i]->prec)
       {
        /* Shift-reduce conflict occurs for token number i


@@ -154,54 +155,49 @@ 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 < tokensetsize; ++j)
-       if (LA (state->lookaheadsp + i)[j] & 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 < 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)
 {
     }
 }
 
 void
 solve_conflicts (void)
 {

-  int i;
+  size_t i;

 
   conflicts = XCALLOC (char, nstates);
 
   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]);


@@ -215,33 +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 < 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;
 }
 
   return src_count;
 }


@@ -265,7 +254,7 @@ count_rr_conflicts (state_t *state)
       int count = 0;
       int j;
       for (j = 0; j < state->nlookaheads; ++j)
       int count = 0;
       int j;
       for (j = 0; j < state->nlookaheads; ++j)

-       if (BITISSET (LA (state->lookaheadsp + j), i))
+       if (bitset_test (LA[state->lookaheadsp + j], i))

          count++;
 
       if (count >= 2)
          count++;
 
       if (count >= 2)


@@ -322,7 +311,7 @@ void
 conflicts_output (FILE *out)
 {
   bool printed_sth = FALSE;
 conflicts_output (FILE *out)
 {
   bool printed_sth = FALSE;

-  int i;
+  size_t i;

   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {
   for (i = 0; i < nstates; i++)
     if (conflicts[i])
       {


@@ -343,7 +332,7 @@ conflicts_output (FILE *out)
 void
 conflicts_print (void)
 {
 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
 
   /* 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


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

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

 }
 }