#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structseq.h"

#include "structmember.h"

#include <ctype.h>

static PyTypeObject PyStructType;

#if (PY_VERSION_HEX < 0x02050000)

typedef int Py_ssize_t;

#define PY_STRUCT_OVERFLOW_MASKING 1

#ifdef PY_STRUCT_OVERFLOW_MASKING

static PyObject *pylong_ulong_mask = NULL;

static PyObject *pyint_zero = NULL;

#define PY_STRUCT_FLOAT_COERCE 1

#ifdef PY_STRUCT_FLOAT_COERCE

#define FLOAT_COERCE "integer argument expected, got float"

typedef struct _formatdef {

} formatdef;

typedef struct _formatcode {

} formatcode;

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) ((op)->ob_type == &PyStructType)

static PyObject *StructError;

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

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

#define STRINGIFY(x) #x

#ifdef __powerc

#pragma options align=reset

static PyObject *

get_pylong(PyObject *v)

{

PyNumberMethods *m;

assert(v != NULL);

if (PyInt_Check(v))

return PyLong_FromLong(PyInt_AS_LONG(v));

if (PyLong_Check(v)) {

Py_INCREF(v);

return v;

}

m = v->ob_type->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;

}

static int

get_long(PyObject *v, long *p)

{

long x = PyInt_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;

}

if (PyErr_ExceptionMatches(PyExc_TypeError))

PyErr_SetString(StructError,

"required argument is not an integer");

return -1;

}

*p = x;

return 0;

}

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

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;

}

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;

}

#ifdef PY_STRUCT_OVERFLOW_MASKING

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

}

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;

}

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)

#define get_wrapped_long get_long

#define get_wrapped_ulong get_ulong

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

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

}

static int

_range_error(const formatdef *f, int is_unsigned)

{

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

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,

PyString_AS_STRING(msg), 2);

Py_DECREF(msg);

if (rval == 0)

return 0;

}

return -1;

}

static PyObject *

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

{

return PyString_FromStringAndSize(p, 1);

}

static PyObject *

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

{

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

}

static PyObject *

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

{

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

}

static PyObject *

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

{

short x;

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

return PyInt_FromLong((long)x);

}

static PyObject *

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

{

unsigned short x;

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

return PyInt_FromLong((long)x);

}

static PyObject *

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

{

int x;

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

return PyInt_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 PyInt_FromLong((long)x);

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

return PyInt_FromLong((long)x);

return PyLong_FromUnsignedLong((unsigned long)x);

}

static PyObject *

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

{

long x;

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

return PyInt_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 PyInt_FromLong((long)x);

return PyLong_FromUnsignedLong(x);

}

#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 PyInt_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 PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));

return PyLong_FromUnsignedLongLong(x);

}

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 (!PyString_Check(v) || PyString_Size(v) != 1) {

PyErr_SetString(StructError,

"char format require string of length 1");

return -1;

}

*p = *PyString_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)))

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

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

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_wrapped_ulong(v, &x) < 0)

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

}

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

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

};

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 PyInt_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 PyInt_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 PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));

return PyLong_FromLongLong(x);

return _PyLong_FromByteArray((const unsigned char *)p,

8,

0, /* little-endian */

1 /* signed */);

}

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 PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));

return PyLong_FromUnsignedLongLong(x);

return _PyLong_FromByteArray((const unsigned char *)p,

8,

0, /* little-endian */

0 /* signed */);

}

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

#ifdef PY_STRUCT_OVERFLOW_MASKING

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

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

}

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,

"required argument is not a float");

return -1;

}

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

}

static formatdef bigendian_table[] = {

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

#ifdef PY_STRUCT_OVERFLOW_MASKING

/* Native packers do range checking without overflow masking. */

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

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

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

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

{'d', 8, 0, bu_double, bp_double},

{0}

};

static PyObject *