(bitset_iterator.num, bitset_iterator.i, bitset_first, bitset_last):
[bison.git] / lib / lbitset.c
index 39e5b4e56ab8f89cff9a7e3d043638747d67986b..5ce9e903de96053d5c5e05406277a1dc8ee21711 100644 (file)
 
    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.  */
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+*/
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
-#include "bbitset.h"
+#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
@@ -39,9 +41,7 @@
    but the more memory wasted for sparse bitsets and the longer the time
    to search for set bits.  */
 
-#ifndef LBITSET_ELT_WORDS
 #define LBITSET_ELT_WORDS 2
-#endif
 
 typedef bitset_word lbitset_word;
 
@@ -79,10 +79,13 @@ struct bitset_struct
 };
 
 
+typedef void(*PFV)();
+
+
 enum lbitset_find_mode
   { LBITSET_FIND, LBITSET_CREATE, LBITSET_SUBST };
 
-static lbitset_elt lbitset_zero_elts[3];       /* Elements of all zero bits.  */
+static lbitset_elt lbitset_zero_elts[3]; /* Elements of all zero bits.  */
 
 /* Obstack to allocate bitset elements from.  */
 static struct obstack lbitset_obstack;
@@ -103,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_op2 PARAMS ((bitset, bitset, enum bitset_ops));
-static int lbitset_op3 PARAMS ((bitset, bitset, bitset, enum bitset_ops));
+static int lbitset_op3_cmp 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));
 
@@ -138,9 +139,6 @@ lbitset_elt_alloc ()
     }
   else
     {
-      /* We can't use gcc_obstack_init to initialize the obstack since
-        print-rtl.c now calls bitset functions, and bitset is linked
-        into the gen* functions.  */
       if (!lbitset_obstack_init)
        {
          lbitset_obstack_init = 1;
@@ -183,7 +181,7 @@ lbitset_elt_alloc ()
 }
 
 
-/* Allocate a lbitset element.  The bits are not cleared.  */
+/* Allocate a lbitset element.  The bits are cleared.  */
 static inline lbitset_elt *
 lbitset_elt_calloc ()
 {
@@ -306,7 +304,7 @@ lbitset_elt_link (bset, elt)
      bitset bset;
      lbitset_elt *elt;
 {
-  bitset_windex index = elt->index;
+  bitset_windex windex = elt->index;
   lbitset_elt *ptr;
   lbitset_elt *current;
 
@@ -325,10 +323,10 @@ lbitset_elt_link (bset, elt)
 
   /* If this index is less than that of the current element, it goes
      somewhere before the current element.  */
-  else if (index < bset->b.cindex)
+  else if (windex < bset->b.cindex)
     {
       for (ptr = current;
-          ptr->prev && ptr->prev->index > index; ptr = ptr->prev)
+          ptr->prev && ptr->prev->index > windex; ptr = ptr->prev)
        continue;
 
       if (ptr->prev)
@@ -345,7 +343,7 @@ lbitset_elt_link (bset, elt)
   else
     {
       for (ptr = current;
-          ptr->next && ptr->next->index < index; ptr = ptr->next)
+          ptr->next && ptr->next->index < windex; ptr = ptr->next)
        continue;
 
       if (ptr->next)
@@ -359,16 +357,16 @@ lbitset_elt_link (bset, elt)
     }
 
   /* Set up so this is the first element searched.  */
-  bset->b.cindex = index;
+  bset->b.cindex = windex;
   bset->b.csize = LBITSET_ELT_WORDS;
   bset->b.cdata = elt->words;
 }
 
 
 static lbitset_elt *
-lbitset_elt_find (bset, index, mode)
+lbitset_elt_find (bset, windex, mode)
      bitset bset;
-     bitset_windex index;
+     bitset_windex windex;
      enum lbitset_find_mode mode;
 {
   lbitset_elt *elt;
@@ -378,7 +376,7 @@ lbitset_elt_find (bset, index, mode)
     {
       current = LBITSET_CURRENT (bset);
       /* Check if element is the cached element.  */
-      if ((index - bset->b.cindex) < bset->b.csize)
+      if ((windex - bset->b.cindex) < bset->b.csize)
        return current;
     }
   else
@@ -388,23 +386,23 @@ lbitset_elt_find (bset, index, mode)
 
   if (current)
     {
-      if (index < bset->b.cindex)
+      if (windex < bset->b.cindex)
        {
          for (elt = current;
-              elt->prev && elt->index > index; elt = elt->prev)
+              elt->prev && elt->index > windex; elt = elt->prev)
            continue;
        }
       else
        {
          for (elt = current;
-              elt->next && (elt->index + LBITSET_ELT_WORDS - 1) < index;
+              elt->next && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
               elt = elt->next)
            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 && (index - elt->index) < LBITSET_ELT_WORDS)
+      if (elt && (windex - elt->index) < LBITSET_ELT_WORDS)
        {
          bset->b.cindex = elt->index;
          bset->b.csize = LBITSET_ELT_WORDS;
@@ -419,10 +417,10 @@ lbitset_elt_find (bset, index, mode)
       return 0;
 
     case LBITSET_CREATE:
-      index = (index / (unsigned) LBITSET_ELT_WORDS) * LBITSET_ELT_WORDS;
+      windex = (windex / (unsigned) LBITSET_ELT_WORDS) * LBITSET_ELT_WORDS;
 
       elt = lbitset_elt_calloc ();
-      elt->index = index;
+      elt->index = windex;
       lbitset_elt_link (bset, elt);
       return elt;
 
@@ -453,7 +451,7 @@ lbitset_weed (bset)
 
 
 /* Set all bits in the bitset to zero.  */
-static inline void
+static void
 lbitset_zero (bset)
      bitset bset;
 {
@@ -468,6 +466,7 @@ lbitset_zero (bset)
 }
 
 
+/* Return 1 if DST == SRC.  */
 static inline int
 lbitset_equal_p (dst, src)
      bitset dst;
@@ -542,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;
 {
@@ -585,11 +584,12 @@ lbitset_set (dst, bitno)
      bitset dst;
      bitset_bindex bitno;
 {
-  bitset_windex index = bitno / BITSET_WORD_BITS;
+  bitset_windex windex = bitno / BITSET_WORD_BITS;
 
-  lbitset_elt_find (dst, index, LBITSET_CREATE);
+  lbitset_elt_find (dst, windex, LBITSET_CREATE);
 
-  dst->b.cdata[index - dst->b.cindex] |= (1 << (bitno % BITSET_WORD_BITS));
+  dst->b.cdata[windex - dst->b.cindex] |=
+    (bitset_word) 1 << (bitno % BITSET_WORD_BITS);
 }
 
 
@@ -599,12 +599,13 @@ lbitset_reset (dst, bitno)
      bitset dst;
      bitset_bindex bitno;
 {
-  bitset_windex index = bitno / BITSET_WORD_BITS;
+  bitset_windex windex = bitno / BITSET_WORD_BITS;
 
-  if (!lbitset_elt_find (dst, index, LBITSET_FIND))
+  if (!lbitset_elt_find (dst, windex, LBITSET_FIND))
     return;
 
-  dst->b.cdata[index - dst->b.cindex] &= ~(1 << (bitno % BITSET_WORD_BITS));
+  dst->b.cdata[windex - dst->b.cindex] &=
+    ~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
 
   /* If all the data is zero, perhaps we should unlink it now...  */
 }
@@ -616,13 +617,13 @@ lbitset_test (src, bitno)
      bitset src;
      bitset_bindex bitno;
 {
-  bitset_windex index = bitno / BITSET_WORD_BITS;
+  bitset_windex windex = bitno / BITSET_WORD_BITS;
 
-  if (!lbitset_elt_find (src, index, LBITSET_FIND))
+  if (!lbitset_elt_find (src, windex, LBITSET_FIND))
     return 0;
 
-  return (src->b.
-         cdata[index - src->b.cindex] >> (bitno % BITSET_WORD_BITS)) & 1;
+  return (src->b.cdata[windex - src->b.cindex] 
+         >> (bitno % BITSET_WORD_BITS)) & 1;
 }
 
 
@@ -638,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;
@@ -646,9 +647,9 @@ lbitset_reverse_list (bset, list, num, next)
 {
   bitset_bindex rbitno;
   bitset_bindex bitno;
-  unsigned int bitcnt;
-  bitset_bindex bitoff;
-  bitset_windex index;
+  unsigned int bcount;
+  bitset_bindex boffset;
+  bitset_windex windex;
   bitset_bindex count;
   lbitset_elt *elt;
   bitset_word word;
@@ -666,41 +667,52 @@ lbitset_reverse_list (bset, list, num, next)
 
   bitno = n_bits - (rbitno + 1);
 
-  index = bitno / BITSET_WORD_BITS;
+  windex = bitno / BITSET_WORD_BITS;
 
   /* Skip back to starting element.  */
-  for (; elt && elt->index > index; elt = elt->prev)
+  for (; elt && elt->index > windex; elt = elt->prev)
     continue;
 
   if (!elt)
     return 0;
 
-  /* If num is 1, we could speed things up with a binary search
-     of the word of interest.  */
+  if (windex >= elt->index + LBITSET_ELT_WORDS)
+    {
+      /* 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;
-  bitcnt = bitno % BITSET_WORD_BITS;
-  bitoff = index * 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;
 
-      for (; (index - elt->index) < LBITSET_ELT_WORDS;
-          index--, bitoff -= BITSET_WORD_BITS,
-            bitcnt = BITSET_WORD_BITS - 1)
+      for (; (windex - elt->index) < LBITSET_ELT_WORDS;
+          windex--, boffset -= BITSET_WORD_BITS,
+            bcount = BITSET_WORD_BITS - 1)
        {
          word =
-           srcp[index - elt->index] << (BITSET_WORD_BITS - 1 - bitcnt);
+           srcp[windex - elt->index] << (BITSET_WORD_BITS - 1 - bcount);
 
-         for (; word; bitcnt--)
+         for (; word; bcount--)
            {
              if (word & BITSET_MSB)
                {
-                 list[count++] = bitoff + bitcnt;
+                 list[count++] = boffset + bcount;
                  if (count >= num)
                    {
-                     *next = n_bits - (bitoff + bitcnt);
+                     *next = n_bits - (boffset + bcount);
                      return count;
                    }
                }
@@ -711,12 +723,12 @@ lbitset_reverse_list (bset, list, num, next)
       elt = elt->prev;
       if (elt)
        {
-         index = elt->index + LBITSET_ELT_WORDS - 1;
-         bitoff = index * BITSET_WORD_BITS;
+         windex = elt->index + LBITSET_ELT_WORDS - 1;
+         boffset = windex * BITSET_WORD_BITS;
        }
     }
 
-  *next = n_bits - (bitoff + 1);
+  *next = n_bits - (boffset + 1);
   return count;
 }
 
@@ -732,7 +744,7 @@ lbitset_list (bset, list, num, next)
      bitset_bindex *next;
 {
   bitset_bindex bitno;
-  bitset_windex index;
+  bitset_windex windex;
   bitset_bindex count;
   lbitset_elt *elt;
   lbitset_elt *head;
@@ -751,26 +763,26 @@ lbitset_list (bset, list, num, next)
 
       /* Start with the first element.  */
       elt = head;
-      index = elt->index;
-      bitno = index * BITSET_WORD_BITS;
+      windex = elt->index;
+      bitno = windex * BITSET_WORD_BITS;
     }
   else
     {
-      index = bitno / BITSET_WORD_BITS;
+      windex = bitno / BITSET_WORD_BITS;
 
       /* Skip to starting element.  */
       for (elt = head;
-          elt && (elt->index + LBITSET_ELT_WORDS - 1) < index;
+          elt && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
           elt = elt->next)
        continue;
 
       if (!elt)
        return 0;
 
-      if (index < elt->index)
+      if (windex < elt->index)
        {
-         index = elt->index;
-         bitno = index * BITSET_WORD_BITS;
+         windex = elt->index;
+         bitno = windex * BITSET_WORD_BITS;
        }
       else
        {
@@ -778,9 +790,9 @@ lbitset_list (bset, list, num, next)
 
          /* We are starting within an element.  */
 
-         for (; (index - elt->index) < LBITSET_ELT_WORDS; index++)
+         for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++)
            {
-             word = srcp[index - elt->index] >> (bitno % BITSET_WORD_BITS);
+             word = srcp[windex - elt->index] >> (bitno % BITSET_WORD_BITS);
 
              for (; word; bitno++)
                {
@@ -795,14 +807,14 @@ lbitset_list (bset, list, num, next)
                    }
                  word >>= 1;
                }
-             bitno = (index + 1) * BITSET_WORD_BITS;
+             bitno = (windex + 1) * BITSET_WORD_BITS;
            }
 
          elt = elt->next;
          if (elt)
            {
-             index = elt->index;
-             bitno = index * BITSET_WORD_BITS;
+             windex = elt->index;
+             bitno = windex * BITSET_WORD_BITS;
            }
        }
     }
@@ -841,8 +853,8 @@ lbitset_list (bset, list, num, next)
                  word >>= 1;
                }
            }
-         index++;
-         bitno = index * BITSET_WORD_BITS;
+         windex++;
+         bitno = windex * BITSET_WORD_BITS;
 
          word = srcp[1];
          if (word)
@@ -859,8 +871,8 @@ lbitset_list (bset, list, num, next)
                  word >>= 1;
                }
            }
-         index++;
-         bitno = index * BITSET_WORD_BITS;
+         windex++;
+         bitno = windex * BITSET_WORD_BITS;
 #else
          for (i = 0; i < LBITSET_ELT_WORDS; i++)
            {
@@ -884,8 +896,8 @@ lbitset_list (bset, list, num, next)
                      word >>= 1;
                    }
                }
-             index++;
-             bitno = index * BITSET_WORD_BITS;
+             windex++;
+             bitno = windex * BITSET_WORD_BITS;
            }
 #endif
        }
@@ -909,16 +921,16 @@ lbitset_list (bset, list, num, next)
                    }
                  word >>= 1;
                }
-             index++;
-             bitno = index * BITSET_WORD_BITS;
+             windex++;
+             bitno = windex * BITSET_WORD_BITS;
            }
        }
 
       elt = elt->next;
       if (elt)
        {
-         index = elt->index;
-         bitno = index * BITSET_WORD_BITS;
+         windex = elt->index;
+         bitno = windex * BITSET_WORD_BITS;
        }
     }
 
@@ -928,161 +940,157 @@ 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 index;
+  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:
-      lbitset_zero (dst);
-      break;
-
-    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;
-
-      index = elt->index;
-      for (i = 0; i < index; i += LBITSET_ELT_WORDS)
-       {
-         /* Create new elements if they cannot be found.  */
-         elt = lbitset_elt_find (dst, i, LBITSET_CREATE);
-         memset (elt->words, ~0, sizeof (elt->words));
-       }
-      break;
-
-    case BITSET_OP_EMPTY_P:
-      lbitset_weed (dst);
-      if (LBITSET_HEAD (dst))
-       return 0;
-      break;
-
-    default:
-      abort ();
+      /* Create new elements if they cannot be found.  */
+      elt = lbitset_elt_find (dst, i, LBITSET_CREATE);
+      memset (elt->words, -1, sizeof (elt->words));
     }
-
-  return 1;
 }
 
 
-static int
-lbitset_op2 (dst, src, op)
+static void
+lbitset_not (dst, src)
      bitset dst;
      bitset src;
-     enum bitset_ops op;
 {
   lbitset_elt *elt;
   lbitset_elt *selt;
   lbitset_elt *delt;
   unsigned int i;
   unsigned int j;
-  bitset_windex index;
+  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:
-      lbitset_copy (dst, src);
-      break;
-
-    case BITSET_OP_NOT:
-      /* This is another unfriendly operation for a linked list
-        bitset!  */
-      elt = LBITSET_TAIL (dst);
-      /* Ignore empty set.  */
-      if (!elt)
-       return 0;
-
-      index = elt->index;
-      for (i = 0; i < index; 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);
+      /* Create new elements for dst if they cannot be found
+        or substitute zero elements if src elements not found.  */
+      selt = lbitset_elt_find (src, 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);
+  return;
+}
 
-         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.  */
+static int
+lbitset_subset_p (dst, src)
+     bitset dst;
+     bitset src;
+{
+  lbitset_elt *selt;
+  lbitset_elt *delt;
+  unsigned int j;
 
-      /* 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)
+  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)
-           selt = &lbitset_zero_elts[0];
-         else if (!delt)
-           delt = &lbitset_zero_elts[0];
-         else if (selt->index != delt->index)
+         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];
-               }
+             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;
+      
+      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;
 
-      /* 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)
+  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)
+         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];
-               }
+             lbitset_zero_elts[2].next = delt;
+             delt = &lbitset_zero_elts[2];
            }
-
-         for (j = 0; j < LBITSET_ELT_WORDS; j++)
-           if (selt->words[j] & delt->words[j])
-             return 0;
+         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;
        }
-      break;
-
-    default:
-      abort ();
+      
+      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;
@@ -1091,9 +1099,9 @@ lbitset_op3 (dst, src1, src2, op)
   lbitset_elt *selt1 = LBITSET_HEAD (src1);
   lbitset_elt *selt2 = LBITSET_HEAD (src2);
   lbitset_elt *delt = LBITSET_HEAD (dst);
-  bitset_windex index1;
-  bitset_windex index2;
-  bitset_windex index;
+  bitset_windex windex1;
+  bitset_windex windex2;
+  bitset_windex windex;
   lbitset_elt *stmp1;
   lbitset_elt *stmp2;
   lbitset_elt *dtmp;
@@ -1103,84 +1111,53 @@ 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;
 
-  index1 = (selt1) ? selt1->index : BITSET_INDEX_MAX;
-  index2 = (selt2) ? selt2->index : BITSET_INDEX_MAX;
+  windex1 = (selt1) ? selt1->index : BITSET_INDEX_MAX;
+  windex2 = (selt2) ? selt2->index : BITSET_INDEX_MAX;
 
   while (selt1 || selt2)
     {
       /* Figure out whether we need to substitute zero elements for
         missing links.  */
-      if (index1 == index2)
+      if (windex1 == windex2)
        {
-         index = index1;
+         windex = windex1;
          stmp1 = selt1;
          stmp2 = selt2;
          selt1 = selt1->next;
-         index1 = (selt1) ? selt1->index : BITSET_INDEX_MAX;
+         windex1 = (selt1) ? selt1->index : BITSET_INDEX_MAX;
          selt2 = selt2->next;
-         index2 = (selt2) ? selt2->index : BITSET_INDEX_MAX;
+         windex2 = (selt2) ? selt2->index : BITSET_INDEX_MAX;
        }
-      else if (index1 < index2)
+      else if (windex1 < windex2)
        {
-         index = index1;
+         windex = windex1;
          stmp1 = selt1;
          stmp2 = &lbitset_zero_elts[0];
          selt1 = selt1->next;
-         index1 = (selt1) ? selt1->index : BITSET_INDEX_MAX;
+         windex1 = (selt1) ? selt1->index : BITSET_INDEX_MAX;
        }
       else
        {
-         index = index2;
+         windex = windex2;
          stmp1 = &lbitset_zero_elts[0];
          stmp2 = selt2;
          selt2 = selt2->next;
-         index2 = (selt2) ? selt2->index : BITSET_INDEX_MAX;
+         windex2 = (selt2) ? selt2->index : BITSET_INDEX_MAX;
        }
 
       /* Find the appropriate element from DST.  Begin by discarding
         elements that we've skipped.  */
-      while (delt && delt->index < index)
+      while (delt && delt->index < windex)
        {
          changed = 1;
          dtmp = delt;
          delt = delt->next;
          lbitset_elt_free (dtmp);
        }
-      if (delt && delt->index == index)
+      if (delt && delt->index == windex)
        {
          dtmp = delt;
          delt = delt->next;
@@ -1247,26 +1224,13 @@ lbitset_op3 (dst, src1, src2, op)
            }
          break;
 
-       case BITSET_OP_ORN:
-         for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
-           {
-             bitset_word tmp = *srcp1++ | ~(*srcp2++);
-
-             if (*dstp != tmp)
-               {
-                 changed = 1;
-                 *dstp = tmp;
-               }
-           }
-         break;
-
        default:
          abort ();
        }
 
       if (!lbitset_elt_zero_p (dtmp))
        {
-         dtmp->index = index;
+         dtmp->index = windex;
          /* Perhaps this could be optimised...  */
          lbitset_elt_link (dst, dtmp);
        }
@@ -1287,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,
-  lbitset_op2,
-  lbitset_op3,
-  bitset_op4,
+  bitset_count_,
+  lbitset_empty_p,
+  lbitset_ones,
+  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
 };
@@ -1314,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;
 }
 
@@ -1335,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");
+       }
+    }
+}