/* 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 "structseq.h"

#include "structmember.h"

#include <ctype.h>

static PyTypeObject PyStructType;

/* If PY_STRUCT_OVERFLOW_MASKING is defined, the struct module will wrap all input

numbers for explicit endians such that they fit in the given type, much

like explicit casting in C. A warning will be raised if the number did

not originally fit within the range of the requested type. If it is

not defined, then all range errors and overflow will be struct.error

exceptions. */

#define PY_STRUCT_OVERFLOW_MASKING 1

#ifdef PY_STRUCT_OVERFLOW_MASKING

static PyObject *pylong_ulong_mask = NULL;

static PyObject *pyint_zero = NULL;

#endif

/* If PY_STRUCT_FLOAT_COERCE is defined, the struct module will allow float

arguments for integer formats with a warning for backwards

compatibility. */

#define PY_STRUCT_FLOAT_COERCE 1

#ifdef PY_STRUCT_FLOAT_COERCE

#define FLOAT_COERCE "integer argument expected, got float"

#endif

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

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

#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 *))

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

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

#ifdef HAVE_LONG_LONG

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

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

#endif

#ifdef HAVE_C99_BOOL

#define BOOL_TYPE _Bool

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

#define BOOL_ALIGN (sizeof(s_bool) - sizeof(BOOL_TYPE))

#else

#define BOOL_TYPE char

#define BOOL_ALIGN 0

#endif

#define STRINGIFY(x) #x

#ifdef __powerc

#pragma options align=reset

#endif

/* Helper to get a PyLongObject by hook or by crook. Caller should decref. */

static PyObject *

get_pylong(PyObject *v)

{

PyNumberMethods *m;

assert(v != NULL);

if (PyLong_Check(v)) {

Py_INCREF(v);

return v;

}

m = Py_TYPE(v)->tp_as_number;

if (m != NULL && m->nb_long != NULL) {

v = m->nb_long(v);

if (v == NULL)

return NULL;

if (PyLong_Check(v))

return v;

Py_DECREF(v);

}

PyErr_SetString(StructError,

"cannot convert argument to long");

return NULL;

}

/* Helper routine to get a Python integer and raise the appropriate error

if it isn't one */

static int

get_long(PyObject *v, long *p)

{

long x = PyLong_AsLong(v);

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

#ifdef PY_STRUCT_FLOAT_COERCE

if (PyFloat_Check(v)) {

PyObject *o;

int res;

PyErr_Clear();

if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)

return -1;

o = PyNumber_Int(v);

if (o == NULL)

return -1;

res = get_long(o, p);

Py_DECREF(o);

return res;

}

#endif

if (PyErr_ExceptionMatches(PyExc_TypeError))

PyErr_SetString(StructError,

"required argument is not an integer");

return -1;

}

*p = x;

return 0;

}

/* Same, but handling unsigned long */

static int

get_ulong(PyObject *v, unsigned long *p)

{

if (PyLong_Check(v)) {

unsigned long x = PyLong_AsUnsignedLong(v);

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

return -1;

*p = x;

return 0;

}

if (get_long(v, (long *)p) < 0)

return -1;

if (((long)*p) < 0) {

PyErr_SetString(StructError,

"unsigned argument is < 0");

return -1;

}

return 0;

}

#ifdef HAVE_LONG_LONG

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

static int

get_longlong(PyObject *v, PY_LONG_LONG *p)

{

PY_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 == (PY_LONG_LONG)-1 && PyErr_Occurred())

return -1;

*p = x;

return 0;

}

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

static int

get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)

{

unsigned PY_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 PY_LONG_LONG)-1 && PyErr_Occurred())

return -1;

*p = x;

return 0;

}

#endif

#ifdef PY_STRUCT_OVERFLOW_MASKING

/* Helper routine to get a Python integer and raise the appropriate error

if it isn't one */

#define INT_OVERFLOW "struct integer overflow masking is deprecated"

static int

get_wrapped_long(PyObject *v, long *p)

{

if (get_long(v, p) < 0) {

if (PyLong_Check(v) &&

PyErr_ExceptionMatches(PyExc_OverflowError)) {

PyObject *wrapped;

long x;

PyErr_Clear();

#ifdef PY_STRUCT_FLOAT_COERCE

if (PyFloat_Check(v)) {

PyObject *o;

int res;

PyErr_Clear();

if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)

return -1;

o = PyNumber_Int(v);

if (o == NULL)

return -1;

res = get_wrapped_long(o, p);

Py_DECREF(o);

return res;

}

#endif

if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0)

return -1;

wrapped = PyNumber_And(v, pylong_ulong_mask);

if (wrapped == NULL)

return -1;

x = (long)PyLong_AsUnsignedLong(wrapped);

Py_DECREF(wrapped);

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

return -1;

*p = x;

} else {

return -1;

}

}

return 0;

}

static int

get_wrapped_ulong(PyObject *v, unsigned long *p)

{

long x = (long)PyLong_AsUnsignedLong(v);

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

PyObject *wrapped;

PyErr_Clear();

#ifdef PY_STRUCT_FLOAT_COERCE

if (PyFloat_Check(v)) {

PyObject *o;

int res;

PyErr_Clear();

if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)

return -1;

o = PyNumber_Int(v);

if (o == NULL)

return -1;

res = get_wrapped_ulong(o, p);

Py_DECREF(o);

return res;

}

#endif

wrapped = PyNumber_And(v, pylong_ulong_mask);

if (wrapped == NULL)

return -1;

if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0) {

Py_DECREF(wrapped);

return -1;

}

x = (long)PyLong_AsUnsignedLong(wrapped);

Py_DECREF(wrapped);

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

return -1;

}

*p = (unsigned long)x;

return 0;

}

#define RANGE_ERROR(x, f, flag, mask) \

do { \

if (_range_error(f, flag) < 0) \

return -1; \

else \

(x) &= (mask); \

} while (0)

#else

#define get_wrapped_long get_long

#define get_wrapped_ulong get_ulong

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

#endif

/* Floating point helpers */

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);

}

#ifdef PY_STRUCT_OVERFLOW_MASKING

{

PyObject *ptype, *pvalue, *ptraceback;

PyObject *msg;

int rval;

PyErr_Fetch(&ptype, &pvalue, &ptraceback);

assert(pvalue != NULL);

msg = PyObject_Str(pvalue);

Py_XDECREF(ptype);

Py_XDECREF(pvalue);

Py_XDECREF(ptraceback);

if (msg == NULL)

return -1;

rval = PyErr_WarnEx(PyExc_DeprecationWarning,

_PyUnicode_AsString(msg), 2);

Py_DECREF(msg);

if (rval == 0)

return 0;

}

#endif

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);

}

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

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

#ifdef HAVE_LONG_LONG

static PyObject *

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

{

PY_LONG_LONG x;

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

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

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

return PyLong_FromLongLong(x);

}

static PyObject *

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

{

unsigned PY_LONG_LONG x;

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

if (x <= LONG_MAX)

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

return PyLong_FromUnsignedLongLong(x);

}

#endif

static PyObject *

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

{

BOOL_TYPE x;

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

return PyBool_FromLong(x != 0);

}

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 (PyUnicode_Check(v)) {

v = _PyUnicode_AsDefaultEncodedString(v, NULL);

if (v == NULL)

return -1;

}

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

PyErr_SetString(StructError,

"char format requires bytes or string 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 " STRINGIFY(SHRT_MIN)

" <= number <= " 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,

"short format requires 0 <= number <= " 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)))

return _range_error(f, 0);

#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 _range_error(f, 1);

y = (unsigned int)x;

#if (SIZEOF_LONG > SIZEOF_INT)

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

return _range_error(f, 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 _range_error(f, 1);

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

return 0;

}

#ifdef HAVE_LONG_LONG

static int

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

{

PY_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 PY_LONG_LONG x;

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

return -1;

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

return 0;

}

#endif

static int

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

{

BOOL_TYPE y;

y = PyObject_IsTrue(v);

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

return 0;

}

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 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},

#ifdef HAVE_LONG_LONG

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

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

#endif

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

{'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)

{

#ifdef HAVE_LONG_LONG

PY_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 & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));

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

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

return PyLong_FromLongLong(x);

#else

return _PyLong_FromByteArray((const unsigned char *)p,

8,

0, /* little-endian */

1 /* signed */);

#endif

}

static PyObject *

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

{

#ifdef HAVE_LONG_LONG

unsigned PY_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 PY_LONG_LONG, long));

return PyLong_FromUnsignedLongLong(x);

#else

return _PyLong_FromByteArray((const unsigned char *)p,

8,

0, /* little-endian */

0 /* signed */);

#endif

}

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_wrapped_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

#ifdef PY_STRUCT_OVERFLOW_MASKING

else if ((i == 1) && (x < -128 || x > 127))

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

#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_wrapped_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_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,