X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ef0175024063536689906e706f83ee9a12af98e3..eb34f4177cc4f71ee819e2fc741b9487d561b2ec:/lib/bitset.h

diff --git a/lib/bitset.h b/lib/bitset.h
index b96a7e67..42cf06f9 100644
--- a/lib/bitset.h
+++ b/lib/bitset.h
@@ -17,7 +17,7 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #ifndef _BITSET_H
-#define _BITSET_H
+#define _BITSET_H 
 
 /* This file is the public interface to the bitset abstract data type.
    Only use the functions and macros defined in this file.  */
@@ -44,6 +44,18 @@ struct bitset_struct
   struct bbitset_struct b;
 };
 
+
+/* The contents of this structure should be considered private.
+   It is used for iterating over set bits.  */
+typedef struct
+{
+  bitset_bindex list[BITSET_LIST_SIZE];
+  bitset_bindex next;
+  int num;
+  int i;
+} bitset_iterator;
+
+
 /* Return bytes required for bitset of desired type and size.  */
 extern int bitset_bytes PARAMS ((enum bitset_type, bitset_bindex));
 
@@ -78,7 +90,10 @@ extern int bitset_size PARAMS ((bitset));
 /* Return number of bits set in bitset SRC.  */
 extern int bitset_count PARAMS ((bitset));
 
-#if BITSET_CACHE && BITSET_INLINE
+/* Return bitset type.  */
+extern enum bitset_type bitset_type_get PARAMS ((bitset));
+
+#if BITSET_INLINE
 static inline void bitset_set PARAMS ((bitset, bitset_bindex));
 static inline void bitset_reset PARAMS ((bitset, bitset_bindex));
 static inline int bitset_test PARAMS ((bitset, bitset_bindex));
@@ -90,9 +105,9 @@ static inline void bitset_set (bset, bitno)
 {
   bitset_windex index = bitno / BITSET_WORD_BITS;
   bitset_windex offset = index - bset->b.cindex;
-
+  
   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));
   else
     BITSET_SET_ (bset, bitno);
 }
@@ -105,9 +120,9 @@ static inline void bitset_reset (bset, bitno)
 {
   bitset_windex index = bitno / BITSET_WORD_BITS;
   bitset_windex offset = index - bset->b.cindex;
-
+  
   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));
   else
     BITSET_RESET_ (bset, bitno);
 }
@@ -120,7 +135,7 @@ static inline int bitset_test (bset, bitno)
 {
   bitset_windex index = bitno / BITSET_WORD_BITS;
   bitset_windex offset = index - bset->b.cindex;
-
+  
   if (offset < bset->b.csize)
     return (bset->b.cdata[offset] >> (bitno % BITSET_WORD_BITS)) & 1;
   else
@@ -128,7 +143,7 @@ static inline int bitset_test (bset, bitno)
 }
 #endif
 
-#if BITSET_CACHE && ! BITSET_INLINE
+#if ! BITSET_INLINE
 
 /* Set bit BITNO in bitset BSET.  */
 #define bitset_set(bset, bitno)					\
@@ -139,7 +154,8 @@ do   								\
   bitset_windex _offset = _index - (bset)->b.cindex;		\
   								\
   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)); 	\
   else  							\
     BITSET_SET_ ((bset), _bitno);				\
 } while (0)
@@ -154,7 +170,8 @@ do   								\
   bitset_windex _offset = _index - (bset)->b.cindex;		\
   								\
   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)); 	\
   else  							\
     BITSET_RESET_ ((bset), _bitno);				\
 } while (0)
@@ -163,21 +180,16 @@ do   								\
 /* Test bit BITNO in bitset BSET.  */
 #define bitset_test(bset, bitno) \
 (((((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex) < (bset)->b.csize) \
-  ? ((bset)->b.cdata[(((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex)] \
-     >> ((bitno) % BITSET_WORD_BITS)) & 1 \
-  : (unsigned int) BITSET_TEST_ ((bset), (bitno)))
+  ? (((int)							\
+      ((bset)->b.cdata[(((bitno) / BITSET_WORD_BITS) - (bset)->b.cindex)] \
+       >> ((bitno) % BITSET_WORD_BITS)))			\
+     & 1)							\
+  : BITSET_TEST_ ((bset), (bitno)))
 #endif
 
-#if ! BITSET_CACHE
-/* Set bit BITNO in bitset SRC.  */
-#define bitset_set(SRC, BITNO) BITSET_SET_ (SRC, BITNO)
 
-/* Reset bit BITNO in bitset SRC.  */
-#define bitset_reset(SRC, BITNO) BITSET_RESET_ (SRC, BITNO)
-
-/* Return non-zero if bit BITNO in bitset SRC is set.  */
-#define bitset_test(SRC, BITNO) BITSET_TEST_ (SRC, BITNO)
-#endif
+/* Toggle bit BITNO in bitset BSET and return non-zero if now set.  */
+extern int bitset_toggle PARAMS ((bitset, bitset_bindex));
 
 /* DST = 0.  */
 extern int bitset_zero PARAMS ((bitset));
@@ -215,9 +227,6 @@ extern int bitset_xor PARAMS ((bitset, bitset, bitset));
 /* DST = SRC1 & ~SRC2.  Return non-zero if DST != SRC1 & ~SRC2.  */
 extern int bitset_andn PARAMS ((bitset, bitset, bitset));
 
-/* DST = SRC1 | ~SRC2.  Return non-zero if DST != SRC1 | ~SRC2.  */
-extern int bitset_orn PARAMS ((bitset, bitset, bitset));
-
 /* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
    DST != (SRC1 | SRC2) & SRC3.  */
 extern int bitset_or_and PARAMS ((bitset, bitset, bitset, bitset));
@@ -236,22 +245,20 @@ extern int bitset_next PARAMS ((bitset, bitset_bindex));
 /* Find previous bit set in BSET starting from and including BITNO.  */
 extern int bitset_prev PARAMS ((bitset, bitset_bindex));
 
-/* Find list of up to NUM bits set in BSET starting from and including
+/* Return non-zero if BITNO in SRC is the only set bit.  */
+extern int bitset_only_set_p PARAMS ((bitset, bitset_bindex));
+
+/* Find list of up to NUM bits set in BSET starting from and including 
    *NEXT.  Return with actual number of bits found and with *NEXT
    indicating where search stopped.  */
-#if BITSET_STATS
-extern int bitset_list PARAMS ((bitset, bitset_bindex *, bitset_bindex,
-				bitset_bindex *));
-#else
 #define bitset_list(BSET, LIST, NUM, NEXT) \
-BITSET_LIST_ (BSET, LIST, NUM, NEXT)
-#endif
+BITSET_LIST_ (BSET, LIST, NUM, NEXT) 
 
 /* Find reverse list of up to NUM bits set in BSET starting from and
    including NEXT.  Return with actual number of bits found and with
    *NEXT indicating where search stopped.  */
 #define bitset_reverse_list(BSET, LIST, NUM, NEXT) \
-BITSET_REVERSE_LIST_ (BSET, LIST, NUM, NEXT)
+BITSET_REVERSE_LIST_ (BSET, LIST, NUM, NEXT) 
 
 /* Find first set bit.  */
 extern int bitset_first PARAMS ((bitset));
@@ -262,69 +269,52 @@ extern int bitset_last PARAMS ((bitset));
 /* Dump bitset.  */
 extern void bitset_dump PARAMS ((FILE *, bitset));
 
-/* Loop over all elements of BSET, starting with MIN, executing CODE.  */
-#define BITSET_EXECUTE(BSET, MIN, N, CODE)				\
-do {									\
-  bitset_bindex _list[BITSET_LIST_SIZE];				\
-  bitset_bindex _next = (MIN);						\
-  int _num;								\
-    									\
-  while ((_num = bitset_list ((BSET), _list, BITSET_LIST_SIZE, &_next)))\
-    {									\
-       int _i;								\
-									\
-       for (_i = 0; _i < _num; _i++)					\
-	 {								\
-	    (N) = _list[_i];						\
-            CODE;							\
-	 }								\
-       if (_num < BITSET_LIST_SIZE)					\
-         break;								\
-    }									\
-} while (0)
+/* Loop over all elements of BSET, starting with MIN, setting BIT
+   to the index of each set bit.  */
+#define BITSET_FOR_EACH(ITER, BSET, BIT, MIN)				      \
+  for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;			      \
+       (ITER.num == BITSET_LIST_SIZE) 					      \
+       && (ITER.num = bitset_list (BSET, ITER.list, 			      \
+                                   BITSET_LIST_SIZE, &ITER.next));)	      \
+    for (ITER.i = 0; (BIT) = ITER.list[ITER.i], ITER.i < ITER.num; ITER.i++)
 
 
 /* Loop over all elements of BSET, in reverse order starting with
-   MIN, executing CODE.  */
-#define BITSET_REVERSE_EXECUTE(BSET, MIN, N, CODE)			\
-do {									\
-  bitset_bindex _list[BITSET_LIST_SIZE];				\
-  bitset_bindex _next = (MIN);						\
-  int _num;								\
-    									\
-  while ((_num = bitset_reverse_list ((BSET), _list, 			\
-                                      BITSET_LIST_SIZE, &_next)))	\
-    {									\
-       int _i;								\
-									\
-       for (_i = 0; _i < _num; _i++)					\
-	 {								\
-	    (N) = _list[_i];						\
-            CODE;							\
-	 }								\
-       if (_num < BITSET_LIST_SIZE)					\
-         break;								\
-    }									\
-} while (0)
+   MIN,  setting BIT to the index of each set bit.  */
+#define BITSET_FOR_EACH_REVERSE(ITER, BSET, BIT, MIN)			      \
+  for (ITER.next = (MIN), ITER.num = BITSET_LIST_SIZE;			      \
+       (ITER.num == BITSET_LIST_SIZE) 					      \
+       && (ITER.num = bitset_list_reverse (BSET, ITER.list,		      \
+                                          BITSET_LIST_SIZE, &ITER.next));)    \
+    for (ITER.i = 0; (BIT) = ITER.list[ITER.i], ITER.i < ITER.num; ITER.i++)
 
 
 /* Define set operations in terms of logical operations.  */
 
-#define bitset_diff(DST, SRC1, SRC2)  bitset_andn (DST, SRC1, SRC2)
+#define bitset_diff(DST, SRC1, SRC2)  bitset_andn (DST, SRC1, SRC2) 
 
-#define bitset_intersection(DST, SRC1, SRC2)  bitset_and (DST, SRC1, SRC2)
+#define bitset_intersection(DST, SRC1, SRC2)  bitset_and (DST, SRC1, SRC2) 
 
-#define bitset_union(DST, SRC1, SRC2)  bitset_or (DST, SRC1, SRC2)
+#define bitset_union(DST, SRC1, SRC2)  bitset_or (DST, SRC1, SRC2) 
 
 #define bitset_diff_union(DST, SRC1, SRC2, SRC3) \
-  bitset_andn_or (DST, SRC1, SRC2, SRC3)
+  bitset_andn_or (DST, SRC1, SRC2, SRC3) 
 
 
 /* Release any memory tied up with bitsets.  */
 extern void bitset_release_memory PARAMS ((void));
 
-/* Initialise bitset stats.  */
-extern void bitset_stats_init PARAMS ((void));
+/* Enable bitset stats gathering.  */
+extern void bitset_stats_enable PARAMS ((void));
+
+/* Disable bitset stats gathering.  */
+extern void bitset_stats_disable PARAMS ((void));
+
+/* Read bitset stats file of accummulated stats.  */
+void bitset_stats_read PARAMS ((const char *filename));
+
+/* Write bitset stats file of accummulated stats.  */
+void bitset_stats_write PARAMS ((const char *filename));
 
 /* Dump bitset stats.  */
 extern void bitset_stats_dump PARAMS ((FILE *));
@@ -336,3 +326,4 @@ extern void debug_bitset PARAMS ((bitset));
 extern void debug_bitset_stats PARAMS ((void));
 
 #endif /* _BITSET_H  */
+