#include "Python.h"

#include <ffi.h>

#ifdef MS_WIN32

#include <windows.h>

#include "ctypes.h"

#define CTYPES_CAPSULE_WCHAR_T "_ctypes/cfield.c wchar_t buffer from unicode"

CTYPES_CAPSULE_INSTANTIATE_DESTRUCTOR(CTYPES_CAPSULE_WCHAR_T)

static PyObject *

PyCField_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

CFieldObject *obj;

obj = (CFieldObject *)type->tp_alloc(type, 0);

return (PyObject *)obj;

}

PyObject *

PyCField_FromDesc(PyObject *desc, Py_ssize_t index,

Py_ssize_t *pfield_size, int bitsize, int *pbitofs,

Py_ssize_t *psize, Py_ssize_t *poffset, Py_ssize_t *palign,

int pack, int big_endian)

{

CFieldObject *self;

PyObject *proto;

Py_ssize_t size, align, length;

SETFUNC setfunc = NULL;

GETFUNC getfunc = NULL;

StgDictObject *dict;

int fieldtype;

#define NO_BITFIELD 0

#define NEW_BITFIELD 1

#define CONT_BITFIELD 2

#define EXPAND_BITFIELD 3

self = (CFieldObject *)PyObject_CallObject((PyObject *)&PyCField_Type,

NULL);

if (self == NULL)

return NULL;

dict = PyType_stgdict(desc);

if (!dict) {

PyErr_SetString(PyExc_TypeError,

"has no _stginfo_");

Py_DECREF(self);

return NULL;

}

if (bitsize /* this is a bitfield request */

&& *pfield_size /* we have a bitfield open */

#ifdef MS_WIN32

/* MSVC, GCC with -mms-bitfields */

&& dict->size * 8 == *pfield_size

/* GCC */

&& dict->size * 8 <= *pfield_size

&& (*pbitofs + bitsize) <= *pfield_size) {

/* continue bit field */

fieldtype = CONT_BITFIELD;

#ifndef MS_WIN32

} else if (bitsize /* this is a bitfield request */

&& *pfield_size /* we have a bitfield open */

&& dict->size * 8 >= *pfield_size

&& (*pbitofs + bitsize) <= dict->size * 8) {

/* expand bit field */

fieldtype = EXPAND_BITFIELD;

} else if (bitsize) {

/* start new bitfield */

fieldtype = NEW_BITFIELD;

*pbitofs = 0;

*pfield_size = dict->size * 8;

} else {

/* not a bit field */

fieldtype = NO_BITFIELD;

*pbitofs = 0;

*pfield_size = 0;

}

size = dict->size;

length = dict->length;

proto = desc;

/* Field descriptors for 'c_char * n' are be scpecial cased to

if (PyCArrayTypeObject_Check(proto)) {

StgDictObject *adict = PyType_stgdict(proto);

StgDictObject *idict;

if (adict && adict->proto) {

idict = PyType_stgdict(adict->proto);

if (!idict) {

PyErr_SetString(PyExc_TypeError,

"has no _stginfo_");

Py_DECREF(self);

return NULL;

}

if (idict->getfunc == _ctypes_get_fielddesc("c")->getfunc) {

struct fielddesc *fd = _ctypes_get_fielddesc("s");

getfunc = fd->getfunc;

setfunc = fd->setfunc;

}

#ifdef CTYPES_UNICODE

if (idict->getfunc == _ctypes_get_fielddesc("u")->getfunc) {

struct fielddesc *fd = _ctypes_get_fielddesc("U");

getfunc = fd->getfunc;

setfunc = fd->setfunc;

}

}

}

self->setfunc = setfunc;

self->getfunc = getfunc;

self->index = index;

Py_INCREF(proto);

self->proto = proto;

switch (fieldtype) {

case NEW_BITFIELD:

if (big_endian)

self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize;

else

self->size = (bitsize << 16) + *pbitofs;

*pbitofs = bitsize;

/* fall through */

case NO_BITFIELD:

if (pack)

align = min(pack, dict->align);

else

align = dict->align;

if (align && *poffset % align) {

Py_ssize_t delta = align - (*poffset % align);

*psize += delta;

*poffset += delta;

}

if (bitsize == 0)

self->size = size;

*psize += size;

self->offset = *poffset;

*poffset += size;

*palign = align;

break;

case EXPAND_BITFIELD:

*poffset += dict->size - *pfield_size/8;

*psize += dict->size - *pfield_size/8;

*pfield_size = dict->size * 8;

if (big_endian)

self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize;

else

self->size = (bitsize << 16) + *pbitofs;

self->offset = *poffset - size; /* poffset is already updated for the NEXT field */

*pbitofs += bitsize;

break;

case CONT_BITFIELD:

if (big_endian)

self->size = (bitsize << 16) + *pfield_size - *pbitofs - bitsize;

else

self->size = (bitsize << 16) + *pbitofs;

self->offset = *poffset - size; /* poffset is already updated for the NEXT field */

*pbitofs += bitsize;

break;

}

return (PyObject *)self;

}

static int

PyCField_set(CFieldObject *self, PyObject *inst, PyObject *value)

{

CDataObject *dst;

char *ptr;

assert(CDataObject_Check(inst));

dst = (CDataObject *)inst;

ptr = dst->b_ptr + self->offset;

if (value == NULL) {

PyErr_SetString(PyExc_TypeError,

"can't delete attribute");

return -1;

}

return PyCData_set(inst, self->proto, self->setfunc, value,

self->index, self->size, ptr);

}

static PyObject *

PyCField_get(CFieldObject *self, PyObject *inst, PyTypeObject *type)

{

CDataObject *src;

if (inst == NULL) {

Py_INCREF(self);

return (PyObject *)self;

}

assert(CDataObject_Check(inst));

src = (CDataObject *)inst;

return PyCData_get(self->proto, self->getfunc, inst,

self->index, self->size, src->b_ptr + self->offset);

}

static PyObject *

PyCField_get_offset(PyObject *self, void *data)

{

return PyInt_FromSsize_t(((CFieldObject *)self)->offset);

}

static PyObject *

PyCField_get_size(PyObject *self, void *data)

{

return PyInt_FromSsize_t(((CFieldObject *)self)->size);

}

static PyGetSetDef PyCField_getset[] = {

{ "offset", PyCField_get_offset, NULL, "offset in bytes of this field" },

{ "size", PyCField_get_size, NULL, "size in bytes of this field" },

{ NULL, NULL, NULL, NULL },

};

static int

PyCField_traverse(CFieldObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->proto);

return 0;

}

static int

PyCField_clear(CFieldObject *self)

{

Py_CLEAR(self->proto);

return 0;

}

static void

PyCField_dealloc(PyObject *self)

{

PyCField_clear((CFieldObject *)self);

self->ob_type->tp_free((PyObject *)self);

}

static PyObject *

PyCField_repr(CFieldObject *self)

{

PyObject *result;

Py_ssize_t bits = self->size >> 16;

Py_ssize_t size = self->size & 0xFFFF;

const char *name;

name = ((PyTypeObject *)self->proto)->tp_name;

if (bits)

result = PyString_FromFormat(

#if (PY_VERSION_HEX < 0x02050000)

"<Field type=%s, ofs=%d:%d, bits=%d>",

"<Field type=%s, ofs=%zd:%zd, bits=%zd>",

name, self->offset, size, bits);

else

result = PyString_FromFormat(

#if (PY_VERSION_HEX < 0x02050000)

"<Field type=%s, ofs=%d, size=%d>",

"<Field type=%s, ofs=%zd, size=%zd>",

name, self->offset, size);

return result;

}

PyTypeObject PyCField_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_ctypes.CField", /* tp_name */

sizeof(CFieldObject), /* tp_basicsize */

0, /* tp_itemsize */

PyCField_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

(reprfunc)PyCField_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

0, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

"Structure/Union member", /* tp_doc */

(traverseproc)PyCField_traverse, /* tp_traverse */

(inquiry)PyCField_clear, /* tp_clear */

0, /* tp_richcompare */

0, /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

0, /* tp_methods */

0, /* tp_members */

PyCField_getset, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

(descrgetfunc)PyCField_get, /* tp_descr_get */

(descrsetfunc)PyCField_set, /* tp_descr_set */

0, /* tp_dictoffset */

0, /* tp_init */

0, /* tp_alloc */

PyCField_new, /* tp_new */

0, /* tp_free */

};

static int

get_long(PyObject *v, long *p)

{

long x;

if (PyFloat_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"int expected instead of float");

return -1;

}

x = PyInt_AsUnsignedLongMask(v);

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

return -1;

*p = x;

return 0;

}

static int

get_ulong(PyObject *v, unsigned long *p)

{

unsigned long x;

if (PyFloat_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"int expected instead of float");

return -1;

}

x = PyInt_AsUnsignedLongMask(v);

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

return -1;

*p = x;

return 0;

}

#ifdef HAVE_LONG_LONG

static int

get_longlong(PyObject *v, PY_LONG_LONG *p)

{

PY_LONG_LONG x;

if (PyFloat_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"int expected instead of float");

return -1;

}

x = PyInt_AsUnsignedLongLongMask(v);

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

return -1;

*p = x;

return 0;

}

static int

get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)

{

unsigned PY_LONG_LONG x;

if (PyFloat_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"int expected instead of float");

return -1;

}

x = PyInt_AsUnsignedLongLongMask(v);

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

return -1;

*p = x;

return 0;

}

#define LOW_BIT(x) ((x) & 0xFFFF)

#define NUM_BITS(x) ((x) >> 16)

#define BIT_MASK(type, size) (((((type)1 << (NUM_BITS(size) - 1)) - 1) << 1) + 1)

#define GET_BITFIELD(v, size) \

if (NUM_BITS(size)) { \

v <<= (sizeof(v)*8 - LOW_BIT(size) - NUM_BITS(size)); \

v >>= (sizeof(v)*8 - NUM_BITS(size)); \

}

#define SET(type, x, v, size) \

(NUM_BITS(size) ? \

( ( (type)x & ~(BIT_MASK(type, size) << LOW_BIT(size)) ) | ( ((type)v & BIT_MASK(type, size)) << LOW_BIT(size) ) ) \

: (type)v)

#define SWAP_2(v) \

( ( (v >> 8) & 0x00FF) | \

( (v << 8) & 0xFF00) )

#define SWAP_4(v) \

( ( (v & 0x000000FF) << 24 ) | \

( (v & 0x0000FF00) << 8 ) | \

( (v & 0x00FF0000) >> 8 ) | \

( ((v >> 24) & 0xFF)) )

#ifdef _MSC_VER

#define SWAP_8(v) \

( ( (v & 0x00000000000000FFL) << 56 ) | \

( (v & 0x000000000000FF00L) << 40 ) | \

( (v & 0x0000000000FF0000L) << 24 ) | \

( (v & 0x00000000FF000000L) << 8 ) | \

( (v & 0x000000FF00000000L) >> 8 ) | \

( (v & 0x0000FF0000000000L) >> 24 ) | \

( (v & 0x00FF000000000000L) >> 40 ) | \

( ((v >> 56) & 0xFF)) )

#define SWAP_8(v) \

( ( (v & 0x00000000000000FFLL) << 56 ) | \

( (v & 0x000000000000FF00LL) << 40 ) | \

( (v & 0x0000000000FF0000LL) << 24 ) | \

( (v & 0x00000000FF000000LL) << 8 ) | \

( (v & 0x000000FF00000000LL) >> 8 ) | \

( (v & 0x0000FF0000000000LL) >> 24 ) | \

( (v & 0x00FF000000000000LL) >> 40 ) | \

( ((v >> 56) & 0xFF)) )

#define SWAP_INT SWAP_4

#if SIZEOF_LONG == 4

# define SWAP_LONG SWAP_4

#elif SIZEOF_LONG == 8

# define SWAP_LONG SWAP_8

#ifdef _CTYPES_DEBUG_KEEP

#define _RET(x) Py_INCREF(x); return x

#define _RET(X) Py_INCREF(Py_None); return Py_None

static PyObject *

b_set(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

if (get_long(value, &val) < 0)

return NULL;

*(signed char *)ptr = SET(signed char, *(signed char *)ptr, val, size);

_RET(value);

}

static PyObject *

b_get(void *ptr, Py_ssize_t size)

{

signed char val = *(signed char *)ptr;

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

B_set(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

if (get_ulong(value, &val) < 0)

return NULL;

*(unsigned char *)ptr = SET(unsigned char, *(unsigned char*)ptr, val, size);

_RET(value);

}

static PyObject *

B_get(void *ptr, Py_ssize_t size)

{

unsigned char val = *(unsigned char *)ptr;

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

h_set(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

short x;

if (get_long(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(short, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

h_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

short field;

if (get_long(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_2(field);

field = SET(short, field, val, size);

field = SWAP_2(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

h_get(void *ptr, Py_ssize_t size)

{

short val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyInt_FromLong((long)val);

}

static PyObject *

h_get_sw(void *ptr, Py_ssize_t size)

{

short val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_2(val);

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

H_set(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

unsigned short x;

if (get_ulong(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(unsigned short, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

H_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

unsigned short field;

if (get_ulong(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_2(field);

field = SET(unsigned short, field, val, size);

field = SWAP_2(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

H_get(void *ptr, Py_ssize_t size)

{

unsigned short val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

H_get_sw(void *ptr, Py_ssize_t size)

{

unsigned short val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_2(val);

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

i_set(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

int x;

if (get_long(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(int, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

i_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

int field;

if (get_long(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_INT(field);

field = SET(int, field, val, size);

field = SWAP_INT(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

i_get(void *ptr, Py_ssize_t size)

{

int val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

i_get_sw(void *ptr, Py_ssize_t size)

{

int val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_INT(val);

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

#ifdef MS_WIN32

static PyObject *

vBOOL_set(void *ptr, PyObject *value, Py_ssize_t size)

{

switch (PyObject_IsTrue(value)) {

case -1:

return NULL;

case 0:

*(short int *)ptr = VARIANT_FALSE;

_RET(value);

default:

*(short int *)ptr = VARIANT_TRUE;

_RET(value);

}

}

static PyObject *

vBOOL_get(void *ptr, Py_ssize_t size)

{

return PyBool_FromLong((long)*(short int *)ptr);

}

#ifdef HAVE_C99_BOOL

#define BOOL_TYPE _Bool

#define BOOL_TYPE char

#undef SIZEOF__BOOL

#define SIZEOF__BOOL 1

static PyObject *

bool_set(void *ptr, PyObject *value, Py_ssize_t size)

{

switch (PyObject_IsTrue(value)) {

case -1:

return NULL;

case 0:

*(BOOL_TYPE *)ptr = 0;

_RET(value);

default:

*(BOOL_TYPE *)ptr = 1;

_RET(value);

}

}

static PyObject *

bool_get(void *ptr, Py_ssize_t size)

{

return PyBool_FromLong((long)*(BOOL_TYPE *)ptr);

}

static PyObject *

I_set(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

unsigned int x;

if (get_ulong(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(unsigned int, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

I_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

unsigned int field;

if (get_ulong(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SET(unsigned int, field, (unsigned int)val, size);

field = SWAP_INT(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

I_get(void *ptr, Py_ssize_t size)

{

unsigned int val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyLong_FromUnsignedLong(val);

}

static PyObject *

I_get_sw(void *ptr, Py_ssize_t size)

{

unsigned int val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_INT(val);

GET_BITFIELD(val, size);

return PyLong_FromUnsignedLong(val);

}

static PyObject *

l_set(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

long x;

if (get_long(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(long, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

l_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

long val;

long field;

if (get_long(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_LONG(field);

field = SET(long, field, val, size);

field = SWAP_LONG(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

l_get(void *ptr, Py_ssize_t size)

{

long val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

l_get_sw(void *ptr, Py_ssize_t size)

{

long val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_LONG(val);

GET_BITFIELD(val, size);

return PyInt_FromLong(val);

}

static PyObject *

L_set(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

unsigned long x;

if (get_ulong(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(unsigned long, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

L_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned long val;

unsigned long field;

if (get_ulong(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_LONG(field);

field = SET(unsigned long, field, val, size);

field = SWAP_LONG(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

L_get(void *ptr, Py_ssize_t size)

{

unsigned long val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyLong_FromUnsignedLong(val);

}

static PyObject *

L_get_sw(void *ptr, Py_ssize_t size)

{

unsigned long val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_LONG(val);

GET_BITFIELD(val, size);

return PyLong_FromUnsignedLong(val);

}

#ifdef HAVE_LONG_LONG

static PyObject *

q_set(void *ptr, PyObject *value, Py_ssize_t size)

{

PY_LONG_LONG val;

PY_LONG_LONG x;

if (get_longlong(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(PY_LONG_LONG, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

PY_LONG_LONG val;

PY_LONG_LONG field;

if (get_longlong(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_8(field);

field = SET(PY_LONG_LONG, field, val, size);

field = SWAP_8(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

q_get(void *ptr, Py_ssize_t size)

{

PY_LONG_LONG val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyLong_FromLongLong(val);

}

static PyObject *

q_get_sw(void *ptr, Py_ssize_t size)

{

PY_LONG_LONG val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_8(val);

GET_BITFIELD(val, size);

return PyLong_FromLongLong(val);

}

static PyObject *

Q_set(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned PY_LONG_LONG val;

unsigned PY_LONG_LONG x;

if (get_ulonglong(value, &val) < 0)

return NULL;

memcpy(&x, ptr, sizeof(x));

x = SET(PY_LONG_LONG, x, val, size);

memcpy(ptr, &x, sizeof(x));

_RET(value);

}

static PyObject *

Q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)

{

unsigned PY_LONG_LONG val;

unsigned PY_LONG_LONG field;

if (get_ulonglong(value, &val) < 0)

return NULL;

memcpy(&field, ptr, sizeof(field));

field = SWAP_8(field);

field = SET(unsigned PY_LONG_LONG, field, val, size);

field = SWAP_8(field);

memcpy(ptr, &field, sizeof(field));

_RET(value);

}

static PyObject *

Q_get(void *ptr, Py_ssize_t size)

{

unsigned PY_LONG_LONG val;

memcpy(&val, ptr, sizeof(val));

GET_BITFIELD(val, size);

return PyLong_FromUnsignedLongLong(val);

}

static PyObject *

Q_get_sw(void *ptr, Py_ssize_t size)

{

unsigned PY_LONG_LONG val;

memcpy(&val, ptr, sizeof(val));

val = SWAP_8(val);

GET_BITFIELD(val, size);

return PyLong_FromUnsignedLongLong(val);

}

static PyObject *

g_set(void *ptr, PyObject *value, Py_ssize_t size)

{

long double x;

x = PyFloat_AsDouble(value);