]> git.saurik.com Git - bison.git/blobdiff - lib/bitset_stats.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(relation_transpose): Rewrite to avoid bogus complaint
[bison.git] / lib / bitset_stats.c
diff --git a/lib/bitset_stats.c b/lib/bitset_stats.c
index 47dec487d21a02d646a0059464c928517b962700..48cf5c747f1223d90839bc0061ce32e5614ce6df 100644 (file)
--- a/lib/bitset_stats.c
+++ b/lib/bitset_stats.c
@@ -1,5 +1,5 @@
 /* Bitset statistics.
 /* Bitset statistics.
-   Copyright (C) 2002 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 
    This program is free software; you can redistribute it and/or modify
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 
    This program is free software; you can redistribute it and/or modify
@@ -14,7 +14,7 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
 /* This file is a wrapper bitset implementation for the other bitset
 */
 
 /* This file is a wrapper bitset implementation for the other bitset
@@ -22,7 +22,7 @@
    statistics gathering without having to instrument the bitset
    implementations.  When statistics gathering is enabled, the bitset
    operations get vectored through here and we then call the appropriate
    statistics gathering without having to instrument the bitset
    implementations.  When statistics gathering is enabled, the bitset
    operations get vectored through here and we then call the appropriate
-   routines.  
+   routines.
 */
 
 #ifdef HAVE_CONFIG_H
 */
 
 #ifdef HAVE_CONFIG_H
@@ -33,11 +33,14 @@
 #include "abitset.h"
 #include "ebitset.h"
 #include "lbitset.h"
 #include "abitset.h"
 #include "ebitset.h"
 #include "lbitset.h"
+#include "vbitset.h"
 #include "bitset_stats.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "bitset_stats.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
+#include "gettext.h"
+#define _(Msgid)  gettext (Msgid)
 
 /* Configuration macros.  */
 #define BITSET_STATS_FILE "bitset.dat"
 
 /* Configuration macros.  */
 #define BITSET_STATS_FILE "bitset.dat"
@@ -73,19 +76,6 @@
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_density[(I)]++
 
 
     bitset_stats_info->types[BITSET_TYPE_ (BSET)].list_density[(I)]++
 
 
-typedef struct bitset_stats_struct
-{
-  bitset bset;
-} *bitset_stats;
-
-
-struct bitset_struct
-{
-  struct bbitset_struct b;
-  struct bitset_stats_struct s;
-};
-
-
 struct bitset_type_info_struct
 {
   unsigned int allocs;
 struct bitset_type_info_struct
 {
   unsigned int allocs;
@@ -111,44 +101,13 @@ struct bitset_stats_info_struct
 
 struct bitset_stats_info_struct bitset_stats_info_data;
 struct bitset_stats_info_struct *bitset_stats_info;
 
 struct bitset_stats_info_struct bitset_stats_info_data;
 struct bitset_stats_info_struct *bitset_stats_info;
-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_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
-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 *,
-                                                   const char *,
-                                                   unsigned int,
-                                                   unsigned int *));
-static void bitset_log_histogram_print PARAMS ((FILE *, const char *,
-                                               const char *,
-                                               unsigned int,
-                                               unsigned int *));
-static void bitset_stats_print_1
-PARAMS ((FILE *, const char *, struct bitset_type_info_struct *));
-static void bitset_stats_print PARAMS ((FILE *, int));
+bool bitset_stats_enabled = false;
 
 
 /* Print a percentage histogram with message MSG to FILE.  */
 static void
 
 
 /* Print a percentage histogram with message MSG to FILE.  */
 static void
-bitset_percent_histogram_print (file, name, msg, n_bins, bins)
-     FILE *file;
-     const char *name;
-     const char *msg;
-     unsigned int n_bins;
-     unsigned int *bins;
+bitset_percent_histogram_print (FILE *file, const char *name, const char *msg,
+                               unsigned int n_bins, unsigned int *bins)
 {
   unsigned int i;
   unsigned int total;
 {
   unsigned int i;
   unsigned int total;
@@ -162,7 +121,7 @@ bitset_percent_histogram_print (file, name, msg, n_bins, bins)
 
   fprintf (file, "%s %s", name, msg);
   for (i = 0; i < n_bins; i++)
 
   fprintf (file, "%s %s", name, msg);
   for (i = 0; i < n_bins; i++)
-    fprintf (file, "%.0f-%.0f%%\t%8d (%5.1f%%)\n",
+    fprintf (file, "%.0f-%.0f%%\t%8u (%5.1f%%)\n",
             i * 100.0 / n_bins,
             (i + 1) * 100.0 / n_bins, bins[i],
             (100.0 * bins[i]) / total);
             i * 100.0 / n_bins,
             (i + 1) * 100.0 / n_bins, bins[i],
             (100.0 * bins[i]) / total);
@@ -171,17 +130,12 @@ bitset_percent_histogram_print (file, name, msg, n_bins, bins)
 
 /* Print a log histogram with message MSG to FILE.  */
 static void
 
 /* Print a log histogram with message MSG to FILE.  */
 static void
-bitset_log_histogram_print (file, name, msg, n_bins, bins)
-     FILE *file;
-     const char *name;
-     const char *msg;
-     unsigned int n_bins;
-     unsigned int *bins;
+bitset_log_histogram_print (FILE *file, const char *name, const char *msg,
+                           unsigned int n_bins, unsigned int *bins)
 {
   unsigned int i;
   unsigned int total;
   unsigned int max_width;
 {
   unsigned int i;
   unsigned int total;
   unsigned int max_width;
-  unsigned int last_bin;
 
   total = 0;
   for (i = 0; i < n_bins; i++)
 
   total = 0;
   for (i = 0; i < n_bins; i++)
@@ -190,112 +144,110 @@ bitset_log_histogram_print (file, name, msg, n_bins, bins)
   if (!total)
     return;
 
   if (!total)
     return;
 
+  /* Determine number of useful bins.  */
   for (i = n_bins; i > 3 && ! bins[i - 1]; i--)
      continue;
   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;
 
   fprintf (file, "%s %s", name, msg);
   for (i = 0; i < 2; i++)
 
   /* 2 * ceil (log10 (2) * (N - 1)) + 1.  */
   max_width = 2 * (unsigned int) (0.30103 * (n_bins - 1) + 0.9999) + 1;
 
   fprintf (file, "%s %s", name, msg);
   for (i = 0; i < 2; i++)
-    fprintf (file, "%*d\t%8d (%5.1f%%)\n",
+    fprintf (file, "%*d\t%8u (%5.1f%%)\n",
             max_width, i, bins[i], 100.0 * bins[i] / total);
 
             max_width, i, bins[i], 100.0 * bins[i] / total);
 
-  for (; i <= last_bin; i++)
-    fprintf (file, "%*d-%d\t%8d (%5.1f%%)\n",
+  for (; i < n_bins; i++)
+    fprintf (file, "%*lu-%lu\t%8u (%5.1f%%)\n",
             max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
             max_width - ((unsigned int) (0.30103 * (i) + 0.9999) + 1),
-            1 << (i - 1), (1 << i) - 1, bins[i],
+            1UL << (i - 1),
+            (1UL << i) - 1,
+            bins[i],
             (100.0 * bins[i]) / total);
 }
 
 
 /* Print bitset statistics to FILE.  */
 static void
             (100.0 * bins[i]) / total);
 }
 
 
 /* Print bitset statistics to FILE.  */
 static void
-bitset_stats_print_1 (file, name, stats)
-     FILE *file;
-     const char *name;
-     struct bitset_type_info_struct *stats;
+bitset_stats_print_1 (FILE *file, const char *name,
+                     struct bitset_type_info_struct *stats)
 {
   if (!stats)
     return;
 {
   if (!stats)
     return;
-  
+
   fprintf (file, "%s:\n", name);
   fprintf (file, "%s:\n", name);
-  fprintf (file, "%d bitset_allocs, %d freed (%.2f%%).\n",
+  fprintf (file, _("%u bitset_allocs, %u freed (%.2f%%).\n"),
           stats->allocs, stats->frees,
           stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
           stats->allocs, stats->frees,
           stats->allocs ? 100.0 * stats->frees / stats->allocs : 0);
-  fprintf (file, "%d bitset_sets, %d cached (%.2f%%)\n",
+  fprintf (file, _("%u bitset_sets, %u cached (%.2f%%)\n"),
           stats->sets, stats->cache_sets,
           stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
           stats->sets, stats->cache_sets,
           stats->sets ? 100.0 * stats->cache_sets / stats->sets : 0);
-  fprintf (file, "%d bitset_resets, %d cached (%.2f%%)\n",
+  fprintf (file, _("%u bitset_resets, %u cached (%.2f%%)\n"),
           stats->resets, stats->cache_resets,
           stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
           stats->resets, stats->cache_resets,
           stats->resets ? 100.0 * stats->cache_resets / stats->resets : 0);
-  fprintf (file, "%d bitset_tests, %d cached (%.2f%%)\n",
+  fprintf (file, _("%u bitset_tests, %u cached (%.2f%%)\n"),
           stats->tests, stats->cache_tests,
           stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);
 
           stats->tests, stats->cache_tests,
           stats->tests ? 100.0 * stats->cache_tests / stats->tests : 0);
 
-  fprintf (file, "%d bitset_lists\n", stats->lists);
+  fprintf (file, _("%u bitset_lists\n"), stats->lists);
 
 
-  bitset_log_histogram_print (file, name, "count log histogram\n",
+  bitset_log_histogram_print (file, name, _("count log histogram\n"),
                              BITSET_LOG_COUNT_BINS, stats->list_counts);
 
                              BITSET_LOG_COUNT_BINS, stats->list_counts);
 
-  bitset_log_histogram_print (file, name, "size log histogram\n",
+  bitset_log_histogram_print (file, name, _("size log histogram\n"),
                              BITSET_LOG_SIZE_BINS, stats->list_sizes);
 
                              BITSET_LOG_SIZE_BINS, stats->list_sizes);
 
-  bitset_percent_histogram_print (file, name, "density histogram\n",
+  bitset_percent_histogram_print (file, name, _("density histogram\n"),
                                  BITSET_DENSITY_BINS, stats->list_density);
 }
 
 
 /* Print all bitset statistics to FILE.  */
 static void
                                  BITSET_DENSITY_BINS, stats->list_density);
 }
 
 
 /* Print all bitset statistics to FILE.  */
 static void
-bitset_stats_print (file, verbose)
-     FILE *file;
-     int verbose ATTRIBUTE_UNUSED;
+bitset_stats_print (FILE *file, bool verbose ATTRIBUTE_UNUSED)
 {
   int i;
 {
   int i;
-  static const char *names[] = BITSET_TYPE_NAMES;
 
   if (!bitset_stats_info)
     return;
 
 
   if (!bitset_stats_info)
     return;
 
-  fprintf (file, "Bitset statistics:\n\n");
+  fprintf (file, _("Bitset statistics:\n\n"));
 
   if (bitset_stats_info->runs > 1)
 
   if (bitset_stats_info->runs > 1)
-    fprintf (file, "Accumulated runs = %d\n", bitset_stats_info->runs);
+    fprintf (file, _("Accumulated runs = %u\n"), bitset_stats_info->runs);
 
   for (i = 0; i < BITSET_TYPE_NUM; i++)
 
   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]);
 }
 
 
 /* Initialise bitset statistics logging.  */
 void
 }
 
 
 /* Initialise bitset statistics logging.  */
 void
-bitset_stats_enable ()
+bitset_stats_enable (void)
 {
   if (!bitset_stats_info)
     bitset_stats_info = &bitset_stats_info_data;
 {
   if (!bitset_stats_info)
     bitset_stats_info = &bitset_stats_info_data;
-  bitset_stats_enabled = 1;
+  bitset_stats_enabled = true;
 }
 
 
 void
 }
 
 
 void
-bitset_stats_disable ()
+bitset_stats_disable (void)
 {
 {
-  bitset_stats_enabled = 0;
+  bitset_stats_enabled = false;
 }
 
 
 /* Read bitset statistics file.  */
 void
 }
 
 
 /* Read bitset statistics file.  */
 void
-bitset_stats_read (filename)
-     const char *filename;
+bitset_stats_read (const char *filename)
 {
   FILE *file;
 
   if (!bitset_stats_info)
     return;
 {
   FILE *file;
 
   if (!bitset_stats_info)
     return;
-  
+
   if (!filename)
     filename = BITSET_STATS_FILE;
 
   if (!filename)
     filename = BITSET_STATS_FILE;
 
@@ -306,11 +258,12 @@ bitset_stats_read (filename)
                 1, file) != 1)
        {
          if (ferror (file))
                 1, file) != 1)
        {
          if (ferror (file))
-           perror ("Could not read stats file.");
+           perror (_("Could not read stats file."));
          else
          else
-           fprintf (stderr, "Bad stats file size.\n");
+           fprintf (stderr, _("Bad stats file size.\n"));
        }
        }
-      fclose (file);
+      if (fclose (file) != 0)
+       perror (_("Could not read stats file."));
     }
   bitset_stats_info_data.runs++;
 }
     }
   bitset_stats_info_data.runs++;
 }
@@ -318,8 +271,7 @@ bitset_stats_read (filename)
 
 /* Write bitset statistics file.  */
 void
 
 /* Write bitset statistics file.  */
 void
-bitset_stats_write (filename)
-     const char *filename;
+bitset_stats_write (const char *filename)
 {
   FILE *file;
 
 {
   FILE *file;
 
@@ -334,20 +286,20 @@ bitset_stats_write (filename)
     {
       if (fwrite (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
                  1, file) != 1)
     {
       if (fwrite (&bitset_stats_info_data, sizeof (bitset_stats_info_data),
                  1, file) != 1)
-       perror ("Could not write stats file.");
-      fclose (file);
+       perror (_("Could not write stats file."));
+      if (fclose (file) != 0)
+       perror (_("Could not write stats file."));
     }
   else
     }
   else
-    perror ("Could not open stats file for writing.");
+    perror (_("Could not open stats file for writing."));
 }
 
 
 /* Dump bitset statistics to FILE.  */
 void
 }
 
 
 /* Dump bitset statistics to FILE.  */
 void
-bitset_stats_dump (file)
-     FILE *file;
+bitset_stats_dump (FILE *file)
 {
 {
-  bitset_stats_print (file, 0);
+  bitset_stats_print (file, false);
 }
 
 
 }
 
 
@@ -355,24 +307,22 @@ bitset_stats_dump (file)
 void
 debug_bitset_stats (void)
 {
 void
 debug_bitset_stats (void)
 {
-  bitset_stats_print (stderr, 1);
+  bitset_stats_print (stderr, true);
 }
 
 
 static void
 }
 
 
 static void
-bitset_stats_set (dst, bitno)
-     bitset dst;
-     bitset_bindex bitno;
+bitset_stats_set (bitset dst, bitset_bindex bitno)
 {
   bitset bset = dst->s.bset;
 {
   bitset bset = dst->s.bset;
-  bitset_windex index = bitno / BITSET_WORD_BITS;
-  bitset_windex offset = index - bset->b.cindex;
-  
+  bitset_windex wordno = bitno / BITSET_WORD_BITS;
+  bitset_windex offset = wordno - bset->b.cindex;
+
   BITSET_STATS_SETS_INC (bset);
 
   if (offset < bset->b.csize)
     {
   BITSET_STATS_SETS_INC (bset);
 
   if (offset < bset->b.csize)
     {
-      bset->b.cdata[offset] |= (1 << (bitno % BITSET_WORD_BITS));
+      bset->b.cdata[offset] |= (bitset_word) 1 << (bitno % BITSET_WORD_BITS);
       BITSET_STATS_CACHE_SETS_INC (bset);
     }
   else
       BITSET_STATS_CACHE_SETS_INC (bset);
     }
   else
@@ -381,19 +331,18 @@ bitset_stats_set (dst, bitno)
 
 
 static void
 
 
 static void
-bitset_stats_reset (dst, bitno)
-     bitset dst;
-     bitset_bindex bitno;
+bitset_stats_reset (bitset dst, bitset_bindex bitno)
 {
   bitset bset = dst->s.bset;
 {
   bitset bset = dst->s.bset;
-  bitset_windex index = bitno / BITSET_WORD_BITS;
-  bitset_windex offset = index - bset->b.cindex;
-  
+  bitset_windex wordno = bitno / BITSET_WORD_BITS;
+  bitset_windex offset = wordno - bset->b.cindex;
+
   BITSET_STATS_RESETS_INC (bset);
 
   if (offset < bset->b.csize)
     {
   BITSET_STATS_RESETS_INC (bset);
 
   if (offset < bset->b.csize)
     {
-      bset->b.cdata[offset] &= ~(1 << (bitno % BITSET_WORD_BITS));
+      bset->b.cdata[offset] &=
+       ~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
       BITSET_STATS_CACHE_RESETS_INC (bset);
     }
   else
       BITSET_STATS_CACHE_RESETS_INC (bset);
     }
   else
@@ -401,17 +350,22 @@ bitset_stats_reset (dst, bitno)
 }
 
 
 }
 
 
-static int
-bitset_stats_test (src, bitno)
-     bitset src;
-     bitset_bindex bitno;
+static bool
+bitset_stats_toggle (bitset src, bitset_bindex bitno)
+{
+    return BITSET_TOGGLE_ (src->s.bset, bitno);
+}
+
+
+static bool
+bitset_stats_test (bitset src, bitset_bindex bitno)
 {
   bitset bset = src->s.bset;
 {
   bitset bset = src->s.bset;
-  bitset_windex index = bitno / BITSET_WORD_BITS;
-  bitset_windex offset = index - bset->b.cindex;
+  bitset_windex wordno = bitno / BITSET_WORD_BITS;
+  bitset_windex offset = wordno - bset->b.cindex;
 
   BITSET_STATS_TESTS_INC (bset);
 
   BITSET_STATS_TESTS_INC (bset);
-  
+
   if (offset < bset->b.csize)
     {
       BITSET_STATS_CACHE_TESTS_INC (bset);
   if (offset < bset->b.csize)
     {
       BITSET_STATS_CACHE_TESTS_INC (bset);
@@ -422,74 +376,203 @@ bitset_stats_test (src, bitno)
 }
 
 
 }
 
 
-static int
-bitset_stats_size (src)
-     bitset src;
+static bitset_bindex
+bitset_stats_resize (bitset src, bitset_bindex size)
+{
+    return BITSET_RESIZE_ (src->s.bset, size);
+}
+
+
+static bitset_bindex
+bitset_stats_size (bitset src)
 {
   return BITSET_SIZE_ (src->s.bset);
 }
 
 
 {
   return BITSET_SIZE_ (src->s.bset);
 }
 
 
-static int
-bitset_stats_op1 (dst, op)
-     bitset dst;
-     enum bitset_ops op;
+static bitset_bindex
+bitset_stats_count (bitset src)
+{
+  return BITSET_COUNT_ (src->s.bset);
+}
+
+
+static bool
+bitset_stats_empty_p (bitset dst)
+{
+  return BITSET_EMPTY_P_ (dst->s.bset);
+}
+
+
+static void
+bitset_stats_ones (bitset dst)
 {
 {
-  return BITSET_OP1_ (dst->s.bset, op);
+  BITSET_ONES_ (dst->s.bset);
 }
 
 
 }
 
 
-static int
-bitset_stats_op2 (dst, src, op)
-     bitset dst;
-     bitset src;
-     enum bitset_ops op;
+static void
+bitset_stats_zero (bitset dst)
+{
+  BITSET_ZERO_ (dst->s.bset);
+}
+
+
+static void
+bitset_stats_copy (bitset dst, bitset src)
+{
+  BITSET_CHECK2_ (dst, src);
+  BITSET_COPY_ (dst->s.bset, src->s.bset);
+}
+
+
+static bool
+bitset_stats_disjoint_p (bitset dst, bitset src)
+{
+  BITSET_CHECK2_ (dst, src);
+  return BITSET_DISJOINT_P_ (dst->s.bset, src->s.bset);
+}
+
+
+static bool
+bitset_stats_equal_p (bitset dst, bitset src)
+{
+  BITSET_CHECK2_ (dst, src);
+  return BITSET_EQUAL_P_ (dst->s.bset, src->s.bset);
+}
+
+
+static void
+bitset_stats_not (bitset dst, bitset src)
+{
+  BITSET_CHECK2_ (dst, src);
+  BITSET_NOT_ (dst->s.bset, src->s.bset);
+}
+
+
+static bool
+bitset_stats_subset_p (bitset dst, bitset src)
 {
   BITSET_CHECK2_ (dst, src);
 {
   BITSET_CHECK2_ (dst, src);
-  return BITSET_OP2_ (dst->s.bset, src->s.bset, op);
+  return BITSET_SUBSET_P_ (dst->s.bset, src->s.bset);
+}
+
+
+static void
+bitset_stats_and (bitset dst, bitset src1, bitset src2)
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  BITSET_AND_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static bool
+bitset_stats_and_cmp (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 int
-bitset_stats_op3 (dst, src1, src2, op)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     enum bitset_ops op;
+static void
+bitset_stats_andn (bitset dst, bitset src1, bitset src2)
 {
   BITSET_CHECK3_ (dst, src1, src2);
 {
   BITSET_CHECK3_ (dst, src1, src2);
-  return BITSET_OP3_ (dst->s.bset, src1->s.bset, src2->s.bset, op);
+  BITSET_ANDN_ (dst->s.bset, src1->s.bset, src2->s.bset);
 }
 
 
 }
 
 
-static int
-bitset_stats_op4 (dst, src1, src2, src3, op)
-     bitset dst;
-     bitset src1;
-     bitset src2;
-     bitset src3;
-     enum bitset_ops op;
+static bool
+bitset_stats_andn_cmp (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 (bitset dst, bitset src1, bitset src2)
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  BITSET_OR_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static bool
+bitset_stats_or_cmp (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 (bitset dst, bitset src1, bitset src2)
+{
+  BITSET_CHECK3_ (dst, src1, src2);
+  BITSET_XOR_ (dst->s.bset, src1->s.bset, src2->s.bset);
+}
+
+
+static bool
+bitset_stats_xor_cmp (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 (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   BITSET_CHECK4_ (dst, src1, src2, src3);
 {
   BITSET_CHECK4_ (dst, src1, src2, src3);
+  BITSET_AND_OR_ (dst->s.bset, src1->s.bset, src2->s.bset, src3->s.bset);
+}
 
 
-  /* This is a bit of a hack.  If the implementation handles
-     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 bool
+bitset_stats_and_or_cmp (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 (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 bool
+bitset_stats_andn_or_cmp (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 (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 bool
+bitset_stats_or_and_cmp (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);
 }
 
 
 }
 
 
-static int
-bitset_stats_list (bset, list, num, next)
-     bitset bset;
-     bitset_bindex *list;
-     bitset_bindex num;
-     bitset_bindex *next;
+static bitset_bindex
+bitset_stats_list (bitset bset, bitset_bindex *list,
+                  bitset_bindex num, bitset_bindex *next)
 {
   bitset_bindex count;
   bitset_bindex tmp;
 {
   bitset_bindex count;
   bitset_bindex tmp;
@@ -498,17 +581,17 @@ bitset_stats_list (bset, list, num, next)
   enum bitset_type type;
 
   count = BITSET_LIST_ (bset->s.bset, list, num, next);
   enum bitset_type type;
 
   count = BITSET_LIST_ (bset->s.bset, list, num, next);
-  
+
   type = BITSET_TYPE_ (bset->s.bset);
   BITSET_STATS_LISTS_INC (bset->s.bset);
   type = BITSET_TYPE_ (bset->s.bset);
   BITSET_STATS_LISTS_INC (bset->s.bset);
-  
+
   /* Log histogram of number of set bits.  */
   for (i = 0, tmp = count; tmp; tmp >>= 1, i++)
      continue;
   if (i >= BITSET_LOG_COUNT_BINS)
      i = BITSET_LOG_COUNT_BINS - 1;
   BITSET_STATS_LIST_COUNTS_INC (bset->s.bset, i);
   /* Log histogram of number of set bits.  */
   for (i = 0, tmp = count; tmp; tmp >>= 1, i++)
      continue;
   if (i >= BITSET_LOG_COUNT_BINS)
      i = BITSET_LOG_COUNT_BINS - 1;
   BITSET_STATS_LIST_COUNTS_INC (bset->s.bset, i);
-  
+
   /* Log histogram of number of bits in set.  */
   size = BITSET_SIZE_ (bset->s.bset);
   for (i = 0, tmp = size; tmp; tmp >>= 1, i++)
   /* Log histogram of number of bits in set.  */
   size = BITSET_SIZE_ (bset->s.bset);
   for (i = 0, tmp = size; tmp; tmp >>= 1, i++)
@@ -516,7 +599,7 @@ bitset_stats_list (bset, list, num, next)
   if (i >= BITSET_LOG_SIZE_BINS)
      i = BITSET_LOG_SIZE_BINS - 1;
   BITSET_STATS_LIST_SIZES_INC (bset->s.bset, i);
   if (i >= BITSET_LOG_SIZE_BINS)
      i = BITSET_LOG_SIZE_BINS - 1;
   BITSET_STATS_LIST_SIZES_INC (bset->s.bset, i);
-  
+
   /* Histogram of fraction of bits set.  */
   i = size ? (count * BITSET_DENSITY_BINS) / size : 0;
   if (i >= BITSET_DENSITY_BINS)
   /* Histogram of fraction of bits set.  */
   i = size ? (count * BITSET_DENSITY_BINS) / size : 0;
   if (i >= BITSET_DENSITY_BINS)
@@ -526,37 +609,54 @@ bitset_stats_list (bset, list, num, next)
 }
 
 
 }
 
 
-static int
-bitset_stats_reverse_list (bset, list, num, next)
-     bitset bset;
-     bitset_bindex *list;
-     bitset_bindex num;
-     bitset_bindex *next;
+static bitset_bindex
+bitset_stats_list_reverse (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);
 }
 
 
 static void
 }
 
 
 static void
-bitset_stats_free (bset)
-     bitset bset;
+bitset_stats_free (bitset bset)
 {
   BITSET_STATS_FREES_INC (bset->s.bset);
   BITSET_FREE_ (bset->s.bset);
 }
 
 
 {
   BITSET_STATS_FREES_INC (bset->s.bset);
   BITSET_FREE_ (bset->s.bset);
 }
 
 
-struct bitset_ops_struct bitset_stats_ops = {
+struct bitset_vtable bitset_stats_vtable = {
   bitset_stats_set,
   bitset_stats_reset,
   bitset_stats_set,
   bitset_stats_reset,
+  bitset_stats_toggle,
   bitset_stats_test,
   bitset_stats_test,
+  bitset_stats_resize,
   bitset_stats_size,
   bitset_stats_size,
-  bitset_stats_op1,
-  bitset_stats_op2,
-  bitset_stats_op3,
-  bitset_stats_op4,
+  bitset_stats_count,
+  bitset_stats_empty_p,
+  bitset_stats_ones,
+  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_list,
-  bitset_stats_reverse_list,
+  bitset_stats_list_reverse,
   bitset_stats_free,
   BITSET_STATS
 };
   bitset_stats_free,
   BITSET_STATS
 };
@@ -564,35 +664,34 @@ struct bitset_ops_struct bitset_stats_ops = {
 
 /* Return enclosed bitset type.  */
 enum bitset_type
 
 /* Return enclosed bitset type.  */
 enum bitset_type
-bitset_stats_type_get (bset)
-   bitset bset;
+bitset_stats_type_get (bitset bset)
 {
    return BITSET_TYPE_ (bset->s.bset);
 }
 
 
 {
    return BITSET_TYPE_ (bset->s.bset);
 }
 
 
-int bitset_stats_bytes (void)
+size_t
+bitset_stats_bytes (void)
 {
 {
-  return sizeof (struct bitset_struct);
+  return sizeof (struct bitset_stats_struct);
 }
 
 
 bitset
 }
 
 
 bitset
-bitset_stats_init (bset, n_bits, type)
-     bitset bset;
-     bitset_bindex n_bits;
-     enum bitset_type type;
+bitset_stats_init (bitset bset, bitset_bindex n_bits, enum bitset_type type)
 {
 {
-  unsigned int bytes;
+  size_t bytes;
   bitset sbset;
 
   bitset sbset;
 
-  bset->b.ops = &bitset_stats_ops;
+  bset->b.vtable = &bitset_stats_vtable;
 
   /* Disable cache.  */
   bset->b.cindex = 0;
   bset->b.csize = 0;
   bset->b.cdata = 0;
 
 
   /* Disable cache.  */
   bset->b.cindex = 0;
   bset->b.csize = 0;
   bset->b.cdata = 0;
 
+  BITSET_NBITS_ (bset) = n_bits;
+
   /* Set up the actual bitset implementation that
      we are a wrapper over.  */
   switch (type)
   /* Set up the actual bitset implementation that
      we are a wrapper over.  */
   switch (type)
@@ -615,6 +714,12 @@ bitset_stats_init (bset, n_bits, type)
       ebitset_init (sbset, n_bits);
       break;
 
       ebitset_init (sbset, n_bits);
       break;
 
+    case BITSET_VARRAY:
+      bytes = vbitset_bytes (n_bits);
+      sbset = (bitset) xcalloc (1, bytes);
+      vbitset_init (sbset, n_bits);
+      break;
+
     default:
       abort ();
     }
     default:
       abort ();
     }
@@ -622,6 +727,6 @@ bitset_stats_init (bset, n_bits, type)
   bset->s.bset = sbset;
 
   BITSET_STATS_ALLOCS_INC (type);
   bset->s.bset = sbset;
 
   BITSET_STATS_ALLOCS_INC (type);
-  
+
   return bset;
 }
   return bset;
 }
bison