* src/conflicts.c (set_conflicts): Use bitset_disjoint_p.

(count_sr_conflicts): Use bitset_count.
* src/reduce.c (inaccessable_symbols): Ditto.
(bits_size): Remove.
* src/warshall.h, src/warshall.c: Convert to bitsetv.

src/closure.c

@@ -1,5 +1,5 @@
 /* Subroutines for bison
-   Copyright 1984, 1989, 2000, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -19,13 +19,14 @@
    02111-1307, USA.  */
 
 #include "system.h"
+#include "bitset.h"
+#include "bitsetv.h"
 #include "getargs.h"
 #include "symtab.h"
 #include "gram.h"
 #include "reader.h"
 #include "closure.h"
 #include "derives.h"
-#include "bitset.h"
 #include "warshall.h"
 
 /* NITEMSET is the size of the array ITEMSET.  */
@@ -35,8 +36,8 @@ int nitemset;
 static bitset ruleset;
 
 /* internal data.  See comments before set_fderives and set_firsts.  */
-static bitset *fderives = NULL;
-static bitset *firsts = NULL;
+static bitsetv fderives = NULL;
+static bitsetv firsts = NULL;
 
 /* Retrieve the FDERIVES/FIRSTS sets of the nonterminals numbered Var.  */
 #define FDERIVES(Var)   fderives[(Var) - ntokens]
@@ -120,19 +121,17 @@ set_firsts (void)
 {
   int i, j;
 
-  firsts = XCALLOC (bitset, nvars);
-  for (i = ntokens; i < nsyms; i++)
-    {
-      FIRSTS (i) = bitset_create (nvars, BITSET_FIXED);
-      for (j = 0; derives[i][j] >= 0; ++j)
-	{
-	  int symbol = ritem[rules[derives[i][j]].rhs];
-	  if (ISVAR (symbol))
-	    bitset_set (FIRSTS (i), symbol - ntokens);
-	}
-    }
+  firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
 
-  RTC (firsts, nvars);
+  for (i = ntokens; i < nsyms; i++)
+    for (j = 0; derives[i][j] >= 0; ++j)
+      {
+	int symbol = ritem[rules[derives[i][j]].rhs];
+	if (ISVAR (symbol))
+	  bitset_set (FIRSTS (i), symbol - ntokens);
+      }
+
+  RTC (firsts);
 
   if (trace_flag)
     print_firsts ();
@@ -153,10 +152,7 @@ set_fderives (void)
 {
   int i, j, k;
 
-  fderives = XCALLOC (bitset, nvars);
-  bitset_stats_init ();
-  for (i = 0 ; i < nvars; ++i)
-    fderives[i] = bitset_create (nrules + 1, BITSET_FIXED);
+  fderives = bitsetv_create (nvars, nrules + 1, BITSET_FIXED);
 
   set_firsts ();
 
@@ -169,9 +165,7 @@ set_fderives (void)
   if (trace_flag)
     print_fderives ();
 
-  for (i = ntokens; i < nsyms; ++i)
-    bitset_free (FIRSTS (i));
-  XFREE (firsts);
+  bitsetv_free (firsts);
 }
 
 
@@ -246,12 +240,7 @@ closure (short *core, int n)
 void
 free_closure (void)
 {
-  int i;
   XFREE (itemset);
-
   bitset_free (ruleset);
-
-  for (i = 0 ; i < nvars; ++i)
-    bitset_free (fderives[i]);
-  free (fderives);
+  bitsetv_free (fderives);
 }

src/conflicts.c

@@ -155,7 +155,7 @@ 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)
@@ -172,25 +172,19 @@ set_conflicts (state_t *state)
      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)
-	    && bitset_test (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)
     {
-      /* FIXME: Here, I need something like `bitset_disjoint_p'. */
-      for (j = 0; j < ntokens; ++j)
-	if (bitset_test (LA[state->lookaheadsp + i], j)
-	    && bitset_test (lookaheadset, j))
-	  conflicts[state->number] = 1;
+      if (!bitset_disjoint_p (LA[state->lookaheadsp + i], lookaheadset))
+	conflicts[state->number] = 1;
 
       bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]);
     }
@@ -236,9 +230,7 @@ count_sr_conflicts (state_t *state)
 
   bitset_and (lookaheadset, lookaheadset, shiftset);
 
-  for (i = 0; i < ntokens; i++)
-    if (bitset_test (lookaheadset, i))
-      src_count++;
+  src_count = bitset_count (lookaheadset);
 
   return src_count;
 }

src/lalr.c

@@ -25,6 +25,7 @@
 
 #include "system.h"
 #include "bitset.h"
+#include "bitsetv.h"
 #include "reader.h"
 #include "types.h"
 #include "LR0.h"
@@ -40,7 +41,7 @@
 state_t **states = NULL;
 
 short *LAruleno = NULL;
-bitset *LA = NULL;
+bitsetv LA = NULL;
 size_t nLA;
 
 static int ngotos;
@@ -50,7 +51,7 @@ short *to_state = NULL;
 
 /* And for the famous F variable, which name is so descriptive that a
    comment is hardly needed.  <grin>.  */
-static bitset *F = NULL;
+static bitsetv F = NULL;
 
 static short **includes;
 static shorts **lookback;
@@ -139,9 +140,7 @@ initialize_LA (void)
   if (!nLA)
     nLA = 1;
 
-  LA = XCALLOC (bitset, nLA);
-  for (i = 0; i < nLA; ++i)
-    LA[i] = bitset_create (ntokens, BITSET_FIXED);
+  LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
   LAruleno = XCALLOC (short, nLA);
   lookback = XCALLOC (shorts *, nLA);
 
@@ -253,9 +252,7 @@ initialize_F (void)
 
   int i;
 
-  F = XCALLOC (bitset, ngotos);
-  for (i = 0; i < ngotos; ++i)
-    F[i] = bitset_create (ntokens, BITSET_FIXED);
+  F = bitsetv_create (ngotos, ntokens, BITSET_FIXED);
 
   for (i = 0; i < ngotos; i++)
     {
@@ -500,9 +497,7 @@ compute_lookaheads (void)
     LIST_FREE (shorts, lookback[i]);
 
   XFREE (lookback);
-  for (i = 0; i < (unsigned) ngotos; ++i)
-    bitset_free (F[i]);
-  XFREE (F);
+  bitsetv_free (F);
 }
 
 

src/main.c

@@ -50,6 +50,8 @@ main (int argc, char *argv[])
   bindtextdomain (PACKAGE, LOCALEDIR);
   textdomain (PACKAGE);
 
+  bitset_stats_init ();
+
   lineno = 0;
   getargs (argc, argv);
 

src/output.c

@@ -89,6 +89,7 @@
    negative short int.  Used to flag ??  */
 
 #include "system.h"
+#include "bitsetv.h"
 #include "quotearg.h"
 #include "error.h"
 #include "getargs.h"
@@ -922,7 +923,7 @@ output_actions (void)
   width = XCALLOC (short, nvectors);
 
   token_actions ();
-  XFREE (LA);
+  bitsetv_free (LA);
   XFREE (LAruleno);
 
   goto_actions ();

src/reduce.c

@@ -57,15 +57,6 @@ static int nuseless_productions;
 static int nuseful_nonterminals;
 int nuseless_nonterminals;
 
-static int
-bits_size (bitset S)
-{
-  int i, count = 0;
-
-  BITSET_EXECUTE (S, 0, i, { ++count; });
-  return count;
-}
-
 /*-------------------------------------------------------------------.
 | Another way to do this would be with a set for each production and |
 | then do subset tests against N0, but even for the C grammar the    |
@@ -82,9 +73,8 @@ useful_production (int i, bitset N0)
      in the set of useful nonterminals.  */
 
   for (r = &ritem[rules[i].rhs]; *r >= 0; r++)
-    if (ISVAR (n = *r))
-      if (!bitset_test (N0, n - ntokens))
-	return FALSE;
+    if (ISVAR (n = *r) && !bitset_test (N0, n - ntokens))
+      return FALSE;
   return TRUE;
 }
 
@@ -215,7 +205,7 @@ inaccessable_symbols (void)
   bitset_free (P);
   P = Pp;
 
-  nuseful_productions = bits_size (P);
+  nuseful_productions = bitset_count (P);
   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;

src/warshall.c

@@ -21,7 +21,7 @@
 
 #include "system.h"
 #include "getargs.h"
-#include "bitset.h"
+#include "bitsetv.h"
 #include "warshall.h"
 
 /*--------------------------------------------------------.
@@ -29,9 +29,10 @@
 `--------------------------------------------------------*/
 
 static void
-bitmatrix_print (const char *title, bitset *matrix, size_t size)
+bitmatrix_print (const char *title, bitsetv matrix)
 {
   size_t i, j;
+  size_t size = bitset_size (matrix[0]);
 
   /* Title. */
   fprintf (stderr, "%s BEGIN\n", title);
@@ -77,23 +78,23 @@ bitmatrix_print (const char *title, bitset *matrix, size_t size)
 `-------------------------------------------------------------------*/
 
 static void
-TC (bitset *matrix, int n)
+TC (bitsetv matrix)
 {
   int i, j;
 
   if (trace_flag)
-    bitmatrix_print ("TC: Input", matrix, n);
+    bitmatrix_print ("TC: Input", matrix);
 
   /* R (J, I) && R (I, K) => R (J, K).
      I *must* be the outter loop. */
 
-  for (i = 0; i < n; ++i)
-    for (j = 0; j < n; ++j)
+  for (i = 0; matrix[i]; ++i)
+    for (j = 0; matrix[j]; ++j)
       if (bitset_test (matrix[j], i))
 	bitset_or (matrix[j], matrix[j], matrix[i]);
 
   if (trace_flag)
-    bitmatrix_print ("TC: Output", matrix, n);
+    bitmatrix_print ("TC: Output", matrix);
 }
 
 
@@ -103,11 +104,11 @@ TC (bitset *matrix, int n)
 `---------------------------------------------------------------*/
 
 void
-RTC (bitset *matrix, int n)
+RTC (bitsetv matrix)
 {
   int i;
 
-  TC (matrix, n);
-  for (i = 0; i < n; ++i)
+  TC (matrix);
+  for (i = 0; matrix[i]; ++i)
     bitset_set (matrix[i], i);
 }

src/warshall.h

@@ -1,5 +1,5 @@
 /* Generate transitive closure of a matrix,
-   Copyright 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 2000, 2001, 2002 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -21,5 +21,5 @@
 #ifndef WARSHALL_H_
 # define WARSHALL_H_
 
-void RTC PARAMS ((bitset *, int));
+void RTC PARAMS ((bitsetv));
 #endif /* !WARSHALL_H_ */