#include "lbitset.h"
#include "obstack.h"
+#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
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 };
static int lbitset_obstack_init = 0;
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 PARAMS ((bitset));
+
+#define LBITSET_CURRENT1(X) \
+ ((lbitset_elt *) (void *) ((char *) (X) - offsetof (lbitset_elt, words)))
#define LBITSET_CURRENT(X) LBITSET_CURRENT1((X)->b.cdata)
/* Allocate a lbitset element. The bits are not cleared. */
static inline lbitset_elt *
-lbitset_elt_alloc ()
+lbitset_elt_alloc (void)
{
lbitset_elt *elt;
/* Allocate a lbitset element. The bits are cleared. */
static inline lbitset_elt *
-lbitset_elt_calloc ()
+lbitset_elt_calloc (void)
{
lbitset_elt *elt;
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;
/* 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;
/* 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;
/* Return nonzero if all bits in an element are zero. */
static inline int
-lbitset_elt_zero_p (elt)
- lbitset_elt *elt;
+lbitset_elt_zero_p (lbitset_elt *elt)
{
int i;
/* 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;
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;
/* 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;
/* Set all bits in the bitset to zero. */
static void
-lbitset_zero (bset)
- bitset bset;
+lbitset_zero (bitset bset)
{
lbitset_elt *head;
/* Return 1 if DST == SRC. */
static inline int
-lbitset_equal_p (dst, src)
- bitset dst;
- bitset src;
+lbitset_equal_p (bitset dst, bitset src)
{
lbitset_elt *selt;
lbitset_elt *delt;
/* 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;
/* Copy bits from bitset SRC to bitset DST. Return non-zero if
bitsets different. */
static inline int
-lbitset_copy_cmp (dst, src)
- bitset dst;
- bitset src;
+lbitset_copy_cmp (bitset dst, bitset src)
{
if (src == dst)
return 0;
/* Return size in bits of bitset SRC. */
static bitset_bindex
-lbitset_size (src)
- bitset src;
+lbitset_size (bitset src)
{
lbitset_elt *elt;
/* 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;
/* 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;
/* Test bit BITNO in bitset SRC. */
static int
-lbitset_test (src, bitno)
- bitset src;
- bitset_bindex bitno;
+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]
+ return (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);
}
*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;
*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;
static int
-lbitset_empty_p (dst)
- bitset dst;
+lbitset_empty_p (bitset dst)
{
lbitset_weed (dst);
if (LBITSET_HEAD (dst))
static void
-lbitset_ones (dst)
- bitset dst;
+lbitset_ones (bitset dst)
{
bitset_windex i;
bitset_windex windex;
/* Ignore empty set. */
if (!elt)
return;
-
+
windex = elt->index;
for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
{
static void
-lbitset_not (dst, src)
- bitset dst;
- bitset src;
+lbitset_not (bitset dst, bitset src)
{
lbitset_elt *elt;
lbitset_elt *selt;
/* Ignore empty set. */
if (!elt)
return;
-
+
windex = elt->index;
for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
{
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];
}
/* Return 1 if DST == DST | SRC. */
static int
-lbitset_subset_p (dst, src)
- bitset dst;
- bitset src;
+lbitset_subset_p (bitset dst, bitset src)
{
lbitset_elt *selt;
lbitset_elt *delt;
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 if DST & SRC == 0. */
static int
-lbitset_disjoint_p (dst, src)
- bitset dst;
- bitset src;
+lbitset_disjoint_p (bitset dst, bitset src)
{
lbitset_elt *selt;
lbitset_elt *delt;
intersection of these elements. */
continue;
}
-
+
for (j = 0; j < LBITSET_ELT_WORDS; j++)
if (selt->words[j] & delt->words[j])
return 0;
static int
-lbitset_op3_cmp (dst, src1, src2, op)
- bitset dst;
- bitset src1;
- bitset src2;
- enum bitset_ops op;
+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);
static int
-lbitset_and_cmp (dst, src1, src2)
- bitset dst;
- bitset src1;
- bitset src2;
+lbitset_and_cmp (bitset dst, bitset src1, bitset src2)
{
lbitset_elt *selt1 = LBITSET_HEAD (src1);
lbitset_elt *selt2 = LBITSET_HEAD (src2);
}
+static void
+lbitset_and (bitset dst, bitset src1, bitset src2)
+{
+ lbitset_and_cmp (dst, src1, src2);
+}
+
+
static int
-lbitset_andn_cmp (dst, src1, src2)
- bitset dst;
- bitset src1;
- bitset src2;
+lbitset_andn_cmp (bitset dst, bitset src1, bitset src2)
{
lbitset_elt *selt1 = LBITSET_HEAD (src1);
lbitset_elt *selt2 = LBITSET_HEAD (src2);
}
+static void
+lbitset_andn (bitset dst, bitset src1, bitset src2)
+{
+ lbitset_andn_cmp (dst, src1, src2);
+}
+
+
static int
-lbitset_or_cmp (dst, src1, src2)
- bitset dst;
- bitset src1;
- bitset src2;
+lbitset_or_cmp (bitset dst, bitset src1, bitset src2)
{
lbitset_elt *selt1 = LBITSET_HEAD (src1);
lbitset_elt *selt2 = LBITSET_HEAD (src2);
}
+static void
+lbitset_or (bitset dst, bitset src1, bitset src2)
+{
+ lbitset_or_cmp (dst, src1, src2);
+}
+
+
static int
-lbitset_xor_cmp (dst, src1, src2)
- bitset dst;
- bitset src1;
- bitset src2;
+lbitset_xor_cmp (bitset dst, bitset src1, bitset src2)
{
lbitset_elt *selt1 = LBITSET_HEAD (src1);
lbitset_elt *selt2 = LBITSET_HEAD (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 = {
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,
/* 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)
{
bset->b.vtable = &lbitset_vtable;
return bset;
void
-lbitset_release_memory ()
+lbitset_release_memory (void)
{
lbitset_free_list = 0;
if (lbitset_obstack_init)
/* 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);
{
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 & (1 << j)))
+ if ((word & ((bitset_word) 1 << j)))
fprintf (stderr, " %u", j);
fprintf (stderr, "\n");
}
projects / bison.git / blobdiff