_struct.c

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

/* New version supporting byte order, alignment and size options,
 character strings, and unsigned numbers */

#definePY_SSIZE_T_CLEAN

#include"Python.h"
#include"structmember.h"
#include<ctype.h>

/*[clinic input]
class Struct "PyStructObject *" "&PyStructType"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b032058a83ed7c3]*/

staticPyTypeObjectPyStructType;

/* The translation function for each format character is table driven */
typedefstruct_formatdef {
charformat;
Py_ssize_tsize;
Py_ssize_talignment;
PyObject* (*unpack)(constchar*,
conststruct_formatdef*);
int (*pack)(char*, PyObject*,
conststruct_formatdef*);
} formatdef;

typedefstruct_formatcode {
conststruct_formatdef*fmtdef;
Py_ssize_toffset;
Py_ssize_tsize;
Py_ssize_trepeat;
} formatcode;

/* Struct object interface */

typedefstruct {
PyObject_HEAD
Py_ssize_ts_size;
Py_ssize_ts_len;
formatcode*s_codes;
PyObject*s_format;
PyObject*weakreflist; /* List of weak references */
} PyStructObject;


#definePyStruct_Check(op) PyObject_TypeCheck(op, &PyStructType)
#definePyStruct_CheckExact(op) (Py_TYPE(op) == &PyStructType)


/* Exception */

staticPyObject*StructError;


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


typedefstruct { charc; shortx; } st_short;
typedefstruct { charc; intx; } st_int;
typedefstruct { charc; longx; } st_long;
typedefstruct { charc; floatx; } st_float;
typedefstruct { charc; doublex; } st_double;
typedefstruct { charc; void*x; } st_void_p;
typedefstruct { charc; size_tx; } st_size_t;
typedefstruct { charc; _Boolx; } st_bool;

#defineSHORT_ALIGN (sizeof(st_short) - sizeof(short))
#defineINT_ALIGN (sizeof(st_int) - sizeof(int))
#defineLONG_ALIGN (sizeof(st_long) - sizeof(long))
#defineFLOAT_ALIGN (sizeof(st_float) - sizeof(float))
#defineDOUBLE_ALIGN (sizeof(st_double) - sizeof(double))
#defineVOID_P_ALIGN (sizeof(st_void_p) - sizeof(void *))
#defineSIZE_T_ALIGN (sizeof(st_size_t) - sizeof(size_t))
#defineBOOL_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. */
typedefstruct { charc; long longx; } s_long_long;
#defineLONG_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"

 def cleanup(self):
 return "Py_XDECREF(%s);\n" % self.name
[python start generated code]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=49957cca130ffb63]*/

staticintcache_struct_converter(PyObject*, PyObject**);

#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. */

staticPyObject*
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)
returnNULL;
 }
else {
PyErr_SetString(StructError,
"required argument is not an integer");
returnNULL;
 }
 }
else
Py_INCREF(v);

assert(PyLong_Check(v));
returnv;
}

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

staticint
get_long(PyObject*v, long*p)
{
longx;

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


/* Same, but handling unsigned long */

staticint
get_ulong(PyObject*v, unsigned long*p)
{
unsigned longx;

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

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

staticint
get_longlong(PyObject*v, long long*p)
{
long longx;

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

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

staticint
get_ulonglong(PyObject*v, unsigned long long*p)
{
unsigned long longx;

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

/* Same, but handling Py_ssize_t */

staticint
get_ssize_t(PyObject*v, Py_ssize_t*p)
{
Py_ssize_tx;

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

/* Same, but handling size_t */

staticint
get_size_t(PyObject*v, size_t*p)
{
size_tx;

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


#defineRANGE_ERROR(x, f, flag, mask) return _range_error(f, flag)


/* Floating point helpers */

staticPyObject*
unpack_halffloat(constchar*p, /* start of 2-byte string */
intle) /* true for little-endian, false for big-endian */
{
doublex;

x=_PyFloat_Unpack2((unsigned char*)p, le);
if (x==-1.0&&PyErr_Occurred()) {
returnNULL;
 }
returnPyFloat_FromDouble(x);
}

staticint
pack_halffloat(char*p, /* start of 2-byte string */
PyObject*v, /* value to pack */
intle) /* true for little-endian, false for big-endian */
{
doublex=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);
}

staticPyObject*
unpack_float(constchar*p, /* start of 4-byte string */
intle) /* true for little-endian, false for big-endian */
{
doublex;

x=_PyFloat_Unpack4((unsigned char*)p, le);
if (x==-1.0&&PyErr_Occurred())
returnNULL;
returnPyFloat_FromDouble(x);
}

staticPyObject*
unpack_double(constchar*p, /* start of 8-byte string */
intle) /* true for little-endian, false for big-endian */
{
doublex;

x=_PyFloat_Unpack8((unsigned char*)p, le);
if (x==-1.0&&PyErr_Occurred())
returnNULL;
returnPyFloat_FromDouble(x);
}

/* Helper to format the range error exceptions */
staticint
_range_error(constformatdef*f, intis_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.
 */
constsize_tulargest= (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 {
constPy_ssize_tlargest= (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). */

staticPyObject*
nu_char(constchar*p, constformatdef*f)
{
returnPyBytes_FromStringAndSize(p, 1);
}

staticPyObject*
nu_byte(constchar*p, constformatdef*f)
{
returnPyLong_FromLong((long) *(signed char*)p);
}

staticPyObject*
nu_ubyte(constchar*p, constformatdef*f)
{
returnPyLong_FromLong((long) *(unsigned char*)p);
}

staticPyObject*
nu_short(constchar*p, constformatdef*f)
{
shortx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromLong((long)x);
}

staticPyObject*
nu_ushort(constchar*p, constformatdef*f)
{
unsigned shortx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromLong((long)x);
}

staticPyObject*
nu_int(constchar*p, constformatdef*f)
{
intx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromLong((long)x);
}

staticPyObject*
nu_uint(constchar*p, constformatdef*f)
{
unsigned intx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromUnsignedLong((unsigned long)x);
}

staticPyObject*
nu_long(constchar*p, constformatdef*f)
{
longx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromLong(x);
}

staticPyObject*
nu_ulong(constchar*p, constformatdef*f)
{
unsigned longx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromUnsignedLong(x);
}

staticPyObject*
nu_ssize_t(constchar*p, constformatdef*f)
{
Py_ssize_tx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromSsize_t(x);
}

staticPyObject*
nu_size_t(constchar*p, constformatdef*f)
{
size_tx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromSize_t(x);
}

staticPyObject*
nu_longlong(constchar*p, constformatdef*f)
{
long longx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromLongLong(x);
}

staticPyObject*
nu_ulonglong(constchar*p, constformatdef*f)
{
unsigned long longx;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromUnsignedLongLong(x);
}

staticPyObject*
nu_bool(constchar*p, constformatdef*f)
{
_Boolx;
memcpy((char*)&x, p, sizeofx);
returnPyBool_FromLong(x!=0);
}


staticPyObject*
nu_halffloat(constchar*p, constformatdef*f)
{
#ifPY_LITTLE_ENDIAN
returnunpack_halffloat(p, 1);
#else
returnunpack_halffloat(p, 0);
#endif
}

staticPyObject*
nu_float(constchar*p, constformatdef*f)
{
floatx;
memcpy((char*)&x, p, sizeofx);
returnPyFloat_FromDouble((double)x);
}

staticPyObject*
nu_double(constchar*p, constformatdef*f)
{
doublex;
memcpy((char*)&x, p, sizeofx);
returnPyFloat_FromDouble(x);
}

staticPyObject*
nu_void_p(constchar*p, constformatdef*f)
{
void*x;
memcpy((char*)&x, p, sizeofx);
returnPyLong_FromVoidPtr(x);
}

staticint
np_byte(char*p, PyObject*v, constformatdef*f)
{
longx;
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;
return0;
}

staticint
np_ubyte(char*p, PyObject*v, constformatdef*f)
{
longx;
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;
return0;
}

staticint
np_char(char*p, PyObject*v, constformatdef*f)
{
if (!PyBytes_Check(v) ||PyBytes_GET_SIZE(v) !=1) {
PyErr_SetString(StructError,
"char format requires a bytes object of length 1");
return-1;
 }
*p=*PyBytes_AS_STRING(v);
return0;
}

staticint
np_short(char*p, PyObject*v, constformatdef*f)
{
longx;
shorty;
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, sizeofy);
return0;
}

staticint
np_ushort(char*p, PyObject*v, constformatdef*f)
{
longx;
unsigned shorty;
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, sizeofy);
return0;
}

staticint
np_int(char*p, PyObject*v, constformatdef*f)
{
longx;
inty;
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, sizeofy);
return0;
}

staticint
np_uint(char*p, PyObject*v, constformatdef*f)
{
unsigned longx;
unsigned inty;
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, sizeofy);
return0;
}

staticint
np_long(char*p, PyObject*v, constformatdef*f)
{
longx;
if (get_long(v, &x) <0)
return-1;
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_ulong(char*p, PyObject*v, constformatdef*f)
{
unsigned longx;
if (get_ulong(v, &x) <0)
return-1;
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_ssize_t(char*p, PyObject*v, constformatdef*f)
{
Py_ssize_tx;
if (get_ssize_t(v, &x) <0)
return-1;
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_size_t(char*p, PyObject*v, constformatdef*f)
{
size_tx;
if (get_size_t(v, &x) <0)
return-1;
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_longlong(char*p, PyObject*v, constformatdef*f)
{
long longx;
if (get_longlong(v, &x) <0)
return-1;
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_ulonglong(char*p, PyObject*v, constformatdef*f)
{
unsigned long longx;
if (get_ulonglong(v, &x) <0)
return-1;
memcpy(p, (char*)&x, sizeofx);
return0;
}


staticint
np_bool(char*p, PyObject*v, constformatdef*f)
{
inty;
_Boolx;
y=PyObject_IsTrue(v);
if (y<0)
return-1;
x=y;
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_halffloat(char*p, PyObject*v, constformatdef*f)
{
#ifPY_LITTLE_ENDIAN
returnpack_halffloat(p, v, 1);
#else
returnpack_halffloat(p, v, 0);
#endif
}

staticint
np_float(char*p, PyObject*v, constformatdef*f)
{
floatx= (float)PyFloat_AsDouble(v);
if (x==-1&&PyErr_Occurred()) {
PyErr_SetString(StructError,
"required argument is not a float");
return-1;
 }
memcpy(p, (char*)&x, sizeofx);
return0;
}

staticint
np_double(char*p, PyObject*v, constformatdef*f)
{
doublex=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));
return0;
}

staticint
np_void_p(char*p, PyObject*v, constformatdef*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, sizeofx);
return0;
}

staticconstformatdefnative_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. *****************************************************/

staticPyObject*
bu_int(constchar*p, constformatdef*f)
{
longx=0;
Py_ssize_ti=f->size;
constunsigned char*bytes= (constunsigned 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)));
returnPyLong_FromLong(x);
}

staticPyObject*
bu_uint(constchar*p, constformatdef*f)
{
unsigned longx=0;
Py_ssize_ti=f->size;
constunsigned char*bytes= (constunsigned char*)p;
do {
x= (x<<8) | *bytes++;
 } while (--i>0);
returnPyLong_FromUnsignedLong(x);
}

staticPyObject*
bu_longlong(constchar*p, constformatdef*f)
{
long longx=0;
Py_ssize_ti=f->size;
constunsigned char*bytes= (constunsigned 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)));
returnPyLong_FromLongLong(x);
}

staticPyObject*
bu_ulonglong(constchar*p, constformatdef*f)
{
unsigned long longx=0;
Py_ssize_ti=f->size;
constunsigned char*bytes= (constunsigned char*)p;
do {
x= (x<<8) | *bytes++;
 } while (--i>0);
returnPyLong_FromUnsignedLongLong(x);
}

staticPyObject*
bu_halffloat(constchar*p, constformatdef*f)
{
returnunpack_halffloat(p, 0);
}

staticPyObject*
bu_float(constchar*p, constformatdef*f)
{
returnunpack_float(p, 0);
}

staticPyObject*
bu_double(constchar*p, constformatdef*f)
{
returnunpack_double(p, 0);
}

staticPyObject*
bu_bool(constchar*p, constformatdef*f)
{
returnPyBool_FromLong(*p!=0);
}

staticint
bp_int(char*p, PyObject*v, constformatdef*f)
{
longx;
Py_ssize_ti;
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))
RANGE_ERROR(x, f, 0, 0xffffL);
#if (SIZEOF_LONG!=4)
elseif ((i==4) && (x<-2147483648L||x>2147483647L))
RANGE_ERROR(x, f, 0, 0xffffffffL);
#endif
 }
do {
q[--i] = (unsigned char)(x&0xffL);
x >>= 8;
 } while (i>0);
return0;
}

staticint
bp_uint(char*p, PyObject*v, constformatdef*f)
{
unsigned longx;
Py_ssize_ti;
unsigned char*q= (unsigned char*)p;
if (get_ulong(v, &x) <0)
return-1;
i=f->size;
if (i!=SIZEOF_LONG) {
unsigned longmaxint=1;
maxint <<= (unsigned long)(i*8);
if (x >= maxint)
RANGE_ERROR(x, f, 1, maxint-1);
 }
do {
q[--i] = (unsigned char)(x&0xffUL);
x >>= 8;
 } while (i>0);
return0;
}

staticint
bp_longlong(char*p, PyObject*v, constformatdef*f)
{
intres;
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);
returnres;
}

staticint
bp_ulonglong(char*p, PyObject*v, constformatdef*f)
{
intres;
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);
returnres;
}

staticint
bp_halffloat(char*p, PyObject*v, constformatdef*f)
{
returnpack_halffloat(p, v, 0);
}

staticint
bp_float(char*p, PyObject*v, constformatdef*f)
{
doublex=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);
}

staticint
bp_double(char*p, PyObject*v, constformatdef*f)
{
doublex=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);
}

staticint
bp_bool(char*p, PyObject*v, constformatdef*f)
{
inty;
y=PyObject_IsTrue(v);
if (y<0)
return-1;
*p= (char)y;
return0;
}

staticformatdefbigendian_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},
 {'d', 8, 0, bu_double, bp_double},
 {0}