Actually handle the yytable zero value correctly this time.

[bison.git] / lib / abitset.c

diff --git a/lib/abitset.c b/lib/abitset.c
index 05f37179a723d70681935df4c91aa14868ff8d47..551848c913d58d3777d1b7faaf0b2c246a7daf49 100644 (file)
--- a/lib/abitset.c
+++ b/lib/abitset.c
@@ -1,10 +1,10 @@
 /* Array bitsets.
 /* Array bitsets.

-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2006, 2009 Free Software Foundation, Inc.

    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 

-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -13,13 +13,9 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
-*/
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <config.h>

 
 #include "abitset.h"
 #include <stddef.h>
 
 #include "abitset.h"
 #include <stddef.h>


@@ -29,67 +25,26 @@
 /* This file implements fixed size bitsets stored as an array
    of words.  Any unused bits in the last word must be zero.  */
 
 /* This file implements fixed size bitsets stored as an array
    of words.  Any unused bits in the last word must be zero.  */
 

-static void abitset_unused_clear PARAMS ((bitset));
-static void abitset_ones PARAMS ((bitset));
-static void abitset_zero PARAMS ((bitset));
-static int abitset_empty_p PARAMS ((bitset));
-static void abitset_copy1 PARAMS ((bitset, bitset));
-static void abitset_not PARAMS ((bitset, bitset));
-static int abitset_equal_p PARAMS ((bitset, bitset));
-static int abitset_subset_p PARAMS ((bitset, bitset));
-static int abitset_disjoint_p PARAMS ((bitset, bitset));
-static void abitset_and PARAMS ((bitset, bitset, bitset));
-static int abitset_and_cmp PARAMS ((bitset, bitset, bitset));
-static void abitset_andn PARAMS ((bitset, bitset, bitset));
-static int abitset_andn_cmp PARAMS ((bitset, bitset, bitset));
-static void abitset_or PARAMS ((bitset, bitset, bitset));
-static int abitset_or_cmp PARAMS ((bitset, bitset, bitset));
-static void abitset_xor PARAMS ((bitset, bitset, bitset));
-static int abitset_xor_cmp PARAMS ((bitset, bitset, bitset));
-static void abitset_and_or PARAMS ((bitset, bitset, bitset, bitset));
-static int abitset_and_or_cmp PARAMS ((bitset, bitset, bitset, bitset));
-static void abitset_andn_or PARAMS ((bitset, bitset, bitset, bitset));
-static int abitset_andn_or_cmp PARAMS ((bitset, bitset, bitset, bitset));
-static void abitset_or_and PARAMS ((bitset, bitset, bitset, bitset));
-static int abitset_or_and_cmp PARAMS ((bitset, bitset, bitset, bitset));
-static void abitset_copy PARAMS ((bitset, bitset));
-
-static bitset_bindex abitset_small_list PARAMS ((bitset, bitset_bindex *,
-                                                bitset_bindex,
-                                                bitset_bindex *));
-
-static void abitset_set PARAMS ((bitset, bitset_bindex));
-static void abitset_reset PARAMS ((bitset, bitset_bindex));
-static int abitset_test PARAMS ((bitset, bitset_bindex));
-static bitset_bindex abitset_size PARAMS ((bitset));
-static bitset_bindex abitset_list PARAMS ((bitset, bitset_bindex *,
-                                          bitset_bindex, bitset_bindex *));
-static bitset_bindex abitset_list_reverse
-PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *));
-

 #define ABITSET_N_WORDS(N) (((N) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS)
 #define ABITSET_WORDS(X) ((X)->a.words)
 #define ABITSET_N_WORDS(N) (((N) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS)
 #define ABITSET_WORDS(X) ((X)->a.words)

-#define ABITSET_N_BITS(X) ((X)->a.n_bits)

 
 
 
 

-/* Return size in bits of bitset SRC.  */

 static bitset_bindex
 static bitset_bindex

-abitset_size (src)
-     bitset src;
+abitset_resize (bitset src, bitset_bindex size)

 {
 {

-  return ABITSET_N_BITS (src);
-}
+    /* These bitsets have a fixed size.  */
+    if (BITSET_SIZE_ (src) != size)
+      abort ();

 
 

+    return size;
+}

 
 /* Find list of up to NUM bits set in BSET starting from and including
  *NEXT and store in array LIST.  Return with actual number of bits
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 
 /* Find list of up to NUM bits set in BSET starting from and including
  *NEXT and store in array LIST.  Return with actual number of bits
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex

-abitset_small_list (src, list, num, next)
-     bitset src;
-     bitset_bindex *list;
-     bitset_bindex num;
-     bitset_bindex *next;
+abitset_small_list (bitset src, bitset_bindex *list,
+                   bitset_bindex num, bitset_bindex *next)

 {
   bitset_bindex bitno;
   bitset_bindex count;
 {
   bitset_bindex bitno;
   bitset_bindex count;


@@ -102,7 +57,7 @@ abitset_small_list (src, list, num, next)
   if (!word)
     return 0;
 
   if (!word)
     return 0;
 

-  size = ABITSET_N_BITS (src);
+  size = BITSET_SIZE_ (src);

   bitno = *next;
   if (bitno >= size)
     return 0;
   bitno = *next;
   if (bitno >= size)
     return 0;


@@ -145,38 +100,34 @@ abitset_small_list (src, list, num, next)
 
 /* Set bit BITNO in bitset DST.  */
 static void
 
 /* Set bit BITNO in bitset DST.  */
 static void

-abitset_set (dst, bitno)
-     bitset dst ATTRIBUTE_UNUSED;
-     bitset_bindex bitno ATTRIBUTE_UNUSED;
+abitset_set (bitset dst ATTRIBUTE_UNUSED, bitset_bindex bitno ATTRIBUTE_UNUSED)

 {
 {

-  /* This should never occur for abitsets since we should always
-     hit the cache.  */
+  /* This should never occur for abitsets since we should always hit
+     the cache.  It is likely someone is trying to access outside the
+     bounds of the bitset.  */

   abort ();
 }
 
 
 /* Reset bit BITNO in bitset DST.  */
 static void
   abort ();
 }
 
 
 /* Reset bit BITNO in bitset DST.  */
 static void

-abitset_reset (dst, bitno)
-     bitset dst ATTRIBUTE_UNUSED;
-     bitset_bindex bitno ATTRIBUTE_UNUSED;
+abitset_reset (bitset dst ATTRIBUTE_UNUSED,
+              bitset_bindex bitno ATTRIBUTE_UNUSED)

 {
 {

-  /* This should never occur for abitsets since we should always
-     hit the cache.  */
-  abort ();
+  /* This should never occur for abitsets since we should always hit
+     the cache.  It is likely someone is trying to access outside the
+     bounds of the bitset.  Since the bit is zero anyway, let it pass.  */

 }
 
 
 /* Test bit BITNO in bitset SRC.  */
 }
 
 
 /* Test bit BITNO in bitset SRC.  */

-static int
-abitset_test (src, bitno)
-     bitset src ATTRIBUTE_UNUSED;
-     bitset_bindex bitno ATTRIBUTE_UNUSED;
+static bool
+abitset_test (bitset src ATTRIBUTE_UNUSED,
+             bitset_bindex bitno ATTRIBUTE_UNUSED)

 {
   /* This should never occur for abitsets since we should always
      hit the cache.  */
 {
   /* This should never occur for abitsets since we should always
      hit the cache.  */

-  abort ();
-  return 0;
+  return false;

 }
 
 
 }
 
 


@@ -185,11 +136,8 @@ abitset_test (src, bitno)
    actual number of bits found and with *NEXT indicating where search
    stopped.  */
 static bitset_bindex
    actual number of bits found and with *NEXT indicating where search
    stopped.  */
 static bitset_bindex

-abitset_list_reverse (src, list, num, next)
-     bitset src;
-     bitset_bindex *list;
-     bitset_bindex num;
-     bitset_bindex *next;
+abitset_list_reverse (bitset src, bitset_bindex *list,
+                     bitset_bindex num, bitset_bindex *next)

 {
   bitset_bindex bitno;
   bitset_bindex rbitno;
 {
   bitset_bindex bitno;
   bitset_bindex rbitno;


@@ -198,7 +146,7 @@ abitset_list_reverse (src, list, num, next)
   unsigned int bitcnt;
   bitset_bindex bitoff;
   bitset_word *srcp = ABITSET_WORDS (src);
   unsigned int bitcnt;
   bitset_bindex bitoff;
   bitset_word *srcp = ABITSET_WORDS (src);

-  bitset_bindex n_bits = ABITSET_N_BITS (src);
+  bitset_bindex n_bits = BITSET_SIZE_ (src);

 
   rbitno = *next;
 
 
   rbitno = *next;
 


@@ -248,11 +196,8 @@ abitset_list_reverse (src, list, num, next)
  *NEXT and store in array LIST.  Return with actual number of bits
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
  *NEXT and store in array LIST.  Return with actual number of bits
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex

-abitset_list (src, list, num, next)
-     bitset src;
-     bitset_bindex *list;
-     bitset_bindex num;
-     bitset_bindex *next;
+abitset_list (bitset src, bitset_bindex *list,
+             bitset_bindex num, bitset_bindex *next)

 {
   bitset_bindex bitno;
   bitset_bindex count;
 {
   bitset_bindex bitno;
   bitset_bindex count;


@@ -280,7 +225,7 @@ abitset_list (src, list, num, next)
     }
   else
     {
     }
   else
     {

-      if (bitno >= ABITSET_N_BITS (src))
+      if (bitno >= BITSET_SIZE_ (src))

        return 0;
 
       windex = bitno / BITSET_WORD_BITS;
        return 0;
 
       windex = bitno / BITSET_WORD_BITS;


@@ -352,12 +297,11 @@ abitset_list (src, list, num, next)
 
 /* Ensure that any unused bits within the last word are clear.  */
 static inline void
 
 /* Ensure that any unused bits within the last word are clear.  */
 static inline void

-abitset_unused_clear (dst)
-     bitset dst;
+abitset_unused_clear (bitset dst)

 {
   unsigned int last_bit;
 
 {
   unsigned int last_bit;
 

-  last_bit = ABITSET_N_BITS (dst) % BITSET_WORD_BITS;
+  last_bit = BITSET_SIZE_ (dst) % BITSET_WORD_BITS;

   if (last_bit)
     ABITSET_WORDS (dst)[dst->b.csize - 1] &=
       ((bitset_word) 1 << last_bit) - 1;
   if (last_bit)
     ABITSET_WORDS (dst)[dst->b.csize - 1] &=
       ((bitset_word) 1 << last_bit) - 1;


@@ -365,8 +309,7 @@ abitset_unused_clear (dst)
 
 
 static void
 
 
 static void

-abitset_ones (dst)
-     bitset dst;
+abitset_ones (bitset dst)

 {
   bitset_word *dstp = ABITSET_WORDS (dst);
   size_t bytes;
 {
   bitset_word *dstp = ABITSET_WORDS (dst);
   size_t bytes;


@@ -379,8 +322,7 @@ abitset_ones (dst)
 
 
 static void
 
 
 static void

-abitset_zero (dst)
-     bitset dst;
+abitset_zero (bitset dst)

 {
   bitset_word *dstp = ABITSET_WORDS (dst);
   size_t bytes;
 {
   bitset_word *dstp = ABITSET_WORDS (dst);
   size_t bytes;


@@ -391,25 +333,22 @@ abitset_zero (dst)
 }
 
 
 }
 
 

-static int
-abitset_empty_p (dst)
-     bitset dst;
+static bool
+abitset_empty_p (bitset dst)

 {
   bitset_windex i;
   bitset_word *dstp = ABITSET_WORDS (dst);
 
   for (i = 0; i < dst->b.csize; i++)
     if (dstp[i])
 {
   bitset_windex i;
   bitset_word *dstp = ABITSET_WORDS (dst);
 
   for (i = 0; i < dst->b.csize; i++)
     if (dstp[i])

-      return 0;
+      return false;

 
 

-  return 1;
+  return true;

 }
 
 
 static void
 }
 
 
 static void

-abitset_copy1 (dst, src)
-     bitset dst;
-     bitset src;
+abitset_copy1 (bitset dst, bitset src)

 {
   bitset_word *srcp = ABITSET_WORDS (src);
   bitset_word *dstp = ABITSET_WORDS (dst);
 {
   bitset_word *srcp = ABITSET_WORDS (src);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -422,9 +361,7 @@ abitset_copy1 (dst, src)
 
 
 static void
 
 
 static void

-abitset_not (dst, src)
-     bitset dst;
-     bitset src;
+abitset_not (bitset dst, bitset src)

 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);
 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);


@@ -436,11 +373,9 @@ abitset_not (dst, src)
   abitset_unused_clear (dst);
 }
 
   abitset_unused_clear (dst);
 }
 

- 
-static int
-abitset_equal_p (dst, src)
-     bitset dst;
-     bitset src;
+
+static bool
+abitset_equal_p (bitset dst, bitset src)

 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);
 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);


@@ -449,32 +384,28 @@ abitset_equal_p (dst, src)
 
   for (i = 0; i < size; i++)
       if (*srcp++ != *dstp++)
 
   for (i = 0; i < size; i++)
       if (*srcp++ != *dstp++)

-         return 0;
-  return 1;
+         return false;
+  return true;

 }
 
 
 }
 
 

-static int
-abitset_subset_p (dst, src)
-     bitset dst;
-     bitset src;
+static bool
+abitset_subset_p (bitset dst, bitset src)

 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++, dstp++, srcp++)
       if (*dstp != (*srcp | *dstp))
   for (i = 0; i < size; i++, dstp++, srcp++)
       if (*dstp != (*srcp | *dstp))

-         return 0;
-  return 1;
+         return false;
+  return true;

 }
 
 
 }
 
 

-static int
-abitset_disjoint_p (dst, src)
-     bitset dst;
-     bitset src;
+static bool
+abitset_disjoint_p (bitset dst, bitset src)

 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);
 {
   bitset_windex i;
   bitset_word *srcp = ABITSET_WORDS (src);


@@ -483,17 +414,14 @@ abitset_disjoint_p (dst, src)
 
   for (i = 0; i < size; i++)
       if (*srcp++ & *dstp++)
 
   for (i = 0; i < size; i++)
       if (*srcp++ & *dstp++)

-         return 0;
+         return false;

 
 

-  return 1;
+  return true;

 }
 
 
 static void
 }
 
 
 static void

-abitset_and (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+abitset_and (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -506,14 +434,11 @@ abitset_and (dst, src1, src2)
 }
 
 
 }
 
 

-static int
-abitset_and_cmp (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+static bool
+abitset_and_cmp (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -522,10 +447,10 @@ abitset_and_cmp (dst, src1, src2)
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ & *src2p++;
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ & *src2p++;

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -534,10 +459,7 @@ abitset_and_cmp (dst, src1, src2)
 
 
 static void
 
 
 static void

-abitset_andn (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+abitset_andn (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -550,26 +472,23 @@ abitset_andn (dst, src1, src2)
 }
 
 
 }
 
 

-static int
-abitset_andn_cmp (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+static bool
+abitset_andn_cmp (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ & ~(*src2p++);
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ & ~(*src2p++);

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -578,10 +497,7 @@ abitset_andn_cmp (dst, src1, src2)
 
 
 static void
 
 
 static void

-abitset_or (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+abitset_or (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -594,14 +510,11 @@ abitset_or (dst, src1, src2)
 }
 
 
 }
 
 

-static int
-abitset_or_cmp (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+static bool
+abitset_or_cmp (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -610,10 +523,10 @@ abitset_or_cmp (dst, src1, src2)
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ | *src2p++;
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ | *src2p++;

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -622,10 +535,7 @@ abitset_or_cmp (dst, src1, src2)
 
 
 static void
 
 
 static void

-abitset_xor (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+abitset_xor (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -638,14 +548,11 @@ abitset_xor (dst, src1, src2)
 }
 
 
 }
 
 

-static int
-abitset_xor_cmp (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
+static bool
+abitset_xor_cmp (bitset dst, bitset src1, bitset src2)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -654,10 +561,10 @@ abitset_xor_cmp (dst, src1, src2)
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ ^ *src2p++;
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = *src1p++ ^ *src2p++;

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -666,11 +573,7 @@ abitset_xor_cmp (dst, src1, src2)
 
 
 static void
 
 
 static void

-abitset_and_or (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
+abitset_and_or (bitset dst, bitset src1, bitset src2, bitset src3)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -678,34 +581,30 @@ abitset_and_or (dst, src1, src2, src3)
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++)
       *dstp++ = (*src1p++ & *src2p++) | *src3p++;
 }
 
 
   for (i = 0; i < size; i++)
       *dstp++ = (*src1p++ & *src2p++) | *src3p++;
 }
 
 

-static int
-abitset_and_or_cmp (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
+static bool
+abitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -714,11 +613,7 @@ abitset_and_or_cmp (dst, src1, src2, src3)
 
 
 static void
 
 
 static void

-abitset_andn_or (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
+abitset_andn_or (bitset dst, bitset src1, bitset src2, bitset src3)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -726,34 +621,30 @@ abitset_andn_or (dst, src1, src2, src3)
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++)
       *dstp++ = (*src1p++ & ~(*src2p++)) | *src3p++;
 }
 
 
   for (i = 0; i < size; i++)
       *dstp++ = (*src1p++ & ~(*src2p++)) | *src3p++;
 }
 
 

-static int
-abitset_andn_or_cmp (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
+static bool
+abitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -762,11 +653,7 @@ abitset_andn_or_cmp (dst, src1, src2, src3)
 
 
 static void
 
 
 static void

-abitset_or_and (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
+abitset_or_and (bitset dst, bitset src1, bitset src2, bitset src3)

 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);
 {
   bitset_windex i;
   bitset_word *src1p = ABITSET_WORDS (src1);


@@ -774,34 +661,30 @@ abitset_or_and (dst, src1, src2, src3)
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++)
       *dstp++ = (*src1p++ | *src2p++) & *src3p++;
 }
 
 
   for (i = 0; i < size; i++)
       *dstp++ = (*src1p++ | *src2p++) & *src3p++;
 }
 
 

-static int
-abitset_or_and_cmp (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
+static bool
+abitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)

 {
   bitset_windex i;
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;

-  
+

   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;
   for (i = 0; i < size; i++, dstp++)
     {
       bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;

-      
+

       if (*dstp != tmp)
        {
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -810,9 +693,7 @@ abitset_or_and_cmp (dst, src1, src2, src3)
 
 
 static void
 
 
 static void

-abitset_copy (dst, src)
-     bitset dst;
-     bitset src;
+abitset_copy (bitset dst, bitset src)

 {
   if (BITSET_COMPATIBLE_ (dst, src))
       abitset_copy1 (dst, src);
 {
   if (BITSET_COMPATIBLE_ (dst, src))
       abitset_copy1 (dst, src);


@@ -827,7 +708,8 @@ struct bitset_vtable abitset_small_vtable = {
   abitset_reset,
   bitset_toggle_,
   abitset_test,
   abitset_reset,
   bitset_toggle_,
   abitset_test,

-  abitset_size,
+  abitset_resize,
+  bitset_size_,

   bitset_count_,
   abitset_empty_p,
   abitset_ones,
   bitset_count_,
   abitset_empty_p,
   abitset_ones,


@@ -864,7 +746,8 @@ struct bitset_vtable abitset_vtable = {
   abitset_reset,
   bitset_toggle_,
   abitset_test,
   abitset_reset,
   bitset_toggle_,
   abitset_test,

-  abitset_size,
+  abitset_resize,
+  bitset_size_,

   bitset_count_,
   abitset_empty_p,
   abitset_ones,
   bitset_count_,
   abitset_empty_p,
   abitset_ones,


@@ -896,8 +779,7 @@ struct bitset_vtable abitset_vtable = {
 
 
 size_t
 
 
 size_t

-abitset_bytes (n_bits)
-     bitset_bindex n_bits;
+abitset_bytes (bitset_bindex n_bits)

 {
   bitset_windex size;
   size_t bytes;
 {
   bitset_windex size;
   size_t bytes;


@@ -921,14 +803,12 @@ abitset_bytes (n_bits)
 
 
 bitset
 
 
 bitset

-abitset_init (bset, n_bits)
-     bitset bset;
-     bitset_bindex n_bits;
+abitset_init (bitset bset, bitset_bindex n_bits)

 {
   bitset_windex size;
 
   size = ABITSET_N_WORDS (n_bits);
 {
   bitset_windex size;
 
   size = ABITSET_N_WORDS (n_bits);

-  ABITSET_N_BITS (bset) = n_bits;
+  BITSET_NBITS_ (bset) = n_bits;

 
   /* Use optimized routines if bitset fits within a single word.
      There is probably little merit if using caching since
 
   /* Use optimized routines if bitset fits within a single word.
      There is probably little merit if using caching since