* lib/abitset.c, lib/bbitset.h, lib/bitset.c, lib/bitset.h,

* lib/bitset_stats.c, lib/bitsetv.c, lib/ebitset.c, lib/lbitset.c:
Updates from Michael Hayes.

ChangeLog

@@ -1,3 +1,9 @@
+2002-09-30  Akim Demaille  <akim@epita.fr>
+
+	* lib/abitset.c, lib/bbitset.h, lib/bitset.c, lib/bitset.h,
+	* lib/bitset_stats.c, lib/bitsetv.c, lib/ebitset.c, lib/lbitset.c:
+	Updates from Michael Hayes.
+
 2002-09-30  Art Haas  <ahaas@neosoft.com>
 
 	* configure.ac: Update AC_OUTPUT and AM_CONFIG_HEADER

lib/abitset.c

@@ -51,14 +51,9 @@ 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 int abitset_size PARAMS ((bitset));
-static int abitset_op1 PARAMS ((bitset, enum bitset_ops));
-static int abitset_op2 PARAMS ((bitset, bitset, enum bitset_ops));
-static int abitset_op3 PARAMS ((bitset, bitset, bitset, enum bitset_ops));
-static int abitset_op4 PARAMS ((bitset, bitset, bitset, bitset,
-				enum bitset_ops));
 static int abitset_list PARAMS ((bitset, bitset_bindex *, bitset_bindex,
 				 bitset_bindex *));
-static int abitset_reverse_list
+static int abitset_list_reverse
 PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *));
 
 #define ABITSET_N_WORDS(N) (((N) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS)
@@ -143,7 +138,8 @@ abitset_set (dst, bitno)
      bitset dst ATTRIBUTE_UNUSED;
      bitset_bindex bitno ATTRIBUTE_UNUSED;
 {
-  /* This should never occur for abitsets.  */
+  /* This should never occur for abitsets since we should always
+     hit the cache.  */
   abort ();
 }
 
@@ -154,7 +150,8 @@ abitset_reset (dst, bitno)
      bitset dst ATTRIBUTE_UNUSED;
      bitset_bindex bitno ATTRIBUTE_UNUSED;
 {
-  /* This should never occur for abitsets.  */
+  /* This should never occur for abitsets since we should always
+     hit the cache.  */
   abort ();
 }
 
@@ -165,7 +162,8 @@ abitset_test (src, bitno)
      bitset src ATTRIBUTE_UNUSED;
      bitset_bindex bitno ATTRIBUTE_UNUSED;
 {
-  /* This should never occur for abitsets.  */
+  /* This should never occur for abitsets since we should always
+     hit the cache.  */
   abort ();
   return 0;
 }
@@ -176,7 +174,7 @@ abitset_test (src, bitno)
    actual number of bits found and with *NEXT indicating where search
    stopped.  */
 static int
-abitset_reverse_list (src, list, num, next)
+abitset_list_reverse (src, list, num, next)
      bitset src;
      bitset_bindex *list;
      bitset_bindex num;
@@ -188,7 +186,6 @@ abitset_reverse_list (src, list, num, next)
   bitset_windex windex;
   unsigned int bitcnt;
   bitset_bindex bitoff;
-  bitset_word word;
   bitset_word *srcp = ABITSET_WORDS (src);
   bitset_bindex n_bits = ABITSET_N_BITS (src);
 
@@ -210,6 +207,8 @@ abitset_reverse_list (src, list, num, next)
 
   do
     {
+      bitset_word word;
+
       word = srcp[windex] << (BITSET_WORD_BITS - 1 - bitcnt);
       for (; word; bitcnt--)
 	{
@@ -354,99 +353,153 @@ abitset_unused_clear (dst)
 }
 
 
-static int
+static void
-abitset_op1 (dst, op)
+abitset_ones (dst)
      bitset dst;
-     enum bitset_ops op;
 {
-  unsigned int i;
   bitset_word *dstp = ABITSET_WORDS (dst);
   unsigned int bytes;
 
   bytes = sizeof (bitset_word) * dst->b.csize;
 
-  switch (op)
+  memset (dstp, -1, bytes);
-    {
+  abitset_unused_clear (dst);
-    case BITSET_OP_ZERO:
+}
-      memset (dstp, 0, bytes);
-      break;
 
-    case BITSET_OP_ONES:
-      memset (dstp, -1, bytes);
-      abitset_unused_clear (dst);
-      break;
 
-    case BITSET_OP_EMPTY_P:
+static void
-      for (i = 0; i < dst->b.csize; i++)
+abitset_zero (dst)
-	if (dstp[i])
+     bitset dst;
-	  return 0;
+{
-      break;
+  bitset_word *dstp = ABITSET_WORDS (dst);
+  unsigned int bytes;
 
-    default:
+  bytes = sizeof (bitset_word) * dst->b.csize;
-      abort ();
+
-    }
+  memset (dstp, 0, bytes);
+}
+
+
+static int
+abitset_empty_p (dst)
+     bitset dst;
+{
+  unsigned int i;
+  bitset_word *dstp = ABITSET_WORDS (dst);
+
+  for (i = 0; i < dst->b.csize; i++)
+    if (dstp[i])
+      return 0;
 
   return 1;
 }
 
 
-static int
+static void
-abitset_op2 (dst, src, op)
+abitset_copy1 (dst, src)
+     bitset dst;
+     bitset src;
+{
+  bitset_word *srcp = ABITSET_WORDS (src);
+  bitset_word *dstp = ABITSET_WORDS (dst);
+  bitset_windex size = dst->b.csize;
+
+  if (srcp == dstp)
+      return;
+  memcpy (dstp, srcp, sizeof (bitset_word) * size);
+}
+
+
+static void
+abitset_not (dst, src)
      bitset dst;
      bitset src;
-     enum bitset_ops op;
 {
   unsigned int i;
   bitset_word *srcp = ABITSET_WORDS (src);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
 
-  switch (op)
+  for (i = 0; i < size; i++)
-    {
+      *dstp++ = ~(*srcp++);
-    case BITSET_OP_COPY:
+  abitset_unused_clear (dst);
-      if (srcp == dstp)
+}
-	break;
-      memcpy (dstp, srcp, sizeof (bitset_word) * size);
-      break;
 
-    case BITSET_OP_NOT:
+ 
-      for (i = 0; i < size; i++)
+static int
-	*dstp++ = ~(*srcp++);
+abitset_equal_p (dst, src)
-      abitset_unused_clear (dst);
+     bitset dst;
-      break;
+     bitset src;
+{
+  unsigned int i;
+  bitset_word *srcp = ABITSET_WORDS (src);
+  bitset_word *dstp = ABITSET_WORDS (dst);
+  bitset_windex size = dst->b.csize;
 
-    case BITSET_OP_EQUAL_P:
+  for (i = 0; i < size; i++)
-      for (i = 0; i < size; i++)
+      if (*srcp++ != *dstp++)
-	if (*srcp++ != *dstp++)
 	  return 0;
-      break;
-      
-    case BITSET_OP_SUBSET_P:
-      for (i = 0; i < size; i++, dstp++, srcp++)
-	if (*dstp != (*srcp | *dstp))
-	  return 0;
-      break;
-      
-    case BITSET_OP_DISJOINT_P:
-      for (i = 0; i < size; i++)
-	if (*srcp++ & *dstp++)
-	  return 0;
-      break;
-      
-    default:
-      abort ();
-    }
-
   return 1;
 }
 
 
 static int
-abitset_op3 (dst, src1, src2, op)
+abitset_subset_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  unsigned int 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))
+	  return 0;
+  return 1;
+}
+
+
+static int
+abitset_disjoint_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  unsigned int 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++)
+      if (*srcp++ & *dstp++)
+	  return 0;
+
+  return 1;
+}
+
+
+static void
+abitset_and (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  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++ = *src1p++ & *src2p++;
+}
+
+
+static int
+abitset_and_cmp (dst, src1, src2)
      bitset dst;
      bitset src1;
      bitset src2;
-     enum bitset_ops op;
 {
   unsigned int i;
   int changed = 0;
@@ -455,75 +508,177 @@ abitset_op3 (dst, src1, src2, op)
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
 
-  switch (op)
+  for (i = 0; i < size; i++, dstp++)
     {
-    case BITSET_OP_OR:
+      bitset_word tmp = *src1p++ & *src2p++;
-      for (i = 0; i < size; i++, dstp++)
+      
+      if (*dstp != tmp)
 	{
-	  bitset_word tmp = *src1p++ | *src2p++;
+	  changed = 1;
-
+	  *dstp = tmp;
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
 	}
-      break;
-
-    case BITSET_OP_AND:
-      for (i = 0; i < size; i++, dstp++)
-	{
-	  bitset_word tmp = *src1p++ & *src2p++;
-
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
-	}
-      break;
-
-    case BITSET_OP_XOR:
-      for (i = 0; i < size; i++, dstp++)
-	{
-	  bitset_word tmp = *src1p++ ^ *src2p++;
-
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
-	}
-      break;
-
-    case BITSET_OP_ANDN:
-      for (i = 0; i < size; i++, dstp++)
-	{
-	  bitset_word tmp = *src1p++ & ~(*src2p++);
-
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
-	}
-      break;
-
-    default:
-      abort ();
     }
-
   return changed;
 }
 
 
+static void
+abitset_andn (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  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++ = *src1p++ & ~(*src2p++);
+}
+
+
 static int
-abitset_op4 (dst, src1, src2, src3, op)
+abitset_andn_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  int changed = 0;
+  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++);
+      
+      if (*dstp != tmp)
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
+    }
+  return changed;
+}
+
+
+static void
+abitset_or (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  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++ = *src1p++ | *src2p++;
+}
+
+
+static int
+abitset_or_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  int changed = 0;
+  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++;
+      
+      if (*dstp != tmp)
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
+    }
+  return changed;
+}
+
+
+static void
+abitset_xor (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  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++ = *src1p++ ^ *src2p++;
+}
+
+
+static int
+abitset_xor_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  unsigned int i;
+  int changed = 0;
+  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++;
+      
+      if (*dstp != tmp)
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
+    }
+  return changed;
+}
+
+
+static void
+abitset_and_or (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  unsigned int i;
+  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++ = (*src1p++ & *src2p++) | *src3p++;
+}
+
+
+static int
+abitset_and_or_cmp (dst, src1, src2, src3)
      bitset dst;
      bitset src1;
      bitset src2;
      bitset src3;
-     enum bitset_ops op;
 {
   unsigned int i;
   int changed = 0;
@@ -532,85 +687,198 @@ abitset_op4 (dst, src1, src2, src3, op)
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_windex size = dst->b.csize;
-
+  
-  switch (op)
+  for (i = 0; i < size; i++, dstp++)
     {
-    case BITSET_OP_OR_AND:
+      bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
-      for (i = 0; i < size; i++, dstp++)
+      
+      if (*dstp != tmp)
 	{
-	  bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;
+	  changed = 1;
-
+	  *dstp = tmp;
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
 	}
-      break;
-
-    case BITSET_OP_AND_OR:
-      for (i = 0; i < size; i++, dstp++)
-	{
-	  bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
-
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
-	}
-      break;
-
-    case BITSET_OP_ANDN_OR:
-      for (i = 0; i < size; i++, dstp++)
-	{
-	  bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;
-
-	  if (*dstp != tmp)
-	    {
-	      changed = 1;
-	      *dstp = tmp;
-	    }
-	}
-      break;
-
-    default:
-      abort ();
     }
-
   return changed;
 }
 
 
+static void
+abitset_andn_or (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  unsigned int i;
+  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++ = (*src1p++ & ~(*src2p++)) | *src3p++;
+}
+
+
+static int
+abitset_andn_or_cmp (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  unsigned int i;
+  int changed = 0;
+  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++;
+      
+      if (*dstp != tmp)
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
+    }
+  return changed;
+}
+
+
+static void
+abitset_or_and (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  unsigned int i;
+  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++ = (*src1p++ | *src2p++) & *src3p++;
+}
+
+
+static int
+abitset_or_and_cmp (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  unsigned int i;
+  int changed = 0;
+  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++;
+      
+      if (*dstp != tmp)
+	{
+	  changed = 1;
+	  *dstp = tmp;
+	}
+    }
+  return changed;
+}
+
+
+void
+abitset_copy (dst, src)
+     bitset dst;
+     bitset src;
+{
+  if (BITSET_COMPATIBLE_ (dst, src))
+      abitset_copy1 (dst, src);
+  else
+      bitset_copy_ (dst, src);
+}
+
+
 /* Vector of operations for single word bitsets.  */
-struct bitset_ops_struct abitset_small_ops = {
+struct bitset_vtable abitset_small_vtable = {
   abitset_set,
   abitset_reset,
+  bitset_toggle_,
   abitset_test,
   abitset_size,
-  abitset_op1,
+  bitset_count_,
-  abitset_op2,
+  abitset_empty_p,
-  abitset_op3,
+  abitset_ones,
-  abitset_op4,
+  abitset_zero,
+  abitset_copy,
+  abitset_disjoint_p,
+  abitset_equal_p,
+  abitset_not,
+  abitset_subset_p,
+  abitset_and,
+  abitset_and_cmp,
+  abitset_andn,
+  abitset_andn_cmp,
+  abitset_or,
+  abitset_or_cmp,
+  abitset_xor,
+  abitset_xor_cmp,
+  abitset_and_or,
+  abitset_and_or_cmp,
+  abitset_andn_or,
+  abitset_andn_or_cmp,
+  abitset_or_and,
+  abitset_or_and_cmp,
   abitset_small_list,
-  abitset_reverse_list,
+  abitset_list_reverse,
   NULL,
   BITSET_ARRAY
 };
 
 
 /* Vector of operations for multiple word bitsets.  */
-struct bitset_ops_struct abitset_ops = {
+struct bitset_vtable abitset_vtable = {
   abitset_set,
   abitset_reset,
+  bitset_toggle_,
   abitset_test,
   abitset_size,
-  abitset_op1,
+  bitset_count_,
-  abitset_op2,
+  abitset_empty_p,
-  abitset_op3,
+  abitset_ones,
-  abitset_op4,
+  abitset_zero,
+  abitset_copy,
+  abitset_disjoint_p,
+  abitset_equal_p,
+  abitset_not,
+  abitset_subset_p,
+  abitset_and,
+  abitset_and_cmp,
+  abitset_andn,
+  abitset_andn_cmp,
+  abitset_or,
+  abitset_or_cmp,
+  abitset_xor,
+  abitset_xor_cmp,
+  abitset_and_or,
+  abitset_and_or_cmp,
+  abitset_andn_or,
+  abitset_andn_or_cmp,
+  abitset_or_and,
+  abitset_or_and_cmp,
   abitset_list,
-  abitset_reverse_list,
+  abitset_list_reverse,
   NULL,
   BITSET_ARRAY
 };
@@ -642,9 +910,9 @@ abitset_init (bset, n_bits)
      There is probably little merit if using caching since
      the small bitset will always fit in the cache.  */
   if (size == 1)
-    bset->b.ops = &abitset_small_ops;
+    bset->b.vtable = &abitset_small_vtable;
   else
-    bset->b.ops = &abitset_ops;
+    bset->b.vtable = &abitset_vtable;
 
   bset->b.cindex = 0;
   bset->b.csize = size;

lib/bbitset.h

@@ -26,11 +26,11 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #endif
 
 /* Currently we support three flavours of bitsets:
-   BITSET_ARRAY:  Array of bits (fixed size, faster).
+   BITSET_ARRAY:  Array of bits (fixed size, fast for dense bitsets).
    BITSET_LIST:   Linked list of array of bits (variable size, least storage
-   for large very sparse sets). 
+                  for large very sparse sets). 
    BITSET_TABLE:  Expandable table of pointers to array of bits 
-   (variable size, less storage for large sparse sets). 
+                  (variable size, less storage for large sparse sets). 
 
    BITSET_STATS:  Wrapper bitset for internal use only.
 */
@@ -38,6 +38,8 @@ enum bitset_type {BITSET_ARRAY, BITSET_LIST, BITSET_TABLE, BITSET_TYPE_NUM,
 		  BITSET_STATS};
 #define BITSET_TYPE_NAMES {"abitset", "lbitset", "ebitset"}
 
+extern const char * const bitset_type_names[];
+
 enum bitset_alloc_type {BITSET_MALLOC, BITSET_OBALLOC};
 
 /* Non-zero to use inline functions instead of macros.  */
@@ -68,111 +70,9 @@ enum bitset_ops {BITSET_OP_ZERO, BITSET_OP_ONES,
 		 BITSET_OP_AND, BITSET_OP_OR, BITSET_OP_XOR, BITSET_OP_ANDN, 
 		 BITSET_OP_OR_AND, BITSET_OP_AND_OR, BITSET_OP_ANDN_OR};
 
-/* Return size in bits of bitset SRC.  */
-#define BITSET_SIZE_(SRC) (SRC)->b.ops->size (SRC) 
-
-/* Return type of bitset SRC.  */
-#define BITSET_TYPE_(DST) (DST)->b.ops->type 
-
-/* Set bit BITNO in bitset DST.  */
-#define BITSET_SET_(DST, BITNO) (DST)->b.ops->set (DST, BITNO) 
-
-/* Reset bit BITNO in bitset DST.  */
-#define BITSET_RESET_(DST, BITNO) (DST)->b.ops->reset (DST, BITNO) 
-
-/* Return non-zero if bit BITNO in bitset SRC is set.  */
-#define BITSET_TEST_(SRC, BITNO) (SRC)->b.ops->test (SRC, BITNO) 
-
-/* Free bitset SRC.  */
-#define BITSET_FREE_(SRC)\
- ((SRC)->b.ops->free ? (SRC)->b.ops->free (SRC) :(void)0)
-
-/* Perform operation OP on DST.  */
-#define BITSET_OP1_(DST, OP) (DST)->b.ops->op1 (DST, OP) 
-
-/* Perform operation OP on SRC and store in DST.  */
-#define BITSET_OP2_(DST, SRC, OP) (DST)->b.ops->op2 (DST, SRC, OP) 
-
-/* DST = SRC1 OP SRC2.  */
-#define BITSET_OP3_(DST, SRC1, SRC2, OP) \
-(DST)->b.ops->op3 (DST, SRC1, SRC2, OP) 
-
-/* DST = (SRC1 OP1 SRC2) OP2 SRC3.  */
-#define BITSET_OP4_(DST, SRC1, SRC2, SRC3, OP) \
-(DST)->b.ops->op4 (DST, SRC1, SRC2, SRC3, OP) 
-
-/* DST = 0.  */
-#define BITSET_ZERO_(DST) BITSET_OP1_ (DST, BITSET_OP_ZERO);
-
-/* DST = ~0.  */
-#define BITSET_ONES_(DST) BITSET_OP1_ (DST, BITSET_OP_ONES);
-
-/* Return SRC == 0.  */
-#define BITSET_EMPTY_P_(SRC) BITSET_OP1_ (SRC, BITSET_OP_EMPTY_P);
-
-/* Return DST == SRC.  */
-#define BITSET_EQUAL_P_(DST, SRC) BITSET_OP2_ (DST, SRC, BITSET_OP_EQUAL_P) 
-
-/* Return DST == DST | SRC.  */
-#define BITSET_SUBSET_P_(DST, SRC) BITSET_OP2_ (DST, SRC, BITSET_OP_SUBSET_P) 
-
-/* Return DST & SRC == 0.  */
-#define BITSET_DISJOINT_P_(DST, SRC)\
- BITSET_OP2_ (DST, SRC, BITSET_OP_DISJOINT_P) 
-
-/* DST = SRC.  */
-#define BITSET_COPY_(DST, SRC) BITSET_OP2_ (DST, SRC, BITSET_OP_COPY) 
-
-/* DST = ~SRC.  */
-#define BITSET_NOT_(DST, SRC) BITSET_OP2_ (DST, SRC, BITSET_OP_NOT) 
-
-/* DST = SRC1 | SRC2.  */
-#define BITSET_OR_(DST, SRC1, SRC2) BITSET_OP3_ (DST, SRC1, SRC2,\
-  BITSET_OP_OR) 
-
-/* DST = SRC1 ^ SRC2.  */
-#define BITSET_XOR_(DST, SRC1, SRC2) BITSET_OP3_ (DST, SRC1, SRC2,\
-  BITSET_OP_XOR) 
-
-/* DST = SRC1 & SRC2.  */
-#define BITSET_AND_(DST, SRC1, SRC2) BITSET_OP3_ (DST, SRC1, SRC2, \
-  BITSET_OP_AND) 
-
-/* DST = SRC1 & ~SRC2.  */
-#define BITSET_ANDN_(DST, SRC1, SRC2) BITSET_OP3_ (DST, SRC1, SRC2, \
-  BITSET_OP_ANDN) 
-
-/* DST = (SRC1 & SRC2) | SRC3.  Return non-zero if
-   DST != (SRC1 & SRC2) | SRC3.  */
-#define BITSET_AND_OR_(DST, SRC1, SRC2, SRC3)\
-  BITSET_OP4_ (DST, SRC1, SRC2, SRC3, BITSET_OP_AND_OR) 
-
-/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
-   DST != (SRC1 | SRC2) & SRC3.  */
-#define BITSET_OR_AND_(DST, SRC1, SRC2, SRC3)\
-  BITSET_OP4_ (DST, SRC1, SRC2, SRC3, BITSET_OP_OR_AND) 
-
-/* DST = (SRC1 & ~SRC2) | SRC3.  Return non-zero if
-   DST != (SRC1 & ~SRC2) | SRC3.  */
-#define BITSET_ANDN_OR_(DST, SRC1, SRC2, SRC3)\
-  BITSET_OP4_ (DST, SRC1, SRC2, SRC3, BITSET_OP_ANDN_OR) 
-
-/* Find list of up to NUM bits set in BSET starting from and including 
-   *NEXT.  Return with actual number of bits found and with *NEXT
-   indicating where search stopped.  */
-#define BITSET_LIST_(BSET, LIST, NUM, NEXT) \
-(BSET)->b.ops->list (BSET, LIST, NUM, NEXT) 
-
-/* Find reverse list of up to NUM bits set in BSET starting from and
-   including NEXT.  Return with actual number of bits found and with
-   *NEXT indicating where search stopped.  */
-#define BITSET_REVERSE_LIST_(BSET, LIST, NUM, NEXT) \
-(BSET)->b.ops->reverse_list (BSET, LIST, NUM, NEXT) 
-
-
 struct bbitset_struct
 {
-  struct bitset_ops_struct *ops;
+  const struct bitset_vtable * vtable;
   bitset_windex cindex;		/* Cache word index.  */
   bitset_windex csize;		/* Cache size in words.  */
   bitset_word *cdata;		/* Cache data pointer.  */
@@ -188,29 +88,64 @@ typedef struct bitset_struct *bitset;
 
 
 /* The contents of this structure should be considered private.  */
-struct bitset_ops_struct
+struct bitset_vtable
 {
   void (*set) PARAMS ((struct bitset_struct *, bitset_bindex));
   void (*reset) PARAMS ((struct bitset_struct *, bitset_bindex));
+  int (*toggle) PARAMS ((struct bitset_struct *, bitset_bindex));
   int (*test) PARAMS ((struct bitset_struct *, bitset_bindex));
   int (*size) PARAMS ((struct bitset_struct *));
-  int (*op1) PARAMS ((struct bitset_struct *, enum bitset_ops));
+  int (*count) PARAMS ((struct bitset_struct *));
-  int (*op2) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+
-		      enum bitset_ops));
+  int (*empty_p) PARAMS ((struct bitset_struct *));
-  int (*op3) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+  void (*ones) PARAMS ((struct bitset_struct *));
-		      struct bitset_struct *, enum bitset_ops));
+  void (*zero) PARAMS ((struct bitset_struct *));
-  int (*op4) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+
-		      struct bitset_struct *, struct bitset_struct *,
+  void (*copy) PARAMS ((struct bitset_struct *, struct bitset_struct *));
-		      enum bitset_ops));
+  int (*disjoint_p) PARAMS ((struct bitset_struct *, struct bitset_struct *));
+  int (*equal_p) PARAMS ((struct bitset_struct *, struct bitset_struct *));
+  void (*not) PARAMS ((struct bitset_struct *, struct bitset_struct *));
+  int (*subset_p) PARAMS ((struct bitset_struct *, struct bitset_struct *));
+
+  void (*and) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+		       struct bitset_struct *));
+  int (*and_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			  struct bitset_struct *));
+  void (*andn) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+		       struct bitset_struct *));
+  int (*andn_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			   struct bitset_struct *));
+  void (*or) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+		      struct bitset_struct *));
+  int (*or_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			 struct bitset_struct *));
+  void (*xor) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+		      struct bitset_struct *));
+  int (*xor_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			  struct bitset_struct *));
+
+  void (*and_or) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			  struct bitset_struct *, struct bitset_struct *));
+  int (*and_or_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			 struct bitset_struct *, struct bitset_struct *));
+  void (*andn_or) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			  struct bitset_struct *, struct bitset_struct *));
+  int (*andn_or_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			      struct bitset_struct *, struct bitset_struct *));
+  void (*or_and) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			  struct bitset_struct *, struct bitset_struct *));
+  int (*or_and_cmp) PARAMS ((struct bitset_struct *, struct bitset_struct *,
+			     struct bitset_struct *, struct bitset_struct *));
+
   int (*list) PARAMS ((struct bitset_struct *, bitset_bindex *,
 		       bitset_bindex, bitset_bindex *));
-  int (*reverse_list) PARAMS ((struct bitset_struct *, bitset_bindex *,
+  int (*list_reverse) PARAMS ((struct bitset_struct *, bitset_bindex *,
 			       bitset_bindex, bitset_bindex *));
   void (*free) PARAMS ((struct bitset_struct *));
   enum bitset_type type;
 };
 
-#define BITSET_COMPATIBLE_(BSET1, BSET2) ((BSET1)->b.ops == (BSET2)->b.ops)
+#define BITSET_COMPATIBLE_(BSET1, BSET2) ((BSET1)->b.vtable == (BSET2)->b.vtable)
 
 #define BITSET_CHECK2_(DST, SRC) \
 if (!BITSET_COMPATIBLE_ (DST, SRC)) abort ();
@@ -224,7 +159,124 @@ if (!BITSET_COMPATIBLE_ (DST, SRC1) || !BITSET_COMPATIBLE_ (DST, SRC2) \
     || !BITSET_COMPATIBLE_ (DST, SRC3)) abort ();
 
 
-extern int bitset_op4 PARAMS ((bitset, bitset, bitset, bitset, 
+/* Return size in bits of bitset SRC.  */
-			       enum bitset_ops op));
+#define BITSET_SIZE_(SRC) (SRC)->b.vtable->size (SRC) 
+
+/* Return number of bits set in bitset SRC.  */
+#define BITSET_COUNT_(SRC) (SRC)->b.vtable->count (SRC) 
+
+/* Return type of bitset SRC.  */
+#define BITSET_TYPE_(DST) (DST)->b.vtable->type 
+
+/* Set bit BITNO in bitset DST.  */
+#define BITSET_SET_(DST, BITNO) (DST)->b.vtable->set (DST, BITNO) 
+
+/* Reset bit BITNO in bitset DST.  */
+#define BITSET_RESET_(DST, BITNO) (DST)->b.vtable->reset (DST, BITNO) 
+
+/* Toggle bit BITNO in bitset DST.  */
+#define BITSET_TOGGLE_(DST, BITNO) (DST)->b.vtable->toggle (DST, BITNO) 
+
+/* Return non-zero if bit BITNO in bitset SRC is set.  */
+#define BITSET_TEST_(SRC, BITNO) (SRC)->b.vtable->test (SRC, BITNO) 
+
+/* Free bitset SRC.  */
+#define BITSET_FREE_(SRC)\
+ ((SRC)->b.vtable->free ? (SRC)->b.vtable->free (SRC) :(void)0)
+
+
+/* Return SRC == 0.  */
+#define BITSET_EMPTY_P_(SRC) (SRC)->b.vtable->empty_p (SRC)
+
+/* DST = ~0.  */
+#define BITSET_ONES_(DST) (DST)->b.vtable->ones (DST)
+
+/* DST = 0.  */
+#define BITSET_ZERO_(DST) (DST)->b.vtable->zero (DST)
+
+
+
+/* DST = SRC.  */
+#define BITSET_COPY_(DST, SRC) (SRC)->b.vtable->copy (DST, SRC)
+
+/* Return DST & SRC == 0.  */
+#define BITSET_DISJOINT_P_(DST, SRC) (SRC)->b.vtable->disjoint_p (DST, SRC)
+
+/* Return DST == SRC.  */
+#define BITSET_EQUAL_P_(DST, SRC) (SRC)->b.vtable->equal_p (DST, SRC)
+
+/* DST = ~SRC.  */
+#define BITSET_NOT_(DST, SRC) (SRC)->b.vtable->not (DST, SRC)
+
+/* Return DST == DST | SRC.  */
+#define BITSET_SUBSET_P_(DST, SRC) (SRC)->b.vtable->subset_p (DST, SRC)
+
+
+/* DST = SRC1 & SRC2.  */
+#define BITSET_AND_(DST, SRC1, SRC2) (SRC1)->b.vtable->and (DST, SRC1, SRC2)
+#define BITSET_AND_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->and_cmp (DST, SRC1, SRC2)
+
+/* DST = SRC1 & ~SRC2.  */
+#define BITSET_ANDN_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn (DST, SRC1, SRC2)
+#define BITSET_ANDN_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn_cmp (DST, SRC1, SRC2)
+
+/* DST = SRC1 | SRC2.  */
+#define BITSET_OR_(DST, SRC1, SRC2) (SRC1)->b.vtable->or (DST, SRC1, SRC2)
+#define BITSET_OR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->or_cmp (DST, SRC1, SRC2)
+
+/* DST = SRC1 ^ SRC2.  */
+#define BITSET_XOR_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor (DST, SRC1, SRC2)
+#define BITSET_XOR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor_cmp (DST, SRC1, SRC2)
+
+
+
+/* DST = (SRC1 & SRC2) | SRC3.  Return non-zero if
+   DST != (SRC1 & SRC2) | SRC3.  */
+#define BITSET_AND_OR_(DST, SRC1, SRC2, SRC3) \
+ (SRC1)->b.vtable->and_or (DST, SRC1, SRC2, SRC3)
+#define BITSET_AND_OR_CMP_(DST, SRC1, SRC2, SRC3) \
+ (SRC1)->b.vtable->and_or_cmp (DST, SRC1, SRC2, SRC3)
+
+/* DST = (SRC1 & ~SRC2) | SRC3.  Return non-zero if
+   DST != (SRC1 & ~SRC2) | SRC3.  */
+#define BITSET_ANDN_OR_(DST, SRC1, SRC2, SRC3) \
+ (SRC1)->b.vtable->andn_or (DST, SRC1, SRC2, SRC3)
+#define BITSET_ANDN_OR_CMP_(DST, SRC1, SRC2, SRC3) \
+ (SRC1)->b.vtable->andn_or_cmp (DST, SRC1, SRC2, SRC3)
+
+/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
+   DST != (SRC1 | SRC2) & SRC3.  */
+#define BITSET_OR_AND_(DST, SRC1, SRC2, SRC3) \
+ (SRC1)->b.vtable->or_and (DST, SRC1, SRC2, SRC3)
+#define BITSET_OR_AND_CMP_(DST, SRC1, SRC2, SRC3) \
+ (SRC1)->b.vtable->or_and_cmp (DST, SRC1, SRC2, SRC3)
+
+
+/* Find list of up to NUM bits set in BSET starting from and including 
+   *NEXT.  Return with actual number of bits found and with *NEXT
+   indicating where search stopped.  */
+#define BITSET_LIST_(BSET, LIST, NUM, NEXT) \
+ (BSET)->b.vtable->list (BSET, LIST, NUM, NEXT) 
+
+/* Find reverse list of up to NUM bits set in BSET starting from and
+   including NEXT.  Return with actual number of bits found and with
+   *NEXT indicating where search stopped.  */
+#define BITSET_LIST_REVERSE_(BSET, LIST, NUM, NEXT) \
+ (BSET)->b.vtable->list_reverse (BSET, LIST, NUM, NEXT) 
+
+
+/* Private functions for bitset implementations.  */
+ 
+extern int bitset_toggle_ PARAMS ((bitset, bitset_bindex));
+
+extern int bitset_count_ PARAMS ((bitset));
+
+extern int bitset_copy_ PARAMS ((bitset, bitset));
+
+extern int bitset_and_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
+
+extern int bitset_andn_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
+
+extern int bitset_or_and_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
 
 #endif /* _BBITSET_H  */

lib/bitset.c

@@ -28,6 +28,8 @@
 #include "bitset_stats.h"
 #include "obstack.h"
 
+const char * const bitset_type_names[] = BITSET_TYPE_NAMES;
+
 static void bitset_print PARAMS ((FILE *, bitset, int));
 
 
@@ -108,10 +110,8 @@ bitset_type_choose (n_bits, attr)
   if (attr & BITSET_SPARSE && attr & BITSET_DENSE)
     abort ();
 
-  /* Note that sometimes we will be asked for a zero length
+  /* Choose the type of bitset. Note that sometimes we will be asked
-     fixed size bitset.  */
+  for a zero length fixed size bitset.  */
-
-  /* Choose the type of bitset.  */
 
   type = BITSET_ARRAY;
   /* Currently, the simple bitsets do not support a variable size.  */
@@ -215,6 +215,19 @@ bitset_type_get (bset)
 }
 
 
+/* Return name of bitset type.  */
+const char *
+bitset_type_name_get (bset)
+     bitset bset;
+{
+  enum bitset_type type;
+
+  type = bitset_type_get (bset);
+
+  return bitset_type_names[type];
+}
+
+
 /* Find next bit set in SRC starting from and including BITNO.
    Return -1 if SRC empty.  */
 int
@@ -241,7 +254,7 @@ bitset_prev (src, bitno)
   bitset_bindex val;
   bitset_bindex next = bitno;
 
-  if (!bitset_reverse_list (src, &val, 1, &next))
+  if (!bitset_list_reverse (src, &val, 1, &next))
     return -1;
   return val;
 }
@@ -280,27 +293,6 @@ bitset_only_set_p (src, bitno)
 }
 
 
-/* Toggle bit BITNO in bitset BSET and return non-zero if now set.  */
-int
-bitset_toggle (bset, bitno)
-    bitset bset;
-    bitset_bindex bitno;
-{
-  /* This routine is for completeness.  It could be optimized if
-     required.  */
-  if (bitset_test (bset, bitno))
-    {
-      bitset_reset (bset, bitno);
-      return 0;
-    }
-  else
-    {
-      bitset_set (bset, bitno);
-      return 1;
-    }
-}
-
-
 /* Print contents of bitset BSET to FILE.   */
 static void
 bitset_print (file, bset, verbose)
@@ -308,7 +300,8 @@ bitset_print (file, bset, verbose)
      bitset bset;
      int verbose;
 {
-  unsigned int i, pos;
+  unsigned int pos;
+  bitset_bindex i;
   bitset_iterator iter;
 
   if (verbose)
@@ -332,42 +325,51 @@ bitset_print (file, bset, verbose)
 }
 
 
-/* DST = SRC.  Return non-zero if DST != SRC.  */
+/* Dump bitset BSET to FILE.  */
-int
+void
-bitset_copy (dst, src)
+bitset_dump (file, bset)
-     bitset dst;
+     FILE *file;
-     bitset src;
+     bitset bset;
 {
-  unsigned int i;
+  bitset_print (file, bset, 0);
-  bitset_iterator iter;
-
-  if (BITSET_COMPATIBLE_ (dst, src))
-    return BITSET_COPY_ (dst, src);
-
-  /* Convert bitset types.  We assume that the DST bitset
-     is large enough to hold the SRC bitset.  */
-  bitset_zero (dst);
-  BITSET_FOR_EACH (iter, src, i, 0)
-  {
-     bitset_set (dst, i);
-  };
-
-  return 1;
 }
 
 
-/* Return size in bits of bitset SRC.  */
+
-int
+/* Release memory associated with bitsets.  */
-bitset_size (src)
+void
-     bitset src;
+bitset_release_memory ()
 {
-  return BITSET_SIZE_ (src);
+  lbitset_release_memory ();
+  ebitset_release_memory ();
+}
+
+
+
+/* Toggle bit BITNO in bitset BSET and return non-zero if not set.  */
+int
+bitset_toggle_ (bset, bitno)
+    bitset bset;
+    bitset_bindex bitno;
+{
+  /* This routine is for completeness.  It could be optimized if
+     required.  */
+  if (bitset_test (bset, bitno))
+    {
+      bitset_reset (bset, bitno);
+      return 0;
+    }
+  else
+    {
+      bitset_set (bset, bitno);
+      return 1;
+    }
 }
 
 
 /* Return number of bits set in bitset SRC.  */
 int
-bitset_count (src)
+bitset_count_ (src)
      bitset src;
 {
   bitset_bindex list[BITSET_LIST_SIZE];
@@ -388,121 +390,33 @@ bitset_count (src)
 }
 
 
-/* DST = 0.  */
+/* DST = SRC.  Return non-zero if DST != SRC. 
+   This is a fallback for the case where SRC and DST are different
+   bitset types.  */
 int
-bitset_zero (dst)
+bitset_copy_ (dst, src)
-     bitset dst;
-{
-  return BITSET_ZERO_ (dst);
-}
-
-
-/* DST = ~0.  */
-int
-bitset_ones (dst)
-     bitset dst;
-{
-  return BITSET_ONES_ (dst);
-}
-
-
-/* Return SRC == 0.  */
-int
-bitset_empty_p (src)
-     bitset src;
-{
-  return BITSET_EMPTY_P_ (src);
-}
-
-
-/* Return DST == DST | SRC.  */
-int
-bitset_subset_p (dst, src)
      bitset dst;
      bitset src;
 {
-  return BITSET_SUBSET_P_ (dst, src);
+  bitset_bindex i;
-}
+  bitset_iterator iter;
 
+  /* Convert bitset types.  We assume that the DST bitset
+     is large enough to hold the SRC bitset.  */
+  bitset_zero (dst);
+  BITSET_FOR_EACH (iter, src, i, 0)
+  {
+     bitset_set (dst, i);
+  };
 
-/* Return DST == SRC.  */
+  return 1;
-int
-bitset_equal_p (dst, src)
-     bitset dst;
-     bitset src;
-{
-  return BITSET_EQUAL_P_ (dst, src);
-}
-
-
-/* Return DST & SRC == 0.  */
-int
-bitset_disjoint_p (dst, src)
-     bitset dst;
-     bitset src;
-{
-  return BITSET_DISJOINT_P_ (dst, src);
-}
-
-
-/* DST = ~SRC.  */
-int
-bitset_not (dst, src)
-     bitset dst;
-     bitset src;
-{
-  return BITSET_NOT_ (dst, src);
-}
-
-
-/* DST = SRC1 | SRC2.  Return non-zero if DST != SRC1 | SRC2.  */
-int
-bitset_or (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-{
-  return BITSET_OR_ (dst, src1, src2);
-}
-
-
-/* DST = SRC1 & SRC2.  Return non-zero if DST != SRC1 & SRC2.  */
-int
-bitset_and (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-{
-  return BITSET_AND_ (dst, src1, src2);
-}
-
-
-/* DST = SRC1 ^ SRC2.  Return non-zero if DST != SRC1 ^ SRC2.  */
-int
-bitset_xor (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-{
-  return BITSET_XOR_ (dst, src1, src2);
-}
-
-
-/* DST = SRC1 & ~SRC2.  Return non-zero if DST != SRC1 & ~SRC2.  */
-int
-bitset_andn (dst, src1, src2)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-{
-  return BITSET_ANDN_ (dst, src1, src2);
 }
 
 
 /* This is a fallback for implementations that do not support
    four operand operations.  */
-int
+static inline int
-bitset_op4 (dst, src1, src2, src3, op)
+bitset_op4_cmp (dst, src1, src2, src3, op)
      bitset dst;
      bitset src1;
      bitset src2;
@@ -510,26 +424,30 @@ bitset_op4 (dst, src1, src2, src3, op)
      enum bitset_ops op;
 {
   int changed = 0;
+  int stats_enabled_save;
   bitset tmp;
 
   /* Create temporary bitset.  */
+  stats_enabled_save = bitset_stats_enabled;
+  bitset_stats_enabled = 0;
   tmp = bitset_alloc (0, bitset_type_get (dst));
+  bitset_stats_enabled = stats_enabled_save;
 
   switch (op)
     {
     case BITSET_OP_OR_AND:
-      BITSET_OR_ (tmp, src1, src2);
+      bitset_or (tmp, src1, src2);
-      changed = BITSET_AND_ (dst, src3, tmp);
+      changed = bitset_and_cmp (dst, src3, tmp);
       break;
 
     case BITSET_OP_AND_OR:
-      BITSET_AND_ (tmp, src1, src2);
+      bitset_and (tmp, src1, src2);
-      changed = BITSET_OR_ (dst, src3, tmp);
+      changed = bitset_or_cmp (dst, src3, tmp);
       break;
 
     case BITSET_OP_ANDN_OR:
-      BITSET_ANDN_ (tmp, src1, src2);
+      bitset_andn (tmp, src1, src2);
-      changed = BITSET_OR_ (dst, src3, tmp);
+      changed = bitset_or_cmp (dst, src3, tmp);
       break;
 
     default:
@@ -541,52 +459,42 @@ bitset_op4 (dst, src1, src2, src3, op)
 }
 
 
-/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
-   DST != (SRC1 | SRC2) & SRC3.  */
-int
-bitset_or_and (dst, src1, src2, src3)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
-{
-  return BITSET_OR_AND_ (dst, src1, src2, src3);
-}
-
-
 /* DST = (SRC1 & SRC2) | SRC3.  Return non-zero if
    DST != (SRC1 & SRC2) | SRC3.  */
 int
-bitset_and_or (dst, src1, src2, src3)
+bitset_and_or_cmp_ (dst, src1, src2, src3)
      bitset dst;
      bitset src1;
      bitset src2;
      bitset src3;
 {
-  return BITSET_AND_OR_ (dst, src1, src2, src3);
+  return bitset_op4_cmp (dst, src1, src2, src3, BITSET_OP_AND_OR);
 }
 
 
 /* DST = (SRC1 & ~SRC2) | SRC3.  Return non-zero if
    DST != (SRC1 & ~SRC2) | SRC3.  */
 int
-bitset_andn_or (dst, src1, src2, src3)
+bitset_andn_or_cmp_ (dst, src1, src2, src3)
      bitset dst;
      bitset src1;
      bitset src2;
      bitset src3;
 {
-  return BITSET_ANDN_OR_ (dst, src1, src2, src3);
+  return bitset_op4_cmp (dst, src1, src2, src3, BITSET_OP_ANDN_OR);
 }
 
 
-/* Dump bitset BSET to FILE.  */
+/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
-void
+   DST != (SRC1 | SRC2) & SRC3.  */
-bitset_dump (file, bset)
+int
-     FILE *file;
+bitset_or_and_cmp_ (dst, src1, src2, src3)
-     bitset bset;
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
 {
-  bitset_print (file, bset, 0);
+  return bitset_op4_cmp (dst, src1, src2, src3, BITSET_OP_OR_AND);
 }
 
 
@@ -598,12 +506,3 @@ debug_bitset (bset)
   if (bset)
     bitset_print (stderr, bset, 1);
 }
-
-
-/* Release memory associated with bitsets.  */
-void
-bitset_release_memory ()
-{
-  lbitset_release_memory ();
-  ebitset_release_memory ();
-}

lib/bitset.h

@@ -32,7 +32,7 @@ enum bitset_attr {BITSET_FIXED = 1,    /* Bitset size fixed.  */
 		  BITSET_DENSE = 4,    /* Bitset dense.  */
 		  BITSET_SPARSE = 8,   /* Bitset sparse.  */
 		  BITSET_FRUGAL = 16,  /* Prefer most compact.  */
-		  BITSET_GREEDY = 32}; /* Prefer fastest.  */
+		  BITSET_GREEDY = 32}; /* Prefer fastest at memory expense.  */
 
 typedef unsigned int bitset_attrs;
 
@@ -84,15 +84,12 @@ extern void bitset_obstack_free PARAMS ((bitset));
 /* Create a bitset of desired size and attributes.  The bitset is zeroed.  */
 extern bitset bitset_create PARAMS ((bitset_bindex, bitset_attrs));
 
-/* Return size in bits of bitset SRC.  */
-extern int bitset_size PARAMS ((bitset));
-
-/* Return number of bits set in bitset SRC.  */
-extern int bitset_count PARAMS ((bitset));
-
 /* Return bitset type.  */
 extern enum bitset_type bitset_type_get PARAMS ((bitset));
 
+/* Return bitset type name.  */
+extern const char *bitset_type_name_get PARAMS ((bitset));
+
 #if BITSET_INLINE
 static inline void bitset_set PARAMS ((bitset, bitset_bindex));
 static inline void bitset_reset PARAMS ((bitset, bitset_bindex));
@@ -169,9 +166,8 @@ do   								\
   bitset_windex _index = _bitno / BITSET_WORD_BITS; 		\
   bitset_windex _offset = _index - (bset)->b.cindex;		\
   								\
-  if (_offset < (bset)->b.csize)					\
+  if (_offset < (bset)->b.csize)				\
-    (bset)->b.cdata[_offset] &=					\
+    (bset)->b.cdata[_offset] &= ~(1 << (_bitno % BITSET_WORD_BITS)); 	\
-      ~((bitset_word) 1 << (_bitno % BITSET_WORD_BITS)); 	\
   else  							\
     BITSET_RESET_ ((bset), _bitno);				\
 } while (0)
@@ -179,86 +175,116 @@ do   								\
 
 /* Test bit BITNO in bitset BSET.  */
 #define bitset_test(bset, bitno) \
-(((((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex) < (bset)->b.csize) \
+(((((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex) < (bset)->b.csize)  \
-  ? (((int)							\
+  ? ((bset)->b.cdata[(((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex)] \
-      ((bset)->b.cdata[(((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex)] \
+     >> ((bitno) % BITSET_WORD_BITS)) & 1 \
-       >> ((bitno) % BITSET_WORD_BITS)))			\
+  : (unsigned int) BITSET_TEST_ ((bset), (bitno)))
-     & 1)							\
-  : BITSET_TEST_ ((bset), (bitno)))
 #endif
 
 
 /* Toggle bit BITNO in bitset BSET and return non-zero if now set.  */
-extern int bitset_toggle PARAMS ((bitset, bitset_bindex));
+#define bitset_toggle(bset, bitno) BITSET_TOGGLE_ (bset, bitno)
 
-/* DST = 0.  */
+/* Return size in bits of bitset SRC.  */
-extern int bitset_zero PARAMS ((bitset));
+#define bitset_size(SRC) BITSET_SIZE_ (SRC)
+
+/* Return number of bits set in bitset SRC.  */
+#define bitset_count(SRC) BITSET_COUNT_ (SRC)
+
+
+/* Return SRC == 0.  */
+#define bitset_empty_p(SRC) BITSET_EMPTY_P_ (SRC)
 
 /* DST = ~0.  */
-extern int bitset_ones PARAMS ((bitset));
+#define bitset_ones(DST) BITSET_ONES_ (DST)
 
-/* Return non-zero if all bits in bitset SRC are reset.  */
+/* DST = 0.  */
-extern int bitset_empty_p PARAMS ((bitset));
+#define bitset_zero(DST) BITSET_ZERO_ (DST)
 
-/* Return DST == DST | SRC.  */
-extern int bitset_subset_p PARAMS ((bitset, bitset));
 
-/* Return DST == SRC.  */
+
-extern int bitset_equal_p PARAMS ((bitset, bitset));
+/* DST = SRC.  */
+#define bitset_copy(DST, SRC) BITSET_COPY_ (DST, SRC)
 
 /* Return DST & SRC == 0.  */
-extern int bitset_disjoint_p PARAMS ((bitset, bitset));
+#define bitset_disjoint_p(DST, SRC) BITSET_DISJOINT_P_ (DST, SRC)
 
-/* DST == SRC.  */
+/* Return DST == SRC.  */
-extern int bitset_copy PARAMS ((bitset, bitset));
+#define bitset_equal_p(DST, SRC) BITSET_EQUAL_P_ (DST, SRC)
 
 /* DST = ~SRC.  */
-extern int bitset_not PARAMS ((bitset, bitset));
+#define bitset_not(DST, SRC) BITSET_NOT_ (DST, SRC)
 
-/* DST = SRC1 | SRC2.  Return non-zero if DST != SRC1 | SRC2.  */
+/* Return DST == DST | SRC.  */
-extern int bitset_or PARAMS ((bitset, bitset, bitset));
+#define bitset_subset_p(DST, SRC) BITSET_SUBSET_P_ (DST, SRC)
+
+
+
+/* DST = SRC1 & SRC2.  */
+#define bitset_and(DST, SRC1, SRC2) BITSET_AND_ (DST, SRC1, SRC2)
 
 /* DST = SRC1 & SRC2.  Return non-zero if DST != SRC1 & SRC2.  */
-extern int bitset_and PARAMS ((bitset, bitset, bitset));
+#define bitset_and_cmp(DST, SRC1, SRC2) BITSET_AND_CMP_ (DST, SRC1, SRC2)
 
-/* DST = SRC1 ^ SRC2.  Return non-zero if DST != SRC1 ^ SRC2.  */
+/* DST = SRC1 & ~SRC2.  */
-extern int bitset_xor PARAMS ((bitset, bitset, bitset));
+#define bitset_andn(DST, SRC1, SRC2) BITSET_ANDN_ (DST, SRC1, SRC2)
 
 /* DST = SRC1 & ~SRC2.  Return non-zero if DST != SRC1 & ~SRC2.  */
-extern int bitset_andn PARAMS ((bitset, bitset, bitset));
+#define bitset_andn_cmp(DST, SRC1, SRC2) BITSET_ANDN_CMP_ (DST, SRC1, SRC2)
 
-/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
+/* DST = SRC1 | SRC2.  */
-   DST != (SRC1 | SRC2) & SRC3.  */
+#define bitset_or(DST, SRC1, SRC2) BITSET_OR_ (DST, SRC1, SRC2)
-extern int bitset_or_and PARAMS ((bitset, bitset, bitset, bitset));
+
+/* DST = SRC1 | SRC2.  Return non-zero if DST != SRC1 | SRC2.  */
+#define bitset_or_cmp(DST, SRC1, SRC2) BITSET_OR_CMP_ (DST, SRC1, SRC2)
+
+/* DST = SRC1 ^ SRC2.  */
+#define bitset_xor(DST, SRC1, SRC2) BITSET_XOR_ (DST, SRC1, SRC2)
+
+/* DST = SRC1 ^ SRC2.  Return non-zero if DST != SRC1 ^ SRC2.  */
+#define bitset_xor_cmp(DST, SRC1, SRC2) BITSET_XOR_CMP_ (DST, SRC1, SRC2)
+
+
+
+/* DST = (SRC1 & SRC2) | SRC3.  */
+#define bitset_and_or(DST, SRC1, SRC2, SRC3) \
+ BITSET_AND_OR_ (DST, SRC1, SRC2, SRC3)
 
 /* DST = (SRC1 & SRC2) | SRC3.  Return non-zero if
    DST != (SRC1 & SRC2) | SRC3.  */
-extern int bitset_and_or PARAMS ((bitset, bitset, bitset, bitset));
+#define bitset_and_or_cmp(DST, SRC1, SRC2, SRC3) \
+ BITSET_AND_OR_CMP_ (DST, SRC1, SRC2, SRC3)
+
+/* DST = (SRC1 & ~SRC2) | SRC3.  */
+#define bitset_andn_or(DST, SRC1, SRC2, SRC3) \
+ BITSET_ANDN_OR_ (DST, SRC1, SRC2, SRC3)
 
 /* DST = (SRC1 & ~SRC2) | SRC3.  Return non-zero if
    DST != (SRC1 & ~SRC2) | SRC3.  */
-extern int bitset_andn_or PARAMS ((bitset, bitset, bitset, bitset));
+#define bitset_andn_or_cmp(DST, SRC1, SRC2, SRC3) \
+ BITSET_ANDN_OR_CMP_ (DST, SRC1, SRC2, SRC3)
 
-/* Find next bit set in BSET starting from and including BITNO.  */
+/* DST = (SRC1 | SRC2) & SRC3.  */
-extern int bitset_next PARAMS ((bitset, bitset_bindex));
+#define bitset_or_and(DST, SRC1, SRC2, SRC3)\
+ BITSET_OR_AND_ (DST, SRC1, SRC2, SRC3)
 
-/* Find previous bit set in BSET starting from and including BITNO.  */
+/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
-extern int bitset_prev PARAMS ((bitset, bitset_bindex));
+   DST != (SRC1 | SRC2) & SRC3.  */
-
+#define bitset_or_and_cmp(DST, SRC1, SRC2, SRC3)\
-/* Return non-zero if BITNO in SRC is the only set bit.  */
+ BITSET_OR_AND_CMP_ (DST, SRC1, SRC2, SRC3)
-extern int bitset_only_set_p PARAMS ((bitset, bitset_bindex));
 
 /* Find list of up to NUM bits set in BSET starting from and including 
    *NEXT.  Return with actual number of bits found and with *NEXT
    indicating where search stopped.  */
 #define bitset_list(BSET, LIST, NUM, NEXT) \
-BITSET_LIST_ (BSET, LIST, NUM, NEXT) 
+ BITSET_LIST_ (BSET, LIST, NUM, NEXT) 
 
 /* Find reverse list of up to NUM bits set in BSET starting from and
    including NEXT.  Return with actual number of bits found and with
    *NEXT indicating where search stopped.  */
-#define bitset_reverse_list(BSET, LIST, NUM, NEXT) \
+#define bitset_list_reverse(BSET, LIST, NUM, NEXT) \
-BITSET_REVERSE_LIST_ (BSET, LIST, NUM, NEXT) 
+ BITSET_LIST_REVERSE_ (BSET, LIST, NUM, NEXT) 
+
 
 /* Find first set bit.  */
 extern int bitset_first PARAMS ((bitset));
@@ -270,7 +296,18 @@ extern int bitset_last PARAMS ((bitset));
 extern void bitset_dump PARAMS ((FILE *, bitset));
 
 /* Loop over all elements of BSET, starting with MIN, setting BIT
-   to the index of each set bit.  */
+   to the index of each set bit.  For example, the following will print
+   the bits set in a bitset:
+
+   bitset_bindex i;
+   bitset_iterator iter;
+
+   bitset_zero (dst);
+   BITSET_FOR_EACH (iter, src, i, 0)
+   {
+      printf ("%ld ", i);
+   };
+*/
 #define BITSET_FOR_EACH(ITER, BSET, BIT, MIN)				      \
   for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;			      \
        (ITER.num == BITSET_LIST_SIZE) 					      \
@@ -280,7 +317,18 @@ extern void bitset_dump PARAMS ((FILE *, bitset));
 
 
 /* Loop over all elements of BSET, in reverse order starting with
-   MIN,  setting BIT to the index of each set bit.  */
+   MIN,  setting BIT to the index of each set bit. For example, the 
+   following will print the bits set in a bitset in reverse order:
+
+   bitset_bindex i;
+   bitset_iterator iter;
+
+   bitset_zero (dst);
+   BITSET_FOR_EACH_REVERSE (iter, src, i, 0)
+   {
+      printf ("%ld ", i);
+   };
+*/
 #define BITSET_FOR_EACH_REVERSE(ITER, BSET, BIT, MIN)			      \
   for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;			      \
        (ITER.num == BITSET_LIST_SIZE) 					      \
@@ -291,14 +339,25 @@ extern void bitset_dump PARAMS ((FILE *, bitset));
 
 /* Define set operations in terms of logical operations.  */
 
-#define bitset_diff(DST, SRC1, SRC2)  bitset_andn (DST, SRC1, SRC2) 
+#define bitset_diff(DST, SRC1, SRC2) bitset_andn (DST, SRC1, SRC2) 
+#define bitset_diff_cmp(DST, SRC1, SRC2) bitset_andn_cmp (DST, SRC1, SRC2) 
 
-#define bitset_intersection(DST, SRC1, SRC2)  bitset_and (DST, SRC1, SRC2) 
+#define bitset_intersection(DST, SRC1, SRC2) bitset_and (DST, SRC1, SRC2) 
+#define bitset_intersection_cmp(DST, SRC1, SRC2) bitset_and_cmp (DST, SRC1, SRC2) 
 
-#define bitset_union(DST, SRC1, SRC2)  bitset_or (DST, SRC1, SRC2) 
+#define bitset_union(DST, SRC1, SRC2) bitset_or (DST, SRC1, SRC2) 
+#define bitset_union_cmp(DST, SRC1, SRC2) bitset_or_cmp (DST, SRC1, SRC2) 
 
+/* Symmetrical difference.  */
+#define bitset_symdiff(DST, SRC1, SRC2) bitset_xor (DST, SRC1, SRC2) 
+#define bitset_symdiff_cmp(DST, SRC1, SRC2) bitset_xor_cmp (DST, SRC1, SRC2) 
+
+/* Union of difference.  */
 #define bitset_diff_union(DST, SRC1, SRC2, SRC3) \
   bitset_andn_or (DST, SRC1, SRC2, SRC3) 
+#define bitset_diff_union_cmp(DST, SRC1, SRC2, SRC3) \
+  bitset_andn_or_cmp (DST, SRC1, SRC2, SRC3) 
+
 
 
 /* Release any memory tied up with bitsets.  */

lib/bitset_stats.c

@@ -118,16 +118,12 @@ int bitset_stats_enabled = 0;
 
 static void bitset_stats_set PARAMS ((bitset, bitset_bindex));
 static void bitset_stats_reset PARAMS ((bitset, bitset_bindex));
+static int bitset_stats_toggle PARAMS ((bitset, bitset_bindex));
 static int bitset_stats_test PARAMS ((bitset, bitset_bindex));
 static int bitset_stats_size PARAMS ((bitset));
-static int bitset_stats_op1 PARAMS ((bitset, enum bitset_ops));
-static int bitset_stats_op2 PARAMS ((bitset, bitset, enum bitset_ops));
-static int bitset_stats_op3 PARAMS ((bitset, bitset, bitset, enum bitset_ops));
-static int bitset_stats_op4 PARAMS ((bitset, bitset, bitset, bitset,
-				     enum bitset_ops));
 static int bitset_stats_list PARAMS ((bitset, bitset_bindex *, bitset_bindex,
 				      bitset_bindex *));
-static int bitset_stats_reverse_list
+static int bitset_stats_list_reverse
 PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *));
 static void bitset_stats_free PARAMS ((bitset));
 static void bitset_percent_histogram_print PARAMS ((FILE *, const char *,
@@ -183,7 +179,6 @@ bitset_log_histogram_print (file, name, msg, n_bins, bins)
   unsigned int i;
   unsigned int total;
   unsigned int max_width;
-  unsigned int last_bin;
 
   total = 0;
   for (i = 0; i < n_bins; i++)
@@ -192,9 +187,10 @@ bitset_log_histogram_print (file, name, msg, n_bins, bins)
   if (!total)
     return;
 
+  /* Determine number of useful bins.  */
   for (i = n_bins; i > 3 && ! bins[i - 1]; i--)
      continue;
-  last_bin = i - 1;
+  n_bins = i;
 
   /* 2 * ceil (log10 (2) * (N - 1)) + 1.  */
   max_width = 2 * (unsigned int) (0.30103 * (n_bins - 1) + 0.9999) + 1;
@@ -204,7 +200,7 @@ bitset_log_histogram_print (file, name, msg, n_bins, bins)
     fprintf (file, "%*d\t%8d (%5.1f%%)\n",
 	     max_width, i, bins[i], 100.0 * bins[i] / total);
 
-  for (; i <= last_bin; i++)
+  for (; i < n_bins; i++)
     fprintf (file, "%*d-%d\t%8d (%5.1f%%)\n",
 	     max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
 	     1 << (i - 1), (1 << i) - 1, bins[i],
@@ -256,7 +252,6 @@ bitset_stats_print (file, verbose)
      int verbose ATTRIBUTE_UNUSED;
 {
   int i;
-  static const char *names[] = BITSET_TYPE_NAMES;
 
   if (!bitset_stats_info)
     return;
@@ -267,7 +262,8 @@ bitset_stats_print (file, verbose)
     fprintf (file, _("Accumulated runs = %d\n"), bitset_stats_info->runs);
 
   for (i = 0; i < BITSET_TYPE_NUM; i++)
-    bitset_stats_print_1 (file, names[i], &bitset_stats_info->types[i]);
+    bitset_stats_print_1 (file, bitset_type_names[i], 
+			  &bitset_stats_info->types[i]);
 }
 
 
@@ -404,6 +400,15 @@ bitset_stats_reset (dst, bitno)
 }
 
 
+static int
+bitset_stats_toggle (src, bitno)
+     bitset src;
+     bitset_bindex bitno;
+{
+    return BITSET_TOGGLE_ (src->s.bset, bitno);
+}
+
+
 static int
 bitset_stats_test (src, bitno)
      bitset src;
@@ -434,56 +439,250 @@ bitset_stats_size (src)
 
 
 static int
-bitset_stats_op1 (dst, op)
+bitset_stats_count (src)
-     bitset dst;
+     bitset src;
-     enum bitset_ops op;
 {
-  return BITSET_OP1_ (dst->s.bset, op);
+  return BITSET_COUNT_ (src->s.bset);
 }
 
 
 static int
-bitset_stats_op2 (dst, src, op)
+bitset_stats_empty_p (dst)
+     bitset dst;
+{
+  return BITSET_EMPTY_P_ (dst->s.bset);
+}
+
+
+static void
+bitset_stats_ones (dst)
+     bitset dst;
+{
+  BITSET_ONES_ (dst->s.bset);
+}
+
+
+static void
+bitset_stats_zero (dst)
+     bitset dst;
+{
+  BITSET_ZERO_ (dst->s.bset);
+}
+
+
+static void
+bitset_stats_copy (dst, src)
      bitset dst;
      bitset src;
-     enum bitset_ops op;
 {
   BITSET_CHECK2_ (dst, src);
-  return BITSET_OP2_ (dst->s.bset, src->s.bset, op);
+  BITSET_COPY_ (dst->s.bset, src->s.bset);
 }
 
 
 static int
-bitset_stats_op3 (dst, src1, src2, op)
+bitset_stats_disjoint_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  BITSET_CHECK2_ (dst, src);
+  return BITSET_DISJOINT_P_ (dst->s.bset, src->s.bset);
+}
+
+
+static int
+bitset_stats_equal_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  BITSET_CHECK2_ (dst, src);
+  return BITSET_EQUAL_P_ (dst->s.bset, src->s.bset);
+}
+
+
+static void
+bitset_stats_not (dst, src)
+     bitset dst;
+     bitset src;
+{
+  BITSET_CHECK2_ (dst, src);
+  BITSET_NOT_ (dst->s.bset, src->s.bset);
+}
+
+
+static int
+bitset_stats_subset_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  BITSET_CHECK2_ (dst, src);
+  return BITSET_SUBSET_P_ (dst->s.bset, src->s.bset);
+}
+
+
+static void
+bitset_stats_and (dst, src1, src2)
      bitset dst;
      bitset src1;
      bitset src2;
-     enum bitset_ops op;
 {
   BITSET_CHECK3_ (dst, src1, src2);
-  return BITSET_OP3_ (dst->s.bset, src1->s.bset, src2->s.bset, op);
+  BITSET_AND_ (dst->s.bset, src1->s.bset, src2->s.bset);
 }
 
 
 static int
-bitset_stats_op4 (dst, src1, src2, src3, op)
+bitset_stats_and_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  return BITSET_AND_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static void
+bitset_stats_andn (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  BITSET_ANDN_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static int
+bitset_stats_andn_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  return BITSET_ANDN_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static void
+bitset_stats_or (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  BITSET_OR_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static int
+bitset_stats_or_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  return BITSET_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static void
+bitset_stats_xor (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  BITSET_XOR_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static int
+bitset_stats_xor_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  return BITSET_XOR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static void
+bitset_stats_and_or (dst, src1, src2, src3)
      bitset dst;
      bitset src1;
      bitset src2;
      bitset src3;
-     enum bitset_ops op;
 {
   BITSET_CHECK4_ (dst, src1, src2, src3);
 
-  /* This is a bit of a hack.  If the implementation handles
+  BITSET_AND_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
-     a four operand operation then vector to it, passing
+}
-     the enclosed bitsets.  Otherwise use the fallback 
-     bitset_op4 routine.  */
-  if (dst->s.bset->b.ops->op4 != bitset_op4)
-     return BITSET_OP4_ (dst->s.bset, src1->s.bset, src2->s.bset,
-			 src3->s.bset, op);
 
-  return bitset_op4 (dst, src1, src2, src3, op);
+
+static int
+bitset_stats_and_or_cmp (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  BITSET_CHECK4_ (dst, src1, src2, src3);
+
+  return BITSET_AND_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
+}
+
+
+static void
+bitset_stats_andn_or (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  BITSET_CHECK4_ (dst, src1, src2, src3);
+
+  BITSET_ANDN_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
+}
+
+
+static int
+bitset_stats_andn_or_cmp (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  BITSET_CHECK4_ (dst, src1, src2, src3);
+
+  return BITSET_ANDN_OR_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
+}
+
+
+static void
+bitset_stats_or_and (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  BITSET_CHECK4_ (dst, src1, src2, src3);
+
+  BITSET_OR_AND_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
+}
+
+
+static int
+bitset_stats_or_and_cmp (dst, src1, src2, src3)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+     bitset src3;
+{
+  BITSET_CHECK4_ (dst, src1, src2, src3);
+
+  return BITSET_OR_AND_CMP_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
 }
 
 
@@ -530,13 +729,13 @@ bitset_stats_list (bset, list, num, next)
 
 
 static int
-bitset_stats_reverse_list (bset, list, num, next)
+bitset_stats_list_reverse (bset, list, num, next)
      bitset bset;
      bitset_bindex *list;
      bitset_bindex num;
      bitset_bindex *next;
 {
-  return BITSET_REVERSE_LIST_ (bset->s.bset, list, num, next);
+  return BITSET_LIST_REVERSE_ (bset->s.bset, list, num, next);
 }
 
 
@@ -549,17 +748,37 @@ bitset_stats_free (bset)
 }
 
 
-struct bitset_ops_struct bitset_stats_ops = {
+struct bitset_vtable bitset_stats_vtable = {
   bitset_stats_set,
   bitset_stats_reset,
+  bitset_stats_toggle,
   bitset_stats_test,
   bitset_stats_size,
-  bitset_stats_op1,
+  bitset_stats_count,
-  bitset_stats_op2,
+  bitset_stats_empty_p,
-  bitset_stats_op3,
+  bitset_stats_ones,
-  bitset_stats_op4,
+  bitset_stats_zero,
+  bitset_stats_copy,
+  bitset_stats_disjoint_p,
+  bitset_stats_equal_p,
+  bitset_stats_not,
+  bitset_stats_subset_p,
+  bitset_stats_and,
+  bitset_stats_and_cmp,
+  bitset_stats_andn,
+  bitset_stats_andn_cmp,
+  bitset_stats_or,
+  bitset_stats_or_cmp,
+  bitset_stats_xor,
+  bitset_stats_xor_cmp,
+  bitset_stats_and_or,
+  bitset_stats_and_or_cmp,
+  bitset_stats_andn_or,
+  bitset_stats_andn_or_cmp,
+  bitset_stats_or_and,
+  bitset_stats_or_and_cmp,
   bitset_stats_list,
-  bitset_stats_reverse_list,
+  bitset_stats_list_reverse,
   bitset_stats_free,
   BITSET_STATS
 };
@@ -589,7 +808,7 @@ bitset_stats_init (bset, n_bits, type)
   unsigned int bytes;
   bitset sbset;
 
-  bset->b.ops = &bitset_stats_ops;
+  bset->b.vtable = &bitset_stats_vtable;
 
   /* Disable cache.  */
   bset->b.cindex = 0;

lib/bitsetv.c

@@ -1,5 +1,5 @@
 /* Bitset vectors.
-   Copyright (C) 2001 Free Software Foundation, Inc.
+   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
 
 This file is part of GCC.
 

lib/ebitset.c

@@ -77,6 +77,9 @@ typedef struct ebitset_struct
 *ebitset;
 
 
+typedef void(*PFV)();
+
+
 /* Number of elements to initially allocate.  */
 
 #ifndef EBITSET_INITIAL_SIZE
@@ -118,19 +121,24 @@ 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 void ebitset_copy PARAMS ((bitset, bitset));
+static int ebitset_copy_cmp 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_disjoint_p PARAMS ((bitset, bitset));
-static int ebitset_op2 PARAMS ((bitset, bitset, enum bitset_ops));
+static int ebitset_equal_p PARAMS ((bitset, bitset));
-static int ebitset_op3 PARAMS ((bitset, bitset, bitset, enum bitset_ops));
+static void ebitset_not PARAMS ((bitset, bitset));
+static int ebitset_subset_p PARAMS ((bitset, bitset));
+static int ebitset_op3_cmp PARAMS ((bitset, bitset, bitset, enum bitset_ops));
+static int ebitset_and_cmp PARAMS ((bitset, bitset, bitset));
+static int ebitset_andn_cmp PARAMS ((bitset, bitset, bitset));
+static int ebitset_or_cmp PARAMS ((bitset, bitset, bitset));
+static int ebitset_xor_cmp PARAMS ((bitset, bitset, bitset));
 static int ebitset_list PARAMS ((bitset, bitset_bindex *, bitset_bindex,
 				 bitset_bindex *));
-static int ebitset_reverse_list
+static int ebitset_list_reverse
 PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *));
 static void ebitset_free PARAMS ((bitset));
 
@@ -141,7 +149,7 @@ static void ebitset_free PARAMS ((bitset));
 #define EBITSET_WORDS(ELT) ((ELT)->u.words)
 
 /* Disable bitset cache and mark BSET as being zero.  */
-#define EBITSET_OP_ZERO_SET(BSET) ((BSET)->b.cindex = BITSET_INDEX_MAX, \
+#define EBITSET_ZERO_SET(BSET) ((BSET)->b.cindex = BITSET_INDEX_MAX, \
         (BSET)->b.cdata = 0)
 
 #define EBITSET_CACHE_DISABLE(BSET)  ((BSET)->b.cindex = BITSET_INDEX_MAX)
@@ -152,7 +160,7 @@ static void ebitset_free PARAMS ((bitset));
 
 /* 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_OP_ZERO_P(BSET) ((BSET)->b.cdata == 0)
+#define EBITSET_ZERO_P(BSET) ((BSET)->b.cdata == 0)
 
 /* Enable cache to point to element with table index EINDEX. 
    The element must exist.  */
@@ -395,7 +403,7 @@ ebitset_weed (bset)
   bitset_windex j;
   int count;
 
-  if (EBITSET_OP_ZERO_P (bset))
+  if (EBITSET_ZERO_P (bset))
     return 0;
 
   elts = EBITSET_ELTS (bset);
@@ -421,7 +429,7 @@ ebitset_weed (bset)
     {
       /* All the bits are zero.  We could shrink the elts. 
 	 For now just mark BSET as known to be zero.  */
-      EBITSET_OP_ZERO_SET (bset);
+      EBITSET_ZERO_SET (bset);
     }
   else
     EBITSET_NONZERO_SET (bset);
@@ -438,7 +446,7 @@ ebitset_zero (bset)
   ebitset_elts *elts;
   bitset_windex j;
 
-  if (EBITSET_OP_ZERO_P (bset))
+  if (EBITSET_ZERO_P (bset))
     return;
 
   elts = EBITSET_ELTS (bset);
@@ -452,7 +460,7 @@ ebitset_zero (bset)
 
   /* All the bits are zero.  We could shrink the elts. 
      For now just mark BSET as known to be zero.  */
-  EBITSET_OP_ZERO_SET (bset);
+  EBITSET_ZERO_SET (bset);
 }
 
 
@@ -498,7 +506,7 @@ ebitset_equal_p (dst, src)
 
 /* Copy bits from bitset SRC to bitset DST.  */
 static inline void
-ebitset_copy (dst, src)
+ebitset_copy_ (dst, src)
      bitset dst;
      bitset src;
 {
@@ -537,23 +545,23 @@ ebitset_copy (dst, src)
 /* Copy bits from bitset SRC to bitset DST.  Return non-zero if
    bitsets different.  */
 static inline int
-ebitset_copy_compare (dst, src)
+ebitset_copy_cmp (dst, src)
      bitset dst;
      bitset src;
 {
   if (src == dst)
     return 0;
 
-  if (EBITSET_OP_ZERO_P (dst))
+  if (EBITSET_ZERO_P (dst))
     {
-      ebitset_copy (dst, src);
+      ebitset_copy_ (dst, src);
-      return !EBITSET_OP_ZERO_P (src);
+      return !EBITSET_ZERO_P (src);
     }
 
   if (ebitset_equal_p (dst, src))
     return 0;
 
-  ebitset_copy (dst, src);
+  ebitset_copy_ (dst, src);
   return 1;
 }
 
@@ -632,7 +640,7 @@ ebitset_free (bset)
  *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)
+ebitset_list_reverse (bset, list, num, next)
      bitset bset;
      bitset_bindex *list;
      bitset_bindex num;
@@ -650,7 +658,7 @@ ebitset_reverse_list (bset, list, num, next)
   bitset_windex size;
   ebitset_elts *elts;
 
-  if (EBITSET_OP_ZERO_P (bset))
+  if (EBITSET_ZERO_P (bset))
     return 0;
 
   size = EBITSET_SIZE (bset);
@@ -678,20 +686,19 @@ ebitset_reverse_list (bset, list, num, next)
   do
     {
       ebitset_elt *elt;
-
+      bitset_word *srcp;
+      
       elt = elts[eindex];
       if (elt)
-	{
+	{      
-	  bitset_word *srcp;
-
 	  srcp = EBITSET_WORDS (elt);
-
+	  
 	  do
 	    {
 	      bitset_word word;
-
+	      
 	      word = srcp[woffset] << (BITSET_WORD_BITS - 1 - bcount);
-
+	      
 	      for (; word; bcount--)
 		{
 		  if (word & BITSET_MSB)
@@ -705,15 +712,13 @@ ebitset_reverse_list (bset, list, num, next)
 		    }
 		  word <<= 1;
 		}
-
 	      boffset -= BITSET_WORD_BITS;
-	      bcount = BITSET_WORD_BITS - 1;
+	      bcount = BITSET_WORD_BITS - 1;	  
 	    }
 	  while (woffset--);
-
-	  woffset = EBITSET_ELT_WORDS;
 	}
 
+      woffset = EBITSET_ELT_WORDS - 1;
       boffset = eindex * EBITSET_ELT_BITS - BITSET_WORD_BITS;
     }
   while (eindex--);
@@ -742,7 +747,7 @@ ebitset_list (bset, list, num, next)
   bitset_word word;
   ebitset_elts *elts;
 
-  if (EBITSET_OP_ZERO_P (bset))
+  if (EBITSET_ZERO_P (bset))
     return 0;
 
   bitno = *next;
@@ -866,156 +871,145 @@ ebitset_list (bset, list, num, next)
 }
 
 
-static int
+static void
-ebitset_op1 (dst, op)
+ebitset_ones (dst)
      bitset dst;
-     enum bitset_ops op;
 {
   bitset_windex j;
   ebitset_elt *elt;
 
-  switch (op)
+
+  for (j = 0; j < EBITSET_SIZE (dst); j++)
     {
-    case BITSET_OP_ZERO:
+      /* Create new elements if they cannot be found.  Perhaps
-      ebitset_zero (dst);
+	 we should just add pointers to a ones element.  */
-      return 1;
+      elt =
-
+	ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);
-    case BITSET_OP_ONES:
+      memset (EBITSET_WORDS (elt), -1, sizeof (EBITSET_WORDS (elt)));
-      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);
-	  memset (EBITSET_WORDS (elt), -1, sizeof (EBITSET_WORDS (elt)));
-	}
-      break;
-
-    case BITSET_OP_EMPTY_P:
-      return !ebitset_weed (dst);
-
-    default:
-      abort ();
     }
-
   EBITSET_NONZERO_SET (dst);
-  return 1;
 }
 
 
 static int
-ebitset_op2 (dst, src, op)
+ebitset_empty_p (dst)
+     bitset dst;
+{
+  return !ebitset_weed (dst);
+}
+
+
+static void
+ebitset_not (dst, src)
      bitset dst;
      bitset src;
-     enum bitset_ops op;
 {
+  unsigned int i;
   ebitset_elt *selt;
   ebitset_elt *delt;
-  unsigned int i;
   bitset_windex j;
 
-  switch (op)
+  for (j = 0; j < EBITSET_SIZE (src); j++)
     {
-    case BITSET_OP_COPY:
+      /* Create new elements for dst if they cannot be found
-      ebitset_copy (dst, src);
-      break;
-
-    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.  */
-	  selt =
+      selt =
-	    ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_SUBST);
+	ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_SUBST);
-	  delt =
+      delt =
-	    ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);
+	ebitset_elt_find (dst, j * EBITSET_ELT_WORDS, EBITSET_CREATE);
 
-	  for (i = 0; i < EBITSET_ELT_WORDS; i++)
+      for (i = 0; i < EBITSET_ELT_WORDS; i++)
-	    EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i];
+	EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i];
-	}
-      break;
-
-      /* Return 1 if DST == SRC.  */
-    case BITSET_OP_EQUAL_P:
-      return ebitset_equal_p (dst, src);
-
-      /* Return 1 if DST == DST | SRC.  */
-    case BITSET_OP_SUBSET_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;
-
-	    if (!selt)
-	      selt = &ebitset_zero_elts[0];
-	    if (!delt)
-	      delt = &ebitset_zero_elts[0];
-
-	    for (i = 0; i < EBITSET_ELT_WORDS; i++)
-	      if (EBITSET_WORDS (delt)[i]
-		  != (EBITSET_WORDS (selt)[i] | EBITSET_WORDS (delt)[i]))
-		return 0;
-	  }
-	return 1;
-      }
-      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 ();
     }
-
   EBITSET_NONZERO_SET (dst);
+}  
+
+
+/* Return 1 if DST == DST | SRC.  */
+static int
+ebitset_subset_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  bitset_windex j;
+  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++)
+    {
+      unsigned int i;
+      ebitset_elt *selt;
+      ebitset_elt *delt;
+
+      selt = j < ssize ? selts[j] : 0;
+      delt = j < dsize ? delts[j] : 0;
+      
+      if (!selt && !delt)
+	continue;
+      
+      if (!selt)
+	selt = &ebitset_zero_elts[0];
+      if (!delt)
+	delt = &ebitset_zero_elts[0];
+      
+      for (i = 0; i < EBITSET_ELT_WORDS; i++)
+	if (EBITSET_WORDS (delt)[i]
+	    != (EBITSET_WORDS (selt)[i] | EBITSET_WORDS (delt)[i]))
+	  return 0;
+    }
   return 1;
 }
 
 
+/* Return 1 if DST & SRC == 0.  */
 static int
-ebitset_op3 (dst, src1, src2, op)
+ebitset_disjoint_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  bitset_windex j;
+  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++)
+    {
+      unsigned int i;
+      ebitset_elt *selt;
+      ebitset_elt *delt;
+
+      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;
+}
+
+
+
+static int
+ebitset_op3_cmp (dst, src1, src2, op)
      bitset dst;
      bitset src1;
      bitset src2;
@@ -1035,37 +1029,6 @@ ebitset_op3 (dst, src1, src2, op)
   unsigned int i;
   bitset_windex j;
 
-  /* Fast track common, simple cases.  */
-  if (EBITSET_OP_ZERO_P (src2))
-    {
-      if (op == BITSET_OP_AND)
-	{
-	  ebitset_weed (dst);
-	  changed = EBITSET_OP_ZERO_P (dst);
-	  ebitset_zero (dst);
-	  return changed;
-	}
-      else if (op == BITSET_OP_ANDN || op == BITSET_OP_OR
-	       || op == BITSET_OP_XOR)
-	{
-	  return ebitset_copy_compare (dst, src1);
-	}
-    }
-  else if (EBITSET_OP_ZERO_P (src1))
-    {
-      if (op == BITSET_OP_AND || op == BITSET_OP_ANDN)
-	{
-	  ebitset_weed (dst);
-	  changed = EBITSET_OP_ZERO_P (dst);
-	  ebitset_zero (dst);
-	  return changed;
-	}
-      else if (op == BITSET_OP_OR || op == BITSET_OP_XOR)
-	{
-	  return ebitset_copy_compare (dst, src2);
-	}
-    }
-
   ssize1 = EBITSET_SIZE (src1);
   ssize2 = EBITSET_SIZE (src2);
   dsize = EBITSET_SIZE (dst);
@@ -1198,18 +1161,135 @@ ebitset_op3 (dst, src1, src2, op)
 }
 
 
+static int
+ebitset_and_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  int changed;
+
+  if (EBITSET_ZERO_P (src2))
+    {
+      ebitset_weed (dst);
+      changed = EBITSET_ZERO_P (dst);
+      ebitset_zero (dst);
+      return changed;
+    }
+  else if (EBITSET_ZERO_P (src1))
+    {
+      ebitset_weed (dst);
+      changed = EBITSET_ZERO_P (dst);
+      ebitset_zero (dst);
+      return changed;
+    }
+  return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_AND);
+}
+
+
+static int
+ebitset_andn_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  int changed;
+
+  if (EBITSET_ZERO_P (src2))
+    {
+      return ebitset_copy_cmp (dst, src1);
+    }
+  else if (EBITSET_ZERO_P (src1))
+    {
+      ebitset_weed (dst);
+      changed = EBITSET_ZERO_P (dst);
+      ebitset_zero (dst);
+      return changed;
+    }
+  return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_ANDN);
+}
+
+
+static int
+ebitset_or_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  if (EBITSET_ZERO_P (src2))
+    {
+      return ebitset_copy_cmp (dst, src1);
+    }
+  else if (EBITSET_ZERO_P (src1))
+    {
+      return ebitset_copy_cmp (dst, src2);
+    }
+  return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_OR);
+}
+
+
+static int
+ebitset_xor_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  if (EBITSET_ZERO_P (src2))
+    {
+      return ebitset_copy_cmp (dst, src1);
+    }
+  else if (EBITSET_ZERO_P (src1))
+    {
+      return ebitset_copy_cmp (dst, src2);
+    }
+  return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_XOR);
+}
+
+
+static void
+ebitset_copy (dst, src)
+     bitset dst;
+     bitset src;
+{
+  if (BITSET_COMPATIBLE_ (dst, src))
+      ebitset_copy_ (dst, src);
+  else
+      bitset_copy_ (dst, src);
+}
+
+
 /* Vector of operations for linked-list bitsets.  */
-struct bitset_ops_struct ebitset_ops = {
+struct bitset_vtable ebitset_vtable = {
   ebitset_set,
   ebitset_reset,
+  bitset_toggle_,
   ebitset_test,
   ebitset_size,
-  ebitset_op1,
+  bitset_count_,
-  ebitset_op2,
+  ebitset_empty_p,
-  ebitset_op3,
+  ebitset_ones,
-  bitset_op4,
+  ebitset_zero,
+  ebitset_copy,
+  ebitset_disjoint_p,
+  ebitset_equal_p,
+  ebitset_not,
+  ebitset_subset_p,
+  (PFV) ebitset_and_cmp,
+  ebitset_and_cmp,
+  (PFV) ebitset_andn_cmp,
+  ebitset_andn_cmp,
+  (PFV) ebitset_or_cmp,
+  ebitset_or_cmp,
+  (PFV) ebitset_xor_cmp,
+  ebitset_xor_cmp,
+  (PFV) bitset_and_or_cmp_,
+  bitset_and_or_cmp_,
+  (PFV) bitset_andn_or_cmp_,
+  bitset_andn_or_cmp_,
+  (PFV) bitset_or_and_cmp_,
+  bitset_or_and_cmp_,
   ebitset_list,
-  ebitset_reverse_list,
+  ebitset_list_reverse,
   ebitset_free,
   BITSET_TABLE
 };
@@ -1233,11 +1313,11 @@ ebitset_init (bset, n_bits)
 {
   unsigned int size;
 
-  bset->b.ops = &ebitset_ops;
+  bset->b.vtable = &ebitset_vtable;
 
   bset->b.csize = EBITSET_ELT_WORDS;
 
-  EBITSET_OP_ZERO_SET (bset);
+  EBITSET_ZERO_SET (bset);
 
   size = n_bits ? (n_bits + EBITSET_ELT_BITS - 1) / EBITSET_ELT_BITS
     : EBITSET_INITIAL_SIZE;

lib/lbitset.c

@@ -24,6 +24,7 @@
 #include "lbitset.h"
 #include "obstack.h"
 #include <stdlib.h>
+#include <stdio.h>
 
 /* This file implements linked-list bitsets.  These bitsets can be of
    arbitrary length and are more efficient than arrays of bits for
@@ -78,6 +79,9 @@ struct bitset_struct
 };
 
 
+typedef void(*PFV)();
+
+
 enum lbitset_find_mode
   { LBITSET_FIND, LBITSET_CREATE, LBITSET_SUBST };
 
@@ -102,17 +106,15 @@ static void lbitset_weed PARAMS ((bitset));
 static void lbitset_zero PARAMS ((bitset));
 static int lbitset_equal_p PARAMS ((bitset, bitset));
 static void lbitset_copy PARAMS ((bitset, bitset));
-static int lbitset_copy_compare PARAMS ((bitset, bitset));
+static int lbitset_copy_cmp PARAMS ((bitset, bitset));
 static void lbitset_set PARAMS ((bitset, bitset_bindex));
 static void lbitset_reset PARAMS ((bitset, bitset_bindex));
 static int lbitset_test PARAMS ((bitset, bitset_bindex));
 static int lbitset_size PARAMS ((bitset));
-static int lbitset_op1 PARAMS ((bitset, enum bitset_ops));
+static int lbitset_op3_cmp PARAMS ((bitset, bitset, bitset, enum bitset_ops));
-static int lbitset_op2 PARAMS ((bitset, bitset, enum bitset_ops));
-static int lbitset_op3 PARAMS ((bitset, bitset, bitset, enum bitset_ops));
 static int lbitset_list PARAMS ((bitset, bitset_bindex *, bitset_bindex,
 				 bitset_bindex *));
-static int lbitset_reverse_list
+static int lbitset_list_reverse
 PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *));
 static void lbitset_free PARAMS ((bitset));
 
@@ -398,7 +400,7 @@ lbitset_elt_find (bset, windex, mode)
 	    continue;
 	}
 
-      /* `element' is the nearest to the one we want.  If it's not the one
+      /* ELT is the nearest to the one we want.  If it's not the one
 	 we want, the one we want does not exist.  */
       if (elt && (windex - elt->index) < LBITSET_ELT_WORDS)
 	{
@@ -449,7 +451,7 @@ lbitset_weed (bset)
 
 
 /* Set all bits in the bitset to zero.  */
-static inline void
+static void
 lbitset_zero (bset)
      bitset bset;
 {
@@ -464,6 +466,7 @@ lbitset_zero (bset)
 }
 
 
+/* Return 1 if DST == SRC.  */
 static inline int
 lbitset_equal_p (dst, src)
      bitset dst;
@@ -538,7 +541,7 @@ lbitset_copy (dst, src)
 /* Copy bits from bitset SRC to bitset DST.  Return non-zero if
    bitsets different.  */
 static inline int
-lbitset_copy_compare (dst, src)
+lbitset_copy_cmp (dst, src)
      bitset dst;
      bitset src;
 {
@@ -636,7 +639,7 @@ lbitset_free (bset)
  *NEXT and store in array LIST.  Return with actual number of bits
  found and with *NEXT indicating where search stopped.  */
 static int
-lbitset_reverse_list (bset, list, num, next)
+lbitset_list_reverse (bset, list, num, next)
      bitset bset;
      bitset_bindex *list;
      bitset_bindex num;
@@ -673,13 +676,24 @@ lbitset_reverse_list (bset, list, num, next)
   if (!elt)
     return 0;
 
-  /* If num is 1, we could speed things up with a binary search
+  if (windex >= elt->index + LBITSET_ELT_WORDS)
-     of the word of interest.  */
+    {
+      /* We are trying to start in no-mans land so start
+	 at end of current elt.  */
+      bcount = BITSET_WORD_BITS - 1;
+      windex = elt->index + LBITSET_ELT_WORDS - 1;
+    }
+  else
+    {
+      bcount = bitno % BITSET_WORD_BITS;
+    }
 
   count = 0;
-  bcount = bitno % BITSET_WORD_BITS;
   boffset = windex * BITSET_WORD_BITS;
 
+  /* If num is 1, we could speed things up with a binary search
+     of the word of interest.  */
+
   while (elt)
     {
       bitset_word *srcp = elt->words;
@@ -926,56 +940,47 @@ lbitset_list (bset, list, num, next)
 
 
 static int
-lbitset_op1 (dst, op)
+lbitset_empty_p (dst)
+     bitset dst;
+{
+  lbitset_weed (dst);
+  if (LBITSET_HEAD (dst))
+      return 0;
+  return 1;
+}
+
+
+static void
+lbitset_ones (dst)
      bitset dst;
-     enum bitset_ops op;
 {
   unsigned int i;
   bitset_windex windex;
   lbitset_elt *elt;
 
-  switch (op)
+  /* This is a decidedly unfriendly operation for a linked list
+      bitset!  It makes a sparse bitset become dense.  An alternative
+      is to have a flag that indicates that the bitset stores the
+      complement of what it indicates.  */
+  elt = LBITSET_TAIL (dst);
+  /* Ignore empty set.  */
+  if (!elt)
+    return;
+  
+  windex = elt->index;
+  for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
     {
-    case BITSET_OP_ZERO:
+      /* Create new elements if they cannot be found.  */
-      lbitset_zero (dst);
+      elt = lbitset_elt_find (dst, i, LBITSET_CREATE);
-      break;
+      memset (elt->words, -1, sizeof (elt->words));
-
-    case BITSET_OP_ONES:
-      /* This is a decidedly unfriendly operation for a linked list
-	 bitset!   */
-      elt = LBITSET_TAIL (dst);
-      /* Ignore empty set.  */
-      if (!elt)
-	return 0;
-
-      windex = elt->index;
-      for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
-	{
-	  /* Create new elements if they cannot be found.  */
-	  elt = lbitset_elt_find (dst, i, LBITSET_CREATE);
-	  memset (elt->words, -1, sizeof (elt->words));
-	}
-      break;
-
-    case BITSET_OP_EMPTY_P:
-      lbitset_weed (dst);
-      if (LBITSET_HEAD (dst))
-	return 0;
-      break;
-
-    default:
-      abort ();
     }
-
-  return 1;
 }
 
 
-static int
+static void
-lbitset_op2 (dst, src, op)
+lbitset_not (dst, src)
      bitset dst;
      bitset src;
-     enum bitset_ops op;
 {
   lbitset_elt *elt;
   lbitset_elt *selt;
@@ -984,106 +989,108 @@ lbitset_op2 (dst, src, op)
   unsigned int j;
   bitset_windex windex;
 
-  switch (op)
+  /* This is another unfriendly operation for a linked list
+     bitset!  */
+  elt = LBITSET_TAIL (dst);
+  /* Ignore empty set.  */
+  if (!elt)
+    return;
+  
+  windex = elt->index;
+  for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
     {
-    case BITSET_OP_COPY:
+      /* Create new elements for dst if they cannot be found
-      lbitset_copy (dst, src);
+	 or substitute zero elements if src elements not found.  */
-      break;
+      selt = lbitset_elt_find (src, i, LBITSET_SUBST);
-
+      delt = lbitset_elt_find (dst, i, LBITSET_CREATE);
-    case BITSET_OP_NOT:
+      
-      /* This is another unfriendly operation for a linked list
+      for (j = 0; j < LBITSET_ELT_WORDS; j++)
-	 bitset!  */
+	delt->words[j] = ~selt->words[j];
-      elt = LBITSET_TAIL (dst);
-      /* Ignore empty set.  */
-      if (!elt)
-	return 0;
-
-      windex = elt->index;
-      for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
-	{
-	  /* Create new elements for dst if they cannot be found
-	     or substitute zero elements if src elements not found.  */
-	  selt = lbitset_elt_find (dst, i, LBITSET_SUBST);
-	  delt = lbitset_elt_find (dst, i, LBITSET_CREATE);
-
-	  for (j = 0; j < LBITSET_ELT_WORDS; j++)
-	    delt->words[j] = ~selt->words[j];
-	}
-      lbitset_weed (dst);
-      break;
-
-      /* Return 1 if DST == SRC.  */
-    case BITSET_OP_EQUAL_P:
-      return lbitset_equal_p (dst, src);
-      break;
-
-      /* Return 1 if DST == DST | SRC.  */
-    case BITSET_OP_SUBSET_P:
-      for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
-	   selt || delt; selt = selt->next, delt = delt->next)
-	{
-	  if (!selt)
-	    selt = &lbitset_zero_elts[0];
-	  else if (!delt)
-	    delt = &lbitset_zero_elts[0];
-	  else if (selt->index != delt->index)
-	    {
-	      if (selt->index < delt->index)
-		{
-		  lbitset_zero_elts[2].next = delt;
-		  delt = &lbitset_zero_elts[2];
-		}
-	      else
-		{
-		  lbitset_zero_elts[1].next = selt;
-		  selt = &lbitset_zero_elts[1];
-		}
-	    }
-
-	  for (j = 0; j < LBITSET_ELT_WORDS; j++)
-	    if (delt->words[j] != (selt->words[j] | delt->words[j]))
-	      return 0;
-	}
-      break;
-
-      /* Return 1 if DST & SRC == 0.  */
-    case BITSET_OP_DISJOINT_P:
-      for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
-	   selt && delt; selt = selt->next, delt = delt->next)
-	{
-	  if (selt->index != delt->index)
-	    {
-	      if (selt->index < delt->index)
-		{
-		  lbitset_zero_elts[2].next = delt;
-		  delt = &lbitset_zero_elts[2];
-		}
-	      else
-		{
-		  lbitset_zero_elts[1].next = selt;
-		  selt = &lbitset_zero_elts[1];
-		}
-	      /* Since the elements are different, there is no
-		 intersection of these elements.  */
-	      continue;
-	    }
-
-	  for (j = 0; j < LBITSET_ELT_WORDS; j++)
-	    if (selt->words[j] & delt->words[j])
-	      return 0;
-	}
-      break;
-
-    default:
-      abort ();
     }
+  lbitset_weed (dst);
+  return;
+}
 
+
+/* Return 1 if DST == DST | SRC.  */
+static int
+lbitset_subset_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  lbitset_elt *selt;
+  lbitset_elt *delt;
+  unsigned int j;
+
+  for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
+       selt || delt; selt = selt->next, delt = delt->next)
+    {
+      if (!selt)
+	selt = &lbitset_zero_elts[0];
+      else if (!delt)
+	delt = &lbitset_zero_elts[0];
+      else if (selt->index != delt->index)
+	{
+	  if (selt->index < delt->index)
+	    {
+	      lbitset_zero_elts[2].next = delt;
+	      delt = &lbitset_zero_elts[2];
+	    }
+	  else
+	    {
+	      lbitset_zero_elts[1].next = selt;
+	      selt = &lbitset_zero_elts[1];
+	    }
+	}
+      
+      for (j = 0; j < LBITSET_ELT_WORDS; j++)
+	if (delt->words[j] != (selt->words[j] | delt->words[j]))
+	  return 0;
+    }
+  return 1;
+}
+
+
+/* Return 1 if DST & SRC == 0.  */
+static int
+lbitset_disjoint_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  lbitset_elt *selt;
+  lbitset_elt *delt;
+  unsigned int j;
+
+  for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
+       selt && delt; selt = selt->next, delt = delt->next)
+    {
+      if (selt->index != delt->index)
+	{
+	  if (selt->index < delt->index)
+	    {
+	      lbitset_zero_elts[2].next = delt;
+	      delt = &lbitset_zero_elts[2];
+	    }
+	  else
+	    {
+	      lbitset_zero_elts[1].next = selt;
+	      selt = &lbitset_zero_elts[1];
+	    }
+	  /* Since the elements are different, there is no
+	     intersection of these elements.  */
+	  continue;
+	}
+      
+      for (j = 0; j < LBITSET_ELT_WORDS; j++)
+	if (selt->words[j] & delt->words[j])
+	  return 0;
+    }
   return 1;
 }
 
 
 static int
-lbitset_op3 (dst, src1, src2, op)
+lbitset_op3_cmp (dst, src1, src2, op)
      bitset dst;
      bitset src1;
      bitset src2;
@@ -1104,37 +1111,6 @@ lbitset_op3 (dst, src1, src2, op)
   int changed = 0;
   unsigned int i;
 
-  /* Fast track common, simple cases.  */
-  if (!selt2)
-    {
-      if (op == BITSET_OP_AND)
-	{
-	  lbitset_weed (dst);
-	  changed = !LBITSET_HEAD (dst);
-	  lbitset_zero (dst);
-	  return changed;
-	}
-      else if (op == BITSET_OP_ANDN || op == BITSET_OP_OR
-	       || op == BITSET_OP_XOR)
-	{
-	  return lbitset_copy_compare (dst, src1);
-	}
-    }
-  else if (!selt1)
-    {
-      if (op == BITSET_OP_AND || op == BITSET_OP_ANDN)
-	{
-	  lbitset_weed (dst);
-	  changed = !LBITSET_HEAD (dst);
-	  lbitset_zero (dst);
-	  return changed;
-	}
-      else if (op == BITSET_OP_OR || op == BITSET_OP_XOR)
-	{
-	  return lbitset_copy_compare (dst, src2);
-	}
-    }
-
   LBITSET_HEAD (dst) = 0;
   dst->b.csize = 0;
 
@@ -1275,18 +1251,134 @@ lbitset_op3 (dst, src1, src2, op)
 }
 
 
+static int
+lbitset_and_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  lbitset_elt *selt1 = LBITSET_HEAD (src1);
+  lbitset_elt *selt2 = LBITSET_HEAD (src2);
+  int changed;
+
+  if (!selt2)
+    {
+      lbitset_weed (dst);
+      changed = !LBITSET_HEAD (dst);
+      lbitset_zero (dst);
+      return changed;
+    }
+  else if (!selt1)
+    {
+      lbitset_weed (dst);
+      changed = !LBITSET_HEAD (dst);
+      lbitset_zero (dst);
+      return changed;
+    }
+  return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_AND);
+}
+
+
+static int
+lbitset_andn_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  lbitset_elt *selt1 = LBITSET_HEAD (src1);
+  lbitset_elt *selt2 = LBITSET_HEAD (src2);
+  int changed;
+
+  if (!selt2)
+    {
+      return lbitset_copy_cmp (dst, src1);
+    }
+  else if (!selt1)
+    {
+      lbitset_weed (dst);
+      changed = !LBITSET_HEAD (dst);
+      lbitset_zero (dst);
+      return changed;
+    }
+  return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_ANDN);
+}
+
+
+static int
+lbitset_or_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  lbitset_elt *selt1 = LBITSET_HEAD (src1);
+  lbitset_elt *selt2 = LBITSET_HEAD (src2);
+
+  if (!selt2)
+    {
+      return lbitset_copy_cmp (dst, src1);
+    }
+  else if (!selt1)
+    {
+      return lbitset_copy_cmp (dst, src2);
+    }
+  return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_OR);
+}
+
+
+static int
+lbitset_xor_cmp (dst, src1, src2)
+     bitset dst;
+     bitset src1;
+     bitset src2;
+{
+  lbitset_elt *selt1 = LBITSET_HEAD (src1);
+  lbitset_elt *selt2 = LBITSET_HEAD (src2);
+
+  if (!selt2)
+    {
+      return lbitset_copy_cmp (dst, src1);
+    }
+  else if (!selt1)
+    {
+      return lbitset_copy_cmp (dst, src2);
+    }
+  return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_XOR);
+}
+
+
+
 /* Vector of operations for linked-list bitsets.  */
-struct bitset_ops_struct lbitset_ops = {
+struct bitset_vtable lbitset_vtable = {
   lbitset_set,
   lbitset_reset,
+  bitset_toggle_,
   lbitset_test,
   lbitset_size,
-  lbitset_op1,
+  bitset_count_,
-  lbitset_op2,
+  lbitset_empty_p,
-  lbitset_op3,
+  lbitset_ones,
-  bitset_op4,
+  lbitset_zero,
+  lbitset_copy,
+  lbitset_disjoint_p,
+  lbitset_equal_p,
+  lbitset_not,
+  lbitset_subset_p,
+  (PFV) lbitset_and_cmp,
+  lbitset_and_cmp,
+  (PFV) lbitset_andn_cmp,
+  lbitset_andn_cmp,
+  (PFV) lbitset_or_cmp,
+  lbitset_or_cmp,
+  (PFV) lbitset_xor_cmp,
+  lbitset_xor_cmp,
+  (PFV) bitset_and_or_cmp_,
+  bitset_and_or_cmp_,
+  (PFV) bitset_andn_or_cmp_,
+  bitset_andn_or_cmp_,
+  (PFV) bitset_or_and_cmp_,
+  bitset_or_and_cmp_,
   lbitset_list,
-  lbitset_reverse_list,
+  lbitset_list_reverse,
   lbitset_free,
   BITSET_LIST
 };
@@ -1302,13 +1394,12 @@ lbitset_bytes (n_bits)
 
 
 /* Initialize a bitset.  */
-
 bitset
 lbitset_init (bset, n_bits)
      bitset bset;
      bitset_bindex n_bits ATTRIBUTE_UNUSED;
 {
-  bset->b.ops = &lbitset_ops;
+  bset->b.vtable = &lbitset_vtable;
   return bset;
 }
 
@@ -1323,3 +1414,34 @@ lbitset_release_memory ()
       obstack_free (&lbitset_obstack, NULL);
     }
 }
+
+
+/* Function to be called from debugger to debug lbitset.  */
+void
+debug_lbitset (bset)
+     bitset bset;
+{
+  lbitset_elt *elt;
+  unsigned int i;
+
+  if (!bset)
+    return;
+  
+  for (elt = LBITSET_HEAD (bset); elt; elt = elt->next)
+    {
+      fprintf (stderr, "Elt %d\n", elt->index);
+      for (i = 0; i < LBITSET_ELT_WORDS; i++)
+	{
+	  unsigned int j;
+	  bitset_word word;
+	  
+	  word = elt->words[i];
+	  
+	  fprintf (stderr, "  Word %d:", i);
+	  for (j = 0; j < LBITSET_WORD_BITS; j++)
+	    if ((word & (1 << j)))
+	      fprintf (stderr, " %d", j);
+	  fprintf (stderr, "\n");
+	}
+    }
+}