#define BITARRAY_VERSION "2.2.3"

typedef struct {

PyObject_VAR_HEAD

char *ob_item; /* buffer */

Py_ssize_t allocated; /* allocated buffer size (in bytes) */

Py_ssize_t nbits; /* length of bitarray, i.e. elements */

int endian; /* bit endianness of bitarray */

int ob_exports; /* how many buffer exports */

PyObject *weakreflist; /* list of weak references */

} bitarrayobject;

#define ENDIAN_LITTLE 0

#define ENDIAN_BIG 1

#define ENDIAN_STR(endian) ((endian) == ENDIAN_LITTLE ? "little" : "big")

#define BITS(bytes) ((bytes) << 3)

#define BYTES(bits) (((bits) + 7) >> 3)

#define BITMASK(endian, i) \

(((char) 1) << ((endian) == ENDIAN_LITTLE ? ((i) & 7) : (7 - ((i) & 7))))

#define assert_nbits(self) assert(BYTES((self)->nbits) == Py_SIZE(self))

#define assert_bit_in_range(self, i) assert(0 <= (i) && (i) < (self)->nbits)

#define assert_byte_in_range(self, i) assert(0 <= (i) && (i) < Py_SIZE(self))

#ifdef STDC_HEADERS

#include <stddef.h>

#else /* !STDC_HEADERS */

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h> /* For size_t */

#endif /* HAVE_SYS_TYPES_H */

#endif /* !STDC_HEADERS */

#if (defined(_MSC_VER) && _MSC_VER < 1900 \

&& !defined(__cplusplus) && !defined(inline))

#define inline __inline

#if PY_MAJOR_VERSION >= 3

#define IS_PY3K

#define BYTES_SIZE_FMT "y#"

#define Py_MIN(x, y) (((x) > (y)) ? (y) : (x))

#define PySlice_GetIndicesEx(slice, len, start, stop, step, slicelength) \

PySlice_GetIndicesEx(((PySliceObject *) slice), \

(len), (start), (stop), (step), (slicelength))

#define PyLong_FromLong PyInt_FromLong

#define BYTES_SIZE_FMT "s#"

static inline int

getbit(bitarrayobject *self, Py_ssize_t i)

{

assert_nbits(self);

assert_bit_in_range(self, i);

assert_byte_in_range(self, i >> 3);

return (self->ob_item[i >> 3] & BITMASK(self->endian, i) ? 1 : 0);

}

static inline void

setbit(bitarrayobject *self, Py_ssize_t i, int bit)

{

char *cp, mask;

assert_nbits(self);

assert_bit_in_range(self, i);

assert_byte_in_range(self, i >> 3);

mask = BITMASK(self->endian, i);

cp = self->ob_item + (i >> 3);

if (bit)

*cp |= mask;

else

*cp &= ~mask;

}

static inline int

setunused(bitarrayobject *self)

{

const char mask[14] = {

0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, /* little endian */

0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, /* big endian */

};

int i = self->nbits % 8; /* index into mask array (minus offset) */

if (i == 0)

return 0;

assert_nbits(self);

assert_byte_in_range(self, Py_SIZE(self) - 1);

/* apply the appropriate mask to the last byte in buffer */

self->ob_item[Py_SIZE(self) - 1] &=

mask[self->endian == ENDIAN_LITTLE ? i - 1 : i + 6];

return 8 - i;

}

static const unsigned char bitcount_lookup[256] = {

#define B2(n) n, n + 1, n + 1, n + 2

#define B4(n) B2(n), B2(n + 1), B2(n + 1), B2(n + 2)

#define B6(n) B4(n), B4(n + 1), B4(n + 1), B4(n + 2)

B6(0), B6(1), B6(1), B6(2)

#undef B2

#undef B4

#undef B6

};

static inline int

pybit_as_int(PyObject *v)

{

Py_ssize_t x;

x = PyNumber_AsSsize_t(v, NULL);

if (x == -1 && PyErr_Occurred())

return -1;

if (x < 0 || x > 1) {

PyErr_Format(PyExc_ValueError, "bit must be 0 or 1, got %zd", x);

return -1;

}

return (int) x;

}