/* struct module -- pack values into and (out of) bytes objects */

/* New version supporting byte order, alignment and size options,

character strings, and unsigned numbers */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include <ctype.h>

static PyTypeObject PyStructType;

/* The translation function for each format character is table driven */

typedef struct _formatdef {

char format;

Py_ssize_t size;

Py_ssize_t alignment;

PyObject* (*unpack)(const char *,

const struct _formatdef *);

int (*pack)(char *, PyObject *,

const struct _formatdef *);

} formatdef;

typedef struct _formatcode {

const struct _formatdef *fmtdef;

Py_ssize_t offset;

Py_ssize_t size;

Py_ssize_t repeat;

} formatcode;

/* Struct object interface */

typedef struct {

PyObject_HEAD

Py_ssize_t s_size;

Py_ssize_t s_len;

formatcode *s_codes;

PyObject *s_format;

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

} PyStructObject;

#define PyStruct_Check(op) PyObject_TypeCheck(op, &PyStructType)

#define PyStruct_CheckExact(op) (Py_TYPE(op) == &PyStructType)

/* Exception */

static PyObject *StructError;

/* Define various structs to figure out the alignments of types */

typedef struct { char c; short x; } st_short;

typedef struct { char c; int x; } st_int;

typedef struct { char c; long x; } st_long;

typedef struct { char c; float x; } st_float;

typedef struct { char c; double x; } st_double;

typedef struct { char c; void *x; } st_void_p;

typedef struct { char c; size_t x; } st_size_t;

typedef struct { char c; _Bool x; } st_bool;

#define SHORT_ALIGN (sizeof(st_short) - sizeof(short))

#define INT_ALIGN (sizeof(st_int) - sizeof(int))

#define LONG_ALIGN (sizeof(st_long) - sizeof(long))

#define FLOAT_ALIGN (sizeof(st_float) - sizeof(float))

#define DOUBLE_ALIGN (sizeof(st_double) - sizeof(double))

#define VOID_P_ALIGN (sizeof(st_void_p) - sizeof(void *))

#define SIZE_T_ALIGN (sizeof(st_size_t) - sizeof(size_t))

#define BOOL_ALIGN (sizeof(st_bool) - sizeof(_Bool))

/* We can't support q and Q in native mode unless the compiler does;

in std mode, they're 8 bytes on all platforms. */

typedef struct { char c; long long x; } s_long_long;

#define LONG_LONG_ALIGN (sizeof(s_long_long) - sizeof(long long))

#ifdef __powerc

#pragma options align=reset

#endif

/* Helper for integer format codes: converts an arbitrary Python object to a

PyLongObject if possible, otherwise fails. Caller should decref. */

static PyObject *

get_pylong(PyObject *v)

{

assert(v != NULL);

if (!PyLong_Check(v)) {

/* Not an integer; try to use __index__ to convert. */

if (PyIndex_Check(v)) {

v = PyNumber_Index(v);

if (v == NULL)

return NULL;

}

else {

PyErr_SetString(StructError,

"required argument is not an integer");

return NULL;

}

}

else

Py_INCREF(v);

assert(PyLong_Check(v));

return v;

}

/* Helper routine to get a C long and raise the appropriate error if it isn't

one */

static int

get_long(PyObject *v, long *p)

{

long x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsLong(v);

Py_DECREF(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError))

PyErr_SetString(StructError,

"argument out of range");

return -1;

}

*p = x;

return 0;

}

/* Same, but handling unsigned long */

static int

get_ulong(PyObject *v, unsigned long *p)

{

unsigned long x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsUnsignedLong(v);

Py_DECREF(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError))

PyErr_SetString(StructError,

"argument out of range");

return -1;

}

*p = x;

return 0;

}

/* Same, but handling native long long. */

static int

get_longlong(PyObject *v, long long *p)

{

long long x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsLongLong(v);

Py_DECREF(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError))

PyErr_SetString(StructError,

"argument out of range");

return -1;

}

*p = x;

return 0;

}

/* Same, but handling native unsigned long long. */

static int

get_ulonglong(PyObject *v, unsigned long long *p)

{

unsigned long long x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsUnsignedLongLong(v);

Py_DECREF(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError))

PyErr_SetString(StructError,

"argument out of range");

return -1;

}

*p = x;

return 0;

}

/* Same, but handling Py_ssize_t */

static int

get_ssize_t(PyObject *v, Py_ssize_t *p)

{

Py_ssize_t x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsSsize_t(v);

Py_DECREF(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError))

PyErr_SetString(StructError,

"argument out of range");

return -1;

}

*p = x;

return 0;

}

/* Same, but handling size_t */

static int

get_size_t(PyObject *v, size_t *p)

{

size_t x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsSize_t(v);

Py_DECREF(v);

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

if (PyErr_ExceptionMatches(PyExc_OverflowError))

PyErr_SetString(StructError,

"argument out of range");

return -1;

}

*p = x;

return 0;

}

#define RANGE_ERROR(x, f, flag, mask) return _range_error(f, flag)

/* Floating point helpers */

static PyObject *

unpack_halffloat(const char *p, /* start of 2-byte string */

int le) /* true for little-endian, false for big-endian */

{

double x;

x = _PyFloat_Unpack2((unsigned char *)p, le);

if (x == -1.0 && PyErr_Occurred()) {

return NULL;

}

return PyFloat_FromDouble(x);

}

static int

pack_halffloat(char *p, /* start of 2-byte string */

PyObject *v, /* value to pack */

int le) /* true for little-endian, false for big-endian */

{

double x = PyFloat_AsDouble(v);

if (x == -1.0 && PyErr_Occurred()) {

PyErr_SetString(StructError,

"required argument is not a float");

return -1;

}

return _PyFloat_Pack2(x, (unsigned char *)p, le);

}

static PyObject *

unpack_float(const char *p, /* start of 4-byte string */

int le) /* true for little-endian, false for big-endian */

{

double x;

x = _PyFloat_Unpack4((unsigned char *)p, le);

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

return NULL;

return PyFloat_FromDouble(x);

}

static PyObject *

unpack_double(const char *p, /* start of 8-byte string */

int le) /* true for little-endian, false for big-endian */

{

double x;

x = _PyFloat_Unpack8((unsigned char *)p, le);

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

return NULL;

return PyFloat_FromDouble(x);

}

/* Helper to format the range error exceptions */

static int

_range_error(const formatdef *f, int is_unsigned)

{

/* ulargest is the largest unsigned value with f->size bytes.

* Note that the simpler:

* ((size_t)1 << (f->size * 8)) - 1

* doesn't work when f->size == sizeof(size_t) because C doesn't

* define what happens when a left shift count is >= the number of

* bits in the integer being shifted; e.g., on some boxes it doesn't

* shift at all when they're equal.

*/

const size_t ulargest = (size_t)-1 >> ((SIZEOF_SIZE_T - f->size)*8);

assert(f->size >= 1 && f->size <= SIZEOF_SIZE_T);

if (is_unsigned)

PyErr_Format(StructError,

"'%c' format requires 0 <= number <= %zu",

f->format,

ulargest);

else {

const Py_ssize_t largest = (Py_ssize_t)(ulargest >> 1);

PyErr_Format(StructError,

"'%c' format requires %zd <= number <= %zd",

f->format,

~ largest,

largest);

}

return -1;

}

/* A large number of small routines follow, with names of the form

[bln][up]_TYPE

[bln] distiguishes among big-endian, little-endian and native.

[pu] distiguishes between pack (to struct) and unpack (from struct).

TYPE is one of char, byte, ubyte, etc.

*/

/* Native mode routines. ****************************************************/

/* NOTE:

In all n[up]_<type> routines handling types larger than 1 byte, there is

*no* guarantee that the p pointer is properly aligned for each type,

therefore memcpy is called. An intermediate variable is used to

compensate for big-endian architectures.

Normally both the intermediate variable and the memcpy call will be

skipped by C optimisation in little-endian architectures (gcc >= 2.91

does this). */

static PyObject *

nu_char(const char *p, const formatdef *f)

{

return PyBytes_FromStringAndSize(p, 1);

}

static PyObject *

nu_byte(const char *p, const formatdef *f)

{

return PyLong_FromLong((long) *(signed char *)p);

}

static PyObject *

nu_ubyte(const char *p, const formatdef *f)

{

return PyLong_FromLong((long) *(unsigned char *)p);

}

static PyObject *

nu_short(const char *p, const formatdef *f)

{

short x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromLong((long)x);

}

static PyObject *

nu_ushort(const char *p, const formatdef *f)

{

unsigned short x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromLong((long)x);

}

static PyObject *

nu_int(const char *p, const formatdef *f)

{

int x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromLong((long)x);

}

static PyObject *

nu_uint(const char *p, const formatdef *f)

{

unsigned int x;

memcpy((char *)&x, p, sizeof x);

#if (SIZEOF_LONG > SIZEOF_INT)

return PyLong_FromLong((long)x);

#else

if (x <= ((unsigned int)LONG_MAX))

return PyLong_FromLong((long)x);

return PyLong_FromUnsignedLong((unsigned long)x);

#endif

}

static PyObject *

nu_long(const char *p, const formatdef *f)

{

long x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromLong(x);

}

static PyObject *

nu_ulong(const char *p, const formatdef *f)

{

unsigned long x;

memcpy((char *)&x, p, sizeof x);

if (x <= LONG_MAX)

return PyLong_FromLong((long)x);

return PyLong_FromUnsignedLong(x);

}

static PyObject *

nu_ssize_t(const char *p, const formatdef *f)

{

Py_ssize_t x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromSsize_t(x);

}

static PyObject *

nu_size_t(const char *p, const formatdef *f)

{

size_t x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromSize_t(x);

}

/* Native mode doesn't support q or Q unless the platform C supports

long long (or, on Windows, __int64). */

static PyObject *

nu_longlong(const char *p, const formatdef *f)

{

long long x;

memcpy((char *)&x, p, sizeof x);

if (x >= LONG_MIN && x <= LONG_MAX)

return PyLong_FromLong(Py_SAFE_DOWNCAST(x, long long, long));

return PyLong_FromLongLong(x);

}

static PyObject *

nu_ulonglong(const char *p, const formatdef *f)

{

unsigned long long x;

memcpy((char *)&x, p, sizeof x);

if (x <= LONG_MAX)

return PyLong_FromLong(Py_SAFE_DOWNCAST(x, unsigned long long, long));

return PyLong_FromUnsignedLongLong(x);

}

static PyObject *

nu_bool(const char *p, const formatdef *f)

{

_Bool x;

memcpy((char *)&x, p, sizeof x);

return PyBool_FromLong(x != 0);

}

static PyObject *

nu_halffloat(const char *p, const formatdef *f)

{

#if PY_LITTLE_ENDIAN

return unpack_halffloat(p, 1);

#else

return unpack_halffloat(p, 0);

#endif

}

static PyObject *

nu_float(const char *p, const formatdef *f)

{

float x;

memcpy((char *)&x, p, sizeof x);

return PyFloat_FromDouble((double)x);

}

static PyObject *

nu_double(const char *p, const formatdef *f)

{

double x;

memcpy((char *)&x, p, sizeof x);

return PyFloat_FromDouble(x);

}

static PyObject *

nu_void_p(const char *p, const formatdef *f)

{

void *x;

memcpy((char *)&x, p, sizeof x);

return PyLong_FromVoidPtr(x);

}

static int

np_byte(char *p, PyObject *v, const formatdef *f)

{

long x;

if (get_long(v, &x) < 0)

return -1;

if (x < -128 || x > 127){

PyErr_SetString(StructError,

"byte format requires -128 <= number <= 127");

return -1;

}

*p = (char)x;

return 0;

}

static int

np_ubyte(char *p, PyObject *v, const formatdef *f)

{

long x;

if (get_long(v, &x) < 0)

return -1;

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

PyErr_SetString(StructError,

"ubyte format requires 0 <= number <= 255");

return -1;

}

*p = (char)x;

return 0;

}

static int

np_char(char *p, PyObject *v, const formatdef *f)

{

if (!PyBytes_Check(v) || PyBytes_Size(v) != 1) {

PyErr_SetString(StructError,

"char format requires a bytes object of length 1");

return -1;

}

*p = *PyBytes_AsString(v);

return 0;

}

static int

np_short(char *p, PyObject *v, const formatdef *f)

{

long x;

short y;

if (get_long(v, &x) < 0)

return -1;

if (x < SHRT_MIN || x > SHRT_MAX){

PyErr_SetString(StructError,

"short format requires " Py_STRINGIFY(SHRT_MIN)

" <= number <= " Py_STRINGIFY(SHRT_MAX));

return -1;

}

y = (short)x;

memcpy(p, (char *)&y, sizeof y);

return 0;

}

static int

np_ushort(char *p, PyObject *v, const formatdef *f)

{

long x;

unsigned short y;

if (get_long(v, &x) < 0)

return -1;

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

PyErr_SetString(StructError,

"ushort format requires 0 <= number <= "

Py_STRINGIFY(USHRT_MAX));

return -1;

}

y = (unsigned short)x;

memcpy(p, (char *)&y, sizeof y);

return 0;

}

static int

np_int(char *p, PyObject *v, const formatdef *f)

{

long x;

int y;

if (get_long(v, &x) < 0)

return -1;

#if (SIZEOF_LONG > SIZEOF_INT)

if ((x < ((long)INT_MIN)) || (x > ((long)INT_MAX)))

RANGE_ERROR(x, f, 0, -1);

#endif

y = (int)x;

memcpy(p, (char *)&y, sizeof y);

return 0;

}

static int

np_uint(char *p, PyObject *v, const formatdef *f)

{

unsigned long x;

unsigned int y;

if (get_ulong(v, &x) < 0)

return -1;

y = (unsigned int)x;

#if (SIZEOF_LONG > SIZEOF_INT)

if (x > ((unsigned long)UINT_MAX))

RANGE_ERROR(y, f, 1, -1);

#endif

memcpy(p, (char *)&y, sizeof y);

return 0;

}

static int

np_long(char *p, PyObject *v, const formatdef *f)

{

long x;

if (get_long(v, &x) < 0)

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_ulong(char *p, PyObject *v, const formatdef *f)

{

unsigned long x;

if (get_ulong(v, &x) < 0)

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_ssize_t(char *p, PyObject *v, const formatdef *f)

{

Py_ssize_t x;

if (get_ssize_t(v, &x) < 0)

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_size_t(char *p, PyObject *v, const formatdef *f)

{

size_t x;

if (get_size_t(v, &x) < 0)

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_longlong(char *p, PyObject *v, const formatdef *f)

{

long long x;

if (get_longlong(v, &x) < 0)

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_ulonglong(char *p, PyObject *v, const formatdef *f)

{

unsigned long long x;

if (get_ulonglong(v, &x) < 0)

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_bool(char *p, PyObject *v, const formatdef *f)

{

int y;

_Bool x;

y = PyObject_IsTrue(v);

if (y < 0)

return -1;

x = y;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_halffloat(char *p, PyObject *v, const formatdef *f)

{

#if PY_LITTLE_ENDIAN

return pack_halffloat(p, v, 1);

#else

return pack_halffloat(p, v, 0);

#endif

}

static int

np_float(char *p, PyObject *v, const formatdef *f)

{

float x = (float)PyFloat_AsDouble(v);

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

PyErr_SetString(StructError,

"required argument is not a float");

return -1;

}

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static int

np_double(char *p, PyObject *v, const formatdef *f)

{

double x = PyFloat_AsDouble(v);

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

PyErr_SetString(StructError,

"required argument is not a float");

return -1;

}

memcpy(p, (char *)&x, sizeof(double));

return 0;

}

static int

np_void_p(char *p, PyObject *v, const formatdef *f)

{

void *x;

v = get_pylong(v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsVoidPtr(v);

Py_DECREF(v);

if (x == NULL && PyErr_Occurred())

return -1;

memcpy(p, (char *)&x, sizeof x);

return 0;

}

static const formatdef native_table[] = {

{'x', sizeof(char), 0, NULL},

{'b', sizeof(char), 0, nu_byte, np_byte},

{'B', sizeof(char), 0, nu_ubyte, np_ubyte},

{'c', sizeof(char), 0, nu_char, np_char},

{'s', sizeof(char), 0, NULL},

{'p', sizeof(char), 0, NULL},

{'h', sizeof(short), SHORT_ALIGN, nu_short, np_short},

{'H', sizeof(short), SHORT_ALIGN, nu_ushort, np_ushort},

{'i', sizeof(int), INT_ALIGN, nu_int, np_int},

{'I', sizeof(int), INT_ALIGN, nu_uint, np_uint},

{'l', sizeof(long), LONG_ALIGN, nu_long, np_long},

{'L', sizeof(long), LONG_ALIGN, nu_ulong, np_ulong},

{'n', sizeof(size_t), SIZE_T_ALIGN, nu_ssize_t, np_ssize_t},

{'N', sizeof(size_t), SIZE_T_ALIGN, nu_size_t, np_size_t},

{'q', sizeof(long long), LONG_LONG_ALIGN, nu_longlong, np_longlong},

{'Q', sizeof(long long), LONG_LONG_ALIGN, nu_ulonglong,np_ulonglong},

{'?', sizeof(_Bool), BOOL_ALIGN, nu_bool, np_bool},

{'e', sizeof(short), SHORT_ALIGN, nu_halffloat, np_halffloat},

{'f', sizeof(float), FLOAT_ALIGN, nu_float, np_float},

{'d', sizeof(double), DOUBLE_ALIGN, nu_double, np_double},

{'P', sizeof(void *), VOID_P_ALIGN, nu_void_p, np_void_p},

{0}

};

/* Big-endian routines. *****************************************************/

static PyObject *

bu_int(const char *p, const formatdef *f)

{

long x = 0;

Py_ssize_t i = f->size;

const unsigned char *bytes = (const unsigned char *)p;

do {

x = (x<<8) | *bytes++;

} while (--i > 0);

/* Extend the sign bit. */

if (SIZEOF_LONG > f->size)

x |= -(x & (1L << ((8 * f->size) - 1)));

return PyLong_FromLong(x);

}

static PyObject *

bu_uint(const char *p, const formatdef *f)

{

unsigned long x = 0;

Py_ssize_t i = f->size;

const unsigned char *bytes = (const unsigned char *)p;

do {

x = (x<<8) | *bytes++;

} while (--i > 0);

if (x <= LONG_MAX)

return PyLong_FromLong((long)x);

return PyLong_FromUnsignedLong(x);

}

static PyObject *

bu_longlong(const char *p, const formatdef *f)

{

long long x = 0;

Py_ssize_t i = f->size;

const unsigned char *bytes = (const unsigned char *)p;

do {

x = (x<<8) | *bytes++;

} while (--i > 0);

/* Extend the sign bit. */

if (SIZEOF_LONG_LONG > f->size)

x |= -(x & ((long long)1 << ((8 * f->size) - 1)));

if (x >= LONG_MIN && x <= LONG_MAX)

return PyLong_FromLong(Py_SAFE_DOWNCAST(x, long long, long));

return PyLong_FromLongLong(x);

}

static PyObject *

bu_ulonglong(const char *p, const formatdef *f)

{

unsigned long long x = 0;

Py_ssize_t i = f->size;

const unsigned char *bytes = (const unsigned char *)p;

do {

x = (x<<8) | *bytes++;

} while (--i > 0);

if (x <= LONG_MAX)

return PyLong_FromLong(Py_SAFE_DOWNCAST(x, unsigned long long, long));

return PyLong_FromUnsignedLongLong(x);

}

static PyObject *

bu_halffloat(const char *p, const formatdef *f)

{

return unpack_halffloat(p, 0);

}

static PyObject *

bu_float(const char *p, const formatdef *f)

{

return unpack_float(p, 0);

}

static PyObject *

bu_double(const char *p, const formatdef *f)

{

return unpack_double(p, 0);

}

static PyObject *

bu_bool(const char *p, const formatdef *f)

{

char x;

memcpy((char *)&x, p, sizeof x);

return PyBool_FromLong(x != 0);

}

static int

bp_int(char *p, PyObject *v, const formatdef *f)

{

long x;

Py_ssize_t i;

if (get_long(v, &x) < 0)

return -1;

i = f->size;

if (i != SIZEOF_LONG) {

if ((i == 2) && (x < -32768 || x > 32767))

RANGE_ERROR(x, f, 0, 0xffffL);

#if (SIZEOF_LONG != 4)

else if ((i == 4) && (x < -2147483648L || x > 2147483647L))

RANGE_ERROR(x, f, 0, 0xffffffffL);

#endif

}

do {

p[--i] = (char)x;

x >>= 8;

} while (i > 0);

return 0;

}

static int

bp_uint(char *p, PyObject *v, const formatdef *f)

{

unsigned long x;

Py_ssize_t i;

if (get_ulong(v, &x) < 0)

return -1;

i = f->size;

if (i != SIZEOF_LONG) {

unsigned long maxint = 1;

maxint <<= (unsigned long)(i * 8);

if (x >= maxint)

RANGE_ERROR(x, f, 1, maxint - 1);

}

do {

p[--i] = (char)x;

x >>= 8;

} while (i > 0);

return 0;

}

static int

bp_longlong(char *p, PyObject *v, const formatdef *f)

{

int res;

v = get_pylong(v);

if (v == NULL)

return -1;

res = _PyLong_AsByteArray((PyLongObject *)v,

(unsigned char *)p,

8,

0, /* little_endian */

1 /* signed */);

Py_DECREF(v);

return res;

}

static int

bp_ulonglong(char *p, PyObject *v, const formatdef *f)

{

int res;

v = get_pylong(v);

if (v == NULL)

return -1;

res = _PyLong_AsByteArray((PyLongObject *)v,

(unsigned char *)p,

8,

0, /* little_endian */

0 /* signed */);

Py_DECREF(v);

return res;

}

static int

bp_halffloat(char *p, PyObject *v, const formatdef *f)

{

return pack_halffloat(p, v, 0);

}

static int

bp_float(char *p, PyObject *v, const formatdef *f)

{

double x = PyFloat_AsDouble(v);

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

PyErr_SetString(StructError,

"required argument is not a float");

return -1;

}

return _PyFloat_Pack4(x, (unsigned char *)p, 0);

}

static int

bp_double(char *p, PyObject *v, const formatdef *f)

{

double x = PyFloat_AsDouble(v);

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

PyErr_SetString(StructError,

"required argument is not a float");

return -1;

}

return _PyFloat_Pack8(x, (unsigned char *)p, 0);

}

static int

bp_bool(char *p, PyObject *v, const formatdef *f)

{

int y;

y = PyObject_IsTrue(v);

if (y < 0)

return -1;

*p = (char)y;

return 0;

}

static formatdef bigendian_table[] = {

{'x', 1, 0, NULL},

{'b', 1, 0, nu_byte, np_byte},

{'B', 1, 0, nu_ubyte, np_ubyte},

{'c', 1, 0, nu_char, np_char},

{'s', 1, 0, NULL},

{'p', 1, 0, NULL},

{'h', 2, 0, bu_int, bp_int},

{'H', 2, 0, bu_uint, bp_uint},

{'i', 4, 0, bu_int, bp_int},

{'I', 4, 0, bu_uint, bp_uint},

{'l', 4, 0, bu_int, bp_int},

{'L', 4, 0, bu_uint, bp_uint},

{'q', 8, 0, bu_longlong, bp_longlong},

{'Q', 8, 0, bu_ulonglong, bp_ulonglong},

{'?', 1, 0, bu_bool, bp_bool},

{'e', 2, 0, bu_halffloat, bp_halffloat},

{'f', 4, 0, bu_float, bp_float},