[bison.git] / lib / bbitset.h

/* Base bitset stuff.
   Copyright (C) 2002, 2003 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"

#include <limits.h>

/* 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};

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