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

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

character strings, and unsigned numbers */

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#include "Python.h"

#include "pycore_bytesobject.h" // _PyBytesWriter

#include "pycore_long.h" // _PyLong_AsByteArray()

#include "pycore_moduleobject.h" // _PyModule_GetState()

#ifdef Py_HAVE_C_COMPLEX

# include "_complex.h" // complex

#endif

#include <stddef.h> // offsetof()

/*[clinic input]

class Struct "PyStructObject *" "&PyStructType"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b032058a83ed7c3]*/

typedef struct {

PyObject *cache;

PyObject *PyStructType;

PyObject *unpackiter_type;

PyObject *StructError;

} _structmodulestate;

static inline _structmodulestate*

get_struct_state(PyObject *module)

{

void *state = _PyModule_GetState(module);

assert(state != NULL);

return (_structmodulestate *)state;

}

static struct PyModuleDef _structmodule;

#define get_struct_state_structinst(self) \

(get_struct_state(PyType_GetModuleByDef(Py_TYPE(self), &_structmodule)))

#define get_struct_state_iterinst(self) \

(get_struct_state(PyType_GetModule(Py_TYPE(self))))

/* 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)(_structmodulestate *, const char *,

const struct _formatdef *);

int (*pack)(_structmodulestate *, 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 PyStructObject_CAST(op) ((PyStructObject *)(op))

#define PyStruct_Check(op, state) PyObject_TypeCheck(op, (PyTypeObject *)(state)->PyStructType)

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

#ifdef Py_HAVE_C_COMPLEX

typedef struct { char c; float complex x; } st_float_complex;

typedef struct { char c; double complex x; } st_double_complex;

#endif

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

#ifdef Py_HAVE_C_COMPLEX

# define FLOAT_COMPLEX_ALIGN (sizeof(st_float_complex) - sizeof(float complex))

# define DOUBLE_COMPLEX_ALIGN (sizeof(st_double_complex) - sizeof(double complex))

#endif

#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

/*[python input]

class cache_struct_converter(CConverter):

type = 'PyStructObject *'

converter = 'cache_struct_converter'

c_default = "NULL"

broken_limited_capi = True

def parse_arg(self, argname, displayname, *, limited_capi):

assert not limited_capi

return self.format_code("""

if (!{converter}(module, {argname}, &{paramname})) {{{{

goto exit;

}}}}

""",

argname=argname,

converter=self.converter)

def cleanup(self):

return "Py_XDECREF(%s);\n" % self.name

[python start generated code]*/

/*[python end generated code: output=da39a3ee5e6b4b0d input=c33b27d6b06006c6]*/

static int cache_struct_converter(PyObject *, PyObject *, PyStructObject **);

#include "clinic/_struct.c.h"

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

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

static PyObject *

get_pylong(_structmodulestate *state, 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(state->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(_structmodulestate *state, PyObject *v, long *p)

{

long x;

v = get_pylong(state, 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;

}

/* Same, but handling unsigned long */

static int

get_ulong(_structmodulestate *state, PyObject *v, unsigned long *p)

{

unsigned long x;

v = get_pylong(state, 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;

}

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

static int

get_longlong(_structmodulestate *state, PyObject *v, long long *p)

{

long long x;

v = get_pylong(state, v);

if (v == NULL)

return -1;

assert(PyLong_Check(v));

x = PyLong_AsLongLong(v);

Py_DECREF(v);

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

return -1;

}

*p = x;

return 0;

}

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

static int

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

{

unsigned long long x;

v = get_pylong(state, 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()) {

return -1;

}

*p = x;

return 0;

}

/* Same, but handling Py_ssize_t */

static int

get_ssize_t(_structmodulestate *state, PyObject *v, Py_ssize_t *p)

{

Py_ssize_t x;

v = get_pylong(state, 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()) {

return -1;

}

*p = x;

return 0;

}

/* Same, but handling size_t */

static int

get_size_t(_structmodulestate *state, PyObject *v, size_t *p)

{

size_t x;

v = get_pylong(state, 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()) {

return -1;

}

*p = x;

return 0;

}

#define RANGE_ERROR(state, f, flag) return _range_error(state, 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 = PyFloat_Unpack2(p, le);

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

return NULL;

}

return PyFloat_FromDouble(x);

}

static int

pack_halffloat(_structmodulestate *state,

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(state->StructError,

"required argument is not a float");

return -1;

}

return PyFloat_Pack2(x, 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(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(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(_structmodulestate *state, 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(state->StructError,

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

f->format,

ulargest);

else {

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

PyErr_Format(state->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] distinguishes among big-endian, little-endian and native.

[pu] distinguishes 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(_structmodulestate *state, const char *p, const formatdef *f)

{

return PyBytes_FromStringAndSize(p, 1);

}

static PyObject *

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

{

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

}

static PyObject *

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

{

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

}

static PyObject *

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

{

short x;

memcpy(&x, p, sizeof x);

return PyLong_FromLong((long)x);

}

static PyObject *

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

{

unsigned short x;

memcpy(&x, p, sizeof x);

return PyLong_FromLong((long)x);

}

static PyObject *

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

{

int x;

memcpy(&x, p, sizeof x);

return PyLong_FromLong((long)x);

}

static PyObject *

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

{

unsigned int x;

memcpy(&x, p, sizeof x);

return PyLong_FromUnsignedLong((unsigned long)x);

}

static PyObject *

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

{

long x;

memcpy(&x, p, sizeof x);

return PyLong_FromLong(x);

}

static PyObject *

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

{

unsigned long x;

memcpy(&x, p, sizeof x);

return PyLong_FromUnsignedLong(x);

}

static PyObject *

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

{

Py_ssize_t x;

memcpy(&x, p, sizeof x);

return PyLong_FromSsize_t(x);

}

static PyObject *

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

{

size_t x;

memcpy(&x, p, sizeof x);

return PyLong_FromSize_t(x);

}

static PyObject *

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

{

long long x;

memcpy(&x, p, sizeof x);

return PyLong_FromLongLong(x);

}

static PyObject *

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

{

unsigned long long x;

memcpy(&x, p, sizeof x);

return PyLong_FromUnsignedLongLong(x);

}

static PyObject *

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

{

const _Bool bool_false = 0;

return PyBool_FromLong(memcmp(p, &bool_false, sizeof(_Bool)));

}

static PyObject *

nu_halffloat(_structmodulestate *state, 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(_structmodulestate *state, const char *p, const formatdef *f)

{

float x;

memcpy(&x, p, sizeof x);

return PyFloat_FromDouble((double)x);

}

static PyObject *

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

{

double x;

memcpy(&x, p, sizeof x);

return PyFloat_FromDouble(x);

}

#ifdef Py_HAVE_C_COMPLEX

static PyObject *

nu_float_complex(_structmodulestate *state, const char *p, const formatdef *f)

{

float complex x;

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

return PyComplex_FromDoubles(creal(x), cimag(x));

}

static PyObject *

nu_double_complex(_structmodulestate *state, const char *p, const formatdef *f)

{

double complex x;

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

return PyComplex_FromDoubles(creal(x), cimag(x));

}

#endif

static PyObject *

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

{

void *x;

memcpy(&x, p, sizeof x);

return PyLong_FromVoidPtr(x);

}

static int

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

{

long x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 0);

}

return -1;

}

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

RANGE_ERROR(state, f, 0);

}

*p = (char)x;

return 0;

}

static int

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

{

long x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 1);

}

return -1;

}

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

RANGE_ERROR(state, f, 1);

}

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

return 0;

}

static int

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

{

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

PyErr_SetString(state->StructError,

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

return -1;

}

*p = *PyBytes_AS_STRING(v);

return 0;

}

static int

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

{

long x;

short y;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 0);

}

return -1;

}

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

RANGE_ERROR(state, f, 0);

}

y = (short)x;

memcpy(p, &y, sizeof y);

return 0;

}

static int

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

{

long x;

unsigned short y;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 1);

}

return -1;

}

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

RANGE_ERROR(state, f, 1);

}

y = (unsigned short)x;

memcpy(p, &y, sizeof y);

return 0;

}

static int

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

{

long x;

int y;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 0);

}

return -1;

}

#if (SIZEOF_LONG > SIZEOF_INT)

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

RANGE_ERROR(state, f, 0);

#endif

y = (int)x;

memcpy(p, &y, sizeof y);

return 0;

}

static int

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

{

unsigned long x;

unsigned int y;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 1);

}

return -1;

}

y = (unsigned int)x;

#if (SIZEOF_LONG > SIZEOF_INT)

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

RANGE_ERROR(state, f, 1);

#endif

memcpy(p, &y, sizeof y);

return 0;

}

static int

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

{

long x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 0);

}

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

unsigned long x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 1);

}

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

Py_ssize_t x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 0);

}

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

size_t x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

RANGE_ERROR(state, f, 1);

}

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

long long x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

PyErr_Format(state->StructError,

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

f->format,

LLONG_MIN,

LLONG_MAX);

}

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

unsigned long long x;

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

if (PyErr_ExceptionMatches(PyExc_OverflowError)) {

PyErr_Format(state->StructError,

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

f->format,

ULLONG_MAX);

}

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

int y;

_Bool x;

y = PyObject_IsTrue(v);

if (y < 0)

return -1;

x = y;

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

#if PY_LITTLE_ENDIAN

return pack_halffloat(state, p, v, 1);

#else

return pack_halffloat(state, p, v, 0);

#endif

}

static int

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

{

float x = (float)PyFloat_AsDouble(v);

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

PyErr_SetString(state->StructError,

"required argument is not a float");

return -1;

}

memcpy(p, &x, sizeof x);

return 0;

}

static int

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

{

double x = PyFloat_AsDouble(v);

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

PyErr_SetString(state->StructError,

"required argument is not a float");

return -1;

}

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

return 0;

}

#ifdef Py_HAVE_C_COMPLEX

static int

np_float_complex(_structmodulestate *state, char *p, PyObject *v,

const formatdef *f)

{

Py_complex c = PyComplex_AsCComplex(v);

float complex x = CMPLXF((float)c.real, (float)c.imag);

if (c.real == -1 && PyErr_Occurred()) {

PyErr_SetString(state->StructError,

"required argument is not a complex");

return -1;

}

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

return 0;

}

static int

np_double_complex(_structmodulestate *state, char *p, PyObject *v,

const formatdef *f)

{

Py_complex c = PyComplex_AsCComplex(v);

double complex x = CMPLX(c.real, c.imag);

if (c.real == -1 && PyErr_Occurred()) {

PyErr_SetString(state->StructError,

"required argument is not a complex");

return -1;

}

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

return 0;

}

#else

static int

np_complex_stub(_structmodulestate *state, char *p, PyObject *v,

const formatdef *f)

{

PyErr_Format(state->StructError,

"'%c' format not supported on this system",

f->format);

return -1;

}

static PyObject *

nu_complex_stub(_structmodulestate *state, const char *p, const formatdef *f)

{

PyErr_Format(state->StructError,

"'%c' format not supported on this system",

f->format);

return NULL;

}

#endif

static int

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

{

void *x;

v = get_pylong(state, 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, &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},

#ifdef Py_HAVE_C_COMPLEX

{'E', sizeof(float complex), FLOAT_COMPLEX_ALIGN, nu_float_complex, np_float_complex},

{'C', sizeof(double complex), DOUBLE_COMPLEX_ALIGN, nu_double_complex, np_double_complex},

#else

{'E', 1, 0, nu_complex_stub, np_complex_stub},

{'C', 1, 0, nu_complex_stub, np_complex_stub},

#endif

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

{0}

};

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

static PyObject *

bu_short(_structmodulestate *state, const char *p, const formatdef *f)

{

unsigned long x = 0;

/* This function is only ever used in the case f->size == 2. */

assert(f->size == 2);

Py_ssize_t i = 2;

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

do {

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

} while (--i > 0);

/* Extend sign, avoiding implementation-defined or undefined behaviour. */

x = (x ^ 0x8000U) - 0x8000U;

return PyLong_FromLong(x & 0x8000U ? -1 - (long)(~x) : (long)x);

}

static PyObject *

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

{

unsigned long x = 0;

/* This function is only ever used in the case f->size == 4. */

assert(f->size == 4);

Py_ssize_t i = 4;

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

do {

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

} while (--i > 0);

/* Extend sign, avoiding implementation-defined or undefined behaviour. */

x = (x ^ 0x80000000U) - 0x80000000U;

return PyLong_FromLong(x & 0x80000000U ? -1 - (long)(~x) : (long)x);

}

static PyObject *

bu_uint(_structmodulestate *state, 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);

return PyLong_FromUnsignedLong(x);

}

static PyObject *

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

{

unsigned long long x = 0;

/* This function is only ever used in the case f->size == 8. */

assert(f->size == 8);

Py_ssize_t i = 8;

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

do {

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

} while (--i > 0);

/* Extend sign, avoiding implementation-defined or undefined behaviour. */

x = (x ^ 0x8000000000000000U) - 0x8000000000000000U;

return PyLong_FromLongLong(

x & 0x8000000000000000U ? -1 - (long long)(~x) : (long long)x);

}

static PyObject *

bu_ulonglong(_structmodulestate *state, 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);