Update from TP.

[bison.git] / lib / ebitset.c

diff --git a/lib/ebitset.c b/lib/ebitset.c
index 0a6cbd41ccb288c8b5d0ce0e15ca5479692df557..3e84efa8ab8dc8787c21157dbca94e08b342398d 100644 (file)
--- a/lib/ebitset.c
+++ b/lib/ebitset.c
@@ -1,43 +1,34 @@
-/* Functions to support efficient bitsets.
+/* Functions to support expandable bitsets.

    Copyright (C) 2002 Free Software Foundation, Inc.
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 
    Copyright (C) 2002 Free Software Foundation, Inc.
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 

-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
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.

 
 

-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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.  */
+   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. 
+*/

 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 

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

 #include "obstack.h"
 #include <stdlib.h>
 
 #include "obstack.h"
 #include <stdlib.h>
 

-# if WITH_DMALLOC
-#  define DMALLOC_FUNC_CHECK
-#  include <dmalloc.h>
-# endif /* WITH_DMALLOC */
-
-/* This file implements linked-list bitsets.  These bitsets can be of
+/* This file implements expandable bitsets.  These bitsets can be of

    arbitrary length and are more efficient than arrays of bits for
    large sparse sets.
 
    arbitrary length and are more efficient than arrays of bits for
    large sparse sets.
 

-   Usually if all the bits in an element are zero we remove the element
-   from the list.  However, a side effect of the bit caching is that we
-   do not always notice when an element becomes zero.  Hence the
-   ebitset_weed function which removes zero elements.
-

    Empty elements are represented by a NULL pointer in the table of
    element pointers.  An alternative is to point to a special zero
    element.  Similarly, we could represent an all 1's element with
    Empty elements are represented by a NULL pointer in the table of
    element pointers.  An alternative is to point to a special zero
    element.  Similarly, we could represent an all 1's element with


@@ -46,33 +37,76 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    Bitsets are commonly empty so we need to ensure that this special
    case is fast.  A zero bitset is indicated when cdata is 0.  This is
    conservative since cdata may be non zero and the bitset may still
    Bitsets are commonly empty so we need to ensure that this special
    case is fast.  A zero bitset is indicated when cdata is 0.  This is
    conservative since cdata may be non zero and the bitset may still

-   be zero.
+   be zero. 

 
    The bitset cache can be disabled either by setting cindex to
 
    The bitset cache can be disabled either by setting cindex to

-   some large number or by setting csize to 0.  Here
+   some large number or by setting csize to 0.  Here 

    we use the former approach since cindex needs to be updated whenever
    we use the former approach since cindex needs to be updated whenever

-   cdata is changed.
+   cdata is changed.   

 */
 
 */
 

+
+/* Number of words to use for each element.  */
+
+#ifndef EBITSET_ELT_WORDS
+#define EBITSET_ELT_WORDS 2
+#endif
+
+/* Number of bits stored in each element.  */
+#define EBITSET_ELT_BITS \
+  ((unsigned) (EBITSET_ELT_WORDS * BITSET_WORD_BITS))
+
+/* Ebitset element.  We use an array of bits.  */
+typedef struct ebitset_elt_struct
+{
+  union
+  {
+    bitset_word words[EBITSET_ELT_WORDS];      /* Bits that are set.  */
+    struct ebitset_elt_struct *next;
+  }
+  u;
+}
+ebitset_elt;
+
+
+typedef ebitset_elt *ebitset_elts;
+
+/* Head of ebitset linked list.  */
+typedef struct ebitset_struct
+{
+  unsigned int size;           /* Number of elements.  */
+  ebitset_elts *elts;          /* Expanding array of pointers to elements.  */
+}
+*ebitset;
+
+

 /* Number of elements to initially allocate.  */
 /* Number of elements to initially allocate.  */

+

 #ifndef EBITSET_INITIAL_SIZE
 #define EBITSET_INITIAL_SIZE 2
 #endif
 
 /* Minimum number of elements to grow table.  */
 #ifndef EBITSET_INITIAL_SIZE
 #define EBITSET_INITIAL_SIZE 2
 #endif
 
 /* Minimum number of elements to grow table.  */

+

 #ifndef EBITSET_GROW_SIZE
 #define EBITSET_GROW_SIZE 4
 #endif
 
 #ifndef EBITSET_GROW_SIZE
 #define EBITSET_GROW_SIZE 4
 #endif
 

+struct bitset_struct
+{
+  struct bbitset_struct b;
+  struct ebitset_struct e;
+};

 
 

-enum ebitset_find_mode {EBITSET_FIND, EBITSET_CREATE, EBITSET_SUBST};
+enum ebitset_find_mode
+  { EBITSET_FIND, EBITSET_CREATE, EBITSET_SUBST };

 
 static ebitset_elt ebitset_zero_elts[1]; /* Elements of all zero bits.  */
 
 /* Obstack to allocate bitset elements from.  */
 static struct obstack ebitset_obstack;
 static int ebitset_obstack_init = 0;
 
 static ebitset_elt ebitset_zero_elts[1]; /* Elements of all zero bits.  */
 
 /* Obstack to allocate bitset elements from.  */
 static struct obstack ebitset_obstack;
 static int ebitset_obstack_init = 0;

-static ebitset_elt *ebitset_free_list; /* Free list of bitset elements.  */
+static ebitset_elt *ebitset_free_list; /* Free list of bitset elements.  */

 
 static void ebitset_elts_grow PARAMS ((bitset, unsigned int));
 static ebitset_elt *ebitset_elt_alloc PARAMS ((void));
 
 static void ebitset_elts_grow PARAMS ((bitset, unsigned int));
 static ebitset_elt *ebitset_elt_alloc PARAMS ((void));


@@ -86,58 +120,55 @@ static ebitset_elt *ebitset_elt_last PARAMS ((bitset));
 static int ebitset_elt_zero_p PARAMS ((ebitset_elt *));
 
 static int ebitset_weed PARAMS ((bitset));
 static int ebitset_elt_zero_p PARAMS ((ebitset_elt *));
 
 static int ebitset_weed PARAMS ((bitset));

-static void ebitset_zero PARAMS((bitset));
-static int ebitset_equal_p PARAMS((bitset, bitset));
-static void ebitset_copy PARAMS((bitset, bitset));
-static int ebitset_copy_compare PARAMS((bitset, bitset));
-static void ebitset_set PARAMS((bitset, bitset_bindex));
-static void ebitset_reset PARAMS((bitset, bitset_bindex));
-static int ebitset_test PARAMS((bitset, bitset_bindex));
-static int ebitset_size PARAMS((bitset));
-static int ebitset_op1 PARAMS((bitset, enum bitset_ops));
-static int ebitset_op2 PARAMS((bitset, bitset, enum bitset_ops));
-static int ebitset_op3 PARAMS((bitset, bitset, bitset, enum bitset_ops));
-static int ebitset_op4 PARAMS((bitset, bitset, bitset, bitset,
-                              enum bitset_ops));
-static int ebitset_list PARAMS((bitset, bitset_bindex *, bitset_bindex,
-                               bitset_bindex *));
-static int ebitset_reverse_list PARAMS((bitset, bitset_bindex *, bitset_bindex,
-                                       bitset_bindex *));
-static void ebitset_free PARAMS((bitset));
-
-
-#define EBITSET_ELTS(BSET) ((BSET)->u.e.elts)
-#define EBITSET_SIZE(BSET) ((BSET)->u.e.size)
+static void ebitset_zero PARAMS ((bitset));
+static int ebitset_equal_p PARAMS ((bitset, bitset));
+static void ebitset_copy PARAMS ((bitset, bitset));
+static int ebitset_copy_compare PARAMS ((bitset, bitset));
+static void ebitset_set PARAMS ((bitset, bitset_bindex));
+static void ebitset_reset PARAMS ((bitset, bitset_bindex));
+static int ebitset_test PARAMS ((bitset, bitset_bindex));
+static int ebitset_size PARAMS ((bitset));
+static int ebitset_op1 PARAMS ((bitset, enum bitset_ops));
+static int ebitset_op2 PARAMS ((bitset, bitset, enum bitset_ops));
+static int ebitset_op3 PARAMS ((bitset, bitset, bitset, enum bitset_ops));
+static int ebitset_list PARAMS ((bitset, bitset_bindex *, bitset_bindex,
+                                bitset_bindex *));
+static int ebitset_reverse_list
+PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *));
+static void ebitset_free PARAMS ((bitset));
+
+#define EBITSET_ELTS(BSET) ((BSET)->e.elts)
+#define EBITSET_SIZE(BSET) ((BSET)->e.size)

 
 #define EBITSET_NEXT(ELT) ((ELT)->u.next)
 #define EBITSET_WORDS(ELT) ((ELT)->u.words)
 
 /* Disable bitset cache and mark BSET as being zero.  */
 
 #define EBITSET_NEXT(ELT) ((ELT)->u.next)
 #define EBITSET_WORDS(ELT) ((ELT)->u.words)
 
 /* Disable bitset cache and mark BSET as being zero.  */

-#define EBITSET_ZERO_SET(BSET) ((BSET)->cindex = BITSET_INDEX_MAX, \
-        (BSET)->cdata = 0)
+#define EBITSET_OP_ZERO_SET(BSET) ((BSET)->b.cindex = BITSET_INDEX_MAX, \
+        (BSET)->b.cdata = 0)

 
 

-#define EBITSET_CACHE_DISABLE(BSET)  ((BSET)->cindex = BITSET_INDEX_MAX)
+#define EBITSET_CACHE_DISABLE(BSET)  ((BSET)->b.cindex = BITSET_INDEX_MAX)

 
 /* Disable bitset cache and mark BSET as being possibly non-zero.  */
 #define EBITSET_NONZERO_SET(BSET) \
 
 /* Disable bitset cache and mark BSET as being possibly non-zero.  */
 #define EBITSET_NONZERO_SET(BSET) \

- (EBITSET_CACHE_DISABLE (BSET), (BSET)->cdata = (bitset_word *)~0)
+ (EBITSET_CACHE_DISABLE (BSET), (BSET)->b.cdata = (bitset_word *)~0)

 
 /* A conservative estimate of whether the bitset is zero.
    This is non-zero only if we know for sure that the bitset is zero.  */
 
 /* A conservative estimate of whether the bitset is zero.
    This is non-zero only if we know for sure that the bitset is zero.  */

-#define EBITSET_ZERO_P(BSET) ((BSET)->cdata == 0)
+#define EBITSET_OP_ZERO_P(BSET) ((BSET)->b.cdata == 0)

 
 

-/* Enable cache to point to element with table index EINDEX.
+/* Enable cache to point to element with table index EINDEX. 

    The element must exist.  */
 #define EBITSET_CACHE_SET(BSET, EINDEX) \
    The element must exist.  */
 #define EBITSET_CACHE_SET(BSET, EINDEX) \

- ((BSET)->cindex = (EINDEX) * EBITSET_ELT_WORDS, \
-  (BSET)->cdata = EBITSET_WORDS (EBITSET_ELTS (BSET) [EINDEX]))
+ ((BSET)->b.cindex = (EINDEX) * EBITSET_ELT_WORDS, \
+  (BSET)->b.cdata = EBITSET_WORDS (EBITSET_ELTS (BSET) [EINDEX]))

 
 
 /* Grow the expandable table for BSET by SIZE elements.  */
 static void
 ebitset_elts_grow (bset, size)
 
 
 /* Grow the expandable table for BSET by SIZE elements.  */
 static void
 ebitset_elts_grow (bset, size)

-    bitset bset;
-    unsigned int size;
+     bitset bset;
+     unsigned int size;

 {
   unsigned int oldsize;
   unsigned int newsize;
 {
   unsigned int oldsize;
   unsigned int newsize;


@@ -146,7 +177,7 @@ ebitset_elts_grow (bset, size)
   newsize = oldsize + size;
 
   EBITSET_ELTS (bset) = xrealloc (EBITSET_ELTS (bset),
   newsize = oldsize + size;
 
   EBITSET_ELTS (bset) = xrealloc (EBITSET_ELTS (bset),

-                                  newsize * sizeof (ebitset_elt *));
+                                 newsize * sizeof (ebitset_elt *));

   EBITSET_SIZE (bset) = newsize;
 
   memset (EBITSET_ELTS (bset) + oldsize, 0, size * sizeof (ebitset_elt *));
   EBITSET_SIZE (bset) = newsize;
 
   memset (EBITSET_ELTS (bset) + oldsize, 0, size * sizeof (ebitset_elt *));


@@ -174,13 +205,17 @@ ebitset_elt_alloc ()
          ebitset_obstack_init = 1;
 
          /* Let particular systems override the size of a chunk.  */
          ebitset_obstack_init = 1;
 
          /* Let particular systems override the size of a chunk.  */

+

 #ifndef OBSTACK_CHUNK_SIZE
 #define OBSTACK_CHUNK_SIZE 0
 #endif
 #ifndef OBSTACK_CHUNK_SIZE
 #define OBSTACK_CHUNK_SIZE 0
 #endif

+

          /* Let them override the alloc and free routines too.  */
          /* Let them override the alloc and free routines too.  */

+

 #ifndef OBSTACK_CHUNK_ALLOC
 #define OBSTACK_CHUNK_ALLOC xmalloc
 #endif
 #ifndef OBSTACK_CHUNK_ALLOC
 #define OBSTACK_CHUNK_ALLOC xmalloc
 #endif

+

 #ifndef OBSTACK_CHUNK_FREE
 #define OBSTACK_CHUNK_FREE free
 #endif
 #ifndef OBSTACK_CHUNK_FREE
 #define OBSTACK_CHUNK_FREE free
 #endif


@@ -191,12 +226,14 @@ ebitset_elt_alloc ()
 
          obstack_specify_allocation (&ebitset_obstack, OBSTACK_CHUNK_SIZE,
                                      __alignof__ (ebitset_elt),
 
          obstack_specify_allocation (&ebitset_obstack, OBSTACK_CHUNK_SIZE,
                                      __alignof__ (ebitset_elt),

-                                     (void *(*) PARAMS ((long))) OBSTACK_CHUNK_ALLOC,
-                                     (void (*) PARAMS ((void *))) OBSTACK_CHUNK_FREE);
+                                     (void *(*)PARAMS ((long)))
+                                     OBSTACK_CHUNK_ALLOC,
+                                     (void (*)PARAMS ((void *)))
+                                     OBSTACK_CHUNK_FREE);

        }
 
       /* Perhaps we should add a number of new elements to the free
        }
 
       /* Perhaps we should add a number of new elements to the free

-         list.  */
+        list.  */

       elt = (ebitset_elt *) obstack_alloc (&ebitset_obstack,
                                           sizeof (ebitset_elt));
     }
       elt = (ebitset_elt *) obstack_alloc (&ebitset_obstack,
                                           sizeof (ebitset_elt));
     }


@@ -275,9 +312,9 @@ ebitset_elt_zero_p (elt)
 
 
 static ebitset_elt *
 
 
 static ebitset_elt *

-ebitset_elt_find (bset, index, mode)
+ebitset_elt_find (bset, windex, mode)

      bitset bset;
      bitset bset;

-     bitset_windex index;
+     bitset_windex windex;

      enum ebitset_find_mode mode;
 {
   ebitset_elt *elt;
      enum ebitset_find_mode mode;
 {
   ebitset_elt *elt;


@@ -285,18 +322,16 @@ ebitset_elt_find (bset, index, mode)
   unsigned int eindex;
   ebitset_elts *elts;
 
   unsigned int eindex;
   ebitset_elts *elts;
 

-  eindex = index / EBITSET_ELT_WORDS;
+  eindex = windex / EBITSET_ELT_WORDS;

 
   elts = EBITSET_ELTS (bset);
   size = EBITSET_SIZE (bset);
 
   if (eindex < size)
     {
 
   elts = EBITSET_ELTS (bset);
   size = EBITSET_SIZE (bset);
 
   if (eindex < size)
     {

-      ebitset_elt *elt;
-

       if ((elt = elts[eindex]))
        {
       if ((elt = elts[eindex]))
        {

-         if (EBITSET_WORDS (elt) == bset->cdata)
+         if (EBITSET_WORDS (elt) == bset->b.cdata)

            return elt;
 
          EBITSET_CACHE_SET (bset, eindex);
            return elt;
 
          EBITSET_CACHE_SET (bset, eindex);


@@ -366,7 +401,7 @@ ebitset_weed (bset)
   bitset_windex j;
   int count;
 
   bitset_windex j;
   int count;
 

-  if (EBITSET_ZERO_P (bset))
+  if (EBITSET_OP_ZERO_P (bset))

     return 0;
 
   elts = EBITSET_ELTS (bset);
     return 0;
 
   elts = EBITSET_ELTS (bset);


@@ -390,14 +425,14 @@ ebitset_weed (bset)
   count = j - count;
   if (!count)
     {
   count = j - count;
   if (!count)
     {

-      /* All the bits are zero.  We could shrink the elts.
+      /* All the bits are zero.  We could shrink the elts. 

         For now just mark BSET as known to be zero.  */
         For now just mark BSET as known to be zero.  */

-      EBITSET_ZERO_SET (bset);
+      EBITSET_OP_ZERO_SET (bset);

     }
   else
     EBITSET_NONZERO_SET (bset);
 
     }
   else
     EBITSET_NONZERO_SET (bset);
 

-  return  count;
+  return count;

 }
 
 
 }
 
 


@@ -409,7 +444,7 @@ ebitset_zero (bset)
   ebitset_elts *elts;
   bitset_windex j;
 
   ebitset_elts *elts;
   bitset_windex j;
 

-  if (EBITSET_ZERO_P (bset))
+  if (EBITSET_OP_ZERO_P (bset))

     return;
 
   elts = EBITSET_ELTS (bset);
     return;
 
   elts = EBITSET_ELTS (bset);


@@ -421,9 +456,9 @@ ebitset_zero (bset)
        ebitset_elt_remove (bset, j);
     }
 
        ebitset_elt_remove (bset, j);
     }
 

-  /* All the bits are zero.  We could shrink the elts.
+  /* All the bits are zero.  We could shrink the elts. 

      For now just mark BSET as known to be zero.  */
      For now just mark BSET as known to be zero.  */

-  EBITSET_ZERO_SET (bset);
+  EBITSET_OP_ZERO_SET (bset);

 }
 
 
 }
 
 


@@ -454,9 +489,9 @@ ebitset_equal_p (dst, src)
       ebitset_elt *selt = selts[j];
       ebitset_elt *delt = delts[j];
 
       ebitset_elt *selt = selts[j];
       ebitset_elt *delt = delts[j];
 

-      if (! selt && ! delt)
+      if (!selt && !delt)

        continue;
        continue;

-      if ((selt && ! delt) || (!selt && delt))
+      if ((selt && !delt) || (!selt && delt))

        return 0;
 
       for (i = 0; i < EBITSET_ELT_WORDS; i++)
        return 0;
 
       for (i = 0; i < EBITSET_ELT_WORDS; i++)


@@ -515,10 +550,10 @@ ebitset_copy_compare (dst, src)
   if (src == dst)
     return 0;
 
   if (src == dst)
     return 0;
 

-  if (EBITSET_ZERO_P (dst))
+  if (EBITSET_OP_ZERO_P (dst))

     {
       ebitset_copy (dst, src);
     {
       ebitset_copy (dst, src);

-      return ! EBITSET_ZERO_P (src);
+      return !EBITSET_OP_ZERO_P (src);

     }
 
   if (ebitset_equal_p (dst, src))
     }
 
   if (ebitset_equal_p (dst, src))


@@ -545,11 +580,11 @@ ebitset_set (dst, bitno)
      bitset dst;
      bitset_bindex bitno;
 {
      bitset dst;
      bitset_bindex bitno;
 {

-  bitset_windex index = bitno / BITSET_WORD_BITS;
+  bitset_windex windex = bitno / BITSET_WORD_BITS;

 
 

-  ebitset_elt_find (dst, index, EBITSET_CREATE);
+  ebitset_elt_find (dst, windex, EBITSET_CREATE);

 
 

-  dst->cdata[index - dst->cindex] |= (1 << (bitno % BITSET_WORD_BITS));
+  dst->b.cdata[windex - dst->b.cindex] |= (1 << (bitno % BITSET_WORD_BITS));

 }
 
 
 }
 
 


@@ -559,15 +594,15 @@ ebitset_reset (dst, bitno)
      bitset dst;
      bitset_bindex bitno;
 {
      bitset dst;
      bitset_bindex bitno;
 {

-  bitset_windex index = bitno / BITSET_WORD_BITS;
+  bitset_windex windex = bitno / BITSET_WORD_BITS;

 
 

-  if (!ebitset_elt_find (dst, index, EBITSET_FIND))
-      return;
+  if (!ebitset_elt_find (dst, windex, EBITSET_FIND))
+    return;

 
 

-  dst->cdata[index - dst->cindex] &= ~(1 << (bitno % BITSET_WORD_BITS));
+  dst->b.cdata[windex - dst->b.cindex] &= ~(1 << (bitno % BITSET_WORD_BITS));

 
 

-  /* If all the data is zero, perhaps we should remove it now...
-     However, there could be a good chance that the element will be needed
+  /* If all the data is zero, perhaps we should remove it now... 
+     However, there is a good chance that the element will be needed

      again soon.  */
 }
 
      again soon.  */
 }
 


@@ -578,12 +613,13 @@ ebitset_test (src, bitno)
      bitset src;
      bitset_bindex bitno;
 {
      bitset src;
      bitset_bindex bitno;
 {

-  bitset_windex index = bitno / BITSET_WORD_BITS;
+  bitset_windex windex = bitno / BITSET_WORD_BITS;

 
 

-  if (!ebitset_elt_find (src, index, EBITSET_FIND))
+  if (!ebitset_elt_find (src, windex, EBITSET_FIND))

     return 0;
 
     return 0;
 

-  return (src->cdata[index - src->cindex] >> (bitno % BITSET_WORD_BITS)) & 1;
+  return (src->b.
+         cdata[windex - src->b.cindex] >> (bitno % BITSET_WORD_BITS)) & 1;

 }
 
 
 }
 
 


@@ -597,8 +633,8 @@ ebitset_free (bset)
 
 
 /* Find list of up to NUM bits set in BSET starting from and including
 
 
 /* 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.  */
+ *NEXT and store in array LIST.  Return with actual number of bits
+ found and with *NEXT indicating where search stopped.  */

 static int
 ebitset_reverse_list (bset, list, num, next)
      bitset bset;
 static int
 ebitset_reverse_list (bset, list, num, next)
      bitset bset;


@@ -609,17 +645,17 @@ ebitset_reverse_list (bset, list, num, next)
   bitset_bindex n_bits;
   bitset_bindex bitno;
   bitset_bindex rbitno;
   bitset_bindex n_bits;
   bitset_bindex bitno;
   bitset_bindex rbitno;

-  unsigned int bitcnt;
-  bitset_bindex bitoff;
-  bitset_windex index;
-  unsigned int eindex;
+  unsigned int bcount;
+  bitset_bindex boffset;

   bitset_windex windex;
   bitset_windex windex;

+  unsigned int eindex;
+  bitset_windex woffset;

   bitset_bindex count;
   bitset_windex size;
   bitset_word word;
   ebitset_elts *elts;
 
   bitset_bindex count;
   bitset_windex size;
   bitset_word word;
   ebitset_elts *elts;
 

-  if (EBITSET_ZERO_P (bset))
+  if (EBITSET_OP_ZERO_P (bset))

     return 0;
 
   size = EBITSET_SIZE (bset);
     return 0;
 
   size = EBITSET_SIZE (bset);


@@ -627,24 +663,25 @@ ebitset_reverse_list (bset, list, num, next)
   rbitno = *next;
 
   if (rbitno >= n_bits)
   rbitno = *next;
 
   if (rbitno >= n_bits)

-      return 0;
+    return 0;

 
   elts = EBITSET_ELTS (bset);
 
   bitno = n_bits - (rbitno + 1);
 
 
   elts = EBITSET_ELTS (bset);
 
   bitno = n_bits - (rbitno + 1);
 

-  index = bitno /  BITSET_WORD_BITS;
+  windex = bitno / BITSET_WORD_BITS;

   eindex = bitno / EBITSET_ELT_BITS;
   eindex = bitno / EBITSET_ELT_BITS;

-  windex = index - eindex * EBITSET_ELT_WORDS;
+  woffset = windex - eindex * EBITSET_ELT_WORDS;

 
   /* If num is 1, we could speed things up with a binary search
      of the word of interest.  */
 
   count = 0;
 
   /* If num is 1, we could speed things up with a binary search
      of the word of interest.  */
 
   count = 0;

-  bitcnt = bitno % BITSET_WORD_BITS;
-  bitoff = index * BITSET_WORD_BITS;
+  bcount = bitno % BITSET_WORD_BITS;
+  boffset = windex * BITSET_WORD_BITS;

 
 

-  for (; eindex != ~0U; eindex--)
+  for (; eindex != ~0U; 
+       boffset = eindex * EBITSET_ELT_BITS - BITSET_WORD_BITS, eindex--) 

     {
       ebitset_elt *elt;
       bitset_word *srcp;
     {
       ebitset_elt *elt;
       bitset_word *srcp;


@@ -655,19 +692,19 @@ ebitset_reverse_list (bset, list, num, next)
 
       srcp = EBITSET_WORDS (elt);
 
 
       srcp = EBITSET_WORDS (elt);
 

-      for (; windex != ~0U; windex--, bitoff -= BITSET_WORD_BITS,
-            bitcnt = BITSET_WORD_BITS - 1)
+      for (; woffset != ~0U; woffset--, boffset -= BITSET_WORD_BITS,
+            bcount = BITSET_WORD_BITS - 1)

        {
        {

-         word = srcp[windex] << (BITSET_WORD_BITS - 1 - bitcnt);
+         word = srcp[woffset] << (BITSET_WORD_BITS - 1 - bcount);

 
 

-         for (; word; bitcnt--)
+         for (; word; bcount--)

            {
              if (word & BITSET_MSB)
                {
            {
              if (word & BITSET_MSB)
                {

-                 list[count++] = bitoff + bitcnt;
+                 list[count++] = boffset + bcount;

                  if (count >= num)
                    {
                  if (count >= num)
                    {

-                     *next = n_bits - (bitoff + bitcnt);
+                     *next = n_bits - (boffset + bcount);

                      return count;
                    }
                }
                      return count;
                    }
                }


@@ -675,17 +712,17 @@ ebitset_reverse_list (bset, list, num, next)
            }
        }
 
            }
        }
 

-      windex = EBITSET_ELT_WORDS;
+      woffset = EBITSET_ELT_WORDS;

     }
 
     }
 

-  *next = n_bits - (bitoff + 1);
+  *next = n_bits - (boffset + 1);

   return count;
 }
 
 
 /* Find list of up to NUM bits set in BSET starting from and including
   return count;
 }
 
 
 /* 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.  */
+ *NEXT and store in array LIST.  Return with actual number of bits
+ found and with *NEXT indicating where search stopped.  */

 static int
 ebitset_list (bset, list, num, next)
      bitset bset;
 static int
 ebitset_list (bset, list, num, next)
      bitset bset;


@@ -694,7 +731,7 @@ ebitset_list (bset, list, num, next)
      bitset_bindex *next;
 {
   bitset_bindex bitno;
      bitset_bindex *next;
 {
   bitset_bindex bitno;

-  bitset_windex index;
+  bitset_windex windex;

   unsigned int eindex;
   bitset_bindex count;
   bitset_windex size;
   unsigned int eindex;
   bitset_bindex count;
   bitset_windex size;


@@ -702,7 +739,7 @@ ebitset_list (bset, list, num, next)
   bitset_word word;
   ebitset_elts *elts;
 
   bitset_word word;
   ebitset_elts *elts;
 

-  if (EBITSET_ZERO_P (bset))
+  if (EBITSET_OP_ZERO_P (bset))

     return 0;
 
   bitno = *next;
     return 0;
 
   bitno = *next;


@@ -719,15 +756,15 @@ ebitset_list (bset, list, num, next)
       elt = elts[eindex];
       if (elt)
        {
       elt = elts[eindex];
       if (elt)
        {

-         bitset_windex windex;
+         bitset_windex woffset;

          bitset_word *srcp = EBITSET_WORDS (elt);
 
          bitset_word *srcp = EBITSET_WORDS (elt);
 

-         index = bitno / BITSET_WORD_BITS;
-         windex = eindex / EBITSET_ELT_WORDS;
+         windex = bitno / BITSET_WORD_BITS;
+         woffset = eindex / EBITSET_ELT_WORDS;

 
 

-         for (; (index - windex) < EBITSET_ELT_WORDS; index++)
+         for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++)

            {
            {

-             word = srcp[index - windex] >> (bitno % BITSET_WORD_BITS);
+             word = srcp[windex - woffset] >> (bitno % BITSET_WORD_BITS);

 
              for (; word; bitno++)
                {
 
              for (; word; bitno++)
                {


@@ -742,7 +779,7 @@ ebitset_list (bset, list, num, next)
                    }
                  word >>= 1;
                }
                    }
                  word >>= 1;
                }

-             bitno = (index + 1) * BITSET_WORD_BITS;
+             bitno = (windex + 1) * BITSET_WORD_BITS;

            }
        }
 
            }
        }
 


@@ -756,7 +793,6 @@ ebitset_list (bset, list, num, next)
   for (; eindex < size; eindex++)
     {
       int i;
   for (; eindex < size; eindex++)
     {
       int i;

-      ebitset_elt *elt;

       bitset_word *srcp;
 
       elt = elts[eindex];
       bitset_word *srcp;
 
       elt = elts[eindex];


@@ -764,25 +800,25 @@ ebitset_list (bset, list, num, next)
        continue;
 
       srcp = EBITSET_WORDS (elt);
        continue;
 
       srcp = EBITSET_WORDS (elt);

-      index = eindex * EBITSET_ELT_WORDS;
+      windex = eindex * EBITSET_ELT_WORDS;

 
       if ((count + EBITSET_ELT_BITS) < num)
        {
          /* The coast is clear, plant boot!  */
 
 
       if ((count + EBITSET_ELT_BITS) < num)
        {
          /* The coast is clear, plant boot!  */
 

-         for (i = 0; i < EBITSET_ELT_WORDS; i++, index++)
+         for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++)

            {
            {

-             bitno = index * BITSET_WORD_BITS;
+             bitno = windex * BITSET_WORD_BITS;

 
              word = srcp[i];
              if (word)
                {
 
              word = srcp[i];
              if (word)
                {

-                 if (! (word & 0xffff))
+                 if (!(word & 0xffff))

                    {
                      word >>= 16;
                      bitno += 16;
                    }
                    {
                      word >>= 16;
                      bitno += 16;
                    }

-                 if (! (word & 0xff))
+                 if (!(word & 0xff))

                    {
                      word >>= 8;
                      bitno += 8;
                    {
                      word >>= 8;
                      bitno += 8;


@@ -801,9 +837,9 @@ ebitset_list (bset, list, num, next)
          /* Tread more carefully since we need to check
             if array overflows.  */
 
          /* Tread more carefully since we need to check
             if array overflows.  */
 

-         for (i = 0; i < EBITSET_ELT_WORDS; i++, index++)
+         for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++)

            {
            {

-             bitno = index * BITSET_WORD_BITS;
+             bitno = windex * BITSET_WORD_BITS;

 
              for (word = srcp[i]; word; bitno++)
                {
 
              for (word = srcp[i]; word; bitno++)
                {


@@ -837,22 +873,23 @@ ebitset_op1 (dst, op)
 
   switch (op)
     {
 
   switch (op)
     {

-    case BITSET_ZERO:
+    case BITSET_OP_ZERO:

       ebitset_zero (dst);
       return 1;
 
       ebitset_zero (dst);
       return 1;
 

-    case BITSET_ONES:
+    case BITSET_OP_ONES:

       for (j = 0; j < EBITSET_SIZE (dst); j++)
        {
          /* Create new elements if they cannot be found.  Perhaps
       for (j = 0; j < EBITSET_SIZE (dst); j++)
        {
          /* Create new elements if they cannot be found.  Perhaps

-          we should just add pointers to a ones element.  */
-         elt = ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);
+            we should just add pointers to a ones element.  */
+         elt =
+           ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);

          memset (EBITSET_WORDS (elt), ~0, sizeof (EBITSET_WORDS (elt)));
        }
       break;
 
          memset (EBITSET_WORDS (elt), ~0, sizeof (EBITSET_WORDS (elt)));
        }
       break;
 

-    case BITSET_EMPTY_P:
-      return ! ebitset_weed (dst);
+    case BITSET_OP_EMPTY_P:
+      return !ebitset_weed (dst);

 
     default:
       abort ();
 
     default:
       abort ();


@@ -876,28 +913,31 @@ ebitset_op2 (dst, src, op)
 
   switch (op)
     {
 
   switch (op)
     {

-    case BITSET_COPY:
+    case BITSET_OP_COPY:

       ebitset_copy (dst, src);
       break;
 
       ebitset_copy (dst, src);
       break;
 

-    case BITSET_NOT:
+    case BITSET_OP_NOT:

       for (j = 0; j < EBITSET_SIZE (src); j++)
        {
          /* Create new elements for dst if they cannot be found
             or substitute zero elements if src elements not found.  */
       for (j = 0; j < EBITSET_SIZE (src); j++)
        {
          /* Create new elements for dst if they cannot be found
             or substitute zero elements if src elements not found.  */

-         selt = ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_SUBST);
-         delt = ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);
+         selt =
+           ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_SUBST);
+         delt =
+           ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);

 
          for (i = 0; i < EBITSET_ELT_WORDS; i++)
            EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i];
        }
       break;
 
 
          for (i = 0; i < EBITSET_ELT_WORDS; i++)
            EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i];
        }
       break;
 

-    case BITSET_EQUAL_P:
+      /* Return 1 if DST == SRC.  */
+    case BITSET_OP_EQUAL_P:

       return ebitset_equal_p (dst, src);
 
       /* Return 1 if DST == DST | SRC.  */
       return ebitset_equal_p (dst, src);
 
       /* Return 1 if DST == DST | SRC.  */

-    case BITSET_SUBSET_P:
+    case BITSET_OP_SUBSET_P:

       {
        ebitset_elts *selts;
        ebitset_elts *delts;
       {
        ebitset_elts *selts;
        ebitset_elts *delts;


@@ -912,13 +952,10 @@ ebitset_op2 (dst, src, op)
 
        for (j = 0; j < ssize; j++)
          {
 
        for (j = 0; j < ssize; j++)
          {

-           ebitset_elt *selt;
-           ebitset_elt *delt;
-

            selt = j < ssize ? selts[j] : 0;
            delt = j < dsize ? delts[j] : 0;
 
            selt = j < ssize ? selts[j] : 0;
            delt = j < dsize ? delts[j] : 0;
 

-           if (! selt && ! delt)
+           if (!selt && !delt)

              continue;
 
            if (!selt)
              continue;
 
            if (!selt)


@@ -935,6 +972,36 @@ ebitset_op2 (dst, src, op)
       }
       break;
 
       }
       break;
 

+      /* Return 1 if DST & SRC == 0.  */
+    case BITSET_OP_DISJOINT_P:
+      {
+       ebitset_elts *selts;
+       ebitset_elts *delts;
+       bitset_windex ssize;
+       bitset_windex dsize;
+
+       selts = EBITSET_ELTS (src);
+       delts = EBITSET_ELTS (dst);
+
+       ssize = EBITSET_SIZE (src);
+       dsize = EBITSET_SIZE (dst);
+
+       for (j = 0; j < ssize; j++)
+         {
+           selt = j < ssize ? selts[j] : 0;
+           delt = j < dsize ? delts[j] : 0;
+
+           if (!selt || !delt)
+             continue;
+
+           for (i = 0; i < EBITSET_ELT_WORDS; i++)
+             if ((EBITSET_WORDS (selt)[i] & EBITSET_WORDS (delt)[i]))
+               return 0;
+         }
+       return 1;
+      }
+      break;
+

     default:
       abort ();
     }
     default:
       abort ();
     }


@@ -966,30 +1033,31 @@ ebitset_op3 (dst, src1, src2, op)
   bitset_windex j;
 
   /* Fast track common, simple cases.  */
   bitset_windex j;
 
   /* Fast track common, simple cases.  */

-  if (EBITSET_ZERO_P (src2))
+  if (EBITSET_OP_ZERO_P (src2))

     {
     {

-      if (op == BITSET_AND)
+      if (op == BITSET_OP_AND)

        {
          ebitset_weed (dst);
        {
          ebitset_weed (dst);

-         changed = EBITSET_ZERO_P (dst);
+         changed = EBITSET_OP_ZERO_P (dst);

          ebitset_zero (dst);
          return changed;
        }
          ebitset_zero (dst);
          return changed;
        }

-      else if (op == BITSET_ANDN || op == BITSET_OR || op == BITSET_XOR)
+      else if (op == BITSET_OP_ANDN || op == BITSET_OP_OR
+              || op == BITSET_OP_XOR)

        {
          return ebitset_copy_compare (dst, src1);
        }
     }
        {
          return ebitset_copy_compare (dst, src1);
        }
     }

-  else if (EBITSET_ZERO_P (src1))
+  else if (EBITSET_OP_ZERO_P (src1))

     {
     {

-      if (op == BITSET_AND || op == BITSET_ANDN)
+      if (op == BITSET_OP_AND || op == BITSET_OP_ANDN)

        {
          ebitset_weed (dst);
        {
          ebitset_weed (dst);

-         changed = EBITSET_ZERO_P (dst);
+         changed = EBITSET_OP_ZERO_P (dst);

          ebitset_zero (dst);
          return changed;
        }
          ebitset_zero (dst);
          return changed;
        }

-      else if (op == BITSET_OR || op == BITSET_XOR)
+      else if (op == BITSET_OP_OR || op == BITSET_OP_XOR)

        {
          return ebitset_copy_compare (dst, src2);
        }
        {
          return ebitset_copy_compare (dst, src2);
        }


@@ -1003,7 +1071,7 @@ ebitset_op3 (dst, src1, src2, op)
     size = ssize2;
 
   if (size > dsize)
     size = ssize2;
 
   if (size > dsize)

-      ebitset_elts_grow (dst, size - dsize);
+    ebitset_elts_grow (dst, size - dsize);

 
   selts1 = EBITSET_ELTS (src1);
   selts2 = EBITSET_ELTS (src2);
 
   selts1 = EBITSET_ELTS (src1);
   selts2 = EBITSET_ELTS (src2);


@@ -1019,7 +1087,7 @@ ebitset_op3 (dst, src1, src2, op)
       selt2 = j < ssize2 ? selts2[j] : 0;
       delt = j < dsize ? delts[j] : 0;
 
       selt2 = j < ssize2 ? selts2[j] : 0;
       delt = j < dsize ? delts[j] : 0;
 

-      if (! selt1 && ! selt2)
+      if (!selt1 && !selt2)

        {
          if (delt)
            {
        {
          if (delt)
            {


@@ -1043,7 +1111,7 @@ ebitset_op3 (dst, src1, src2, op)
       dstp = EBITSET_WORDS (delt);
       switch (op)
        {
       dstp = EBITSET_WORDS (delt);
       switch (op)
        {

-       case BITSET_OR:
+       case BITSET_OP_OR:

          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ | *srcp2++;
          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ | *srcp2++;


@@ -1056,7 +1124,7 @@ ebitset_op3 (dst, src1, src2, op)
            }
          break;
 
            }
          break;
 

-       case BITSET_AND:
+       case BITSET_OP_AND:

          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ & *srcp2++;
          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ & *srcp2++;


@@ -1069,7 +1137,7 @@ ebitset_op3 (dst, src1, src2, op)
            }
          break;
 
            }
          break;
 

-       case BITSET_XOR:
+       case BITSET_OP_XOR:

          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ ^ *srcp2++;
          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ ^ *srcp2++;


@@ -1082,7 +1150,7 @@ ebitset_op3 (dst, src1, src2, op)
            }
          break;
 
            }
          break;
 

-       case BITSET_ANDN:
+       case BITSET_OP_ANDN:

          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ & ~(*srcp2++);
          for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
            {
              bitset_word tmp = *srcp1++ & ~(*srcp2++);


@@ -1095,24 +1163,11 @@ ebitset_op3 (dst, src1, src2, op)
            }
          break;
 
            }
          break;
 

-       case BITSET_ORN:
-         for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++)
-           {
-             bitset_word tmp = *srcp1++ | ~(*srcp2++);
-
-             if (*dstp != tmp)
-               {
-                 changed = 1;
-                 *dstp = tmp;
-               }
-           }
-         break;
-

        default:
          abort ();
        }
 
        default:
          abort ();
        }
 

-      if (! ebitset_elt_zero_p (delt))
+      if (!ebitset_elt_zero_p (delt))

        {
          ebitset_elt_add (dst, delt, j);
        }
        {
          ebitset_elt_add (dst, delt, j);
        }


@@ -1140,62 +1195,21 @@ ebitset_op3 (dst, src1, src2, op)
 }
 
 
 }
 
 

-static int
-ebitset_op4 (dst, src1, src2, src3, op)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
-     enum bitset_ops op;
-{
-  int changed = 0;
-  bitset tmp;
-
-  tmp = bitset_create (BITSET_LIST, 0);
-
-  switch (op)
-    {
-    case BITSET_OR_AND:
-      bitset_or (tmp, src1, src2);
-      changed = bitset_and (dst, src3, tmp);
-      break;
-
-    case BITSET_AND_OR:
-      bitset_and (tmp, src1, src2);
-      changed = bitset_or (dst, src3, tmp);
-      break;
-
-    case BITSET_ANDN_OR:
-      bitset_andn (tmp, src1, src2);
-      changed = bitset_or (dst, src3, tmp);
-      break;
-
-    default:
-      abort ();
-    }
-
-  bitset_free (tmp);
-  EBITSET_NONZERO_SET (dst);
-  return changed;
-}
-
-

 /* Vector of operations for linked-list bitsets.  */
 /* Vector of operations for linked-list bitsets.  */

-struct bitset_ops_struct ebitset_ops =
-  {
-    ebitset_set,
-    ebitset_reset,
-    ebitset_test,
-    ebitset_size,
-    ebitset_op1,
-    ebitset_op2,
-    ebitset_op3,
-    ebitset_op4,
-    ebitset_list,
-    ebitset_reverse_list,
-    ebitset_free,
-    BITSET_TABLE
-  };
+struct bitset_ops_struct ebitset_ops = {
+  ebitset_set,
+  ebitset_reset,
+  ebitset_test,
+  ebitset_size,
+  ebitset_op1,
+  ebitset_op2,
+  ebitset_op3,
+  bitset_op4,
+  ebitset_list,
+  ebitset_reverse_list,
+  ebitset_free,
+  BITSET_TABLE
+};

 
 
 /* Return size of initial structure.  */
 
 
 /* Return size of initial structure.  */


@@ -1216,11 +1230,11 @@ ebitset_init (bset, n_bits)
 {
   unsigned int size;
 
 {
   unsigned int size;
 

-  bset->ops = &ebitset_ops;
+  bset->b.ops = &ebitset_ops;

 
 

-  bset->csize = EBITSET_ELT_WORDS;
+  bset->b.csize = EBITSET_ELT_WORDS;

 
 

-  EBITSET_ZERO_SET (bset);
+  EBITSET_OP_ZERO_SET (bset);

 
   size = n_bits ? (n_bits + EBITSET_ELT_BITS - 1) / EBITSET_ELT_BITS
     : EBITSET_INITIAL_SIZE;
 
   size = n_bits ? (n_bits + EBITSET_ELT_BITS - 1) / EBITSET_ELT_BITS
     : EBITSET_INITIAL_SIZE;