X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/09147be095972d16f5c1d89dfe99bdb401b2685c..d6bdb90a2a2ced43828cf6591b3baf513d38285d:/lib/lbitset.c diff --git a/lib/lbitset.c b/lib/lbitset.c index 8aa353cf..d48a4a83 100644 --- a/lib/lbitset.c +++ b/lib/lbitset.c @@ -1,10 +1,11 @@ /* Functions to support link list bitsets. - Copyright (C) 2002 Free Software Foundation, Inc. + Copyright (C) 2002-2004, 2006, 2009-2010 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 + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -13,18 +14,17 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -*/ + along with this program. If not, see . */ -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif +#include #include "lbitset.h" + #include "obstack.h" +#include #include #include +#include /* This file implements linked-list bitsets. These bitsets can be of arbitrary length and are more efficient than arrays of bits for @@ -39,7 +39,10 @@ /* Number of words to use for each element. The larger the value the greater the size of the cache and the shorter the time to find a given bit but the more memory wasted for sparse bitsets and the longer the time - to search for set bits. */ + to search for set bits. + + The routines that dominate timing profiles are lbitset_elt_find + and lbitset_elt_link, especially when accessing the bits randomly. */ #define LBITSET_ELT_WORDS 2 @@ -49,7 +52,7 @@ typedef bitset_word lbitset_word; /* Number of bits stored in each element. */ #define LBITSET_ELT_BITS \ - ((unsigned) (LBITSET_ELT_WORDS * LBITSET_WORD_BITS)) + ((unsigned int) (LBITSET_ELT_WORDS * LBITSET_WORD_BITS)) /* Lbitset element. We use an array of bits for each element. These are linked together in a doubly-linked list. */ @@ -63,25 +66,6 @@ typedef struct lbitset_elt_struct lbitset_elt; -/* Head of lbitset linked list. */ -typedef struct lbitset_struct -{ - lbitset_elt *head; /* First element in linked list. */ - lbitset_elt *tail; /* Last element in linked list. */ -} -*lbitset; - - -struct bitset_struct -{ - struct bbitset_struct b; - struct lbitset_struct l; -}; - - -typedef void(*PFV)(); - - enum lbitset_find_mode { LBITSET_FIND, LBITSET_CREATE, LBITSET_SUBST }; @@ -89,37 +73,13 @@ static lbitset_elt lbitset_zero_elts[3]; /* Elements of all zero bits. */ /* Obstack to allocate bitset elements from. */ static struct obstack lbitset_obstack; -static int lbitset_obstack_init = 0; +static bool lbitset_obstack_init = false; static lbitset_elt *lbitset_free_list; /* Free list of bitset elements. */ -static lbitset_elt *lbitset_elt_alloc PARAMS ((void)); -static lbitset_elt *lbitset_elt_calloc PARAMS ((void)); -static void lbitset_elt_link PARAMS ((bitset, lbitset_elt *)); -static void lbitset_elt_unlink PARAMS ((bitset, lbitset_elt *)); -static void lbitset_elt_free PARAMS ((lbitset_elt *)); -static lbitset_elt *lbitset_elt_find PARAMS ((bitset, bitset_windex, - enum lbitset_find_mode)); -static int lbitset_elt_zero_p PARAMS ((lbitset_elt *)); - -static void lbitset_prune PARAMS ((bitset, lbitset_elt *)); -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_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 bitset_bindex lbitset_size PARAMS ((bitset)); -static int lbitset_op3_cmp PARAMS ((bitset, bitset, bitset, enum bitset_ops)); -static bitset_bindex lbitset_list PARAMS ((bitset, bitset_bindex *, - bitset_bindex, bitset_bindex *)); -static bitset_bindex lbitset_list_reverse -PARAMS ((bitset, bitset_bindex *, bitset_bindex, bitset_bindex *)); -static void lbitset_free PARAMS ((bitset)); - - -#define LBITSET_CURRENT1(X) (lbitset_elt *)((char *)(X) + ((char *)&(((lbitset_elt *)(X))->next) - (char *)&(((lbitset_elt *)(X))->words))) +extern void debug_lbitset (bitset); + +#define LBITSET_CURRENT1(X) \ + ((lbitset_elt *) (void *) ((char *) (X) - offsetof (lbitset_elt, words))) #define LBITSET_CURRENT(X) LBITSET_CURRENT1((X)->b.cdata) @@ -128,7 +88,7 @@ static void lbitset_free PARAMS ((bitset)); /* Allocate a lbitset element. The bits are not cleared. */ static inline lbitset_elt * -lbitset_elt_alloc () +lbitset_elt_alloc (void) { lbitset_elt *elt; @@ -141,7 +101,7 @@ lbitset_elt_alloc () { if (!lbitset_obstack_init) { - lbitset_obstack_init = 1; + lbitset_obstack_init = true; /* Let particular systems override the size of a chunk. */ @@ -159,15 +119,13 @@ lbitset_elt_alloc () #define OBSTACK_CHUNK_FREE free #endif -#if !defined(__GNUC__) || (__GNUC__ < 2) +#if ! defined __GNUC__ || __GNUC__ < 2 #define __alignof__(type) 0 #endif obstack_specify_allocation (&lbitset_obstack, OBSTACK_CHUNK_SIZE, __alignof__ (lbitset_elt), - (void *(*)PARAMS ((long))) OBSTACK_CHUNK_ALLOC, - (void (*)PARAMS ((void *))) OBSTACK_CHUNK_FREE); } @@ -183,7 +141,7 @@ lbitset_elt_alloc () /* Allocate a lbitset element. The bits are cleared. */ static inline lbitset_elt * -lbitset_elt_calloc () +lbitset_elt_calloc (void) { lbitset_elt *elt; @@ -194,8 +152,7 @@ lbitset_elt_calloc () static inline void -lbitset_elt_free (elt) - lbitset_elt *elt; +lbitset_elt_free (lbitset_elt *elt) { elt->next = lbitset_free_list; lbitset_free_list = elt; @@ -204,9 +161,7 @@ lbitset_elt_free (elt) /* Unlink element ELT from bitset BSET. */ static inline void -lbitset_elt_unlink (bset, elt) - bitset bset; - lbitset_elt *elt; +lbitset_elt_unlink (bitset bset, lbitset_elt *elt) { lbitset_elt *next = elt->next; lbitset_elt *prev = elt->prev; @@ -251,9 +206,7 @@ lbitset_elt_unlink (bset, elt) /* Cut the chain of bitset BSET before element ELT and free the elements. */ static inline void -lbitset_prune (bset, elt) - bitset bset; - lbitset_elt *elt; +lbitset_prune (bitset bset, lbitset_elt *elt) { lbitset_elt *next; @@ -283,26 +236,23 @@ lbitset_prune (bset, elt) } -/* Return nonzero if all bits in an element are zero. */ -static inline int -lbitset_elt_zero_p (elt) - lbitset_elt *elt; +/* Are all bits in an element zero? */ +static inline bool +lbitset_elt_zero_p (lbitset_elt *elt) { int i; for (i = 0; i < LBITSET_ELT_WORDS; i++) if (elt->words[i]) - return 0; + return false; - return 1; + return true; } /* Link the bitset element into the current bitset linked list. */ static inline void -lbitset_elt_link (bset, elt) - bitset bset; - lbitset_elt *elt; +lbitset_elt_link (bitset bset, lbitset_elt *elt) { bitset_windex windex = elt->index; lbitset_elt *ptr; @@ -364,10 +314,8 @@ lbitset_elt_link (bset, elt) static lbitset_elt * -lbitset_elt_find (bset, windex, mode) - bitset bset; - bitset_windex windex; - enum lbitset_find_mode mode; +lbitset_elt_find (bitset bset, bitset_windex windex, + enum lbitset_find_mode mode) { lbitset_elt *elt; lbitset_elt *current; @@ -413,6 +361,9 @@ lbitset_elt_find (bset, windex, mode) switch (mode) { + default: + abort (); + case LBITSET_FIND: return 0; @@ -426,17 +377,13 @@ lbitset_elt_find (bset, windex, mode) case LBITSET_SUBST: return &lbitset_zero_elts[0]; - - default: - abort (); } } /* Weed out the zero elements from the list. */ static inline void -lbitset_weed (bset) - bitset bset; +lbitset_weed (bitset bset) { lbitset_elt *elt; lbitset_elt *next; @@ -452,8 +399,7 @@ lbitset_weed (bset) /* Set all bits in the bitset to zero. */ static void -lbitset_zero (bset) - bitset bset; +lbitset_zero (bitset bset) { lbitset_elt *head; @@ -466,18 +412,16 @@ lbitset_zero (bset) } -/* Return 1 if DST == SRC. */ -static inline int -lbitset_equal_p (dst, src) - bitset dst; - bitset src; +/* Is DST == SRC? */ +static inline bool +lbitset_equal_p (bitset dst, bitset src) { lbitset_elt *selt; lbitset_elt *delt; int j; if (src == dst) - return 1; + return true; lbitset_weed (src); lbitset_weed (dst); @@ -485,11 +429,11 @@ lbitset_equal_p (dst, src) selt && delt; selt = selt->next, delt = delt->next) { if (selt->index != delt->index) - return 0; + return false; for (j = 0; j < LBITSET_ELT_WORDS; j++) if (delt->words[j] != selt->words[j]) - return 0; + return false; } return !selt && !delt; } @@ -497,9 +441,7 @@ lbitset_equal_p (dst, src) /* Copy bits from bitset SRC to bitset DST. */ static inline void -lbitset_copy (dst, src) - bitset dst; - bitset src; +lbitset_copy (bitset dst, bitset src) { lbitset_elt *elt; lbitset_elt *head; @@ -538,15 +480,13 @@ lbitset_copy (dst, src) } -/* Copy bits from bitset SRC to bitset DST. Return non-zero if +/* Copy bits from bitset SRC to bitset DST. Return true if bitsets different. */ -static inline int -lbitset_copy_cmp (dst, src) - bitset dst; - bitset src; +static inline bool +lbitset_copy_cmp (bitset dst, bitset src) { if (src == dst) - return 0; + return false; if (!LBITSET_HEAD (dst)) { @@ -555,34 +495,25 @@ lbitset_copy_cmp (dst, src) } if (lbitset_equal_p (dst, src)) - return 0; + return false; lbitset_copy (dst, src); - return 1; + return true; } -/* Return size in bits of bitset SRC. */ static bitset_bindex -lbitset_size (src) - bitset src; +lbitset_resize (bitset src, bitset_bindex size) { - lbitset_elt *elt; + BITSET_NBITS_ (src) = size; - elt = LBITSET_TAIL (src); - if (!elt) - return 0; - - /* Return current size of bitset in bits. */ - return (elt->index + LBITSET_ELT_WORDS) * BITSET_WORD_BITS; + /* Need to prune any excess bits. FIXME. */ + return size; } - /* Set bit BITNO in bitset DST. */ static void -lbitset_set (dst, bitno) - bitset dst; - bitset_bindex bitno; +lbitset_set (bitset dst, bitset_bindex bitno) { bitset_windex windex = bitno / BITSET_WORD_BITS; @@ -595,9 +526,7 @@ lbitset_set (dst, bitno) /* Reset bit BITNO in bitset DST. */ static void -lbitset_reset (dst, bitno) - bitset dst; - bitset_bindex bitno; +lbitset_reset (bitset dst, bitset_bindex bitno) { bitset_windex windex = bitno / BITSET_WORD_BITS; @@ -612,24 +541,20 @@ lbitset_reset (dst, bitno) /* Test bit BITNO in bitset SRC. */ -static int -lbitset_test (src, bitno) - bitset src; - bitset_bindex bitno; +static bool +lbitset_test (bitset src, bitset_bindex bitno) { bitset_windex windex = bitno / BITSET_WORD_BITS; - if (!lbitset_elt_find (src, windex, LBITSET_FIND)) - return 0; - - return (src->b.cdata[windex - src->b.cindex] - >> (bitno % BITSET_WORD_BITS)) & 1; + return (lbitset_elt_find (src, windex, LBITSET_FIND) + && ((src->b.cdata[windex - src->b.cindex] + >> (bitno % BITSET_WORD_BITS)) + & 1)); } static void -lbitset_free (bset) - bitset bset; +lbitset_free (bitset bset) { lbitset_zero (bset); } @@ -639,11 +564,8 @@ lbitset_free (bset) *NEXT and store in array LIST. Return with actual number of bits found and with *NEXT indicating where search stopped. */ static bitset_bindex -lbitset_list_reverse (bset, list, num, next) - bitset bset; - bitset_bindex *list; - bitset_bindex num; - bitset_bindex *next; +lbitset_list_reverse (bitset bset, bitset_bindex *list, + bitset_bindex num, bitset_bindex *next) { bitset_bindex rbitno; bitset_bindex bitno; @@ -737,11 +659,8 @@ lbitset_list_reverse (bset, list, num, next) *NEXT and store in array LIST. Return with actual number of bits found and with *NEXT indicating where search stopped. */ static bitset_bindex -lbitset_list (bset, list, num, next) - bitset bset; - bitset_bindex *list; - bitset_bindex num; - bitset_bindex *next; +lbitset_list (bitset bset, bitset_bindex *list, + bitset_bindex num, bitset_bindex *next) { bitset_bindex bitno; bitset_windex windex; @@ -939,20 +858,56 @@ lbitset_list (bset, list, num, next) } -static int -lbitset_empty_p (dst) - bitset dst; +static bool +lbitset_empty_p (bitset dst) { - lbitset_weed (dst); - if (LBITSET_HEAD (dst)) - return 0; + lbitset_elt *elt; + lbitset_elt *next; + + for (elt = LBITSET_HEAD (dst); elt; elt = next) + { + next = elt->next; + if (!lbitset_elt_zero_p (elt)) + return 0; + /* Weed as we go. */ + lbitset_elt_unlink (dst, elt); + } + return 1; } +/* Ensure that any unused bits within the last element are clear. */ +static inline void +lbitset_unused_clear (bitset dst) +{ + unsigned int last_bit; + bitset_bindex n_bits; + + n_bits = BITSET_SIZE_ (dst); + last_bit = n_bits % LBITSET_ELT_BITS; + + if (last_bit) + { + lbitset_elt *elt; + bitset_windex windex; + bitset_word *srcp; + + elt = LBITSET_TAIL (dst); + srcp = elt->words; + windex = n_bits / BITSET_WORD_BITS; + + srcp[windex - elt->index] &= ((bitset_word) 1 << last_bit) - 1; + windex++; + + for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++) + srcp[windex - elt->index] = 0; + } +} + + static void -lbitset_ones (dst) - bitset dst; +lbitset_ones (bitset dst) { bitset_windex i; bitset_windex windex; @@ -962,25 +917,22 @@ lbitset_ones (dst) 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; + + windex = (BITSET_SIZE_ (dst) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS; + 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)); } + + lbitset_unused_clear (dst); } static void -lbitset_not (dst, src) - bitset dst; - bitset src; +lbitset_not (bitset dst, bitset src) { lbitset_elt *elt; lbitset_elt *selt; @@ -992,31 +944,28 @@ lbitset_not (dst, src) /* This is another unfriendly operation for a linked list bitset! */ elt = LBITSET_TAIL (dst); - /* Ignore empty set. */ - if (!elt) - return; - - windex = elt->index; + + windex = (BITSET_SIZE_ (dst) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS; + 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 (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_unused_clear (dst); lbitset_weed (dst); return; } -/* Return 1 if DST == DST | SRC. */ -static int -lbitset_subset_p (dst, src) - bitset dst; - bitset src; +/* Is DST == DST | SRC? */ +static bool +lbitset_subset_p (bitset dst, bitset src) { lbitset_elt *selt; lbitset_elt *delt; @@ -1042,20 +991,18 @@ lbitset_subset_p (dst, src) 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 false; } - return 1; + return true; } -/* Return 1 if DST & SRC == 0. */ -static int -lbitset_disjoint_p (dst, src) - bitset dst; - bitset src; +/* Is DST & SRC == 0? */ +static bool +lbitset_disjoint_p (bitset dst, bitset src) { lbitset_elt *selt; lbitset_elt *delt; @@ -1080,21 +1027,17 @@ lbitset_disjoint_p (dst, src) intersection of these elements. */ continue; } - + for (j = 0; j < LBITSET_ELT_WORDS; j++) if (selt->words[j] & delt->words[j]) - return 0; + return false; } - return 1; + return true; } -static int -lbitset_op3_cmp (dst, src1, src2, op) - bitset dst; - bitset src1; - bitset src2; - enum bitset_ops op; +static bool +lbitset_op3_cmp (bitset dst, bitset src1, bitset src2, enum bitset_ops op) { lbitset_elt *selt1 = LBITSET_HEAD (src1); lbitset_elt *selt2 = LBITSET_HEAD (src2); @@ -1108,7 +1051,7 @@ lbitset_op3_cmp (dst, src1, src2, op) bitset_word *srcp1; bitset_word *srcp2; bitset_word *dstp; - int changed = 0; + bool changed = false; unsigned int i; LBITSET_HEAD (dst) = 0; @@ -1152,7 +1095,7 @@ lbitset_op3_cmp (dst, src1, src2, op) elements that we've skipped. */ while (delt && delt->index < windex) { - changed = 1; + changed = true; dtmp = delt; delt = delt->next; lbitset_elt_free (dtmp); @@ -1172,6 +1115,9 @@ lbitset_op3_cmp (dst, src1, src2, op) dstp = dtmp->words; switch (op) { + default: + abort (); + case BITSET_OP_OR: for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++) { @@ -1179,7 +1125,7 @@ lbitset_op3_cmp (dst, src1, src2, op) if (*dstp != tmp) { - changed = 1; + changed = true; *dstp = tmp; } } @@ -1192,7 +1138,7 @@ lbitset_op3_cmp (dst, src1, src2, op) if (*dstp != tmp) { - changed = 1; + changed = true; *dstp = tmp; } } @@ -1205,7 +1151,7 @@ lbitset_op3_cmp (dst, src1, src2, op) if (*dstp != tmp) { - changed = 1; + changed = true; *dstp = tmp; } } @@ -1218,14 +1164,11 @@ lbitset_op3_cmp (dst, src1, src2, op) if (*dstp != tmp) { - changed = 1; + changed = true; *dstp = tmp; } } break; - - default: - abort (); } if (!lbitset_elt_zero_p (dtmp)) @@ -1243,7 +1186,7 @@ lbitset_op3_cmp (dst, src1, src2, op) /* If we have elements of DST left over, free them all. */ if (delt) { - changed = 1; + changed = true; lbitset_prune (dst, delt); } @@ -1251,15 +1194,12 @@ lbitset_op3_cmp (dst, src1, src2, op) } -static int -lbitset_and_cmp (dst, src1, src2) - bitset dst; - bitset src1; - bitset src2; +static bool +lbitset_and_cmp (bitset dst, bitset src1, bitset src2) { lbitset_elt *selt1 = LBITSET_HEAD (src1); lbitset_elt *selt2 = LBITSET_HEAD (src2); - int changed; + bool changed; if (!selt2) { @@ -1279,15 +1219,19 @@ lbitset_and_cmp (dst, src1, src2) } -static int -lbitset_andn_cmp (dst, src1, src2) - bitset dst; - bitset src1; - bitset src2; +static void +lbitset_and (bitset dst, bitset src1, bitset src2) +{ + lbitset_and_cmp (dst, src1, src2); +} + + +static bool +lbitset_andn_cmp (bitset dst, bitset src1, bitset src2) { lbitset_elt *selt1 = LBITSET_HEAD (src1); lbitset_elt *selt2 = LBITSET_HEAD (src2); - int changed; + bool changed; if (!selt2) { @@ -1304,11 +1248,15 @@ lbitset_andn_cmp (dst, src1, src2) } -static int -lbitset_or_cmp (dst, src1, src2) - bitset dst; - bitset src1; - bitset src2; +static void +lbitset_andn (bitset dst, bitset src1, bitset src2) +{ + lbitset_andn_cmp (dst, src1, src2); +} + + +static bool +lbitset_or_cmp (bitset dst, bitset src1, bitset src2) { lbitset_elt *selt1 = LBITSET_HEAD (src1); lbitset_elt *selt2 = LBITSET_HEAD (src2); @@ -1325,11 +1273,15 @@ lbitset_or_cmp (dst, src1, src2) } -static int -lbitset_xor_cmp (dst, src1, src2) - bitset dst; - bitset src1; - bitset src2; +static void +lbitset_or (bitset dst, bitset src1, bitset src2) +{ + lbitset_or_cmp (dst, src1, src2); +} + + +static bool +lbitset_xor_cmp (bitset dst, bitset src1, bitset src2) { lbitset_elt *selt1 = LBITSET_HEAD (src1); lbitset_elt *selt2 = LBITSET_HEAD (src2); @@ -1346,6 +1298,13 @@ lbitset_xor_cmp (dst, src1, src2) } +static void +lbitset_xor (bitset dst, bitset src1, bitset src2) +{ + lbitset_xor_cmp (dst, src1, src2); +} + + /* Vector of operations for linked-list bitsets. */ struct bitset_vtable lbitset_vtable = { @@ -1353,7 +1312,8 @@ struct bitset_vtable lbitset_vtable = { lbitset_reset, bitset_toggle_, lbitset_test, - lbitset_size, + lbitset_resize, + bitset_size_, bitset_count_, lbitset_empty_p, lbitset_ones, @@ -1363,19 +1323,19 @@ struct bitset_vtable lbitset_vtable = { lbitset_equal_p, lbitset_not, lbitset_subset_p, - (PFV) lbitset_and_cmp, + lbitset_and, lbitset_and_cmp, - (PFV) lbitset_andn_cmp, + lbitset_andn, lbitset_andn_cmp, - (PFV) lbitset_or_cmp, + lbitset_or, lbitset_or_cmp, - (PFV) lbitset_xor_cmp, + lbitset_xor, lbitset_xor_cmp, - (PFV) bitset_and_or_cmp_, + bitset_and_or_, bitset_and_or_cmp_, - (PFV) bitset_andn_or_cmp_, + bitset_andn_or_, bitset_andn_or_cmp_, - (PFV) bitset_or_and_cmp_, + bitset_or_and_, bitset_or_and_cmp_, lbitset_list, lbitset_list_reverse, @@ -1386,31 +1346,29 @@ struct bitset_vtable lbitset_vtable = { /* Return size of initial structure. */ size_t -lbitset_bytes (n_bits) - bitset_bindex n_bits ATTRIBUTE_UNUSED; +lbitset_bytes (bitset_bindex n_bits ATTRIBUTE_UNUSED) { - return sizeof (struct bitset_struct); + return sizeof (struct lbitset_struct); } /* Initialize a bitset. */ bitset -lbitset_init (bset, n_bits) - bitset bset; - bitset_bindex n_bits ATTRIBUTE_UNUSED; +lbitset_init (bitset bset, bitset_bindex n_bits ATTRIBUTE_UNUSED) { + BITSET_NBITS_ (bset) = n_bits; bset->b.vtable = &lbitset_vtable; return bset; } void -lbitset_release_memory () +lbitset_release_memory (void) { lbitset_free_list = 0; if (lbitset_obstack_init) { - lbitset_obstack_init = 0; + lbitset_obstack_init = false; obstack_free (&lbitset_obstack, NULL); } } @@ -1418,25 +1376,24 @@ lbitset_release_memory () /* Function to be called from debugger to debug lbitset. */ void -debug_lbitset (bset) - bitset bset; +debug_lbitset (bitset bset) { lbitset_elt *elt; unsigned int i; if (!bset) return; - + for (elt = LBITSET_HEAD (bset); elt; elt = elt->next) { - fprintf (stderr, "Elt %lu\n", (unsigned long) elt->index); + fprintf (stderr, "Elt %lu\n", (unsigned long int) elt->index); for (i = 0; i < LBITSET_ELT_WORDS; i++) { unsigned int j; bitset_word word; - + word = elt->words[i]; - + fprintf (stderr, " Word %u:", i); for (j = 0; j < LBITSET_WORD_BITS; j++) if ((word & ((bitset_word) 1 << j)))