1 /* struct module -- pack values into and (out of) strings */

     2 

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

     4    character strings, and unsigned numbers */

     5 

     6 #define PY_SSIZE_T_CLEAN

     7 

     8 #include "Python.h"

     9 #include "structseq.h"

    10 #include "structmember.h"

    11 #include <ctype.h>

    12 

    13 static PyTypeObject PyStructType;

    14 

    15 /* compatibility macros */

    16 #if (PY_VERSION_HEX < 0x02050000)

    17 typedef int Py_ssize_t;

    18 #endif

    19 

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

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

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

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

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

    25    exceptions. */

    26 

    27 #define PY_STRUCT_OVERFLOW_MASKING 1

    28 

    29 #ifdef PY_STRUCT_OVERFLOW_MASKING

    30 static PyObject *pylong_ulong_mask = NULL;

    31 static PyObject *pyint_zero = NULL;

    32 #endif

    33 

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

    35    arguments for integer formats with a warning for backwards

    36    compatibility. */

    37 

    38 #define PY_STRUCT_FLOAT_COERCE 1

    39 

    40 #ifdef PY_STRUCT_FLOAT_COERCE

    41 #define FLOAT_COERCE "integer argument expected, got float"

    42 #endif

    43 

    44 

    45 /* The translation function for each format character is table driven */

    46 typedef struct _formatdef {

    47 	char format;

    48 	Py_ssize_t size;

    49 	Py_ssize_t alignment;

    50 	PyObject* (*unpack)(const char *,

    51 			    const struct _formatdef *);

    52 	int (*pack)(char *, PyObject *,

    53 		    const struct _formatdef *);

    54 } formatdef;

    55 

    56 typedef struct _formatcode {

    57 	const struct _formatdef *fmtdef;

    58 	Py_ssize_t offset;

    59 	Py_ssize_t size;

    60 } formatcode;

    61 

    62 /* Struct object interface */

    63 

    64 typedef struct {

    65 	PyObject_HEAD

    66 	Py_ssize_t s_size;

    67 	Py_ssize_t s_len;

    68 	formatcode *s_codes;

    69 	PyObject *s_format;

    70 	PyObject *weakreflist; /* List of weak references */

    71 } PyStructObject;

    72 

    73 

    74 #define PyStruct_Check(op) PyObject_TypeCheck(op, &PyStructType)

    75 #define PyStruct_CheckExact(op) (Py_TYPE(op) == &PyStructType)

    76 

    77 

    78 /* Exception */

    79 

    80 static PyObject *StructError;

    81 

    82 

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

    84 

    85 

    86 typedef struct { char c; short x; } st_short;

    87 typedef struct { char c; int x; } st_int;

    88 typedef struct { char c; long x; } st_long;

    89 typedef struct { char c; float x; } st_float;

    90 typedef struct { char c; double x; } st_double;

    91 typedef struct { char c; void *x; } st_void_p;

    92 

    93 #define SHORT_ALIGN (sizeof(st_short) - sizeof(short))

    94 #define INT_ALIGN (sizeof(st_int) - sizeof(int))

    95 #define LONG_ALIGN (sizeof(st_long) - sizeof(long))

    96 #define FLOAT_ALIGN (sizeof(st_float) - sizeof(float))

    97 #define DOUBLE_ALIGN (sizeof(st_double) - sizeof(double))

    98 #define VOID_P_ALIGN (sizeof(st_void_p) - sizeof(void *))

    99 

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

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

   102 #ifdef HAVE_LONG_LONG

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

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

   105 #endif

   106 

   107 #ifdef HAVE_C99_BOOL

   108 #define BOOL_TYPE _Bool

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

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

   111 #else

   112 #define BOOL_TYPE char

   113 #define BOOL_ALIGN 0

   114 #endif

   115 

   116 #define STRINGIFY(x)    #x

   117 

   118 #ifdef __powerc

   119 #pragma options align=reset

   120 #endif

   121 

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

   123 

   124 static PyObject *

   125 get_pylong(PyObject *v)

   126 {

   127 	PyNumberMethods *m;

   128 

   129 	assert(v != NULL);

   130 	if (PyInt_Check(v))

   131 		return PyLong_FromLong(PyInt_AS_LONG(v));

   132 	if (PyLong_Check(v)) {

   133 		Py_INCREF(v);

   134 		return v;

   135 	}

   136 	m = Py_TYPE(v)->tp_as_number;

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

   138 		v = m->nb_long(v);

   139 		if (v == NULL)

   140 			return NULL;

   141 		if (PyLong_Check(v))

   142 			return v;

   143 		Py_DECREF(v);

   144 	}

   145 	PyErr_SetString(StructError,

   146 			"cannot convert argument to long");

   147 	return NULL;

   148 }

   149 

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

   151    if it isn't one */

   152 

   153 static int

   154 get_long(PyObject *v, long *p)

   155 {

   156 	long x = PyInt_AsLong(v);

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

   158 #ifdef PY_STRUCT_FLOAT_COERCE

   159 		if (PyFloat_Check(v)) {

   160 			PyObject *o;

   161 			int res;

   162 			PyErr_Clear();

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

   164 				return -1;

   165 			o = PyNumber_Int(v);

   166 			if (o == NULL)

   167 				return -1;

   168 			res = get_long(o, p);

   169 			Py_DECREF(o);

   170 			return res;

   171 		}

   172 #endif

   173 		if (PyErr_ExceptionMatches(PyExc_TypeError))

   174 			PyErr_SetString(StructError,

   175 					"required argument is not an integer");

   176 		return -1;

   177 	}

   178 	*p = x;

   179 	return 0;

   180 }

   181 

   182 

   183 /* Same, but handling unsigned long */

   184 

   185 static int

   186 get_ulong(PyObject *v, unsigned long *p)

   187 {

   188 	if (PyLong_Check(v)) {

   189 		unsigned long x = PyLong_AsUnsignedLong(v);

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

   191 			return -1;

   192 		*p = x;

   193 		return 0;

   194 	}

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

   196 		return -1;

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

   198 		PyErr_SetString(StructError,

   199 				"unsigned argument is < 0");

   200 		return -1;

   201 	}

   202 	return 0;

   203 }

   204 

   205 #ifdef HAVE_LONG_LONG

   206 

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

   208 

   209 static int

   210 get_longlong(PyObject *v, PY_LONG_LONG *p)

   211 {

   212 	PY_LONG_LONG x;

   213 

   214 	v = get_pylong(v);

   215 	if (v == NULL)

   216 		return -1;

   217 	assert(PyLong_Check(v));

   218 	x = PyLong_AsLongLong(v);

   219 	Py_DECREF(v);

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

   221 		return -1;

   222 	*p = x;

   223 	return 0;

   224 }

   225 

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

   227 

   228 static int

   229 get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)

   230 {

   231 	unsigned PY_LONG_LONG x;

   232 

   233 	v = get_pylong(v);

   234 	if (v == NULL)

   235 		return -1;

   236 	assert(PyLong_Check(v));

   237 	x = PyLong_AsUnsignedLongLong(v);

   238 	Py_DECREF(v);

   239 	if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())

   240 		return -1;

   241 	*p = x;

   242 	return 0;

   243 }

   244 

   245 #endif

   246 

   247 #ifdef PY_STRUCT_OVERFLOW_MASKING

   248 

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

   250    if it isn't one */

   251 

   252 #define INT_OVERFLOW "struct integer overflow masking is deprecated"

   253 

   254 static int

   255 get_wrapped_long(PyObject *v, long *p)

   256 {

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

   258 		if (PyLong_Check(v) &&

   259 		    PyErr_ExceptionMatches(PyExc_OverflowError)) {

   260 			PyObject *wrapped;

   261 			long x;

   262 			PyErr_Clear();

   263 #ifdef PY_STRUCT_FLOAT_COERCE

   264 			if (PyFloat_Check(v)) {

   265 				PyObject *o;

   266 				int res;

   267 				PyErr_Clear();

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

   269 					return -1;

   270 				o = PyNumber_Int(v);

   271 				if (o == NULL)

   272 					return -1;

   273 				res = get_wrapped_long(o, p);

   274 				Py_DECREF(o);

   275 				return res;

   276 			}

   277 #endif

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

   279 				return -1;

   280 			wrapped = PyNumber_And(v, pylong_ulong_mask);

   281 			if (wrapped == NULL)

   282 				return -1;

   283 			x = (long)PyLong_AsUnsignedLong(wrapped);

   284 			Py_DECREF(wrapped);

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

   286 				return -1;

   287 			*p = x;

   288 		} else {

   289 			return -1;

   290 		}

   291 	}

   292 	return 0;

   293 }

   294 

   295 static int

   296 get_wrapped_ulong(PyObject *v, unsigned long *p)

   297 {

   298 	long x = (long)PyLong_AsUnsignedLong(v);

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

   300 		PyObject *wrapped;

   301 		PyErr_Clear();

   302 #ifdef PY_STRUCT_FLOAT_COERCE

   303 		if (PyFloat_Check(v)) {

   304 			PyObject *o;

   305 			int res;

   306 			PyErr_Clear();

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

   308 				return -1;

   309 			o = PyNumber_Int(v);

   310 			if (o == NULL)

   311 				return -1;

   312 			res = get_wrapped_ulong(o, p);

   313 			Py_DECREF(o);

   314 			return res;

   315 		}

   316 #endif

   317 		wrapped = PyNumber_And(v, pylong_ulong_mask);

   318 		if (wrapped == NULL)

   319 			return -1;

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

   321 			Py_DECREF(wrapped);

   322 			return -1;

   323 		}

   324 		x = (long)PyLong_AsUnsignedLong(wrapped);

   325 		Py_DECREF(wrapped);

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

   327 			return -1;

   328 	}

   329 	*p = (unsigned long)x;

   330 	return 0;

   331 }

   332 

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

   334 	do { \

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

   336 			return -1; \

   337 		else \

   338 			(x) &= (mask); \

   339 	} while (0)

   340 

   341 #else

   342 

   343 #define get_wrapped_long get_long

   344 #define get_wrapped_ulong get_ulong

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

   346 

   347 #endif

   348 

   349 /* Floating point helpers */

   350 

   351 static PyObject *

   352 unpack_float(const char *p,  /* start of 4-byte string */

   353              int le)	     /* true for little-endian, false for big-endian */

   354 {

   355 	double x;

   356 

   357 	x = _PyFloat_Unpack4((unsigned char *)p, le);

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

   359 		return NULL;

   360 	return PyFloat_FromDouble(x);

   361 }

   362 

   363 static PyObject *

   364 unpack_double(const char *p,  /* start of 8-byte string */

   365               int le)         /* true for little-endian, false for big-endian */

   366 {

   367 	double x;

   368 

   369 	x = _PyFloat_Unpack8((unsigned char *)p, le);

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

   371 		return NULL;

   372 	return PyFloat_FromDouble(x);

   373 }

   374 

   375 /* Helper to format the range error exceptions */

   376 static int

   377 _range_error(const formatdef *f, int is_unsigned)

   378 {

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

   380 	 * Note that the simpler:

   381 	 *     ((size_t)1 << (f->size * 8)) - 1

   382 	 * doesn't work when f->size == sizeof(size_t) because C doesn't

   383 	 * define what happens when a left shift count is >= the number of

   384 	 * bits in the integer being shifted; e.g., on some boxes it doesn't

   385 	 * shift at all when they're equal.

   386 	 */

   387 	const size_t ulargest = (size_t)-1 >> ((SIZEOF_SIZE_T - f->size)*8);

   388 	assert(f->size >= 1 && f->size <= SIZEOF_SIZE_T);

   389 	if (is_unsigned)

   390 		PyErr_Format(StructError,

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

   392 			f->format,

   393 			ulargest);

   394 	else {

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

   396 		PyErr_Format(StructError,

   397 			"'%c' format requires %zd <= number <= %zd",

   398 			f->format,

   399 			~ largest,

   400 			largest);

   401 	}

   402 #ifdef PY_STRUCT_OVERFLOW_MASKING

   403 	{

   404 		PyObject *ptype, *pvalue, *ptraceback;

   405 		PyObject *msg;

   406 		int rval;

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

   408 		assert(pvalue != NULL);

   409 		msg = PyObject_Str(pvalue);

   410 		Py_XDECREF(ptype);

   411 		Py_XDECREF(pvalue);

   412 		Py_XDECREF(ptraceback);

   413 		if (msg == NULL)

   414 			return -1;

   415 		rval = PyErr_WarnEx(PyExc_DeprecationWarning,

   416 				    PyString_AS_STRING(msg), 2);

   417 		Py_DECREF(msg);

   418 		if (rval == 0)

   419 			return 0;

   420 	}

   421 #endif

   422 	return -1;

   423 }

   424 

   425 

   426 

   427 /* A large number of small routines follow, with names of the form

   428 

   429    [bln][up]_TYPE

   430 

   431    [bln] distiguishes among big-endian, little-endian and native.

   432    [pu] distiguishes between pack (to struct) and unpack (from struct).

   433    TYPE is one of char, byte, ubyte, etc.

   434 */

   435 

   436 /* Native mode routines. ****************************************************/

   437 /* NOTE:

   438    In all n[up]_<type> routines handling types larger than 1 byte, there is

   439    *no* guarantee that the p pointer is properly aligned for each type,

   440    therefore memcpy is called.  An intermediate variable is used to

   441    compensate for big-endian architectures.

   442    Normally both the intermediate variable and the memcpy call will be

   443    skipped by C optimisation in little-endian architectures (gcc >= 2.91

   444    does this). */

   445 

   446 static PyObject *

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

   448 {

   449 	return PyString_FromStringAndSize(p, 1);

   450 }

   451 

   452 static PyObject *

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

   454 {

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

   456 }

   457 

   458 static PyObject *

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

   460 {

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

   462 }

   463 

   464 static PyObject *

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

   466 {

   467 	short x;

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

   469 	return PyInt_FromLong((long)x);

   470 }

   471 

   472 static PyObject *

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

   474 {

   475 	unsigned short x;

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

   477 	return PyInt_FromLong((long)x);

   478 }

   479 

   480 static PyObject *

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

   482 {

   483 	int x;

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

   485 	return PyInt_FromLong((long)x);

   486 }

   487 

   488 static PyObject *

   489 nu_uint(const char *p, const formatdef *f)

   490 {

   491 	unsigned int x;

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

   493 #if (SIZEOF_LONG > SIZEOF_INT)

   494 	return PyInt_FromLong((long)x);

   495 #else

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

   497 		return PyInt_FromLong((long)x);

   498 	return PyLong_FromUnsignedLong((unsigned long)x);

   499 #endif

   500 }

   501 

   502 static PyObject *

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

   504 {

   505 	long x;

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

   507 	return PyInt_FromLong(x);

   508 }

   509 

   510 static PyObject *

   511 nu_ulong(const char *p, const formatdef *f)

   512 {

   513 	unsigned long x;

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

   515 	if (x <= LONG_MAX)

   516 		return PyInt_FromLong((long)x);

   517 	return PyLong_FromUnsignedLong(x);

   518 }

   519 

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

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

   522 

   523 #ifdef HAVE_LONG_LONG

   524 

   525 static PyObject *

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

   527 {

   528 	PY_LONG_LONG x;

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

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

   531 		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));

   532 	return PyLong_FromLongLong(x);

   533 }

   534 

   535 static PyObject *

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

   537 {

   538 	unsigned PY_LONG_LONG x;

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

   540 	if (x <= LONG_MAX)

   541 		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));

   542 	return PyLong_FromUnsignedLongLong(x);

   543 }

   544 

   545 #endif

   546 

   547 static PyObject *

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

   549 {

   550 	BOOL_TYPE x;

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

   552 	return PyBool_FromLong(x != 0);

   553 }

   554 

   555 

   556 static PyObject *

   557 nu_float(const char *p, const formatdef *f)

   558 {

   559 	float x;

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

   561 	return PyFloat_FromDouble((double)x);

   562 }

   563 

   564 static PyObject *

   565 nu_double(const char *p, const formatdef *f)

   566 {

   567 	double x;

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

   569 	return PyFloat_FromDouble(x);

   570 }

   571 

   572 static PyObject *

   573 nu_void_p(const char *p, const formatdef *f)

   574 {

   575 	void *x;

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

   577 	return PyLong_FromVoidPtr(x);

   578 }

   579 

   580 static int

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

   582 {

   583 	long x;

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

   585 		return -1;

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

   587 		PyErr_SetString(StructError,

   588 				"byte format requires -128 <= number <= 127");

   589 		return -1;

   590 	}

   591 	*p = (char)x;

   592 	return 0;

   593 }

   594 

   595 static int

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

   597 {

   598 	long x;

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

   600 		return -1;

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

   602 		PyErr_SetString(StructError,

   603 				"ubyte format requires 0 <= number <= 255");

   604 		return -1;

   605 	}

   606 	*p = (char)x;

   607 	return 0;

   608 }

   609 

   610 static int

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

   612 {

   613 	if (!PyString_Check(v) || PyString_Size(v) != 1) {

   614 		PyErr_SetString(StructError,

   615 				"char format require string of length 1");

   616 		return -1;

   617 	}

   618 	*p = *PyString_AsString(v);

   619 	return 0;

   620 }

   621 

   622 static int

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

   624 {

   625 	long x;

   626 	short y;

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

   628 		return -1;

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

   630 		PyErr_SetString(StructError,

   631 				"short format requires " STRINGIFY(SHRT_MIN)

   632 				" <= number <= " STRINGIFY(SHRT_MAX));

   633 		return -1;

   634 	}

   635 	y = (short)x;

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

   637 	return 0;

   638 }

   639 

   640 static int

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

   642 {

   643 	long x;

   644 	unsigned short y;

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

   646 		return -1;

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

   648 		PyErr_SetString(StructError,

   649 				"short format requires 0 <= number <= " STRINGIFY(USHRT_MAX));

   650 		return -1;

   651 	}

   652 	y = (unsigned short)x;

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

   654 	return 0;

   655 }

   656 

   657 static int

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

   659 {

   660 	long x;

   661 	int y;

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

   663 		return -1;

   664 #if (SIZEOF_LONG > SIZEOF_INT)

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

   666 		return _range_error(f, 0);

   667 #endif

   668 	y = (int)x;

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

   670 	return 0;

   671 }

   672 

   673 static int

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

   675 {

   676 	unsigned long x;

   677 	unsigned int y;

   678 	if (get_ulong(v, &x) < 0)

   679 		return _range_error(f, 1);

   680 	y = (unsigned int)x;

   681 #if (SIZEOF_LONG > SIZEOF_INT)

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

   683 		return _range_error(f, 1);

   684 #endif

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

   686 	return 0;

   687 }

   688 

   689 static int

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

   691 {

   692 	long x;

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

   694 		return -1;

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

   696 	return 0;

   697 }

   698 

   699 static int

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

   701 {

   702 	unsigned long x;

   703 	if (get_ulong(v, &x) < 0)

   704 		return _range_error(f, 1);

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

   706 	return 0;

   707 }

   708 

   709 #ifdef HAVE_LONG_LONG

   710 

   711 static int

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

   713 {

   714 	PY_LONG_LONG x;

   715 	if (get_longlong(v, &x) < 0)

   716 		return -1;

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

   718 	return 0;

   719 }

   720 

   721 static int

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

   723 {

   724 	unsigned PY_LONG_LONG x;

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

   726 		return -1;

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

   728 	return 0;

   729 }

   730 #endif

   731 

   732 

   733 static int

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

   735 {

   736 	BOOL_TYPE y; 

   737 	y = PyObject_IsTrue(v);

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

   739 	return 0;

   740 }

   741 

   742 static int

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

   744 {

   745 	float x = (float)PyFloat_AsDouble(v);

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

   747 		PyErr_SetString(StructError,

   748 				"required argument is not a float");

   749 		return -1;

   750 	}

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

   752 	return 0;

   753 }

   754 

   755 static int

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

   757 {

   758 	double x = PyFloat_AsDouble(v);

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

   760 		PyErr_SetString(StructError,

   761 				"required argument is not a float");

   762 		return -1;

   763 	}

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

   765 	return 0;

   766 }

   767 

   768 static int

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

   770 {

   771 	void *x;

   772 

   773 	v = get_pylong(v);

   774 	if (v == NULL)

   775 		return -1;

   776 	assert(PyLong_Check(v));

   777 	x = PyLong_AsVoidPtr(v);

   778 	Py_DECREF(v);

   779 	if (x == NULL && PyErr_Occurred())

   780 		return -1;

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

   782 	return 0;

   783 }

   784 

   785 static formatdef native_table[] = {

   786 	{'x',	sizeof(char),	0,		NULL},

   787 	{'b',	sizeof(char),	0,		nu_byte,	np_byte},

   788 	{'B',	sizeof(char),	0,		nu_ubyte,	np_ubyte},

   789 	{'c',	sizeof(char),	0,		nu_char,	np_char},

   790 	{'s',	sizeof(char),	0,		NULL},

   791 	{'p',	sizeof(char),	0,		NULL},

   792 	{'h',	sizeof(short),	SHORT_ALIGN,	nu_short,	np_short},

   793 	{'H',	sizeof(short),	SHORT_ALIGN,	nu_ushort,	np_ushort},

   794 	{'i',	sizeof(int),	INT_ALIGN,	nu_int,		np_int},

   795 	{'I',	sizeof(int),	INT_ALIGN,	nu_uint,	np_uint},

   796 	{'l',	sizeof(long),	LONG_ALIGN,	nu_long,	np_long},

   797 	{'L',	sizeof(long),	LONG_ALIGN,	nu_ulong,	np_ulong},

   798 #ifdef HAVE_LONG_LONG

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

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

   801 #endif

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

   803 	{'f',	sizeof(float),	FLOAT_ALIGN,	nu_float,	np_float},

   804 	{'d',	sizeof(double),	DOUBLE_ALIGN,	nu_double,	np_double},

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

   806 	{0}

   807 };

   808 

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

   810 

   811 static PyObject *

   812 bu_int(const char *p, const formatdef *f)

   813 {

   814 	long x = 0;

   815 	Py_ssize_t i = f->size;

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

   817 	do {

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

   819 	} while (--i > 0);

   820 	/* Extend the sign bit. */

   821 	if (SIZEOF_LONG > f->size)

   822 		x |= -(x & (1L << ((8 * f->size) - 1)));

   823 	return PyInt_FromLong(x);

   824 }

   825 

   826 static PyObject *

   827 bu_uint(const char *p, const formatdef *f)

   828 {

   829 	unsigned long x = 0;

   830 	Py_ssize_t i = f->size;

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

   832 	do {

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

   834 	} while (--i > 0);

   835 	if (x <= LONG_MAX)

   836 		return PyInt_FromLong((long)x);

   837 	return PyLong_FromUnsignedLong(x);

   838 }

   839 

   840 static PyObject *

   841 bu_longlong(const char *p, const formatdef *f)

   842 {

   843 #ifdef HAVE_LONG_LONG

   844 	PY_LONG_LONG x = 0;

   845 	Py_ssize_t i = f->size;

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

   847 	do {

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

   849 	} while (--i > 0);

   850 	/* Extend the sign bit. */

   851 	if (SIZEOF_LONG_LONG > f->size)

   852 		x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));

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

   854 		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));

   855 	return PyLong_FromLongLong(x);

   856 #else

   857 	return _PyLong_FromByteArray((const unsigned char *)p,

   858 				      8,

   859 				      0, /* little-endian */

   860 				      1  /* signed */);

   861 #endif

   862 }

   863 

   864 static PyObject *

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

   866 {

   867 #ifdef HAVE_LONG_LONG

   868 	unsigned PY_LONG_LONG x = 0;

   869 	Py_ssize_t i = f->size;

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

   871 	do {

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

   873 	} while (--i > 0);

   874 	if (x <= LONG_MAX)

   875 		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));

   876 	return PyLong_FromUnsignedLongLong(x);

   877 #else

   878 	return _PyLong_FromByteArray((const unsigned char *)p,

   879 				      8,

   880 				      0, /* little-endian */

   881 				      0  /* signed */);

   882 #endif

   883 }

   884 

   885 static PyObject *

   886 bu_float(const char *p, const formatdef *f)

   887 {

   888 	return unpack_float(p, 0);

   889 }

   890 

   891 static PyObject *

   892 bu_double(const char *p, const formatdef *f)

   893 {

   894 	return unpack_double(p, 0);

   895 }

   896 

   897 static PyObject *

   898 bu_bool(const char *p, const formatdef *f)

   899 {

   900 	char x;

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

   902 	return PyBool_FromLong(x != 0);

   903 }

   904 

   905 static int

   906 bp_int(char *p, PyObject *v, const formatdef *f)

   907 {

   908 	long x;

   909 	Py_ssize_t i;

   910 	if (get_wrapped_long(v, &x) < 0)

   911 		return -1;

   912 	i = f->size;

   913 	if (i != SIZEOF_LONG) {

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

   915 			RANGE_ERROR(x, f, 0, 0xffffL);

   916 #if (SIZEOF_LONG != 4)

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

   918 			RANGE_ERROR(x, f, 0, 0xffffffffL);

   919 #endif

   920 #ifdef PY_STRUCT_OVERFLOW_MASKING

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

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

   923 #endif

   924 	}

   925 	do {

   926 		p[--i] = (char)x;

   927 		x >>= 8;

   928 	} while (i > 0);

   929 	return 0;

   930 }

   931 

   932 static int

   933 bp_uint(char *p, PyObject *v, const formatdef *f)

   934 {

   935 	unsigned long x;

   936 	Py_ssize_t i;

   937 	if (get_wrapped_ulong(v, &x) < 0)

   938 		return -1;

   939 	i = f->size;

   940 	if (i != SIZEOF_LONG) {

   941 		unsigned long maxint = 1;

   942 		maxint <<= (unsigned long)(i * 8);

   943 		if (x >= maxint)

   944 			RANGE_ERROR(x, f, 1, maxint - 1);

   945 	}

   946 	do {

   947 		p[--i] = (char)x;

   948 		x >>= 8;

   949 	} while (i > 0);

   950 	return 0;

   951 }

   952 

   953 static int

   954 bp_longlong(char *p, PyObject *v, const formatdef *f)

   955 {

   956 	int res;

   957 	v = get_pylong(v);

   958 	if (v == NULL)

   959 		return -1;

   960 	res = _PyLong_AsByteArray((PyLongObject *)v,

   961 			   	  (unsigned char *)p,

   962 				  8,

   963 				  0, /* little_endian */

   964 				  1  /* signed */);

   965 	Py_DECREF(v);

   966 	return res;

   967 }

   968 

   969 static int

   970 bp_ulonglong(char *p, PyObject *v, const formatdef *f)

   971 {

   972 	int res;

   973 	v = get_pylong(v);

   974 	if (v == NULL)

   975 		return -1;

   976 	res = _PyLong_AsByteArray((PyLongObject *)v,

   977 			   	  (unsigned char *)p,

   978 				  8,

   979 				  0, /* little_endian */

   980 				  0  /* signed */);

   981 	Py_DECREF(v);

   982 	return res;

   983 }

   984 

   985 static int

   986 bp_float(char *p, PyObject *v, const formatdef *f)

   987 {

   988 	double x = PyFloat_AsDouble(v);

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

   990 		PyErr_SetString(StructError,

   991 				"required argument is not a float");

   992 		return -1;

   993 	}

   994 	return _PyFloat_Pack4(x, (unsigned char *)p, 0);

   995 }

   996 

   997 static int

   998 bp_double(char *p, PyObject *v, const formatdef *f)

   999 {

  1000 	double x = PyFloat_AsDouble(v);

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

  1002 		PyErr_SetString(StructError,

  1003 				"required argument is not a float");

  1004 		return -1;

  1005 	}

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

  1007 }

  1008 

  1009 static int

  1010 bp_bool(char *p, PyObject *v, const formatdef *f)

  1011 {

  1012 	char y; 

  1013 	y = PyObject_IsTrue(v);

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

  1015 	return 0;

  1016 }

  1017 

  1018 static formatdef bigendian_table[] = {

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

  1020 #ifdef PY_STRUCT_OVERFLOW_MASKING

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

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

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

  1024 #else

  1025 	{'b',	1,		0,		nu_byte,	np_byte},

  1026 	{'B',	1,		0,		nu_ubyte,	np_ubyte},

  1027 #endif

  1028 	{'c',	1,		0,		nu_char,	np_char},

  1029 	{'s',	1,		0,		NULL},

  1030 	{'p',	1,		0,		NULL},

  1031 	{'h',	2,		0,		bu_int,		bp_int},

  1032 	{'H',	2,		0,		bu_uint,	bp_uint},

  1033 	{'i',	4,		0,		bu_int,		bp_int},

  1034 	{'I',	4,		0,		bu_uint,	bp_uint},

  1035 	{'l',	4,		0,		bu_int,		bp_int},

  1036 	{'L',	4,		0,		bu_uint,	bp_uint},

  1037 	{'q',	8,		0,		bu_longlong,	bp_longlong},

  1038 	{'Q',	8,		0,		bu_ulonglong,	bp_ulonglong},

  1039 	{'?',	1,		0,		bu_bool,	bp_bool},

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

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

  1042 	{0}

  1043 };

  1044 

  1045 /* Little-endian routines. *****************************************************/

  1046 

  1047 static PyObject *

  1048 lu_int(const char *p, const formatdef *f)

  1049 {

  1050 	long x = 0;

  1051 	Py_ssize_t i = f->size;

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

  1053 	do {

  1054 		x = (x<<8) | bytes[--i];

  1055 	} while (i > 0);

  1056 	/* Extend the sign bit. */

  1057 	if (SIZEOF_LONG > f->size)

  1058 		x |= -(x & (1L << ((8 * f->size) - 1)));

  1059 	return PyInt_FromLong(x);

  1060 }

  1061 

  1062 static PyObject *

  1063 lu_uint(const char *p, const formatdef *f)

  1064 {

  1065 	unsigned long x = 0;

  1066 	Py_ssize_t i = f->size;

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

  1068 	do {

  1069 		x = (x<<8) | bytes[--i];

  1070 	} while (i > 0);

  1071 	if (x <= LONG_MAX)

  1072 		return PyInt_FromLong((long)x);

  1073 	return PyLong_FromUnsignedLong((long)x);

  1074 }

  1075 

  1076 static PyObject *

  1077 lu_longlong(const char *p, const formatdef *f)

  1078 {

  1079 #ifdef HAVE_LONG_LONG

  1080 	PY_LONG_LONG x = 0;

  1081 	Py_ssize_t i = f->size;

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

  1083 	do {

  1084 		x = (x<<8) | bytes[--i];

  1085 	} while (i > 0);

  1086 	/* Extend the sign bit. */

  1087 	if (SIZEOF_LONG_LONG > f->size)

  1088 		x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));

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

  1090 		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));

  1091 	return PyLong_FromLongLong(x);

  1092 #else

  1093 	return _PyLong_FromByteArray((const unsigned char *)p,

  1094 				      8,

  1095 				      1, /* little-endian */

  1096 				      1  /* signed */);

  1097 #endif

  1098 }

  1099 

  1100 static PyObject *

  1101 lu_ulonglong(const char *p, const formatdef *f)

  1102 {

  1103 #ifdef HAVE_LONG_LONG

  1104 	unsigned PY_LONG_LONG x = 0;

  1105 	Py_ssize_t i = f->size;

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

  1107 	do {

  1108 		x = (x<<8) | bytes[--i];

  1109 	} while (i > 0);

  1110 	if (x <= LONG_MAX)

  1111 		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));

  1112 	return PyLong_FromUnsignedLongLong(x);

  1113 #else

  1114 	return _PyLong_FromByteArray((const unsigned char *)p,

  1115 				      8,

  1116 				      1, /* little-endian */

  1117 				      0  /* signed */);

  1118 #endif

  1119 }

  1120 

  1121 static PyObject *

  1122 lu_float(const char *p, const formatdef *f)

  1123 {

  1124 	return unpack_float(p, 1);

  1125 }

  1126 

  1127 static PyObject *

  1128 lu_double(const char *p, const formatdef *f)

  1129 {

  1130 	return unpack_double(p, 1);

  1131 }

  1132 

  1133 static int

  1134 lp_int(char *p, PyObject *v, const formatdef *f)

  1135 {