[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

/* 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.  */
typedef size_t bitset_bindex;

/* Word index.  */
typedef size_t bitset_windex;

#define BITSET_INDEX_MAX ((bitset_word) 1 << (BITSET_WORD_BITS - 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 struct bitset_struct *bitset;


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

  int (*empty_p) PARAMS ((struct bitset_struct *));
  void (*ones) PARAMS ((struct bitset_struct *));
  void (*zero) PARAMS ((struct bitset_struct *));

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

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

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

  int (*list) PARAMS ((struct bitset_struct *, bitset_bindex *,
		       bitset_bindex, bitset_bindex *));
  int (*list_reverse) PARAMS ((struct bitset_struct *, bitset_bindex *,
			       bitset_bindex, bitset_bindex *));
  void (*free) PARAMS ((struct bitset_struct *));
  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 int bitset_count_ PARAMS ((bitset));

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

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

extern int bitset_andn_or_cmp_ 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
	28	/* Currently we support three flavours of bitsets:
6aa452a6	29	BITSET_ARRAY: Array of bits (fixed size, fast for dense bitsets).
ef017502	30	BITSET_LIST: Linked list of array of bits (variable size, least storage
6aa452a6	31	for large very sparse sets).
613f5e1a	32	BITSET_TABLE: Expandable table of pointers to array of bits
6aa452a6	33	(variable size, less storage for large sparse sets).
613f5e1a AD	34
613f5e1a AD	35	BITSET_STATS: Wrapper bitset for internal use only.
ef017502	36	*/
613f5e1a AD	37	enum bitset_type {BITSET_ARRAY, BITSET_LIST, BITSET_TABLE, BITSET_TYPE_NUM,
	38	BITSET_STATS};
	39	#define BITSET_TYPE_NAMES {"abitset", "lbitset", "ebitset"}
ef017502	40
6aa452a6 AD	41	extern const char * const bitset_type_names[];
6aa452a6 AD	42
613f5e1a	43	enum bitset_alloc_type {BITSET_MALLOC, BITSET_OBALLOC};
ef017502 AD	44
	45	/* Non-zero to use inline functions instead of macros. */
	46	#define BITSET_INLINE 0
	47
ef017502 AD	48	/* Data type used to store a word of bits. */
ef017502 AD	49	typedef unsigned long bitset_word;
50f095c9	50	#define BITSET_WORD_BITS ((unsigned) (CHAR_BIT * sizeof (bitset_word)))
ef017502	51
50f095c9 PE	52	/* Bit index. In theory we might need a type wider than size_t, but
	53	in practice we lose at most a factor of CHAR_BIT by going with
	54	size_t, and that is good enough. */
	55	typedef size_t bitset_bindex;
ef017502 AD	56
ef017502 AD	57	/* Word index. */
50f095c9	58	typedef size_t bitset_windex;
ef017502	59
50f095c9	60	#define BITSET_INDEX_MAX ((bitset_word) 1 << (BITSET_WORD_BITS - 1))
ef017502	61
50f095c9	62	#define BITSET_MSB ((bitset_word) 1 << (BITSET_WORD_BITS - 1))
ef017502 AD	63
	64	#define BITSET_LIST_SIZE 1024
	65
613f5e1a AD	66	enum bitset_ops {BITSET_OP_ZERO, BITSET_OP_ONES,
613f5e1a AD	67	BITSET_OP_COPY, BITSET_OP_NOT,
ef017502 AD	68	BITSET_OP_EMPTY_P, BITSET_OP_EQUAL_P,
ef017502 AD	69	BITSET_OP_SUBSET_P, BITSET_OP_DISJOINT_P,
613f5e1a	70	BITSET_OP_AND, BITSET_OP_OR, BITSET_OP_XOR, BITSET_OP_ANDN,
ef017502 AD	71	BITSET_OP_OR_AND, BITSET_OP_AND_OR, BITSET_OP_ANDN_OR};
ef017502 AD	72
6aa452a6 AD	73	struct bbitset_struct
	74	{
	75	const struct bitset_vtable * vtable;
	76	bitset_windex cindex; /* Cache word index. */
	77	bitset_windex csize; /* Cache size in words. */
	78	bitset_word cdata; / Cache data pointer. */
	79	/* Perhaps we could sacrifice another word to indicate
	80	that the bitset is known to be zero, that a bit has been set
	81	in the cache, and that a bit has been cleared in the cache.
	82	This would speed up some of the searches but slightly slow down
	83	bit set/reset operations of cached bits. */
	84	};
	85
	86
	87	typedef struct bitset_struct *bitset;
	88
	89
	90	/* The contents of this structure should be considered private. */
	91	struct bitset_vtable
	92	{
	93	void (set) PARAMS ((struct bitset_struct , bitset_bindex));
	94	void (reset) PARAMS ((struct bitset_struct , bitset_bindex));
	95	int (toggle) PARAMS ((struct bitset_struct , bitset_bindex));
	96	int (test) PARAMS ((struct bitset_struct , bitset_bindex));
	97	int (size) PARAMS ((struct bitset_struct ));
	98	int (count) PARAMS ((struct bitset_struct ));
	99
	100	int (empty_p) PARAMS ((struct bitset_struct ));
	101	void (ones) PARAMS ((struct bitset_struct ));
	102	void (zero) PARAMS ((struct bitset_struct ));
	103
	104	void (copy) PARAMS ((struct bitset_struct , struct bitset_struct *));
	105	int (disjoint_p) PARAMS ((struct bitset_struct , struct bitset_struct *));
	106	int (equal_p) PARAMS ((struct bitset_struct , struct bitset_struct *));
	107	void (not) PARAMS ((struct bitset_struct , struct bitset_struct *));
	108	int (subset_p) PARAMS ((struct bitset_struct , struct bitset_struct *));
	109
	110	void (and) PARAMS ((struct bitset_struct , struct bitset_struct *,
	111	struct bitset_struct *));
	112	int (and_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
	113	struct bitset_struct *));
	114	void (andn) PARAMS ((struct bitset_struct , struct bitset_struct *,
	115	struct bitset_struct *));
	116	int (andn_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
	117	struct bitset_struct *));
	118	void (or) PARAMS ((struct bitset_struct , struct bitset_struct *,
	119	struct bitset_struct *));
	120	int (or_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
	121	struct bitset_struct *));
	122	void (xor) PARAMS ((struct bitset_struct , struct bitset_struct *,
	123	struct bitset_struct *));
	124	int (xor_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
	125	struct bitset_struct *));
	126
	127	void (and_or) PARAMS ((struct bitset_struct , struct bitset_struct *,
	128	struct bitset_struct , struct bitset_struct ));
	129	int (and_or_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
	130	struct bitset_struct , struct bitset_struct ));
	131	void (andn_or) PARAMS ((struct bitset_struct , struct bitset_struct *,
	132	struct bitset_struct , struct bitset_struct ));
	133	int (andn_or_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
	134	struct bitset_struct , struct bitset_struct ));
	135	void (or_and) PARAMS ((struct bitset_struct , struct bitset_struct *,
	136	struct bitset_struct , struct bitset_struct ));
137	int (or_and_cmp) PARAMS ((struct bitset_struct , struct bitset_struct *,
138	struct bitset_struct , struct bitset_struct ));
139
140	int (list) PARAMS ((struct bitset_struct , bitset_bindex *,
141	bitset_bindex, bitset_bindex *));
142	int (list_reverse) PARAMS ((struct bitset_struct , bitset_bindex *,
143	bitset_bindex, bitset_bindex *));
144	void (free) PARAMS ((struct bitset_struct ));
145	enum bitset_type type;
146	};
147
148	#define BITSET_COMPATIBLE_(BSET1, BSET2) ((BSET1)->b.vtable == (BSET2)->b.vtable)
149
150	#define BITSET_CHECK2_(DST, SRC) \
151	if (!BITSET_COMPATIBLE_ (DST, SRC)) abort ();
152
153	#define BITSET_CHECK3_(DST, SRC1, SRC2) \
154	if (!BITSET_COMPATIBLE_ (DST, SRC1) \
155	\|\| !BITSET_COMPATIBLE_ (DST, SRC2)) abort ();
156
157	#define BITSET_CHECK4_(DST, SRC1, SRC2, SRC3) \
158	if (!BITSET_COMPATIBLE_ (DST, SRC1) \|\| !BITSET_COMPATIBLE_ (DST, SRC2) \
159	\|\| !BITSET_COMPATIBLE_ (DST, SRC3)) abort ();
160
161
ef017502	162	/* Return size in bits of bitset SRC. */
6aa452a6 AD	163	#define BITSET_SIZE_(SRC) (SRC)->b.vtable->size (SRC)
	164
	165	/* Return number of bits set in bitset SRC. */
	166	#define BITSET_COUNT_(SRC) (SRC)->b.vtable->count (SRC)
ef017502 AD	167
ef017502 AD	168	/* Return type of bitset SRC. */
6aa452a6	169	#define BITSET_TYPE_(DST) (DST)->b.vtable->type
ef017502 AD	170
ef017502 AD	171	/* Set bit BITNO in bitset DST. */
6aa452a6	172	#define BITSET_SET_(DST, BITNO) (DST)->b.vtable->set (DST, BITNO)
ef017502 AD	173
ef017502 AD	174	/* Reset bit BITNO in bitset DST. */
6aa452a6 AD	175	#define BITSET_RESET_(DST, BITNO) (DST)->b.vtable->reset (DST, BITNO)
	176
	177	/* Toggle bit BITNO in bitset DST. */
	178	#define BITSET_TOGGLE_(DST, BITNO) (DST)->b.vtable->toggle (DST, BITNO)
ef017502 AD	179
ef017502 AD	180	/* Return non-zero if bit BITNO in bitset SRC is set. */
6aa452a6	181	#define BITSET_TEST_(SRC, BITNO) (SRC)->b.vtable->test (SRC, BITNO)
ef017502 AD	182
	183	/* Free bitset SRC. */
	184	#define BITSET_FREE_(SRC)\
6aa452a6	185	((SRC)->b.vtable->free ? (SRC)->b.vtable->free (SRC) :(void)0)
ef017502	186
ef017502	187
6aa452a6 AD	188	/* Return SRC == 0. */
6aa452a6 AD	189	#define BITSET_EMPTY_P_(SRC) (SRC)->b.vtable->empty_p (SRC)
ef017502	190
6aa452a6 AD	191	/* DST = ~0. */
6aa452a6 AD	192	#define BITSET_ONES_(DST) (DST)->b.vtable->ones (DST)
ef017502 AD	193
ef017502 AD	194	/* DST = 0. */
6aa452a6	195	#define BITSET_ZERO_(DST) (DST)->b.vtable->zero (DST)
ef017502	196
ef017502	197
6aa452a6 AD	198
	199	/* DST = SRC. */
	200	#define BITSET_COPY_(DST, SRC) (SRC)->b.vtable->copy (DST, SRC)
	201
	202	/* Return DST & SRC == 0. */
	203	#define BITSET_DISJOINT_P_(DST, SRC) (SRC)->b.vtable->disjoint_p (DST, SRC)
ef017502 AD	204
ef017502 AD	205	/* Return DST == SRC. */
6aa452a6 AD	206	#define BITSET_EQUAL_P_(DST, SRC) (SRC)->b.vtable->equal_p (DST, SRC)
	207
	208	/* DST = ~SRC. */
	209	#define BITSET_NOT_(DST, SRC) (SRC)->b.vtable->not (DST, SRC)
ef017502 AD	210
ef017502 AD	211	/* Return DST == DST \| SRC. */
6aa452a6	212	#define BITSET_SUBSET_P_(DST, SRC) (SRC)->b.vtable->subset_p (DST, SRC)
ef017502	213
ef017502	214
6aa452a6 AD	215	/* DST = SRC1 & SRC2. */
	216	#define BITSET_AND_(DST, SRC1, SRC2) (SRC1)->b.vtable->and (DST, SRC1, SRC2)
	217	#define BITSET_AND_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->and_cmp (DST, SRC1, SRC2)
ef017502	218
6aa452a6 AD	219	/* DST = SRC1 & ~SRC2. */
	220	#define BITSET_ANDN_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn (DST, SRC1, SRC2)
	221	#define BITSET_ANDN_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->andn_cmp (DST, SRC1, SRC2)
ef017502 AD	222
ef017502 AD	223	/* DST = SRC1 \| SRC2. */
6aa452a6 AD	224	#define BITSET_OR_(DST, SRC1, SRC2) (SRC1)->b.vtable->or (DST, SRC1, SRC2)
6aa452a6 AD	225	#define BITSET_OR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->or_cmp (DST, SRC1, SRC2)
ef017502 AD	226
ef017502 AD	227	/* DST = SRC1 ^ SRC2. */
6aa452a6 AD	228	#define BITSET_XOR_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor (DST, SRC1, SRC2)
6aa452a6 AD	229	#define BITSET_XOR_CMP_(DST, SRC1, SRC2) (SRC1)->b.vtable->xor_cmp (DST, SRC1, SRC2)
ef017502	230
ef017502	231
ef017502	232
ef017502 AD	233	/* DST = (SRC1 & SRC2) \| SRC3. Return non-zero if
ef017502 AD	234	DST != (SRC1 & SRC2) \| SRC3. */
6aa452a6 AD	235	#define BITSET_AND_OR_(DST, SRC1, SRC2, SRC3) \
	236	(SRC1)->b.vtable->and_or (DST, SRC1, SRC2, SRC3)
	237	#define BITSET_AND_OR_CMP_(DST, SRC1, SRC2, SRC3) \
	238	(SRC1)->b.vtable->and_or_cmp (DST, SRC1, SRC2, SRC3)
	239
	240	/* DST = (SRC1 & ~SRC2) \| SRC3. Return non-zero if
	241	DST != (SRC1 & ~SRC2) \| SRC3. */
	242	#define BITSET_ANDN_OR_(DST, SRC1, SRC2, SRC3) \
	243	(SRC1)->b.vtable->andn_or (DST, SRC1, SRC2, SRC3)
	244	#define BITSET_ANDN_OR_CMP_(DST, SRC1, SRC2, SRC3) \
	245	(SRC1)->b.vtable->andn_or_cmp (DST, SRC1, SRC2, SRC3)
ef017502 AD	246
	247	/* DST = (SRC1 \| SRC2) & SRC3. Return non-zero if
	248	DST != (SRC1 \| SRC2) & SRC3. */
6aa452a6 AD	249	#define BITSET_OR_AND_(DST, SRC1, SRC2, SRC3) \
	250	(SRC1)->b.vtable->or_and (DST, SRC1, SRC2, SRC3)
	251	#define BITSET_OR_AND_CMP_(DST, SRC1, SRC2, SRC3) \
	252	(SRC1)->b.vtable->or_and_cmp (DST, SRC1, SRC2, SRC3)
ef017502	253
ef017502	254
613f5e1a	255	/* Find list of up to NUM bits set in BSET starting from and including
ef017502 AD	256	NEXT. Return with actual number of bits found and with NEXT
	257	indicating where search stopped. */
	258	#define BITSET_LIST_(BSET, LIST, NUM, NEXT) \
6aa452a6	259	(BSET)->b.vtable->list (BSET, LIST, NUM, NEXT)
ef017502 AD	260
	261	/* Find reverse list of up to NUM bits set in BSET starting from and
	262	including NEXT. Return with actual number of bits found and with
	263	NEXT indicating where search stopped. /
6aa452a6 AD	264	#define BITSET_LIST_REVERSE_(BSET, LIST, NUM, NEXT) \
6aa452a6 AD	265	(BSET)->b.vtable->list_reverse (BSET, LIST, NUM, NEXT)
ef017502 AD	266
ef017502 AD	267
6aa452a6 AD	268	/* Private functions for bitset implementations. */
	269
	270	extern int bitset_toggle_ PARAMS ((bitset, bitset_bindex));
ef017502	271
6aa452a6	272	extern int bitset_count_ PARAMS ((bitset));
ef017502	273
6aa452a6	274	extern int bitset_copy_ PARAMS ((bitset, bitset));
ef017502	275
6aa452a6	276	extern int bitset_and_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
ef017502	277
6aa452a6	278	extern int bitset_andn_or_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
ef017502	279
6aa452a6	280	extern int bitset_or_and_cmp_ PARAMS ((bitset, bitset, bitset, bitset));
ef017502 AD	281
ef017502 AD	282	#endif /* _BBITSET_H */