Index: bison/src/bison/2.4.1/bison-2.4.1-src/lib/ebitset.c |
=================================================================== |
--- bison/src/bison/2.4.1/bison-2.4.1-src/lib/ebitset.c (revision 0) |
+++ bison/src/bison/2.4.1/bison-2.4.1-src/lib/ebitset.c (revision 0) |
@@ -0,0 +1,1364 @@ |
+/* Functions to support expandable bitsets. |
+ Copyright (C) 2002, 2003, 2004, 2005, 2006 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 |
+ it under the terms of the GNU General Public License as published by |
+ 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, |
+ but WITHOUT ANY WARRANTY; without even the implied warranty of |
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
+ 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, see <http://www.gnu.org/licenses/>. */ |
+ |
+#include <config.h> |
+ |
+#include "ebitset.h" |
+ |
+#include "obstack.h" |
+#include <stdlib.h> |
+#include <string.h> |
+ |
+/* This file implements expandable bitsets. These bitsets can be of |
+ arbitrary length and are more efficient than arrays of bits for |
+ large sparse sets. |
+ |
+ Empty elements are represented by a NULL pointer in the table of |
+ element pointers. An alternative is to point to a special zero |
+ element. Similarly, we could represent an all 1's element with |
+ another special ones element pointer. |
+ |
+ Bitsets are commonly empty so we need to ensure that this special |
+ case is fast. A zero bitset is indicated when cdata is 0. This is |
+ conservative since cdata may be non zero and the bitset may still |
+ be zero. |
+ |
+ The bitset cache can be disabled either by setting cindex to |
+ BITSET_WINDEX_MAX or by setting csize to 0. Here |
+ we use the former approach since cindex needs to be updated whenever |
+ cdata is changed. |
+*/ |
+ |
+ |
+/* Number of words to use for each element. */ |
+#define EBITSET_ELT_WORDS 2 |
+ |
+/* Number of bits stored in each element. */ |
+#define EBITSET_ELT_BITS \ |
+ ((unsigned int) (EBITSET_ELT_WORDS * BITSET_WORD_BITS)) |
+ |
+/* Ebitset element. We use an array of bits. */ |
+typedef struct ebitset_elt_struct |
+{ |
+ union |
+ { |
+ bitset_word words[EBITSET_ELT_WORDS]; /* Bits that are set. */ |
+ struct ebitset_elt_struct *next; |
+ } |
+ u; |
+} |
+ebitset_elt; |
+ |
+ |
+typedef ebitset_elt *ebitset_elts; |
+ |
+ |
+/* Number of elements to initially allocate. */ |
+ |
+#ifndef EBITSET_INITIAL_SIZE |
+#define EBITSET_INITIAL_SIZE 2 |
+#endif |
+ |
+ |
+enum ebitset_find_mode |
+ { EBITSET_FIND, EBITSET_CREATE, EBITSET_SUBST }; |
+ |
+static ebitset_elt ebitset_zero_elts[1]; /* Elements of all zero bits. */ |
+ |
+/* Obstack to allocate bitset elements from. */ |
+static struct obstack ebitset_obstack; |
+static bool ebitset_obstack_init = false; |
+static ebitset_elt *ebitset_free_list; /* Free list of bitset elements. */ |
+ |
+#define EBITSET_N_ELTS(N) (((N) + EBITSET_ELT_BITS - 1) / EBITSET_ELT_BITS) |
+#define EBITSET_ELTS(BSET) ((BSET)->e.elts) |
+#define EBITSET_SIZE(BSET) EBITSET_N_ELTS (BITSET_NBITS_ (BSET)) |
+#define EBITSET_ASIZE(BSET) ((BSET)->e.size) |
+ |
+#define EBITSET_NEXT(ELT) ((ELT)->u.next) |
+#define EBITSET_WORDS(ELT) ((ELT)->u.words) |
+ |
+/* Disable bitset cache and mark BSET as being zero. */ |
+#define EBITSET_ZERO_SET(BSET) ((BSET)->b.cindex = BITSET_WINDEX_MAX, \ |
+ (BSET)->b.cdata = 0) |
+ |
+#define EBITSET_CACHE_DISABLE(BSET) ((BSET)->b.cindex = BITSET_WINDEX_MAX) |
+ |
+/* Disable bitset cache and mark BSET as being possibly non-zero. */ |
+#define EBITSET_NONZERO_SET(BSET) \ |
+ (EBITSET_CACHE_DISABLE (BSET), (BSET)->b.cdata = (bitset_word *)~0) |
+ |
+/* A conservative estimate of whether the bitset is zero. |
+ This is non-zero only if we know for sure that the bitset is zero. */ |
+#define EBITSET_ZERO_P(BSET) ((BSET)->b.cdata == 0) |
+ |
+/* Enable cache to point to element with table index EINDEX. |
+ The element must exist. */ |
+#define EBITSET_CACHE_SET(BSET, EINDEX) \ |
+ ((BSET)->b.cindex = (EINDEX) * EBITSET_ELT_WORDS, \ |
+ (BSET)->b.cdata = EBITSET_WORDS (EBITSET_ELTS (BSET) [EINDEX])) |
+ |
+#undef min |
+#undef max |
+#define min(a, b) ((a) > (b) ? (b) : (a)) |
+#define max(a, b) ((a) > (b) ? (a) : (b)) |
+ |
+static bitset_bindex |
+ebitset_resize (bitset src, bitset_bindex n_bits) |
+{ |
+ bitset_windex oldsize; |
+ bitset_windex newsize; |
+ |
+ if (n_bits == BITSET_NBITS_ (src)) |
+ return n_bits; |
+ |
+ oldsize = EBITSET_SIZE (src); |
+ newsize = EBITSET_N_ELTS (n_bits); |
+ |
+ if (oldsize < newsize) |
+ { |
+ bitset_windex size; |
+ |
+ /* The bitset needs to grow. If we already have enough memory |
+ allocated, then just zero what we need. */ |
+ if (newsize > EBITSET_ASIZE (src)) |
+ { |
+ /* We need to allocate more memory. When oldsize is |
+ non-zero this means that we are changing the size, so |
+ grow the bitset 25% larger than requested to reduce |
+ number of reallocations. */ |
+ |
+ if (oldsize == 0) |
+ size = newsize; |
+ else |
+ size = newsize + newsize / 4; |
+ |
+ EBITSET_ELTS (src) |
+ = realloc (EBITSET_ELTS (src), size * sizeof (ebitset_elt *)); |
+ EBITSET_ASIZE (src) = size; |
+ } |
+ |
+ memset (EBITSET_ELTS (src) + oldsize, 0, |
+ (newsize - oldsize) * sizeof (ebitset_elt *)); |
+ } |
+ else |
+ { |
+ /* The bitset needs to shrink. There's no point deallocating |
+ the memory unless it is shrinking by a reasonable amount. */ |
+ if ((oldsize - newsize) >= oldsize / 2) |
+ { |
+ EBITSET_ELTS (src) |
+ = realloc (EBITSET_ELTS (src), newsize * sizeof (ebitset_elt *)); |
+ EBITSET_ASIZE (src) = newsize; |
+ } |
+ |
+ /* Need to prune any excess bits. FIXME. */ |
+ } |
+ |
+ BITSET_NBITS_ (src) = n_bits; |
+ return n_bits; |
+} |
+ |
+ |
+/* Allocate a ebitset element. The bits are not cleared. */ |
+static inline ebitset_elt * |
+ebitset_elt_alloc (void) |
+{ |
+ ebitset_elt *elt; |
+ |
+ if (ebitset_free_list != 0) |
+ { |
+ elt = ebitset_free_list; |
+ ebitset_free_list = EBITSET_NEXT (elt); |
+ } |
+ else |
+ { |
+ if (!ebitset_obstack_init) |
+ { |
+ ebitset_obstack_init = true; |
+ |
+ /* Let particular systems override the size of a chunk. */ |
+ |
+#ifndef OBSTACK_CHUNK_SIZE |
+#define OBSTACK_CHUNK_SIZE 0 |
+#endif |
+ |
+ /* Let them override the alloc and free routines too. */ |
+ |
+#ifndef OBSTACK_CHUNK_ALLOC |
+#define OBSTACK_CHUNK_ALLOC xmalloc |
+#endif |
+ |
+#ifndef OBSTACK_CHUNK_FREE |
+#define OBSTACK_CHUNK_FREE free |
+#endif |
+ |
+#if ! defined __GNUC__ || __GNUC__ < 2 |
+#define __alignof__(type) 0 |
+#endif |
+ |
+ obstack_specify_allocation (&ebitset_obstack, OBSTACK_CHUNK_SIZE, |
+ __alignof__ (ebitset_elt), |
+ OBSTACK_CHUNK_ALLOC, |
+ OBSTACK_CHUNK_FREE); |
+ } |
+ |
+ /* Perhaps we should add a number of new elements to the free |
+ list. */ |
+ elt = (ebitset_elt *) obstack_alloc (&ebitset_obstack, |
+ sizeof (ebitset_elt)); |
+ } |
+ |
+ return elt; |
+} |
+ |
+ |
+/* Allocate a ebitset element. The bits are cleared. */ |
+static inline ebitset_elt * |
+ebitset_elt_calloc (void) |
+{ |
+ ebitset_elt *elt; |
+ |
+ elt = ebitset_elt_alloc (); |
+ memset (EBITSET_WORDS (elt), 0, sizeof (EBITSET_WORDS (elt))); |
+ return elt; |
+} |
+ |
+ |
+static inline void |
+ebitset_elt_free (ebitset_elt *elt) |
+{ |
+ EBITSET_NEXT (elt) = ebitset_free_list; |
+ ebitset_free_list = elt; |
+} |
+ |
+ |
+/* Remove element with index EINDEX from bitset BSET. */ |
+static inline void |
+ebitset_elt_remove (bitset bset, bitset_windex eindex) |
+{ |
+ ebitset_elts *elts; |
+ ebitset_elt *elt; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ |
+ elt = elts[eindex]; |
+ |
+ elts[eindex] = 0; |
+ ebitset_elt_free (elt); |
+} |
+ |
+ |
+/* Add ELT into elts at index EINDEX of bitset BSET. */ |
+static inline void |
+ebitset_elt_add (bitset bset, ebitset_elt *elt, bitset_windex eindex) |
+{ |
+ ebitset_elts *elts; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ /* Assume that the elts entry not allocated. */ |
+ elts[eindex] = elt; |
+} |
+ |
+ |
+/* Are all bits in an element zero? */ |
+static inline bool |
+ebitset_elt_zero_p (ebitset_elt *elt) |
+{ |
+ int i; |
+ |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++) |
+ if (EBITSET_WORDS (elt)[i]) |
+ return false; |
+ |
+ return true; |
+} |
+ |
+ |
+static ebitset_elt * |
+ebitset_elt_find (bitset bset, bitset_bindex bindex, |
+ enum ebitset_find_mode mode) |
+{ |
+ ebitset_elt *elt; |
+ bitset_windex size; |
+ bitset_windex eindex; |
+ ebitset_elts *elts; |
+ |
+ eindex = bindex / EBITSET_ELT_BITS; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ size = EBITSET_SIZE (bset); |
+ |
+ if (eindex < size) |
+ { |
+ if ((elt = elts[eindex])) |
+ { |
+ if (EBITSET_WORDS (elt) == bset->b.cdata) |
+ return elt; |
+ |
+ EBITSET_CACHE_SET (bset, eindex); |
+ return elt; |
+ } |
+ } |
+ |
+ /* The element could not be found. */ |
+ |
+ switch (mode) |
+ { |
+ default: |
+ abort (); |
+ |
+ case EBITSET_FIND: |
+ return 0; |
+ |
+ case EBITSET_CREATE: |
+ if (eindex >= size) |
+ ebitset_resize (bset, bindex); |
+ |
+ /* Create a new element. */ |
+ elt = ebitset_elt_calloc (); |
+ ebitset_elt_add (bset, elt, eindex); |
+ EBITSET_CACHE_SET (bset, eindex); |
+ return elt; |
+ |
+ case EBITSET_SUBST: |
+ return &ebitset_zero_elts[0]; |
+ } |
+} |
+ |
+ |
+/* Weed out the zero elements from the elts. */ |
+static inline bitset_windex |
+ebitset_weed (bitset bset) |
+{ |
+ ebitset_elts *elts; |
+ bitset_windex j; |
+ bitset_windex count; |
+ |
+ if (EBITSET_ZERO_P (bset)) |
+ return 0; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ count = 0; |
+ for (j = 0; j < EBITSET_SIZE (bset); j++) |
+ { |
+ ebitset_elt *elt = elts[j]; |
+ |
+ if (elt) |
+ { |
+ if (ebitset_elt_zero_p (elt)) |
+ { |
+ ebitset_elt_remove (bset, j); |
+ count++; |
+ } |
+ } |
+ else |
+ count++; |
+ } |
+ |
+ count = j - count; |
+ if (!count) |
+ { |
+ /* All the bits are zero. We could shrink the elts. |
+ For now just mark BSET as known to be zero. */ |
+ EBITSET_ZERO_SET (bset); |
+ } |
+ else |
+ EBITSET_NONZERO_SET (bset); |
+ |
+ return count; |
+} |
+ |
+ |
+/* Set all bits in the bitset to zero. */ |
+static inline void |
+ebitset_zero (bitset bset) |
+{ |
+ ebitset_elts *elts; |
+ bitset_windex j; |
+ |
+ if (EBITSET_ZERO_P (bset)) |
+ return; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ for (j = 0; j < EBITSET_SIZE (bset); j++) |
+ { |
+ ebitset_elt *elt = elts[j]; |
+ |
+ if (elt) |
+ ebitset_elt_remove (bset, j); |
+ } |
+ |
+ /* All the bits are zero. We could shrink the elts. |
+ For now just mark BSET as known to be zero. */ |
+ EBITSET_ZERO_SET (bset); |
+} |
+ |
+ |
+static inline bool |
+ebitset_equal_p (bitset dst, bitset src) |
+{ |
+ ebitset_elts *selts; |
+ ebitset_elts *delts; |
+ bitset_windex j; |
+ |
+ if (src == dst) |
+ return true; |
+ |
+ ebitset_weed (dst); |
+ ebitset_weed (src); |
+ |
+ if (EBITSET_SIZE (src) != EBITSET_SIZE (dst)) |
+ return false; |
+ |
+ selts = EBITSET_ELTS (src); |
+ delts = EBITSET_ELTS (dst); |
+ |
+ for (j = 0; j < EBITSET_SIZE (src); j++) |
+ { |
+ unsigned int i; |
+ ebitset_elt *selt = selts[j]; |
+ ebitset_elt *delt = delts[j]; |
+ |
+ if (!selt && !delt) |
+ continue; |
+ if ((selt && !delt) || (!selt && delt)) |
+ return false; |
+ |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++) |
+ if (EBITSET_WORDS (selt)[i] != EBITSET_WORDS (delt)[i]) |
+ return false; |
+ } |
+ return true; |
+} |
+ |
+ |
+/* Copy bits from bitset SRC to bitset DST. */ |
+static inline void |
+ebitset_copy_ (bitset dst, bitset src) |
+{ |
+ ebitset_elts *selts; |
+ ebitset_elts *delts; |
+ bitset_windex j; |
+ |
+ if (src == dst) |
+ return; |
+ |
+ ebitset_zero (dst); |
+ |
+ if (BITSET_NBITS_ (dst) != BITSET_NBITS_ (src)) |
+ ebitset_resize (dst, BITSET_NBITS_ (src)); |
+ |
+ selts = EBITSET_ELTS (src); |
+ delts = EBITSET_ELTS (dst); |
+ for (j = 0; j < EBITSET_SIZE (src); j++) |
+ { |
+ ebitset_elt *selt = selts[j]; |
+ |
+ if (selt) |
+ { |
+ ebitset_elt *tmp; |
+ |
+ tmp = ebitset_elt_alloc (); |
+ delts[j] = tmp; |
+ memcpy (EBITSET_WORDS (tmp), EBITSET_WORDS (selt), |
+ sizeof (EBITSET_WORDS (selt))); |
+ } |
+ } |
+ EBITSET_NONZERO_SET (dst); |
+} |
+ |
+ |
+/* Copy bits from bitset SRC to bitset DST. Return true if |
+ bitsets different. */ |
+static inline bool |
+ebitset_copy_cmp (bitset dst, bitset src) |
+{ |
+ if (src == dst) |
+ return false; |
+ |
+ if (EBITSET_ZERO_P (dst)) |
+ { |
+ ebitset_copy_ (dst, src); |
+ return !EBITSET_ZERO_P (src); |
+ } |
+ |
+ if (ebitset_equal_p (dst, src)) |
+ return false; |
+ |
+ ebitset_copy_ (dst, src); |
+ return true; |
+} |
+ |
+ |
+/* Set bit BITNO in bitset DST. */ |
+static void |
+ebitset_set (bitset dst, bitset_bindex bitno) |
+{ |
+ bitset_windex windex = bitno / BITSET_WORD_BITS; |
+ |
+ ebitset_elt_find (dst, bitno, EBITSET_CREATE); |
+ |
+ dst->b.cdata[windex - dst->b.cindex] |= |
+ (bitset_word) 1 << (bitno % BITSET_WORD_BITS); |
+} |
+ |
+ |
+/* Reset bit BITNO in bitset DST. */ |
+static void |
+ebitset_reset (bitset dst, bitset_bindex bitno) |
+{ |
+ bitset_windex windex = bitno / BITSET_WORD_BITS; |
+ |
+ if (!ebitset_elt_find (dst, bitno, EBITSET_FIND)) |
+ return; |
+ |
+ dst->b.cdata[windex - dst->b.cindex] &= |
+ ~((bitset_word) 1 << (bitno % BITSET_WORD_BITS)); |
+ |
+ /* If all the data is zero, perhaps we should remove it now... |
+ However, there is a good chance that the element will be needed |
+ again soon. */ |
+} |
+ |
+ |
+/* Test bit BITNO in bitset SRC. */ |
+static bool |
+ebitset_test (bitset src, bitset_bindex bitno) |
+{ |
+ bitset_windex windex = bitno / BITSET_WORD_BITS; |
+ |
+ return (ebitset_elt_find (src, bitno, EBITSET_FIND) |
+ && ((src->b.cdata[windex - src->b.cindex] |
+ >> (bitno % BITSET_WORD_BITS)) |
+ & 1)); |
+} |
+ |
+ |
+static void |
+ebitset_free (bitset bset) |
+{ |
+ ebitset_zero (bset); |
+ free (EBITSET_ELTS (bset)); |
+} |
+ |
+ |
+/* Find list of up to NUM bits set in BSET starting from and including |
+ *NEXT and store in array LIST. Return with actual number of bits |
+ found and with *NEXT indicating where search stopped. */ |
+static bitset_bindex |
+ebitset_list_reverse (bitset bset, bitset_bindex *list, |
+ bitset_bindex num, bitset_bindex *next) |
+{ |
+ bitset_bindex n_bits; |
+ bitset_bindex bitno; |
+ bitset_bindex rbitno; |
+ unsigned int bcount; |
+ bitset_bindex boffset; |
+ bitset_windex windex; |
+ bitset_windex eindex; |
+ bitset_windex woffset; |
+ bitset_bindex count; |
+ bitset_windex size; |
+ ebitset_elts *elts; |
+ |
+ if (EBITSET_ZERO_P (bset)) |
+ return 0; |
+ |
+ size = EBITSET_SIZE (bset); |
+ n_bits = size * EBITSET_ELT_BITS; |
+ rbitno = *next; |
+ |
+ if (rbitno >= n_bits) |
+ return 0; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ |
+ bitno = n_bits - (rbitno + 1); |
+ |
+ windex = bitno / BITSET_WORD_BITS; |
+ eindex = bitno / EBITSET_ELT_BITS; |
+ woffset = windex - eindex * EBITSET_ELT_WORDS; |
+ |
+ /* If num is 1, we could speed things up with a binary search |
+ of the word of interest. */ |
+ |
+ count = 0; |
+ bcount = bitno % BITSET_WORD_BITS; |
+ boffset = windex * BITSET_WORD_BITS; |
+ |
+ do |
+ { |
+ ebitset_elt *elt; |
+ bitset_word *srcp; |
+ |
+ elt = elts[eindex]; |
+ if (elt) |
+ { |
+ srcp = EBITSET_WORDS (elt); |
+ |
+ do |
+ { |
+ bitset_word word; |
+ |
+ word = srcp[woffset] << (BITSET_WORD_BITS - 1 - bcount); |
+ |
+ for (; word; bcount--) |
+ { |
+ if (word & BITSET_MSB) |
+ { |
+ list[count++] = boffset + bcount; |
+ if (count >= num) |
+ { |
+ *next = n_bits - (boffset + bcount); |
+ return count; |
+ } |
+ } |
+ word <<= 1; |
+ } |
+ boffset -= BITSET_WORD_BITS; |
+ bcount = BITSET_WORD_BITS - 1; |
+ } |
+ while (woffset--); |
+ } |
+ |
+ woffset = EBITSET_ELT_WORDS - 1; |
+ boffset = eindex * EBITSET_ELT_BITS - BITSET_WORD_BITS; |
+ } |
+ while (eindex--); |
+ |
+ *next = n_bits - (boffset + 1); |
+ return count; |
+} |
+ |
+ |
+/* Find list of up to NUM bits set in BSET starting from and including |
+ *NEXT and store in array LIST. Return with actual number of bits |
+ found and with *NEXT indicating where search stopped. */ |
+static bitset_bindex |
+ebitset_list (bitset bset, bitset_bindex *list, |
+ bitset_bindex num, bitset_bindex *next) |
+{ |
+ bitset_bindex bitno; |
+ bitset_windex windex; |
+ bitset_windex eindex; |
+ bitset_bindex count; |
+ bitset_windex size; |
+ ebitset_elt *elt; |
+ bitset_word word; |
+ ebitset_elts *elts; |
+ |
+ if (EBITSET_ZERO_P (bset)) |
+ return 0; |
+ |
+ bitno = *next; |
+ count = 0; |
+ |
+ elts = EBITSET_ELTS (bset); |
+ size = EBITSET_SIZE (bset); |
+ eindex = bitno / EBITSET_ELT_BITS; |
+ |
+ if (bitno % EBITSET_ELT_BITS) |
+ { |
+ /* We need to start within an element. This is not very common. */ |
+ |
+ elt = elts[eindex]; |
+ if (elt) |
+ { |
+ bitset_windex woffset; |
+ bitset_word *srcp = EBITSET_WORDS (elt); |
+ |
+ windex = bitno / BITSET_WORD_BITS; |
+ woffset = eindex * EBITSET_ELT_WORDS; |
+ |
+ for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++) |
+ { |
+ word = srcp[windex - woffset] >> (bitno % BITSET_WORD_BITS); |
+ |
+ for (; word; bitno++) |
+ { |
+ if (word & 1) |
+ { |
+ list[count++] = bitno; |
+ if (count >= num) |
+ { |
+ *next = bitno + 1; |
+ return count; |
+ } |
+ } |
+ word >>= 1; |
+ } |
+ bitno = (windex + 1) * BITSET_WORD_BITS; |
+ } |
+ } |
+ |
+ /* Skip to next element. */ |
+ eindex++; |
+ } |
+ |
+ /* If num is 1, we could speed things up with a binary search |
+ of the word of interest. */ |
+ |
+ for (; eindex < size; eindex++) |
+ { |
+ int i; |
+ bitset_word *srcp; |
+ |
+ elt = elts[eindex]; |
+ if (!elt) |
+ continue; |
+ |
+ srcp = EBITSET_WORDS (elt); |
+ windex = eindex * EBITSET_ELT_WORDS; |
+ |
+ if ((count + EBITSET_ELT_BITS) < num) |
+ { |
+ /* The coast is clear, plant boot! */ |
+ |
+#if EBITSET_ELT_WORDS == 2 |
+ word = srcp[0]; |
+ if (word) |
+ { |
+ if (!(word & 0xffff)) |
+ { |
+ word >>= 16; |
+ bitno += 16; |
+ } |
+ if (!(word & 0xff)) |
+ { |
+ word >>= 8; |
+ bitno += 8; |
+ } |
+ for (; word; bitno++) |
+ { |
+ if (word & 1) |
+ list[count++] = bitno; |
+ word >>= 1; |
+ } |
+ } |
+ windex++; |
+ bitno = windex * BITSET_WORD_BITS; |
+ |
+ word = srcp[1]; |
+ if (word) |
+ { |
+ if (!(word & 0xffff)) |
+ { |
+ word >>= 16; |
+ bitno += 16; |
+ } |
+ for (; word; bitno++) |
+ { |
+ if (word & 1) |
+ list[count++] = bitno; |
+ word >>= 1; |
+ } |
+ } |
+ windex++; |
+ bitno = windex * BITSET_WORD_BITS; |
+#else |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++) |
+ { |
+ bitno = windex * BITSET_WORD_BITS; |
+ |
+ word = srcp[i]; |
+ if (word) |
+ { |
+ if (!(word & 0xffff)) |
+ { |
+ word >>= 16; |
+ bitno += 16; |
+ } |
+ if (!(word & 0xff)) |
+ { |
+ word >>= 8; |
+ bitno += 8; |
+ } |
+ for (; word; bitno++) |
+ { |
+ if (word & 1) |
+ list[count++] = bitno; |
+ word >>= 1; |
+ } |
+ } |
+ } |
+#endif |
+ } |
+ else |
+ { |
+ /* Tread more carefully since we need to check |
+ if array overflows. */ |
+ |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++, windex++) |
+ { |
+ bitno = windex * BITSET_WORD_BITS; |
+ |
+ for (word = srcp[i]; word; bitno++) |
+ { |
+ if (word & 1) |
+ { |
+ list[count++] = bitno; |
+ if (count >= num) |
+ { |
+ *next = bitno + 1; |
+ return count; |
+ } |
+ } |
+ word >>= 1; |
+ } |
+ } |
+ } |
+ } |
+ |
+ *next = bitno; |
+ return count; |
+} |
+ |
+ |
+/* Ensure that any unused bits within the last element are clear. */ |
+static inline void |
+ebitset_unused_clear (bitset dst) |
+{ |
+ unsigned int last_bit; |
+ bitset_bindex n_bits; |
+ |
+ n_bits = BITSET_NBITS_ (dst); |
+ last_bit = n_bits % EBITSET_ELT_BITS; |
+ |
+ if (last_bit) |
+ { |
+ bitset_windex eindex; |
+ ebitset_elts *elts; |
+ ebitset_elt *elt; |
+ |
+ elts = EBITSET_ELTS (dst); |
+ |
+ eindex = n_bits / EBITSET_ELT_BITS; |
+ |
+ elt = elts[eindex]; |
+ if (elt) |
+ { |
+ bitset_windex windex; |
+ bitset_windex woffset; |
+ bitset_word *srcp = EBITSET_WORDS (elt); |
+ |
+ windex = n_bits / BITSET_WORD_BITS; |
+ woffset = eindex * EBITSET_ELT_WORDS; |
+ |
+ srcp[windex - woffset] &= ((bitset_word) 1 << last_bit) - 1; |
+ windex++; |
+ for (; (windex - woffset) < EBITSET_ELT_WORDS; windex++) |
+ srcp[windex - woffset] = 0; |
+ } |
+ } |
+} |
+ |
+ |
+static void |
+ebitset_ones (bitset dst) |
+{ |
+ bitset_windex j; |
+ ebitset_elt *elt; |
+ |
+ for (j = 0; j < EBITSET_SIZE (dst); j++) |
+ { |
+ /* Create new elements if they cannot be found. Perhaps |
+ we should just add pointers to a ones element? */ |
+ elt = |
+ ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_CREATE); |
+ memset (EBITSET_WORDS (elt), -1, sizeof (EBITSET_WORDS (elt))); |
+ } |
+ EBITSET_NONZERO_SET (dst); |
+ ebitset_unused_clear (dst); |
+} |
+ |
+ |
+static bool |
+ebitset_empty_p (bitset dst) |
+{ |
+ ebitset_elts *elts; |
+ bitset_windex j; |
+ |
+ if (EBITSET_ZERO_P (dst)) |
+ return 1; |
+ |
+ elts = EBITSET_ELTS (dst); |
+ for (j = 0; j < EBITSET_SIZE (dst); j++) |
+ { |
+ ebitset_elt *elt = elts[j]; |
+ |
+ if (elt) |
+ { |
+ if (!ebitset_elt_zero_p (elt)) |
+ return 0; |
+ /* Do some weeding as we go. */ |
+ ebitset_elt_remove (dst, j); |
+ } |
+ } |
+ |
+ /* All the bits are zero. We could shrink the elts. |
+ For now just mark DST as known to be zero. */ |
+ EBITSET_ZERO_SET (dst); |
+ return 1; |
+} |
+ |
+ |
+static void |
+ebitset_not (bitset dst, bitset src) |
+{ |
+ unsigned int i; |
+ ebitset_elt *selt; |
+ ebitset_elt *delt; |
+ bitset_windex j; |
+ |
+ ebitset_resize (dst, BITSET_NBITS_ (src)); |
+ |
+ for (j = 0; j < EBITSET_SIZE (src); j++) |
+ { |
+ /* Create new elements for dst if they cannot be found |
+ or substitute zero elements if src elements not found. */ |
+ selt = |
+ ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_SUBST); |
+ delt = |
+ ebitset_elt_find (dst, j * EBITSET_ELT_BITS, EBITSET_CREATE); |
+ |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++) |
+ EBITSET_WORDS (delt)[i] = ~EBITSET_WORDS (selt)[i]; |
+ } |
+ EBITSET_NONZERO_SET (dst); |
+ ebitset_unused_clear (dst); |
+} |
+ |
+ |
+/* Is DST == DST | SRC? */ |
+static bool |
+ebitset_subset_p (bitset dst, bitset src) |
+{ |
+ bitset_windex j; |
+ ebitset_elts *selts; |
+ ebitset_elts *delts; |
+ bitset_windex ssize; |
+ bitset_windex dsize; |
+ |
+ selts = EBITSET_ELTS (src); |
+ delts = EBITSET_ELTS (dst); |
+ |
+ ssize = EBITSET_SIZE (src); |
+ dsize = EBITSET_SIZE (dst); |
+ |
+ for (j = 0; j < ssize; j++) |
+ { |
+ unsigned int i; |
+ ebitset_elt *selt; |
+ ebitset_elt *delt; |
+ |
+ selt = j < ssize ? selts[j] : 0; |
+ delt = j < dsize ? delts[j] : 0; |
+ |
+ if (!selt && !delt) |
+ continue; |
+ |
+ if (!selt) |
+ selt = &ebitset_zero_elts[0]; |
+ if (!delt) |
+ delt = &ebitset_zero_elts[0]; |
+ |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++) |
+ if (EBITSET_WORDS (delt)[i] |
+ != (EBITSET_WORDS (selt)[i] | EBITSET_WORDS (delt)[i])) |
+ return false; |
+ } |
+ return true; |
+} |
+ |
+ |
+/* Is DST & SRC == 0? */ |
+static bool |
+ebitset_disjoint_p (bitset dst, bitset src) |
+{ |
+ bitset_windex j; |
+ ebitset_elts *selts; |
+ ebitset_elts *delts; |
+ bitset_windex ssize; |
+ bitset_windex dsize; |
+ |
+ selts = EBITSET_ELTS (src); |
+ delts = EBITSET_ELTS (dst); |
+ |
+ ssize = EBITSET_SIZE (src); |
+ dsize = EBITSET_SIZE (dst); |
+ |
+ for (j = 0; j < ssize; j++) |
+ { |
+ unsigned int i; |
+ ebitset_elt *selt; |
+ ebitset_elt *delt; |
+ |
+ selt = j < ssize ? selts[j] : 0; |
+ delt = j < dsize ? delts[j] : 0; |
+ |
+ if (!selt || !delt) |
+ continue; |
+ |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++) |
+ if ((EBITSET_WORDS (selt)[i] & EBITSET_WORDS (delt)[i])) |
+ return false; |
+ } |
+ return true; |
+} |
+ |
+ |
+ |
+static bool |
+ebitset_op3_cmp (bitset dst, bitset src1, bitset src2, enum bitset_ops op) |
+{ |
+ bitset_windex ssize1; |
+ bitset_windex ssize2; |
+ bitset_windex dsize; |
+ bitset_windex size; |
+ ebitset_elts *selts1; |
+ ebitset_elts *selts2; |
+ ebitset_elts *delts; |
+ bitset_word *srcp1; |
+ bitset_word *srcp2; |
+ bitset_word *dstp; |
+ bool changed = false; |
+ unsigned int i; |
+ bitset_windex j; |
+ |
+ ebitset_resize (dst, max (BITSET_NBITS_ (src1), BITSET_NBITS_ (src2))); |
+ |
+ ssize1 = EBITSET_SIZE (src1); |
+ ssize2 = EBITSET_SIZE (src2); |
+ dsize = EBITSET_SIZE (dst); |
+ size = ssize1; |
+ if (size < ssize2) |
+ size = ssize2; |
+ |
+ selts1 = EBITSET_ELTS (src1); |
+ selts2 = EBITSET_ELTS (src2); |
+ delts = EBITSET_ELTS (dst); |
+ |
+ for (j = 0; j < size; j++) |
+ { |
+ ebitset_elt *selt1; |
+ ebitset_elt *selt2; |
+ ebitset_elt *delt; |
+ |
+ selt1 = j < ssize1 ? selts1[j] : 0; |
+ selt2 = j < ssize2 ? selts2[j] : 0; |
+ delt = j < dsize ? delts[j] : 0; |
+ |
+ if (!selt1 && !selt2) |
+ { |
+ if (delt) |
+ { |
+ changed = true; |
+ ebitset_elt_remove (dst, j); |
+ } |
+ continue; |
+ } |
+ |
+ if (!selt1) |
+ selt1 = &ebitset_zero_elts[0]; |
+ if (!selt2) |
+ selt2 = &ebitset_zero_elts[0]; |
+ if (!delt) |
+ delt = ebitset_elt_calloc (); |
+ else |
+ delts[j] = 0; |
+ |
+ srcp1 = EBITSET_WORDS (selt1); |
+ srcp2 = EBITSET_WORDS (selt2); |
+ dstp = EBITSET_WORDS (delt); |
+ switch (op) |
+ { |
+ default: |
+ abort (); |
+ |
+ case BITSET_OP_OR: |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++) |
+ { |
+ bitset_word tmp = *srcp1++ | *srcp2++; |
+ |
+ if (*dstp != tmp) |
+ { |
+ changed = true; |
+ *dstp = tmp; |
+ } |
+ } |
+ break; |
+ |
+ case BITSET_OP_AND: |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++) |
+ { |
+ bitset_word tmp = *srcp1++ & *srcp2++; |
+ |
+ if (*dstp != tmp) |
+ { |
+ changed = true; |
+ *dstp = tmp; |
+ } |
+ } |
+ break; |
+ |
+ case BITSET_OP_XOR: |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++) |
+ { |
+ bitset_word tmp = *srcp1++ ^ *srcp2++; |
+ |
+ if (*dstp != tmp) |
+ { |
+ changed = true; |
+ *dstp = tmp; |
+ } |
+ } |
+ break; |
+ |
+ case BITSET_OP_ANDN: |
+ for (i = 0; i < EBITSET_ELT_WORDS; i++, dstp++) |
+ { |
+ bitset_word tmp = *srcp1++ & ~(*srcp2++); |
+ |
+ if (*dstp != tmp) |
+ { |
+ changed = true; |
+ *dstp = tmp; |
+ } |
+ } |
+ break; |
+ } |
+ |
+ if (!ebitset_elt_zero_p (delt)) |
+ { |
+ ebitset_elt_add (dst, delt, j); |
+ } |
+ else |
+ { |
+ ebitset_elt_free (delt); |
+ } |
+ } |
+ |
+ /* If we have elements of DST left over, free them all. */ |
+ for (; j < dsize; j++) |
+ { |
+ ebitset_elt *delt; |
+ |
+ changed = true; |
+ |
+ delt = delts[j]; |
+ |
+ if (delt) |
+ ebitset_elt_remove (dst, j); |
+ } |
+ |
+ EBITSET_NONZERO_SET (dst); |
+ return changed; |
+} |
+ |
+ |
+static bool |
+ebitset_and_cmp (bitset dst, bitset src1, bitset src2) |
+{ |
+ bool changed; |
+ |
+ if (EBITSET_ZERO_P (src2)) |
+ { |
+ ebitset_weed (dst); |
+ changed = EBITSET_ZERO_P (dst); |
+ ebitset_zero (dst); |
+ return changed; |
+ } |
+ else if (EBITSET_ZERO_P (src1)) |
+ { |
+ ebitset_weed (dst); |
+ changed = EBITSET_ZERO_P (dst); |
+ ebitset_zero (dst); |
+ return changed; |
+ } |
+ return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_AND); |
+} |
+ |
+ |
+static void |
+ebitset_and (bitset dst, bitset src1, bitset src2) |
+{ |
+ ebitset_and_cmp (dst, src1, src2); |
+} |
+ |
+ |
+static bool |
+ebitset_andn_cmp (bitset dst, bitset src1, bitset src2) |
+{ |
+ bool changed; |
+ |
+ if (EBITSET_ZERO_P (src2)) |
+ { |
+ return ebitset_copy_cmp (dst, src1); |
+ } |
+ else if (EBITSET_ZERO_P (src1)) |
+ { |
+ ebitset_weed (dst); |
+ changed = EBITSET_ZERO_P (dst); |
+ ebitset_zero (dst); |
+ return changed; |
+ } |
+ return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_ANDN); |
+} |
+ |
+ |
+static void |
+ebitset_andn (bitset dst, bitset src1, bitset src2) |
+{ |
+ ebitset_andn_cmp (dst, src1, src2); |
+} |
+ |
+ |
+static bool |
+ebitset_or_cmp (bitset dst, bitset src1, bitset src2) |
+{ |
+ if (EBITSET_ZERO_P (src2)) |
+ { |
+ return ebitset_copy_cmp (dst, src1); |
+ } |
+ else if (EBITSET_ZERO_P (src1)) |
+ { |
+ return ebitset_copy_cmp (dst, src2); |
+ } |
+ return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_OR); |
+} |
+ |
+ |
+static void |
+ebitset_or (bitset dst, bitset src1, bitset src2) |
+{ |
+ ebitset_or_cmp (dst, src1, src2); |
+} |
+ |
+ |
+static bool |
+ebitset_xor_cmp (bitset dst, bitset src1, bitset src2) |
+{ |
+ if (EBITSET_ZERO_P (src2)) |
+ { |
+ return ebitset_copy_cmp (dst, src1); |
+ } |
+ else if (EBITSET_ZERO_P (src1)) |
+ { |
+ return ebitset_copy_cmp (dst, src2); |
+ } |
+ return ebitset_op3_cmp (dst, src1, src2, BITSET_OP_XOR); |
+} |
+ |
+ |
+static void |
+ebitset_xor (bitset dst, bitset src1, bitset src2) |
+{ |
+ ebitset_xor_cmp (dst, src1, src2); |
+} |
+ |
+ |
+static void |
+ebitset_copy (bitset dst, bitset src) |
+{ |
+ if (BITSET_COMPATIBLE_ (dst, src)) |
+ ebitset_copy_ (dst, src); |
+ else |
+ bitset_copy_ (dst, src); |
+} |
+ |
+ |
+/* Vector of operations for linked-list bitsets. */ |
+struct bitset_vtable ebitset_vtable = { |
+ ebitset_set, |
+ ebitset_reset, |
+ bitset_toggle_, |
+ ebitset_test, |
+ ebitset_resize, |
+ bitset_size_, |
+ bitset_count_, |
+ ebitset_empty_p, |
+ ebitset_ones, |
+ ebitset_zero, |
+ ebitset_copy, |
+ ebitset_disjoint_p, |
+ ebitset_equal_p, |
+ ebitset_not, |
+ ebitset_subset_p, |
+ ebitset_and, |
+ ebitset_and_cmp, |
+ ebitset_andn, |
+ ebitset_andn_cmp, |
+ ebitset_or, |
+ ebitset_or_cmp, |
+ ebitset_xor, |
+ ebitset_xor_cmp, |
+ bitset_and_or_, |
+ bitset_and_or_cmp_, |
+ bitset_andn_or_, |
+ bitset_andn_or_cmp_, |
+ bitset_or_and_, |
+ bitset_or_and_cmp_, |
+ ebitset_list, |
+ ebitset_list_reverse, |
+ ebitset_free, |
+ BITSET_TABLE |
+}; |
+ |
+ |
+/* Return size of initial structure. */ |
+size_t |
+ebitset_bytes (bitset_bindex n_bits ATTRIBUTE_UNUSED) |
+{ |
+ return sizeof (struct ebitset_struct); |
+} |
+ |
+ |
+/* Initialize a bitset. */ |
+ |
+bitset |
+ebitset_init (bitset bset, bitset_bindex n_bits) |
+{ |
+ bitset_windex size; |
+ |
+ bset->b.vtable = &ebitset_vtable; |
+ |
+ bset->b.csize = EBITSET_ELT_WORDS; |
+ |
+ EBITSET_ZERO_SET (bset); |
+ |
+ size = n_bits ? (n_bits + EBITSET_ELT_BITS - 1) / EBITSET_ELT_BITS |
+ : EBITSET_INITIAL_SIZE; |
+ |
+ EBITSET_ASIZE (bset) = 0; |
+ EBITSET_ELTS (bset) = 0; |
+ ebitset_resize (bset, n_bits); |
+ |
+ return bset; |
+} |
+ |
+ |
+void |
+ebitset_release_memory (void) |
+{ |
+ ebitset_free_list = 0; |
+ if (ebitset_obstack_init) |
+ { |
+ ebitset_obstack_init = false; |
+ obstack_free (&ebitset_obstack, NULL); |
+ } |
+} |
Property changes on: bison\src\bison\2.4.1\bison-2.4.1-src\lib\ebitset.c |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |