#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 FLOAT_COERCE_WARN "integer argument expected, got float"

#define NON_INTEGER_WARN "integer argument expected, got non-integer " \

"(implicit conversion using __int__ is deprecated)"

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

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

#define BOOL_TYPE char

#define BOOL_ALIGN 0

#define STRINGIFY(x) #x

#ifdef __powerc

#pragma options align=reset

static char *integer_codes = "bBhHiIlLqQ";

static PyObject *

get_pylong(PyObject *v)

{

PyObject *r, *w;

int converted = 0;

assert(v != NULL);

if (!_PyAnyInt_Check(v)) {

PyNumberMethods *m;

/* Not an integer; first try to use __index__ to

m = Py_TYPE(v)->tp_as_number;

if (PyIndex_Check(v)) {

w = PyNumber_Index(v);

if (w != NULL) {

v = w;

/* successfully converted to an integer */

converted = 1;

}

else if (PyErr_ExceptionMatches(PyExc_TypeError)) {

PyErr_Clear();

}

else

return NULL;

}

if (!converted && m != NULL && m->nb_int != NULL) {

/* Special case warning message for floats, for

if (PyFloat_Check(v)) {

if (PyErr_WarnEx(

PyExc_DeprecationWarning,

FLOAT_COERCE_WARN, 1))

return NULL;

}

else {

if (PyErr_WarnEx(

PyExc_DeprecationWarning,

NON_INTEGER_WARN, 1))

return NULL;

}

v = m->nb_int(v);

if (v == NULL)

return NULL;

if (!_PyAnyInt_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"__int__ method returned "

"non-integer");

return NULL;

}

converted = 1;

}

if (!converted) {

PyErr_SetString(StructError,

"cannot convert argument "

"to integer");

return NULL;

}

}

else

/* Ensure we own a reference to v. */

Py_INCREF(v);

assert(_PyAnyInt_Check(v));

if (PyInt_Check(v)) {

r = PyLong_FromLong(PyInt_AS_LONG(v));

Py_DECREF(v);

}

else if (PyLong_Check(v)) {

assert(PyLong_Check(v));

r = v;

}

else {

r = NULL; /* silence compiler warning about

assert(0); /* shouldn't ever get here */

}

return r;

}

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

return -1;

*p = x;

return 0;

}

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

return -1;

*p = x;

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;

}

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

}

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

}

*(unsigned char *)p = (unsigned 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,

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

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

return _range_error(f, 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_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_bool(char *p, PyObject *v, const formatdef *f)

{

int y;

BOOL_TYPE x;

y = PyObject_IsTrue(v);

if (y < 0)

return -1;

x = y;

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

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

};

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

unsigned char *q = (unsigned char *)p;

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

return -1;

i = f->size;

if (i != SIZEOF_LONG) {

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

return _range_error(f, 0);

#if (SIZEOF_LONG != 4)

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

return _range_error(f, 0);

}

do {

q[--i] = (unsigned char)(x & 0xffL);

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;

unsigned char *q = (unsigned char *)p;

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)

return _range_error(f, 1);

}

do {

q[--i] = (unsigned char)(x & 0xffUL);

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

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

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

{0}

};

static PyObject *

lu_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[--i];

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

lu_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[--i];

} while (i > 0);

if (x <= LONG_MAX)

return PyInt_FromLong((long)x);

return PyLong_FromUnsignedLong((long)x);

}

static PyObject *

lu_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[--i];

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

1, /* little-endian */

1 /* signed */);

}