[bison.git] / lib / bbitset.h

/* Base bitset stuff.
   Copyright (C) 2002 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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#ifndef _BBITSET_H
#define _BBITSET_H

#include "libiberty.h"

#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif

/* Use the following types for function parameters where the
   corresponding enum would be the correct type if we could use
   prototyped function definitions.  Standard C says that one cannot
   portably use an enum as a parameter of an old-style function
   definition that is also declared with a prototype.  */

typedef int enum_bitset_ops;
typedef int enum_bitset_type;

/* Currently we support three flavours of bitsets:
   BITSET_ARRAY:  Array of bits (fixed size, fast for dense bitsets).
   BITSET_LIST:   Linked list of array of bits (variable size, least storage
                  for large very sparse sets). 
   BITSET_TABLE:  Expandable table of pointers to array of bits 
                  (variable size, less storage for large sparse sets). 

   BITSET_STATS:  Wrapper bitset for internal use only.
*/
enum bitset_type {BITSET_ARRAY, BITSET_LIST, BITSET_TABLE, BITSET_TYPE_NUM,
		  BITSET_STATS};
#define BITSET_TYPE_NAMES {"abitset", "lbitset", "ebitset"}

extern const char * const bitset_type_names[];

enum bitset_alloc_type {BITSET_MALLOC, BITSET_OBALLOC};

/* Non-zero to use inline functions instead of macros.  */
#define BITSET_INLINE 0

/* Data type used to store a word of bits.  */
typedef unsigned long bitset_word;
#define BITSET_WORD_BITS ((unsigned) (CHAR_BIT * sizeof (bitset_word)))

/* Bit index.  In theory we might need a type wider than size_t, but
   in practice we lose at most a factor of CHAR_BIT by going with
   size_t, and that is good enough.  If this type is changed to be
   wider than size_t, the code needs to be modified to check for
   overflow when converting bit counts to byte or word counts.
   The bit and word index types must be unsigned.  */
typedef size_t bitset_bindex;

/* Word index.  */
typedef size_t bitset_windex;

/* Maximum values for commonly-used unsigned types.  BITSET_SIZE_MAX
   always equals SIZE_MAX, but some older systems lack SIZE_MAX.  */
#define BITSET_BINDEX_MAX ((bitset_bindex) -1)

/* Limit max word index to the maximum value of a signed integer
   to simplify cache disabling.  */
#define BITSET_WINDEX_MAX (((bitset_windex) -1) >> 1)
#define BITSET_SIZE_MAX ((size_t) -1)

#define BITSET_MSB ((bitset_word) 1 << (BITSET_WORD_BITS - 1))

#define BITSET_LIST_SIZE 1024

enum bitset_ops {BITSET_OP_ZERO, BITSET_OP_ONES, 
		 BITSET_OP_COPY, BITSET_OP_NOT, 
		 BITSET_OP_EMPTY_P, BITSET_OP_EQUAL_P,
		 BITSET_OP_SUBSET_P, BITSET_OP_DISJOINT_P,
		 BITSET_OP_AND, BITSET_OP_OR, BITSET_OP_XOR, BITSET_OP_ANDN, 
		 BITSET_OP_OR_AND, BITSET_OP_AND_OR, BITSET_OP_ANDN_OR};

struct bbitset_struct
{
  const struct bitset_vtable * vtable;
  bitset_windex cindex;		/* Cache word index.  */
  bitset_windex csize;		/* Cache size in words.  */
  bitset_word *cdata;		/* Cache data pointer.  */
  /* Perhaps we could sacrifice another word to indicate
     that the bitset is known to be zero, that a bit has been set
     in the cache, and that a bit has been cleared in the cache.
     This would speed up some of the searches but slightly slow down
     bit set/reset operations of cached bits.  */
};


typedef union bitset_union *bitset;


/* The contents of this structure should be considered private.  */
struct bitset_vtable
{
  void (*set) PARAMS ((bitset, bitset_bindex));
  void (*reset) PARAMS ((bitset, bitset_bindex));
  int (*toggle) PARAMS ((bitset, bitset_bindex));
  int (*test) PARAMS ((bitset, bitset_bindex));
  bitset_bindex (*size) PARAMS ((bitset));
  bitset_bindex (*count) PARAMS ((bitset));

  int (*empty_p) PARAMS ((bitset));
  void (*ones) PARAMS ((bitset));
  void (*zero) PARAMS ((bitset));

  void (*copy) PARAMS ((bitset, bitset));
  int (*disjoint_p) PARAMS ((bitset, bitset));
  int (*equal_p) PARAMS ((bitset, bitset));
  void (*not) PARAMS ((bitset, bitset));
  int (*subset_p) PARAMS ((bitset, bitset));

  void (*and) PARAMS ((bitset, bitset, bitset));
  int (*and_cmp) PARAMS ((bitset, bitset, bitset));
  void (*andn) PARAMS ((bitset, bitset, bitset));
  int (*andn_cmp) PARAMS ((bitset, bitset, bitset));
  void (*or) PARAMS ((bitset, bitset, bitset));
  int (*or_cmp) PARAMS ((bitset, bitset, bitset));
  void (*xor) PARAMS ((bitset, bitset, bitset));
  int (*xor_cmp) PARAMS ((bitset, bitset, bitset));

  void (*and_or) PARAMS ((bitset, bitset, bitset, bitset));
  int (*and_or_cmp) PARAMS ((bitset, bitset, bitset, bitset));
  void (*andn_or) PARAMS ((bitset, bitset, bitset, bitset));
  int (*andn_or_cmp) PARAMS ((bitset, bitset, bitset, bitset));
  void (*or_and) PARAMS ((bitset, bitset, bitset, bitset));
  int (*or_and_cmp) PARAMS ((bitset, bitset, bitset, bitset));

  bitset_bindex (*list) PARAMS ((bitset, bitset_bindex *,
				 bitset_bindex, bitset_bindex *));
  bitset_bindex (*list_reverse) PARAMS ((bitset,
					 bitset_bindex *, bitset_bindex,
					 bitset_bindex *));
  void (*free) PARAMS ((bitset));
  enum bitset_type type;
};

#define BITSET_COMPATIBLE_(BSET1, BSET2) ((BSET1)->b.vtable == (BSET2)->b.vtable)

#define BITSET_CHECK2_(DST, SRC) \
if (!BITSET_COMPATIBLE_ (DST, SRC)) abort ();

#define BITSET_CHECK3_(DST, SRC1, SRC2) \
if (!BITSET_COMPATIBLE_ (DST, SRC1) \
    || !BITSET_COMPATIBLE_ (DST, SRC2)) abort ();

#define BITSET_CHECK4_(DST, SRC1, SRC2, SRC3) \
if (!BITSET_COMPATIBLE_ (DST, SRC1) || !BITSET_COMPATIBLE_ (DST, SRC2) \
    || !BITSET_COMPATIBLE_ (DST, SRC3)) abort ();


/* Return size in bits of bitset SRC.  */
#define BITSET_SIZE_(SRC) (SRC)->b.vtable->size (SRC) 

/* Return number of bits set in bitset SRC.  */
#define BITSET_COUNT_(SRC) (SRC)->b.vtable->count (SRC) 

/* Return type of bitset SRC.  */
#define BITSET_TYPE_(DST) (DST)->b.vtable->type 

/* Set bit BITNO in bitset DST.  */
#define BITSET_SET_(DST, BITNO) (DST)->b.vtable->set (DST, BITNO) 

/* Reset bit BITNO in bitset DST.  */
#define BITSET_RESET_(DST, BITNO) (DST)->b.vtable->reset (DST, BITNO) 

/* Toggle bit BITNO in bitset DST.  */
#define BITSET_TOGGLE_(DST, BITNO) (DST)->b.vtable->toggle (DST, BITNO) 

/* Return non-zero if bit BITNO in bitset SRC is set.  */
#define BITSET_TEST_(SRC, BITNO) (SRC)->b.vtable->test (SRC, BITNO) 

/* Free bitset SRC.  */
#define BITSET_FREE_(SRC)\
 ((SRC)->b.vtable->free ? (SRC)->b.vtable->free (SRC) :(void)0)


/* Return SRC == 0.  */
#define BITSET_EMPTY_P_(SRC) (SRC)->b.vtable->empty_p (SRC)

/* DST = ~0.  */
#define BITSET_ONES_(DST) (DST)->b.vtable->ones (DST)

/* DST = 0.  */
#define BITSET_ZERO_(DST) (DST)->b.vtable->zero (DST)


/* DST = SRC.  */
#define BITSET_COPY_(DST, SRC) (SRC)->b.vtable->copy (DST, SRC)

/* Return DST & SRC == 0.  */
#define BITSET_DISJOINT_P_(DST, SRC) (SRC)->b.vtable->disjoint_p (DST, SRC)

/* Return DST == SRC.  */
#define BITSET_EQUAL_P_(DST, SRC) (SRC)->b.vtable->equal_p (DST, SRC)

/* DST = ~SRC.  */
#define BITSET_NOT_(DST, SRC) (SRC)->b.vtable->not (DST, SRC)

/* Return DST == DST | SRC.  */
#define BITSET_SUBSET_P_(DST, SRC) (SRC)->b.vtable->subset_p (DST, SRC)


/* DST = SRC1 & SRC2.  */
#define BITSET_AND_(DST, SRC1, SRC2) (SRC1)->b.vtable->and (DST, SRC1, SRC2)
#define BITSET_AND_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->and_cmp (DST, SRC1, SRC2)

/* DST = SRC1 & ~SRC2.  */
#define BITSET_ANDN_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn (DST, SRC1, SRC2)
#define BITSET_ANDN_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn_cmp (DST, SRC1, SRC2)

/* DST = SRC1 | SRC2.  */
#define BITSET_OR_(DST, SRC1, SRC2) (SRC1)->b.vtable->or (DST, SRC1, SRC2)
#define BITSET_OR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->or_cmp (DST, SRC1, SRC2)

/* DST = SRC1 ^ SRC2.  */
#define BITSET_XOR_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor (DST, SRC1, SRC2)
#define BITSET_XOR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor_cmp (DST, SRC1, SRC2)


/* DST = (SRC1 & SRC2) | SRC3.  Return non-zero if
   DST != (SRC1 & SRC2) | SRC3.  */
#define BITSET_AND_OR_(DST, SRC1, SRC2, SRC3) \
 (SRC1)->b.vtable->and_or (DST, SRC1, SRC2, SRC3)
#define BITSET_AND_OR_CMP_(DST, SRC1, SRC2, SRC3) \
 (SRC1)->b.vtable->and_or_cmp (DST, SRC1, SRC2, SRC3)

/* DST = (SRC1 & ~SRC2) | SRC3.  Return non-zero if
   DST != (SRC1 & ~SRC2) | SRC3.  */
#define BITSET_ANDN_OR_(DST, SRC1, SRC2, SRC3) \
 (SRC1)->b.vtable->andn_or (DST, SRC1, SRC2, SRC3)
#define BITSET_ANDN_OR_CMP_(DST, SRC1, SRC2, SRC3) \
 (SRC1)->b.vtable->andn_or_cmp (DST, SRC1, SRC2, SRC3)

/* DST = (SRC1 | SRC2) & SRC3.  Return non-zero if
   DST != (SRC1 | SRC2) & SRC3.  */
#define BITSET_OR_AND_(DST, SRC1, SRC2, SRC3) \
 (SRC1)->b.vtable->or_and (DST, SRC1, SRC2, SRC3)
#define BITSET_OR_AND_CMP_(DST, SRC1, SRC2, SRC3) \
 (SRC1)->b.vtable->or_and_cmp (DST, SRC1, SRC2, SRC3)


/* 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.  */
#define BITSET_LIST_(BSET, LIST, NUM, NEXT) \
 (BSET)->b.vtable->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_LIST_REVERSE_(BSET, LIST, NUM, NEXT) \
 (BSET)->b.vtable->list_reverse (BSET, LIST, NUM, NEXT) 


/* Private functions for bitset implementations.  */
 
extern int bitset_toggle_ PARAMS ((bitset, bitset_bindex));

extern bitset_bindex bitset_count_ PARAMS ((bitset));

extern int bitset_copy_ PARAMS ((bitset, bitset));

extern void bitset_and_or_ PARAMS ((bitset, bitset, bitset, bitset));

extern int bitset_and_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));

extern void bitset_andn_or_ PARAMS ((bitset, bitset, bitset, bitset));

extern int bitset_andn_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));

extern void bitset_or_and_ PARAMS ((bitset, bitset, bitset, bitset));

extern int bitset_or_and_cmp_ PARAMS ((bitset, bitset, bitset, bitset));

#endif /* _BBITSET_H  */
Commit	Line	Data
ef017502 AD	1	/* Base bitset stuff.
	2	Copyright (C) 2002 Free Software Foundation, Inc.
	3	Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	18
	19	#ifndef _BBITSET_H
	20	#define _BBITSET_H
	21
613f5e1a	22	#include "libiberty.h"
ef017502 AD	23
	24	#ifdef HAVE_LIMITS_H
	25	#include <limits.h>
	26	#endif
	27
d9d83ef2 PE	28	/* Use the following types for function parameters where the
	29	corresponding enum would be the correct type if we could use
	30	prototyped function definitions. Standard C says that one cannot
	31	portably use an enum as a parameter of an old-style function
	32	definition that is also declared with a prototype. */
	33
	34	typedef int enum_bitset_ops;
	35	typedef int enum_bitset_type;
	36
ef017502	37	/* Currently we support three flavours of bitsets:
6aa452a6	38	BITSET_ARRAY: Array of bits (fixed size, fast for dense bitsets).
ef017502	39	BITSET_LIST: Linked list of array of bits (variable size, least storage
6aa452a6	40	for large very sparse sets).
613f5e1a	41	BITSET_TABLE: Expandable table of pointers to array of bits
6aa452a6	42	(variable size, less storage for large sparse sets).
613f5e1a AD	43
613f5e1a AD	44	BITSET_STATS: Wrapper bitset for internal use only.
ef017502	45	*/
613f5e1a AD	46	enum bitset_type {BITSET_ARRAY, BITSET_LIST, BITSET_TABLE, BITSET_TYPE_NUM,
	47	BITSET_STATS};
	48	#define BITSET_TYPE_NAMES {"abitset", "lbitset", "ebitset"}
ef017502	49
6aa452a6 AD	50	extern const char * const bitset_type_names[];
6aa452a6 AD	51
613f5e1a	52	enum bitset_alloc_type {BITSET_MALLOC, BITSET_OBALLOC};
ef017502 AD	53
	54	/* Non-zero to use inline functions instead of macros. */
	55	#define BITSET_INLINE 0
	56
ef017502 AD	57	/* Data type used to store a word of bits. */
ef017502 AD	58	typedef unsigned long bitset_word;
50f095c9	59	#define BITSET_WORD_BITS ((unsigned) (CHAR_BIT * sizeof (bitset_word)))
ef017502	60
50f095c9 PE	61	/* Bit index. In theory we might need a type wider than size_t, but
50f095c9 PE	62	in practice we lose at most a factor of CHAR_BIT by going with
f6ebdb31 PE	63	size_t, and that is good enough. If this type is changed to be
	64	wider than size_t, the code needs to be modified to check for
	65	overflow when converting bit counts to byte or word counts.
	66	The bit and word index types must be unsigned. */
50f095c9	67	typedef size_t bitset_bindex;
ef017502 AD	68
ef017502 AD	69	/* Word index. */
50f095c9	70	typedef size_t bitset_windex;
ef017502	71
f6ebdb31 PE	72	/* Maximum values for commonly-used unsigned types. BITSET_SIZE_MAX
	73	always equals SIZE_MAX, but some older systems lack SIZE_MAX. */
	74	#define BITSET_BINDEX_MAX ((bitset_bindex) -1)
5beedd9b PE	75
	76	/* Limit max word index to the maximum value of a signed integer
	77	to simplify cache disabling. */
	78	#define BITSET_WINDEX_MAX (((bitset_windex) -1) >> 1)
f6ebdb31	79	#define BITSET_SIZE_MAX ((size_t) -1)
ef017502	80
50f095c9	81	#define BITSET_MSB ((bitset_word) 1 << (BITSET_WORD_BITS - 1))
ef017502 AD	82
	83	#define BITSET_LIST_SIZE 1024
	84
613f5e1a AD	85	enum bitset_ops {BITSET_OP_ZERO, BITSET_OP_ONES,
613f5e1a AD	86	BITSET_OP_COPY, BITSET_OP_NOT,
ef017502 AD	87	BITSET_OP_EMPTY_P, BITSET_OP_EQUAL_P,
ef017502 AD	88	BITSET_OP_SUBSET_P, BITSET_OP_DISJOINT_P,
613f5e1a	89	BITSET_OP_AND, BITSET_OP_OR, BITSET_OP_XOR, BITSET_OP_ANDN,
ef017502 AD	90	BITSET_OP_OR_AND, BITSET_OP_AND_OR, BITSET_OP_ANDN_OR};
ef017502 AD	91
6aa452a6 AD	92	struct bbitset_struct
	93	{
	94	const struct bitset_vtable * vtable;
	95	bitset_windex cindex; /* Cache word index. */
	96	bitset_windex csize; /* Cache size in words. */
	97	bitset_word cdata; / Cache data pointer. */
	98	/* Perhaps we could sacrifice another word to indicate
	99	that the bitset is known to be zero, that a bit has been set
	100	in the cache, and that a bit has been cleared in the cache.
	101	This would speed up some of the searches but slightly slow down
	102	bit set/reset operations of cached bits. */
	103	};
	104
	105
d9d83ef2	106	typedef union bitset_union *bitset;
6aa452a6 AD	107
	108
	109	/* The contents of this structure should be considered private. */
	110	struct bitset_vtable
	111	{
d9d83ef2 PE	112	void (*set) PARAMS ((bitset, bitset_bindex));
	113	void (*reset) PARAMS ((bitset, bitset_bindex));
	114	int (*toggle) PARAMS ((bitset, bitset_bindex));
	115	int (*test) PARAMS ((bitset, bitset_bindex));
	116	bitset_bindex (*size) PARAMS ((bitset));
	117	bitset_bindex (*count) PARAMS ((bitset));
	118
	119	int (*empty_p) PARAMS ((bitset));
	120	void (*ones) PARAMS ((bitset));
	121	void (*zero) PARAMS ((bitset));
	122
	123	void (*copy) PARAMS ((bitset, bitset));
	124	int (*disjoint_p) PARAMS ((bitset, bitset));
	125	int (*equal_p) PARAMS ((bitset, bitset));
	126	void (*not) PARAMS ((bitset, bitset));
	127	int (*subset_p) PARAMS ((bitset, bitset));
	128
	129	void (*and) PARAMS ((bitset, bitset, bitset));
	130	int (*and_cmp) PARAMS ((bitset, bitset, bitset));
	131	void (*andn) PARAMS ((bitset, bitset, bitset));
	132	int (*andn_cmp) PARAMS ((bitset, bitset, bitset));
	133	void (*or) PARAMS ((bitset, bitset, bitset));
	134	int (*or_cmp) PARAMS ((bitset, bitset, bitset));
	135	void (*xor) PARAMS ((bitset, bitset, bitset));
	136	int (*xor_cmp) PARAMS ((bitset, bitset, bitset));
	137
	138	void (*and_or) PARAMS ((bitset, bitset, bitset, bitset));
	139	int (*and_or_cmp) PARAMS ((bitset, bitset, bitset, bitset));
	140	void (*andn_or) PARAMS ((bitset, bitset, bitset, bitset));
	141	int (*andn_or_cmp) PARAMS ((bitset, bitset, bitset, bitset));
	142	void (*or_and) PARAMS ((bitset, bitset, bitset, bitset));
	143	int (*or_and_cmp) PARAMS ((bitset, bitset, bitset, bitset));
	144
	145	bitset_bindex (list) PARAMS ((bitset, bitset_bindex ,
f6ebdb31	146	bitset_bindex, bitset_bindex *));
d9d83ef2	147	bitset_bindex (*list_reverse) PARAMS ((bitset,
f6ebdb31 PE	148	bitset_bindex *, bitset_bindex,
f6ebdb31 PE	149	bitset_bindex *));
d9d83ef2	150	void (*free) PARAMS ((bitset));
6aa452a6 AD	151	enum bitset_type type;
	152	};
	153
	154	#define BITSET_COMPATIBLE_(BSET1, BSET2) ((BSET1)->b.vtable == (BSET2)->b.vtable)
	155
	156	#define BITSET_CHECK2_(DST, SRC) \
	157	if (!BITSET_COMPATIBLE_ (DST, SRC)) abort ();
	158
	159	#define BITSET_CHECK3_(DST, SRC1, SRC2) \
	160	if (!BITSET_COMPATIBLE_ (DST, SRC1) \
	161	\|\| !BITSET_COMPATIBLE_ (DST, SRC2)) abort ();
	162
	163	#define BITSET_CHECK4_(DST, SRC1, SRC2, SRC3) \
	164	if (!BITSET_COMPATIBLE_ (DST, SRC1) \|\| !BITSET_COMPATIBLE_ (DST, SRC2) \
	165	\|\| !BITSET_COMPATIBLE_ (DST, SRC3)) abort ();
	166
	167
ef017502	168	/* Return size in bits of bitset SRC. */
6aa452a6 AD	169	#define BITSET_SIZE_(SRC) (SRC)->b.vtable->size (SRC)
	170
	171	/* Return number of bits set in bitset SRC. */
	172	#define BITSET_COUNT_(SRC) (SRC)->b.vtable->count (SRC)
ef017502 AD	173
ef017502 AD	174	/* Return type of bitset SRC. */
6aa452a6	175	#define BITSET_TYPE_(DST) (DST)->b.vtable->type
ef017502 AD	176
ef017502 AD	177	/* Set bit BITNO in bitset DST. */
6aa452a6	178	#define BITSET_SET_(DST, BITNO) (DST)->b.vtable->set (DST, BITNO)
ef017502 AD	179
ef017502 AD	180	/* Reset bit BITNO in bitset DST. */
6aa452a6 AD	181	#define BITSET_RESET_(DST, BITNO) (DST)->b.vtable->reset (DST, BITNO)
	182
	183	/* Toggle bit BITNO in bitset DST. */
	184	#define BITSET_TOGGLE_(DST, BITNO) (DST)->b.vtable->toggle (DST, BITNO)
ef017502 AD	185
ef017502 AD	186	/* Return non-zero if bit BITNO in bitset SRC is set. */
6aa452a6	187	#define BITSET_TEST_(SRC, BITNO) (SRC)->b.vtable->test (SRC, BITNO)
ef017502 AD	188
	189	/* Free bitset SRC. */
	190	#define BITSET_FREE_(SRC)\
6aa452a6	191	((SRC)->b.vtable->free ? (SRC)->b.vtable->free (SRC) :(void)0)
ef017502	192
ef017502	193
6aa452a6 AD	194	/* Return SRC == 0. */
6aa452a6 AD	195	#define BITSET_EMPTY_P_(SRC) (SRC)->b.vtable->empty_p (SRC)
ef017502	196
6aa452a6 AD	197	/* DST = ~0. */
6aa452a6 AD	198	#define BITSET_ONES_(DST) (DST)->b.vtable->ones (DST)
ef017502 AD	199
ef017502 AD	200	/* DST = 0. */
6aa452a6	201	#define BITSET_ZERO_(DST) (DST)->b.vtable->zero (DST)
ef017502	202
ef017502	203
6aa452a6 AD	204
	205	/* DST = SRC. */
	206	#define BITSET_COPY_(DST, SRC) (SRC)->b.vtable->copy (DST, SRC)
	207
	208	/* Return DST & SRC == 0. */
	209	#define BITSET_DISJOINT_P_(DST, SRC) (SRC)->b.vtable->disjoint_p (DST, SRC)
ef017502 AD	210
ef017502 AD	211	/* Return DST == SRC. */
6aa452a6 AD	212	#define BITSET_EQUAL_P_(DST, SRC) (SRC)->b.vtable->equal_p (DST, SRC)
	213
	214	/* DST = ~SRC. */
	215	#define BITSET_NOT_(DST, SRC) (SRC)->b.vtable->not (DST, SRC)
ef017502 AD	216
ef017502 AD	217	/* Return DST == DST \| SRC. */
6aa452a6	218	#define BITSET_SUBSET_P_(DST, SRC) (SRC)->b.vtable->subset_p (DST, SRC)
ef017502	219
ef017502	220
6aa452a6 AD	221	/* DST = SRC1 & SRC2. */
	222	#define BITSET_AND_(DST, SRC1, SRC2) (SRC1)->b.vtable->and (DST, SRC1, SRC2)
	223	#define BITSET_AND_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->and_cmp (DST, SRC1, SRC2)
ef017502	224
6aa452a6 AD	225	/* DST = SRC1 & ~SRC2. */
	226	#define BITSET_ANDN_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn (DST, SRC1, SRC2)
	227	#define BITSET_ANDN_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn_cmp (DST, SRC1, SRC2)
ef017502 AD	228
ef017502 AD	229	/* DST = SRC1 \| SRC2. */
6aa452a6 AD	230	#define BITSET_OR_(DST, SRC1, SRC2) (SRC1)->b.vtable->or (DST, SRC1, SRC2)
6aa452a6 AD	231	#define BITSET_OR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->or_cmp (DST, SRC1, SRC2)
ef017502 AD	232
ef017502 AD	233	/* DST = SRC1 ^ SRC2. */
6aa452a6 AD	234	#define BITSET_XOR_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor (DST, SRC1, SRC2)
6aa452a6 AD	235	#define BITSET_XOR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor_cmp (DST, SRC1, SRC2)
ef017502	236
ef017502	237
ef017502	238
ef017502 AD	239	/* DST = (SRC1 & SRC2) \| SRC3. Return non-zero if
ef017502 AD	240	DST != (SRC1 & SRC2) \| SRC3. */
6aa452a6 AD	241	#define BITSET_AND_OR_(DST, SRC1, SRC2, SRC3) \
	242	(SRC1)->b.vtable->and_or (DST, SRC1, SRC2, SRC3)
	243	#define BITSET_AND_OR_CMP_(DST, SRC1, SRC2, SRC3) \
	244	(SRC1)->b.vtable->and_or_cmp (DST, SRC1, SRC2, SRC3)
	245
	246	/* DST = (SRC1 & ~SRC2) \| SRC3. Return non-zero if
	247	DST != (SRC1 & ~SRC2) \| SRC3. */
	248	#define BITSET_ANDN_OR_(DST, SRC1, SRC2, SRC3) \
	249	(SRC1)->b.vtable->andn_or (DST, SRC1, SRC2, SRC3)
	250	#define BITSET_ANDN_OR_CMP_(DST, SRC1, SRC2, SRC3) \
	251	(SRC1)->b.vtable->andn_or_cmp (DST, SRC1, SRC2, SRC3)
ef017502 AD	252
	253	/* DST = (SRC1 \| SRC2) & SRC3. Return non-zero if
	254	DST != (SRC1 \| SRC2) & SRC3. */
6aa452a6 AD	255	#define BITSET_OR_AND_(DST, SRC1, SRC2, SRC3) \
	256	(SRC1)->b.vtable->or_and (DST, SRC1, SRC2, SRC3)
	257	#define BITSET_OR_AND_CMP_(DST, SRC1, SRC2, SRC3) \
	258	(SRC1)->b.vtable->or_and_cmp (DST, SRC1, SRC2, SRC3)
ef017502	259
ef017502	260
613f5e1a	261	/* Find list of up to NUM bits set in BSET starting from and including
ef017502 AD	262	NEXT. Return with actual number of bits found and with NEXT
	263	indicating where search stopped. */
	264	#define BITSET_LIST_(BSET, LIST, NUM, NEXT) \
6aa452a6	265	(BSET)->b.vtable->list (BSET, LIST, NUM, NEXT)
ef017502 AD	266
	267	/* Find reverse list of up to NUM bits set in BSET starting from and
	268	including NEXT. Return with actual number of bits found and with
	269	NEXT indicating where search stopped. /
6aa452a6 AD	270	#define BITSET_LIST_REVERSE_(BSET, LIST, NUM, NEXT) \
6aa452a6 AD	271	(BSET)->b.vtable->list_reverse (BSET, LIST, NUM, NEXT)
ef017502 AD	272
ef017502 AD	273
6aa452a6 AD	274	/* Private functions for bitset implementations. */
	275
	276	extern int bitset_toggle_ PARAMS ((bitset, bitset_bindex));
ef017502	277
f6ebdb31	278	extern bitset_bindex bitset_count_ PARAMS ((bitset));
ef017502	279
6aa452a6	280	extern int bitset_copy_ PARAMS ((bitset, bitset));
ef017502	281
d9d83ef2 PE	282	extern void bitset_and_or_ PARAMS ((bitset, bitset, bitset, bitset));
d9d83ef2 PE	283
6aa452a6	284	extern int bitset_and_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
ef017502	285
d9d83ef2 PE	286	extern void bitset_andn_or_ PARAMS ((bitset, bitset, bitset, bitset));
d9d83ef2 PE	287
6aa452a6	288	extern int bitset_andn_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
ef017502	289
d9d83ef2 PE	290	extern void bitset_or_and_ PARAMS ((bitset, bitset, bitset, bitset));
d9d83ef2 PE	291
6aa452a6	292	extern int bitset_or_and_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
ef017502 AD	293
ef017502 AD	294	#endif /* _BBITSET_H */