* 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.

diff --git a/ChangeLog b/ChangeLog
index 9555475fcd7a642102881c140aa1944f5140a750..af90d41023ef8166430d3f77b0bf82bbae94b786 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2002-03-04  Akim Demaille  <akim@epita.fr>
+
+       * 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.
+

 2002-03-04  Akim Demaille  <akim@epita.fr>
 
        * src/closure.c, src/conflicts.c, src/lalr.c, src/print.c,
 2002-03-04  Akim Demaille  <akim@epita.fr>
 
        * src/closure.c, src/conflicts.c, src/lalr.c, src/print.c,

diff --git a/src/closure.c b/src/closure.c
index b20e98c0ac54620a62d2f0d55df1cf155d293584..da9d4db3c71f5277d9b45675a2a6587d37701551 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -1,5 +1,5 @@
 /* Subroutines for bison
 /* 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.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -19,13 +19,14 @@
    02111-1307, USA.  */
 
 #include "system.h"
    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 "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.  */
 #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 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]
 
 /* 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;
 
 {
   int i, j;
 

-  firsts = XCALLOC (bitset, nvars);
+  firsts = bitsetv_create (nvars, nvars, BITSET_FIXED);
+

   for (i = ntokens; i < nsyms; i++)
   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);
-       }
-    }
+    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, nvars);
+  RTC (firsts);

 
   if (trace_flag)
     print_firsts ();
 
   if (trace_flag)
     print_firsts ();


@@ -153,10 +152,7 @@ set_fderives (void)
 {
   int i, j, k;
 
 {
   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 ();
 
 
   set_firsts ();
 


@@ -169,9 +165,7 @@ set_fderives (void)
   if (trace_flag)
     print_fderives ();
 
   if (trace_flag)
     print_fderives ();
 

-  for (i = ntokens; i < nsyms; ++i)
-    bitset_free (FIRSTS (i));
-  XFREE (firsts);
+  bitsetv_free (firsts);

 }
 \f
 
 }
 \f
 


@@ -246,12 +240,7 @@ closure (short *core, int n)
 void
 free_closure (void)
 {
 void
 free_closure (void)
 {

-  int i;

   XFREE (itemset);
   XFREE (itemset);

-

   bitset_free (ruleset);
   bitset_free (ruleset);

-
-  for (i = 0 ; i < nvars; ++i)
-    bitset_free (fderives[i]);
-  free (fderives);
+  bitsetv_free (fderives);

 }
 }

diff --git a/src/conflicts.c b/src/conflicts.c
index 1cb7183fe028cfb321722c52bacd80ef74af5bd1..d90b380aa4ef87b5fb8b1cdc6f3d5157b81a4e4b 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -155,7 +155,7 @@ 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)
   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)
      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)
     {
 
   /* 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]);
     }
 
       bitset_or (lookaheadset, lookaheadset, LA[state->lookaheadsp + i]);
     }


@@ -236,9 +230,7 @@ count_sr_conflicts (state_t *state)
 
   bitset_and (lookaheadset, lookaheadset, shiftset);
 
 
   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;
 }
 
   return src_count;
 }

diff --git a/src/lalr.c b/src/lalr.c
index 9dda7f05647331a319e6d8ff7a9b24d7ac7d42a5..bd739dbf2b8ff69171acf56444d6c25bd4958181 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -25,6 +25,7 @@
 
 #include "system.h"
 #include "bitset.h"
 
 #include "system.h"
 #include "bitset.h"

+#include "bitsetv.h"

 #include "reader.h"
 #include "types.h"
 #include "LR0.h"
 #include "reader.h"
 #include "types.h"
 #include "LR0.h"


@@ -40,7 +41,7 @@
 state_t **states = NULL;
 
 short *LAruleno = NULL;
 state_t **states = NULL;
 
 short *LAruleno = NULL;

-bitset *LA = NULL;
+bitsetv LA = NULL;

 size_t nLA;
 
 static int ngotos;
 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>.  */
 
 /* 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;
 
 static short **includes;
 static shorts **lookback;


@@ -139,9 +140,7 @@ initialize_LA (void)
   if (!nLA)
     nLA = 1;
 
   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);
 
   LAruleno = XCALLOC (short, nLA);
   lookback = XCALLOC (shorts *, nLA);
 


@@ -253,9 +252,7 @@ initialize_F (void)
 
   int i;
 
 
   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++)
     {
 
   for (i = 0; i < ngotos; i++)
     {


@@ -500,9 +497,7 @@ compute_lookaheads (void)
     LIST_FREE (shorts, lookback[i]);
 
   XFREE (lookback);
     LIST_FREE (shorts, lookback[i]);
 
   XFREE (lookback);

-  for (i = 0; i < (unsigned) ngotos; ++i)
-    bitset_free (F[i]);
-  XFREE (F);
+  bitsetv_free (F);

 }
 
 
 }
 
 

diff --git a/src/main.c b/src/main.c
index 16634de571dc76612da85757e139b6110006de3b..5d70fa48b976b47fad7ca8dc3728dcb7a0306d72 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -50,6 +50,8 @@ main (int argc, char *argv[])
   bindtextdomain (PACKAGE, LOCALEDIR);
   textdomain (PACKAGE);
 
   bindtextdomain (PACKAGE, LOCALEDIR);
   textdomain (PACKAGE);
 

+  bitset_stats_init ();
+

   lineno = 0;
   getargs (argc, argv);
 
   lineno = 0;
   getargs (argc, argv);
 

diff --git a/src/output.c b/src/output.c
index 706ee272f1357e083e45a10551be5331146b6cc0..c2720d96967fb62d78db25c75ad494febf46aa33 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -89,6 +89,7 @@
    negative short int.  Used to flag ??  */
 
 #include "system.h"
    negative short int.  Used to flag ??  */
 
 #include "system.h"

+#include "bitsetv.h"

 #include "quotearg.h"
 #include "error.h"
 #include "getargs.h"
 #include "quotearg.h"
 #include "error.h"
 #include "getargs.h"


@@ -922,7 +923,7 @@ output_actions (void)
   width = XCALLOC (short, nvectors);
 
   token_actions ();
   width = XCALLOC (short, nvectors);
 
   token_actions ();

-  XFREE (LA);
+  bitsetv_free (LA);

   XFREE (LAruleno);
 
   goto_actions ();
   XFREE (LAruleno);
 
   goto_actions ();

diff --git a/src/reduce.c b/src/reduce.c
index 21a83b1ab64c331cd310e89baeb15c4d9dd81f8e..bef2ae90307d279f78161917446f4ebca66482b6 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -57,15 +57,6 @@ static int nuseless_productions;
 static int nuseful_nonterminals;
 int nuseless_nonterminals;
 \f
 static int nuseful_nonterminals;
 int nuseless_nonterminals;
 \f

-static int
-bits_size (bitset S)
-{
-  int i, count = 0;
-
-  BITSET_EXECUTE (S, 0, i, { ++count; });
-  return count;
-}
-\f

 /*-------------------------------------------------------------------.
 | 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    |
 /*-------------------------------------------------------------------.
 | 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++)
      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;
 }
 
   return TRUE;
 }
 


@@ -215,7 +205,7 @@ inaccessable_symbols (void)
   bitset_free (P);
   P = Pp;
 
   bitset_free (P);
   P = Pp;
 

-  nuseful_productions = bits_size (P);
+  nuseful_productions = bitset_count (P);

   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;
   nuseless_productions = nrules - nuseful_productions;
 
   nuseful_nonterminals = 0;

diff --git a/src/warshall.c b/src/warshall.c
index c962bc7fdb6577046ca037a48519ea9a25d1c0aa..a7ef4cb63d369588747dbe77b3945590cd36a09b 100644 (file)
--- a/src/warshall.c
+++ b/src/warshall.c
@@ -21,7 +21,7 @@
 
 #include "system.h"
 #include "getargs.h"
 
 #include "system.h"
 #include "getargs.h"

-#include "bitset.h"
+#include "bitsetv.h"

 #include "warshall.h"
 
 /*--------------------------------------------------------.
 #include "warshall.h"
 
 /*--------------------------------------------------------.


@@ -29,9 +29,10 @@
 `--------------------------------------------------------*/
 
 static void
 `--------------------------------------------------------*/
 
 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 i, j;

+  size_t size = bitset_size (matrix[0]);

 
   /* Title. */
   fprintf (stderr, "%s BEGIN\n", title);
 
   /* Title. */
   fprintf (stderr, "%s BEGIN\n", title);


@@ -77,23 +78,23 @@ bitmatrix_print (const char *title, bitset *matrix, size_t size)
 `-------------------------------------------------------------------*/
 
 static void
 `-------------------------------------------------------------------*/
 
 static void

-TC (bitset *matrix, int n)
+TC (bitsetv matrix)

 {
   int i, j;
 
   if (trace_flag)
 {
   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. */
 
 
   /* 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)
       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
 `---------------------------------------------------------------*/
 
 void

-RTC (bitset *matrix, int n)
+RTC (bitsetv matrix)

 {
   int i;
 
 {
   int i;
 

-  TC (matrix, n);
-  for (i = 0; i < n; ++i)
+  TC (matrix);
+  for (i = 0; matrix[i]; ++i)

     bitset_set (matrix[i], i);
 }
     bitset_set (matrix[i], i);
 }

diff --git a/src/warshall.h b/src/warshall.h
index 15d8c8006698fdb89153c099948d43c42d26bb14..d97fdd8e17861e490a8621d766b353791fdef1a7 100644 (file)
--- a/src/warshall.h
+++ b/src/warshall.h
@@ -1,5 +1,5 @@
 /* Generate transitive closure of a matrix,
 /* 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.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -21,5 +21,5 @@
 #ifndef WARSHALL_H_
 # define WARSHALL_H_
 
 #ifndef WARSHALL_H_
 # define WARSHALL_H_
 

-void RTC PARAMS ((bitset *, int));
+void RTC PARAMS ((bitsetv));

 #endif /* !WARSHALL_H_ */
 #endif /* !WARSHALL_H_ */