PageRenderTime 183ms CodeModel.GetById 12ms app.highlight 151ms RepoModel.GetById 1ms app.codeStats 1ms

/Modules/_struct.c

http://unladen-swallow.googlecode.com/
C | 2171 lines | 1808 code | 253 blank | 110 comment | 403 complexity | f5e01344d6cd89d1ea0e8b18b427e37d MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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
  13static PyTypeObject PyStructType;
  14
  15/* compatibility macros */
  16#if (PY_VERSION_HEX < 0x02050000)
  17typedef 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
  30static PyObject *pylong_ulong_mask = NULL;
  31static 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 */
  46typedef 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
  56typedef 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
  64typedef 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
  80static PyObject *StructError;
  81
  82
  83/* Define various structs to figure out the alignments of types */
  84
  85
  86typedef struct { char c; short x; } st_short;
  87typedef struct { char c; int x; } st_int;
  88typedef struct { char c; long x; } st_long;
  89typedef struct { char c; float x; } st_float;
  90typedef struct { char c; double x; } st_double;
  91typedef 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
 103typedef 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
 109typedef 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
 124static PyObject *
 125get_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
 153static int
 154get_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#ifndef PY_STRUCT_OVERFLOW_MASKING
 186
 187static int
 188get_ulong(PyObject *v, unsigned long *p)
 189{
 190	if (PyLong_Check(v)) {
 191		unsigned long x = PyLong_AsUnsignedLong(v);
 192		if (x == (unsigned long)(-1) && PyErr_Occurred())
 193			return -1;
 194		*p = x;
 195		return 0;
 196	}
 197	if (get_long(v, (long *)p) < 0)
 198		return -1;
 199	if (((long)*p) < 0) {
 200		PyErr_SetString(StructError,
 201				"unsigned argument is < 0");
 202		return -1;
 203	}
 204	return 0;
 205}
 206
 207#endif /* PY_STRUCT_OVERFLOW_MASKING */
 208
 209#ifdef HAVE_LONG_LONG
 210
 211/* Same, but handling native long long. */
 212
 213static int
 214get_longlong(PyObject *v, PY_LONG_LONG *p)
 215{
 216	PY_LONG_LONG x;
 217
 218	v = get_pylong(v);
 219	if (v == NULL)
 220		return -1;
 221	assert(PyLong_Check(v));
 222	x = PyLong_AsLongLong(v);
 223	Py_DECREF(v);
 224	if (x == (PY_LONG_LONG)-1 && PyErr_Occurred())
 225		return -1;
 226	*p = x;
 227	return 0;
 228}
 229
 230/* Same, but handling native unsigned long long. */
 231
 232static int
 233get_ulonglong(PyObject *v, unsigned PY_LONG_LONG *p)
 234{
 235	unsigned PY_LONG_LONG x;
 236
 237	v = get_pylong(v);
 238	if (v == NULL)
 239		return -1;
 240	assert(PyLong_Check(v));
 241	x = PyLong_AsUnsignedLongLong(v);
 242	Py_DECREF(v);
 243	if (x == (unsigned PY_LONG_LONG)-1 && PyErr_Occurred())
 244		return -1;
 245	*p = x;
 246	return 0;
 247}
 248
 249#endif
 250
 251#ifdef PY_STRUCT_OVERFLOW_MASKING
 252
 253/* Helper routine to get a Python integer and raise the appropriate error
 254   if it isn't one */
 255
 256#define INT_OVERFLOW "struct integer overflow masking is deprecated"
 257
 258static int
 259get_wrapped_long(PyObject *v, long *p)
 260{
 261	if (get_long(v, p) < 0) {
 262		if (PyLong_Check(v) &&
 263		    PyErr_ExceptionMatches(PyExc_OverflowError)) {
 264			PyObject *wrapped;
 265			long x;
 266			PyErr_Clear();
 267#ifdef PY_STRUCT_FLOAT_COERCE
 268			if (PyFloat_Check(v)) {
 269				PyObject *o;
 270				int res;
 271				PyErr_Clear();
 272				if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
 273					return -1;
 274				o = PyNumber_Int(v);
 275				if (o == NULL)
 276					return -1;
 277				res = get_wrapped_long(o, p);
 278				Py_DECREF(o);
 279				return res;
 280			}
 281#endif
 282			if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0)
 283				return -1;
 284			wrapped = PyNumber_And(v, pylong_ulong_mask);
 285			if (wrapped == NULL)
 286				return -1;
 287			x = (long)PyLong_AsUnsignedLong(wrapped);
 288			Py_DECREF(wrapped);
 289			if (x == -1 && PyErr_Occurred())
 290				return -1;
 291			*p = x;
 292		} else {
 293			return -1;
 294		}
 295	}
 296	return 0;
 297}
 298
 299static int
 300get_wrapped_ulong(PyObject *v, unsigned long *p)
 301{
 302	long x = (long)PyLong_AsUnsignedLong(v);
 303	if (x == -1 && PyErr_Occurred()) {
 304		PyObject *wrapped;
 305		PyErr_Clear();
 306#ifdef PY_STRUCT_FLOAT_COERCE
 307		if (PyFloat_Check(v)) {
 308			PyObject *o;
 309			int res;
 310			PyErr_Clear();
 311			if (PyErr_WarnEx(PyExc_DeprecationWarning, FLOAT_COERCE, 2) < 0)
 312				return -1;
 313			o = PyNumber_Int(v);
 314			if (o == NULL)
 315				return -1;
 316			res = get_wrapped_ulong(o, p);
 317			Py_DECREF(o);
 318			return res;
 319		}
 320#endif
 321		wrapped = PyNumber_And(v, pylong_ulong_mask);
 322		if (wrapped == NULL)
 323			return -1;
 324		if (PyErr_WarnEx(PyExc_DeprecationWarning, INT_OVERFLOW, 2) < 0) {
 325			Py_DECREF(wrapped);
 326			return -1;
 327		}
 328		x = (long)PyLong_AsUnsignedLong(wrapped);
 329		Py_DECREF(wrapped);
 330		if (x == -1 && PyErr_Occurred())
 331			return -1;
 332	}
 333	*p = (unsigned long)x;
 334	return 0;
 335}
 336
 337#define RANGE_ERROR(x, f, flag, mask) \
 338	do { \
 339		if (_range_error(f, flag) < 0) \
 340			return -1; \
 341		else \
 342			(x) &= (mask); \
 343	} while (0)
 344
 345#else
 346
 347#define get_wrapped_long get_long
 348#define get_wrapped_ulong get_ulong
 349#define RANGE_ERROR(x, f, flag, mask) return _range_error(f, flag)
 350
 351#endif
 352
 353/* Floating point helpers */
 354
 355static PyObject *
 356unpack_float(const char *p,  /* start of 4-byte string */
 357             int le)	     /* true for little-endian, false for big-endian */
 358{
 359	double x;
 360
 361	x = _PyFloat_Unpack4((unsigned char *)p, le);
 362	if (x == -1.0 && PyErr_Occurred())
 363		return NULL;
 364	return PyFloat_FromDouble(x);
 365}
 366
 367static PyObject *
 368unpack_double(const char *p,  /* start of 8-byte string */
 369              int le)         /* true for little-endian, false for big-endian */
 370{
 371	double x;
 372
 373	x = _PyFloat_Unpack8((unsigned char *)p, le);
 374	if (x == -1.0 && PyErr_Occurred())
 375		return NULL;
 376	return PyFloat_FromDouble(x);
 377}
 378
 379/* Helper to format the range error exceptions */
 380static int
 381_range_error(const formatdef *f, int is_unsigned)
 382{
 383	/* ulargest is the largest unsigned value with f->size bytes.
 384	 * Note that the simpler:
 385	 *     ((size_t)1 << (f->size * 8)) - 1
 386	 * doesn't work when f->size == sizeof(size_t) because C doesn't
 387	 * define what happens when a left shift count is >= the number of
 388	 * bits in the integer being shifted; e.g., on some boxes it doesn't
 389	 * shift at all when they're equal.
 390	 */
 391	const size_t ulargest = (size_t)-1 >> ((SIZEOF_SIZE_T - f->size)*8);
 392	assert(f->size >= 1 && f->size <= SIZEOF_SIZE_T);
 393	if (is_unsigned)
 394		PyErr_Format(StructError,
 395			"'%c' format requires 0 <= number <= %zu",
 396			f->format,
 397			ulargest);
 398	else {
 399		const Py_ssize_t largest = (Py_ssize_t)(ulargest >> 1);
 400		PyErr_Format(StructError,
 401			"'%c' format requires %zd <= number <= %zd",
 402			f->format,
 403			~ largest,
 404			largest);
 405	}
 406#ifdef PY_STRUCT_OVERFLOW_MASKING
 407	{
 408		PyObject *ptype, *pvalue, *ptraceback;
 409		PyObject *msg;
 410		int rval;
 411		PyErr_Fetch(&ptype, &pvalue, &ptraceback);
 412		assert(pvalue != NULL);
 413		msg = PyObject_Str(pvalue);
 414		Py_XDECREF(ptype);
 415		Py_XDECREF(pvalue);
 416		Py_XDECREF(ptraceback);
 417		if (msg == NULL)
 418			return -1;
 419		rval = PyErr_WarnEx(PyExc_DeprecationWarning,
 420				    PyString_AS_STRING(msg), 2);
 421		Py_DECREF(msg);
 422		if (rval == 0)
 423			return 0;
 424	}
 425#endif
 426	return -1;
 427}
 428
 429
 430
 431/* A large number of small routines follow, with names of the form
 432
 433   [bln][up]_TYPE
 434
 435   [bln] distiguishes among big-endian, little-endian and native.
 436   [pu] distiguishes between pack (to struct) and unpack (from struct).
 437   TYPE is one of char, byte, ubyte, etc.
 438*/
 439
 440/* Native mode routines. ****************************************************/
 441/* NOTE:
 442   In all n[up]_<type> routines handling types larger than 1 byte, there is
 443   *no* guarantee that the p pointer is properly aligned for each type,
 444   therefore memcpy is called.  An intermediate variable is used to
 445   compensate for big-endian architectures.
 446   Normally both the intermediate variable and the memcpy call will be
 447   skipped by C optimisation in little-endian architectures (gcc >= 2.91
 448   does this). */
 449
 450static PyObject *
 451nu_char(const char *p, const formatdef *f)
 452{
 453	return PyString_FromStringAndSize(p, 1);
 454}
 455
 456static PyObject *
 457nu_byte(const char *p, const formatdef *f)
 458{
 459	return PyInt_FromLong((long) *(signed char *)p);
 460}
 461
 462static PyObject *
 463nu_ubyte(const char *p, const formatdef *f)
 464{
 465	return PyInt_FromLong((long) *(unsigned char *)p);
 466}
 467
 468static PyObject *
 469nu_short(const char *p, const formatdef *f)
 470{
 471	short x;
 472	memcpy((char *)&x, p, sizeof x);
 473	return PyInt_FromLong((long)x);
 474}
 475
 476static PyObject *
 477nu_ushort(const char *p, const formatdef *f)
 478{
 479	unsigned short x;
 480	memcpy((char *)&x, p, sizeof x);
 481	return PyInt_FromLong((long)x);
 482}
 483
 484static PyObject *
 485nu_int(const char *p, const formatdef *f)
 486{
 487	int x;
 488	memcpy((char *)&x, p, sizeof x);
 489	return PyInt_FromLong((long)x);
 490}
 491
 492static PyObject *
 493nu_uint(const char *p, const formatdef *f)
 494{
 495	unsigned int x;
 496	memcpy((char *)&x, p, sizeof x);
 497#if (SIZEOF_LONG > SIZEOF_INT)
 498	return PyInt_FromLong((long)x);
 499#else
 500	if (x <= ((unsigned int)LONG_MAX))
 501		return PyInt_FromLong((long)x);
 502	return PyLong_FromUnsignedLong((unsigned long)x);
 503#endif
 504}
 505
 506static PyObject *
 507nu_long(const char *p, const formatdef *f)
 508{
 509	long x;
 510	memcpy((char *)&x, p, sizeof x);
 511	return PyInt_FromLong(x);
 512}
 513
 514static PyObject *
 515nu_ulong(const char *p, const formatdef *f)
 516{
 517	unsigned long x;
 518	memcpy((char *)&x, p, sizeof x);
 519	if (x <= LONG_MAX)
 520		return PyInt_FromLong((long)x);
 521	return PyLong_FromUnsignedLong(x);
 522}
 523
 524/* Native mode doesn't support q or Q unless the platform C supports
 525   long long (or, on Windows, __int64). */
 526
 527#ifdef HAVE_LONG_LONG
 528
 529static PyObject *
 530nu_longlong(const char *p, const formatdef *f)
 531{
 532	PY_LONG_LONG x;
 533	memcpy((char *)&x, p, sizeof x);
 534	if (x >= LONG_MIN && x <= LONG_MAX)
 535		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
 536	return PyLong_FromLongLong(x);
 537}
 538
 539static PyObject *
 540nu_ulonglong(const char *p, const formatdef *f)
 541{
 542	unsigned PY_LONG_LONG x;
 543	memcpy((char *)&x, p, sizeof x);
 544	if (x <= LONG_MAX)
 545		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
 546	return PyLong_FromUnsignedLongLong(x);
 547}
 548
 549#endif
 550
 551static PyObject *
 552nu_bool(const char *p, const formatdef *f)
 553{
 554	BOOL_TYPE x;
 555	memcpy((char *)&x, p, sizeof x);
 556	return PyBool_FromLong(x != 0);
 557}
 558
 559
 560static PyObject *
 561nu_float(const char *p, const formatdef *f)
 562{
 563	float x;
 564	memcpy((char *)&x, p, sizeof x);
 565	return PyFloat_FromDouble((double)x);
 566}
 567
 568static PyObject *
 569nu_double(const char *p, const formatdef *f)
 570{
 571	double x;
 572	memcpy((char *)&x, p, sizeof x);
 573	return PyFloat_FromDouble(x);
 574}
 575
 576static PyObject *
 577nu_void_p(const char *p, const formatdef *f)
 578{
 579	void *x;
 580	memcpy((char *)&x, p, sizeof x);
 581	return PyLong_FromVoidPtr(x);
 582}
 583
 584static int
 585np_byte(char *p, PyObject *v, const formatdef *f)
 586{
 587	long x;
 588	if (get_long(v, &x) < 0)
 589		return -1;
 590	if (x < -128 || x > 127){
 591		PyErr_SetString(StructError,
 592				"byte format requires -128 <= number <= 127");
 593		return -1;
 594	}
 595	*p = (char)x;
 596	return 0;
 597}
 598
 599static int
 600np_ubyte(char *p, PyObject *v, const formatdef *f)
 601{
 602	long x;
 603	if (get_long(v, &x) < 0)
 604		return -1;
 605	if (x < 0 || x > 255){
 606		PyErr_SetString(StructError,
 607				"ubyte format requires 0 <= number <= 255");
 608		return -1;
 609	}
 610	*p = (char)x;
 611	return 0;
 612}
 613
 614static int
 615np_char(char *p, PyObject *v, const formatdef *f)
 616{
 617	if (!PyString_Check(v) || PyString_Size(v) != 1) {
 618		PyErr_SetString(StructError,
 619				"char format require string of length 1");
 620		return -1;
 621	}
 622	*p = *PyString_AsString(v);
 623	return 0;
 624}
 625
 626static int
 627np_short(char *p, PyObject *v, const formatdef *f)
 628{
 629	long x;
 630	short y;
 631	if (get_long(v, &x) < 0)
 632		return -1;
 633	if (x < SHRT_MIN || x > SHRT_MAX){
 634		PyErr_SetString(StructError,
 635				"short format requires " STRINGIFY(SHRT_MIN)
 636				" <= number <= " STRINGIFY(SHRT_MAX));
 637		return -1;
 638	}
 639	y = (short)x;
 640	memcpy(p, (char *)&y, sizeof y);
 641	return 0;
 642}
 643
 644static int
 645np_ushort(char *p, PyObject *v, const formatdef *f)
 646{
 647	long x;
 648	unsigned short y;
 649	if (get_long(v, &x) < 0)
 650		return -1;
 651	if (x < 0 || x > USHRT_MAX){
 652		PyErr_SetString(StructError,
 653				"ushort format requires 0 <= number <= " STRINGIFY(USHRT_MAX));
 654		return -1;
 655	}
 656	y = (unsigned short)x;
 657	memcpy(p, (char *)&y, sizeof y);
 658	return 0;
 659}
 660
 661static int
 662np_int(char *p, PyObject *v, const formatdef *f)
 663{
 664	long x;
 665	int y;
 666	if (get_long(v, &x) < 0)
 667		return -1;
 668#if (SIZEOF_LONG > SIZEOF_INT)
 669	if ((x < ((long)INT_MIN)) || (x > ((long)INT_MAX)))
 670		RANGE_ERROR(x, f, 0, -1);
 671#endif
 672	y = (int)x;
 673	memcpy(p, (char *)&y, sizeof y);
 674	return 0;
 675}
 676
 677static int
 678np_uint(char *p, PyObject *v, const formatdef *f)
 679{
 680	unsigned long x;
 681	unsigned int y;
 682	if (get_wrapped_ulong(v, &x) < 0)
 683		return -1;
 684	y = (unsigned int)x;
 685#if (SIZEOF_LONG > SIZEOF_INT)
 686	if (x > ((unsigned long)UINT_MAX))
 687		RANGE_ERROR(y, f, 1, -1);
 688#endif
 689	memcpy(p, (char *)&y, sizeof y);
 690	return 0;
 691}
 692
 693static int
 694np_long(char *p, PyObject *v, const formatdef *f)
 695{
 696	long x;
 697	if (get_long(v, &x) < 0)
 698		return -1;
 699	memcpy(p, (char *)&x, sizeof x);
 700	return 0;
 701}
 702
 703static int
 704np_ulong(char *p, PyObject *v, const formatdef *f)
 705{
 706	unsigned long x;
 707	if (get_wrapped_ulong(v, &x) < 0)
 708		return -1;
 709	memcpy(p, (char *)&x, sizeof x);
 710	return 0;
 711}
 712
 713#ifdef HAVE_LONG_LONG
 714
 715static int
 716np_longlong(char *p, PyObject *v, const formatdef *f)
 717{
 718	PY_LONG_LONG x;
 719	if (get_longlong(v, &x) < 0)
 720		return -1;
 721	memcpy(p, (char *)&x, sizeof x);
 722	return 0;
 723}
 724
 725static int
 726np_ulonglong(char *p, PyObject *v, const formatdef *f)
 727{
 728	unsigned PY_LONG_LONG x;
 729	if (get_ulonglong(v, &x) < 0)
 730		return -1;
 731	memcpy(p, (char *)&x, sizeof x);
 732	return 0;
 733}
 734#endif
 735
 736
 737static int
 738np_bool(char *p, PyObject *v, const formatdef *f)
 739{
 740	BOOL_TYPE y; 
 741	y = PyObject_IsTrue(v);
 742	memcpy(p, (char *)&y, sizeof y);
 743	return 0;
 744}
 745
 746static int
 747np_float(char *p, PyObject *v, const formatdef *f)
 748{
 749	float x = (float)PyFloat_AsDouble(v);
 750	if (x == -1 && PyErr_Occurred()) {
 751		PyErr_SetString(StructError,
 752				"required argument is not a float");
 753		return -1;
 754	}
 755	memcpy(p, (char *)&x, sizeof x);
 756	return 0;
 757}
 758
 759static int
 760np_double(char *p, PyObject *v, const formatdef *f)
 761{
 762	double x = PyFloat_AsDouble(v);
 763	if (x == -1 && PyErr_Occurred()) {
 764		PyErr_SetString(StructError,
 765				"required argument is not a float");
 766		return -1;
 767	}
 768	memcpy(p, (char *)&x, sizeof(double));
 769	return 0;
 770}
 771
 772static int
 773np_void_p(char *p, PyObject *v, const formatdef *f)
 774{
 775	void *x;
 776
 777	v = get_pylong(v);
 778	if (v == NULL)
 779		return -1;
 780	assert(PyLong_Check(v));
 781	x = PyLong_AsVoidPtr(v);
 782	Py_DECREF(v);
 783	if (x == NULL && PyErr_Occurred())
 784		return -1;
 785	memcpy(p, (char *)&x, sizeof x);
 786	return 0;
 787}
 788
 789static formatdef native_table[] = {
 790	{'x',	sizeof(char),	0,		NULL},
 791	{'b',	sizeof(char),	0,		nu_byte,	np_byte},
 792	{'B',	sizeof(char),	0,		nu_ubyte,	np_ubyte},
 793	{'c',	sizeof(char),	0,		nu_char,	np_char},
 794	{'s',	sizeof(char),	0,		NULL},
 795	{'p',	sizeof(char),	0,		NULL},
 796	{'h',	sizeof(short),	SHORT_ALIGN,	nu_short,	np_short},
 797	{'H',	sizeof(short),	SHORT_ALIGN,	nu_ushort,	np_ushort},
 798	{'i',	sizeof(int),	INT_ALIGN,	nu_int,		np_int},
 799	{'I',	sizeof(int),	INT_ALIGN,	nu_uint,	np_uint},
 800	{'l',	sizeof(long),	LONG_ALIGN,	nu_long,	np_long},
 801	{'L',	sizeof(long),	LONG_ALIGN,	nu_ulong,	np_ulong},
 802#ifdef HAVE_LONG_LONG
 803	{'q',	sizeof(PY_LONG_LONG), LONG_LONG_ALIGN, nu_longlong, np_longlong},
 804	{'Q',	sizeof(PY_LONG_LONG), LONG_LONG_ALIGN, nu_ulonglong,np_ulonglong},
 805#endif
 806	{'?',	sizeof(BOOL_TYPE),	BOOL_ALIGN,	nu_bool,	np_bool},
 807	{'f',	sizeof(float),	FLOAT_ALIGN,	nu_float,	np_float},
 808	{'d',	sizeof(double),	DOUBLE_ALIGN,	nu_double,	np_double},
 809	{'P',	sizeof(void *),	VOID_P_ALIGN,	nu_void_p,	np_void_p},
 810	{0}
 811};
 812
 813/* Big-endian routines. *****************************************************/
 814
 815static PyObject *
 816bu_int(const char *p, const formatdef *f)
 817{
 818	long x = 0;
 819	Py_ssize_t i = f->size;
 820	const unsigned char *bytes = (const unsigned char *)p;
 821	do {
 822		x = (x<<8) | *bytes++;
 823	} while (--i > 0);
 824	/* Extend the sign bit. */
 825	if (SIZEOF_LONG > f->size)
 826		x |= -(x & (1L << ((8 * f->size) - 1)));
 827	return PyInt_FromLong(x);
 828}
 829
 830static PyObject *
 831bu_uint(const char *p, const formatdef *f)
 832{
 833	unsigned long x = 0;
 834	Py_ssize_t i = f->size;
 835	const unsigned char *bytes = (const unsigned char *)p;
 836	do {
 837		x = (x<<8) | *bytes++;
 838	} while (--i > 0);
 839	if (x <= LONG_MAX)
 840		return PyInt_FromLong((long)x);
 841	return PyLong_FromUnsignedLong(x);
 842}
 843
 844static PyObject *
 845bu_longlong(const char *p, const formatdef *f)
 846{
 847#ifdef HAVE_LONG_LONG
 848	PY_LONG_LONG x = 0;
 849	Py_ssize_t i = f->size;
 850	const unsigned char *bytes = (const unsigned char *)p;
 851	do {
 852		x = (x<<8) | *bytes++;
 853	} while (--i > 0);
 854	/* Extend the sign bit. */
 855	if (SIZEOF_LONG_LONG > f->size)
 856		x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));
 857	if (x >= LONG_MIN && x <= LONG_MAX)
 858		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
 859	return PyLong_FromLongLong(x);
 860#else
 861	return _PyLong_FromByteArray((const unsigned char *)p,
 862				      8,
 863				      0, /* little-endian */
 864				      1  /* signed */);
 865#endif
 866}
 867
 868static PyObject *
 869bu_ulonglong(const char *p, const formatdef *f)
 870{
 871#ifdef HAVE_LONG_LONG
 872	unsigned PY_LONG_LONG x = 0;
 873	Py_ssize_t i = f->size;
 874	const unsigned char *bytes = (const unsigned char *)p;
 875	do {
 876		x = (x<<8) | *bytes++;
 877	} while (--i > 0);
 878	if (x <= LONG_MAX)
 879		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
 880	return PyLong_FromUnsignedLongLong(x);
 881#else
 882	return _PyLong_FromByteArray((const unsigned char *)p,
 883				      8,
 884				      0, /* little-endian */
 885				      0  /* signed */);
 886#endif
 887}
 888
 889static PyObject *
 890bu_float(const char *p, const formatdef *f)
 891{
 892	return unpack_float(p, 0);
 893}
 894
 895static PyObject *
 896bu_double(const char *p, const formatdef *f)
 897{
 898	return unpack_double(p, 0);
 899}
 900
 901static PyObject *
 902bu_bool(const char *p, const formatdef *f)
 903{
 904	char x;
 905	memcpy((char *)&x, p, sizeof x);
 906	return PyBool_FromLong(x != 0);
 907}
 908
 909static int
 910bp_int(char *p, PyObject *v, const formatdef *f)
 911{
 912	long x;
 913	Py_ssize_t i;
 914	if (get_wrapped_long(v, &x) < 0)
 915		return -1;
 916	i = f->size;
 917	if (i != SIZEOF_LONG) {
 918		if ((i == 2) && (x < -32768 || x > 32767))
 919			RANGE_ERROR(x, f, 0, 0xffffL);
 920#if (SIZEOF_LONG != 4)
 921		else if ((i == 4) && (x < -2147483648L || x > 2147483647L))
 922			RANGE_ERROR(x, f, 0, 0xffffffffL);
 923#endif
 924#ifdef PY_STRUCT_OVERFLOW_MASKING
 925		else if ((i == 1) && (x < -128 || x > 127))
 926			RANGE_ERROR(x, f, 0, 0xffL);
 927#endif
 928	}
 929	do {
 930		p[--i] = (char)x;
 931		x >>= 8;
 932	} while (i > 0);
 933	return 0;
 934}
 935
 936static int
 937bp_uint(char *p, PyObject *v, const formatdef *f)
 938{
 939	unsigned long x;
 940	Py_ssize_t i;
 941	if (get_wrapped_ulong(v, &x) < 0)
 942		return -1;
 943	i = f->size;
 944	if (i != SIZEOF_LONG) {
 945		unsigned long maxint = 1;
 946		maxint <<= (unsigned long)(i * 8);
 947		if (x >= maxint)
 948			RANGE_ERROR(x, f, 1, maxint - 1);
 949	}
 950	do {
 951		p[--i] = (char)x;
 952		x >>= 8;
 953	} while (i > 0);
 954	return 0;
 955}
 956
 957static int
 958bp_longlong(char *p, PyObject *v, const formatdef *f)
 959{
 960	int res;
 961	v = get_pylong(v);
 962	if (v == NULL)
 963		return -1;
 964	res = _PyLong_AsByteArray((PyLongObject *)v,
 965			   	  (unsigned char *)p,
 966				  8,
 967				  0, /* little_endian */
 968				  1  /* signed */);
 969	Py_DECREF(v);
 970	return res;
 971}
 972
 973static int
 974bp_ulonglong(char *p, PyObject *v, const formatdef *f)
 975{
 976	int res;
 977	v = get_pylong(v);
 978	if (v == NULL)
 979		return -1;
 980	res = _PyLong_AsByteArray((PyLongObject *)v,
 981			   	  (unsigned char *)p,
 982				  8,
 983				  0, /* little_endian */
 984				  0  /* signed */);
 985	Py_DECREF(v);
 986	return res;
 987}
 988
 989static int
 990bp_float(char *p, PyObject *v, const formatdef *f)
 991{
 992	double x = PyFloat_AsDouble(v);
 993	if (x == -1 && PyErr_Occurred()) {
 994		PyErr_SetString(StructError,
 995				"required argument is not a float");
 996		return -1;
 997	}
 998	return _PyFloat_Pack4(x, (unsigned char *)p, 0);
 999}
1000
1001static int
1002bp_double(char *p, PyObject *v, const formatdef *f)
1003{
1004	double x = PyFloat_AsDouble(v);
1005	if (x == -1 && PyErr_Occurred()) {
1006		PyErr_SetString(StructError,
1007				"required argument is not a float");
1008		return -1;
1009	}
1010	return _PyFloat_Pack8(x, (unsigned char *)p, 0);
1011}
1012
1013static int
1014bp_bool(char *p, PyObject *v, const formatdef *f)
1015{
1016	char y; 
1017	y = PyObject_IsTrue(v);
1018	memcpy(p, (char *)&y, sizeof y);
1019	return 0;
1020}
1021
1022static formatdef bigendian_table[] = {
1023	{'x',	1,		0,		NULL},
1024#ifdef PY_STRUCT_OVERFLOW_MASKING
1025	/* Native packers do range checking without overflow masking. */
1026	{'b',	1,		0,		nu_byte,	bp_int},
1027	{'B',	1,		0,		nu_ubyte,	bp_uint},
1028#else
1029	{'b',	1,		0,		nu_byte,	np_byte},
1030	{'B',	1,		0,		nu_ubyte,	np_ubyte},
1031#endif
1032	{'c',	1,		0,		nu_char,	np_char},
1033	{'s',	1,		0,		NULL},
1034	{'p',	1,		0,		NULL},
1035	{'h',	2,		0,		bu_int,		bp_int},
1036	{'H',	2,		0,		bu_uint,	bp_uint},
1037	{'i',	4,		0,		bu_int,		bp_int},
1038	{'I',	4,		0,		bu_uint,	bp_uint},
1039	{'l',	4,		0,		bu_int,		bp_int},
1040	{'L',	4,		0,		bu_uint,	bp_uint},
1041	{'q',	8,		0,		bu_longlong,	bp_longlong},
1042	{'Q',	8,		0,		bu_ulonglong,	bp_ulonglong},
1043	{'?',	1,		0,		bu_bool,	bp_bool},
1044	{'f',	4,		0,		bu_float,	bp_float},
1045	{'d',	8,		0,		bu_double,	bp_double},
1046	{0}
1047};
1048
1049/* Little-endian routines. *****************************************************/
1050
1051static PyObject *
1052lu_int(const char *p, const formatdef *f)
1053{
1054	long x = 0;
1055	Py_ssize_t i = f->size;
1056	const unsigned char *bytes = (const unsigned char *)p;
1057	do {
1058		x = (x<<8) | bytes[--i];
1059	} while (i > 0);
1060	/* Extend the sign bit. */
1061	if (SIZEOF_LONG > f->size)
1062		x |= -(x & (1L << ((8 * f->size) - 1)));
1063	return PyInt_FromLong(x);
1064}
1065
1066static PyObject *
1067lu_uint(const char *p, const formatdef *f)
1068{
1069	unsigned long x = 0;
1070	Py_ssize_t i = f->size;
1071	const unsigned char *bytes = (const unsigned char *)p;
1072	do {
1073		x = (x<<8) | bytes[--i];
1074	} while (i > 0);
1075	if (x <= LONG_MAX)
1076		return PyInt_FromLong((long)x);
1077	return PyLong_FromUnsignedLong((long)x);
1078}
1079
1080static PyObject *
1081lu_longlong(const char *p, const formatdef *f)
1082{
1083#ifdef HAVE_LONG_LONG
1084	PY_LONG_LONG x = 0;
1085	Py_ssize_t i = f->size;
1086	const unsigned char *bytes = (const unsigned char *)p;
1087	do {
1088		x = (x<<8) | bytes[--i];
1089	} while (i > 0);
1090	/* Extend the sign bit. */
1091	if (SIZEOF_LONG_LONG > f->size)
1092		x |= -(x & ((PY_LONG_LONG)1 << ((8 * f->size) - 1)));
1093	if (x >= LONG_MIN && x <= LONG_MAX)
1094		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, PY_LONG_LONG, long));
1095	return PyLong_FromLongLong(x);
1096#else
1097	return _PyLong_FromByteArray((const unsigned char *)p,
1098				      8,
1099				      1, /* little-endian */
1100				      1  /* signed */);
1101#endif
1102}
1103
1104static PyObject *
1105lu_ulonglong(const char *p, const formatdef *f)
1106{
1107#ifdef HAVE_LONG_LONG
1108	unsigned PY_LONG_LONG x = 0;
1109	Py_ssize_t i = f->size;
1110	const unsigned char *bytes = (const unsigned char *)p;
1111	do {
1112		x = (x<<8) | bytes[--i];
1113	} while (i > 0);
1114	if (x <= LONG_MAX)
1115		return PyInt_FromLong(Py_SAFE_DOWNCAST(x, unsigned PY_LONG_LONG, long));
1116	return PyLong_FromUnsignedLongLong(x);
1117#else
1118	return _PyLong_FromByteArray((const unsigned char *)p,
1119				      8,
1120				      1, /* little-endian */
1121				      0  /* signed */);
1122#endif
1123}
1124
1125static PyObject *
1126lu_float(const char *p, const formatdef *f)
1127{
1128	return unpack_float(p, 1);
1129}
1130
1131static PyObject *
1132lu_double(const char *p, const formatdef *f)
1133{
1134	return unpack_double(p, 1);
1135}
1136
1137static int
1138lp_int(char *p, PyObject *v, const formatdef *f)
1139{
1140	long x;
1141	Py_ssize_t i;
1142	if (get_wrapped_long(v, &x) < 0)
1143		return -1;
1144	i = f->size;
1145	if (i != SIZEOF_LONG) {
1146		if ((i == 2) && (x < -32768 || x > 32767))
1147			RANGE_ERROR(x, f, 0, 0xffffL);
1148#if (SIZEOF_LONG != 4)
1149		else if ((i == 4) && (x < -2147483648L || x > 2147483647L))
1150			RANGE_ERROR(x, f, 0, 0xffffffffL);
1151#endif
1152#ifdef PY_STRUCT_OVERFLOW_MASKING
1153		else if ((i == 1) && (x < -128 || x > 127))
1154			RANGE_ERROR(x, f, 0, 0xffL);
1155#endif
1156	}
1157	do {
1158		*p++ = (char)x;
1159		x >>= 8;
1160	} while (--i > 0);
1161	return 0;
1162}
1163
1164static int
1165lp_uint(char *p, PyObject *v, const formatdef *f)
1166{
1167	unsigned long x;
1168	Py_ssize_t i;
1169	if (get_wrapped_ulong(v, &x) < 0)
1170		return -1;
1171	i = f->size;
1172	if (i != SIZEOF_LONG) {
1173		unsigned long maxint = 1;
1174		maxint <<= (unsigned long)(i * 8);
1175		if (x >= maxint)
1176			RANGE_ERROR(x, f, 1, maxint - 1);
1177	}
1178	do {
1179		*p++ = (char)x;
1180		x >>= 8;
1181	} while (--i > 0);
1182	return 0;
1183}
1184
1185static int
1186lp_longlong(char *p, PyObject *v, const formatdef *f)
1187{
1188	int res;
1189	v = get_pylong(v);
1190	if (v == NULL)
1191		return -1;
1192	res = _PyLong_AsByteArray((PyLongObject*)v,
1193			   	  (unsigned char *)p,
1194				  8,
1195				  1, /* little_endian */
1196				  1  /* signed */);
1197	Py_DECREF(v);
1198	return res;
1199}
1200
1201static int
1202lp_ulonglong(char *p, PyObject *v, const formatdef *f)
1203{
1204	int res;
1205	v = get_pylong(v);
1206	if (v == NULL)
1207		return -1;
1208	res = _PyLong_AsByteArray((PyLongObject*)v,
1209			   	  (unsigned char *)p,
1210				  8,
1211				  1, /* little_endian */
1212				  0  /* signed */);
1213	Py_DECREF(v);
1214	return res;
1215}
1216
1217static int
1218lp_float(char *p, PyObject *v, const formatdef *f)
1219{
1220	double x = PyFloat_AsDouble(v);
1221	if (x == -1 && PyErr_Occurred()) {
1222		PyErr_SetString(StructError,
1223				"required argument is not a float");
1224		return -1;
1225	}
1226	return _PyFloat_Pack4(x, (unsigned char *)p, 1);
1227}
1228
1229static int
1230lp_double(char *p, PyObject *v, const formatdef *f)
1231{
1232	double x = PyFloat_AsDouble(v);
1233	if (x == -1 && PyErr_Occurred()) {
1234		PyErr_SetString(StructError,
1235				"required argument is not a float");
1236		return -1;
1237	}
1238	return _PyFloat_Pack8(x, (unsigned char *)p, 1);
1239}
1240
1241static formatdef lilendian_table[] = {
1242	{'x',	1,		0,		NULL},
1243#ifdef PY_STRUCT_OVERFLOW_MASKING
1244	/* Native packers do range checking without overflow masking. */
1245	{'b',	1,		0,		nu_byte,	lp_int},
1246	{'B',	1,		0,		nu_ubyte,	lp_uint},
1247#else
1248	{'b',	1,		0,		nu_byte,	np_byte},
1249	{'B',	1,		0,		nu_ubyte,	np_ubyte},
1250#endif
1251	{'c',	1,		0,		nu_char,	np_char},
1252	{'s',	1,		0,		NULL},
1253	{'p',	1,		0,		NULL},
1254	{'h',	2,		0,		lu_int,		lp_int},
1255	{'H',	2,		0,		lu_uint,	lp_uint},
1256	{'i',	4,		0,		lu_int,		lp_int},
1257	{'I',	4,		0,		lu_uint,	lp_uint},
1258	{'l',	4,		0,		lu_int,		lp_int},
1259	{'L',	4,		0,		lu_uint,	lp_uint},
1260	{'q',	8,		0,		lu_longlong,	lp_longlong},
1261	{'Q',	8,		0,		lu_ulonglong,	lp_ulonglong},
1262	{'?',	1,		0,		bu_bool,	bp_bool}, /* Std rep not endian dep,
1263		but potentially different from native rep -- reuse bx_bool funcs. */
1264	{'f',	4,		0,		lu_float,	lp_float},
1265	{'d',	8,		0,		lu_double,	lp_double},
1266	{0}
1267};
1268
1269
1270static const formatdef *
1271whichtable(char **pfmt)
1272{
1273	const char *fmt = (*pfmt)++; /* May be backed out of later */
1274	switch (*fmt) {
1275	case '<':
1276		return lilendian_table;
1277	case '>':
1278	case '!': /* Network byte order is big-endian */
1279		return bigendian_table;
1280	case '=': { /* Host byte order -- different from native in aligment! */
1281		int n = 1;
1282		char *p = (char *) &n;
1283		if (*p == 1)
1284			return lilendian_table;
1285		else
1286			return bigendian_table;
1287	}
1288	default:
1289		--*pfmt; /* Back out of pointer increment */
1290		/* Fall through */
1291	case '@':
1292		return native_table;
1293	}
1294}
1295
1296
1297/* Get the table entry for a format code */
1298
1299static const formatdef *
1300getentry(int c, const formatdef *f)
1301{
1302	for (; f->format != '\0'; f++) {
1303		if (f->format == c) {
1304			return f;
1305		}
1306	}
1307	PyErr_SetString(StructError, "bad char in struct format");
1308	return NULL;
1309}
1310
1311
1312/* Align a size according to a format code */
1313
1314static int
1315align(Py_ssize_t size, char c, const formatdef *e)
1316{
1317	if (e->format == c) {
1318		if (e->alignment) {
1319			size = ((size + e->alignment - 1)
1320				/ e->alignment)
1321				* e->alignment;
1322		}
1323	}
1324	return size;
1325}
1326
1327
1328/* calculate the size of a format string */
1329
1330static int
1331prepare_s(PyStructObject *self)
1332{
1333	const formatdef *f;
1334	const formatdef *e;
1335	formatcode *codes;
1336
1337	const char *s;
1338	const char *fmt;
1339	char c;
1340	Py_ssize_t size, len, num, itemsize, x;
1341
1342	fmt = PyString_AS_STRING(self->s_format);
1343
1344	f = whichtable((char **)&fmt);
1345
1346	s = fmt;
1347	size = 0;
1348	len = 0;
1349	while ((c = *s++) != '\0') {
1350		if (isspace(Py_CHARMASK(c)))
1351			continue;
1352		if ('0' <= c && c <= '9') {
1353			num = c - '0';
1354			while ('0' <= (c = *s++) && c <= '9') {
1355				x = num*10 + (c - '0');
1356				if (x/10 != num) {
1357					PyErr_SetString(
1358						StructError,
1359						"overflow in item count");
1360					return -1;
1361				}
1362				num = x;
1363			}
1364			if (c == '\0')
1365				break;
1366		}
1367		else
1368			num = 1;
1369
1370		e = getentry(c, f);
1371		if (e == NULL)
1372			return -1;
1373
1374		switch (c) {
1375			case 's': /* fall through */
1376			case 'p': len++; break;
1377			case 'x': break;
1378			default: len += num; break;
1379		}
1380
1381		itemsize = e->size;
1382		size = align(size, c, e);
1383		x = num * itemsize;
1384		size += x;
1385		if (x/itemsize != num || size < 0) {
1386			PyErr_SetString(StructError,
1387					"total struct size too long");
1388			return -1;
1389		}
1390	}
1391
1392	/* check for overflow */
1393	if ((len + 1) > (PY_SSIZE_T_MAX / sizeof(formatcode))) {
1394		PyErr_NoMemory();
1395		return -1;
1396	}
1397
1398	self->s_size = size;
1399	self->s_len = len;
1400	codes = PyMem_MALLOC((len + 1) * sizeof(formatcode));
1401	if (codes == NULL) {
1402		PyErr_NoMemory();
1403		return -1;
1404	}
1405	self->s_codes = codes;
1406
1407	s = fmt;
1408	size = 0;
1409	while ((c = *s++) != '\0') {
1410		if (isspace(Py_CHARMASK(c)))
1411			continue;
1412		if ('0' <= c && c <= '9') {
1413			num = c - '0';
1414			while ('0' <= (c = *s++) && c <= '9')
1415				num = num*10 + (c - '0');
1416			if (c == '\0')
1417				break;
1418		}
1419		else
1420			num = 1;
1421
1422		e = getentry(c, f);
1423
1424		size = align(size, c, e);
1425		if (c == 's' || c == 'p') {
1426			codes->offset = size;
1427			codes->size = num;
1428			codes->fmtdef = e;
1429			codes++;
1430			size += num;
1431		} else if (c == 'x') {
1432			size += num;
1433		} else {
1434			while (--num >= 0) {
1435				codes->offset = size;
1436				codes->size = e->size;
1437				codes->fmtdef = e;
1438				codes++;
1439				size += e->size;
1440			}
1441		}
1442	}
1443	codes->fmtdef = NULL;
1444	codes->offset = size;
1445	codes->size = 0;
1446
1447	return 0;
1448}
1449
1450static PyObject *
1451s_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1452{
1453	PyObject *self;
1454
1455	assert(type != NULL && type->tp_alloc != NULL);
1456
1457	self = type->tp_alloc(type, 0);
1458	if (self != NULL) {
1459		PyStructObject *s = (PyStructObject*)self;
1460		Py_INCREF(Py_None);
1461		s->s_format = Py_None;
1462		s->s_codes = NULL;
1463		s->s_size = -1;
1464		s->s_len = -1;
1465	}
1466	return self;
1467}
1468
1469static int
1470s_init(PyObject *self, PyObject *args, PyObject *kwds)
1471{
1472	PyStructObject *soself = (PyStructObject *)self;
1473	PyObject *o_format = NULL;
1474	int ret = 0;
1475	static char *kwlist[] = {"format", 0};
1476
1477	assert(PyStruct_Check(self));
1478
1479	if (!PyArg_ParseTupleAndKeywords(args, kwds, "S:Struct", kwlist,
1480					 &o_format))
1481		return -1;
1482
1483	Py_INCREF(o_format);
1484	Py_CLEAR(soself->s_format);
1485	soself->s_format = o_format;
1486
1487	ret = prepare_s(soself);
1488	return ret;
1489}
1490
1491static void
1492s_dealloc(PyStructObject *s)
1493{
1494	if (s->weakreflist != NULL)
1495		PyObject_ClearWeakRefs((PyObject *)s);
1496	if (s->s_codes != NULL) {
1497		PyMem_FREE(s->s_codes);
1498	}
1499	Py_XDECREF(s->s_format);
1500	Py_TYPE(s)->tp_free((PyObject *)s);
1501}
1502
1503static PyObject *
1504s_unpack_internal(PyStructObject *soself, char *startfrom) {
1505	formatcode *code;
1506	Py_ssize_t i = 0;
1507	PyObject *result = PyTuple_New(soself->s_len);
1508	if (result == NULL)
1509		return NULL;
1510
1511	for (code = soself->s_codes; code->fmtdef != NULL; code++) {
1512		PyObject *v;
1513		const formatdef *e = code->fmtdef;
1514		const char *res = startfrom + code->offset;
1515		if (e->format == 's') {
1516			v = PyString_FromStringAndSize(res, code->size);
1517		} else if (e->format == 'p') {
1518			Py_ssize_t n = *(unsigned char*)res;
1519			if (n >= code->size)
1520				n = code->size - 1;
1521			v = PyString_FromStringAndSize(res + 1, n);
1522		} else {
1523			v = e->unpack(res, e);
1524		}
1525		if (v == NULL)
1526			goto fail;
1527		PyTuple_SET_ITEM(result, i++, v);
1528	}
1529
1530	return result;
1531fail:
1532	Py_DECREF(result);
1533	return NULL;
1534}
1535
1536
1537PyDoc_STRVAR(s_unpack__doc__,
1538"S.unpack(str) -> (v1, v2, ...)\n\
1539\n\
1540Return tuple containing values unpacked according to this Struct's format.\n\
1541Requires len(str) == self.size. See struct.__doc__ for more on format\n\
1542strings.");
1543
1544static PyObject *
1545s_unpack(PyObject *self, PyObject *inputstr)
1546{
1547	char *start;
1548	Py_ssize_t len;
1549	PyObject *args=NULL, *result;
1550	PyStructObject *soself = (PyStructObject *)self;
1551	assert(PyStruct_Check(self));
1552	assert(soself->s_codes != NULL);
1553	if (inputstr == NULL)
1554		goto fail;
1555	if (PyString_Check(inputstr) &&
1556		PyString_GET_SIZE(inputstr) == soself->s_size) {
1557			return s_unpack_internal(soself, PyString_AS_STRING(inputstr));
1558	}
1559	args = PyTuple_Pack(1, inputstr);
1560	if (args == NULL)
1561		return NULL;
1562	if (!PyArg_ParseTuple(args, "s#:unpack", &start, &len))
1563		goto fail;
1564	if (soself->s_size != len)
1565		goto fail;
1566	result = s_unpack_internal(soself, start);
1567	Py_DECREF(args);
1568	return result;
1569
1570fail:
1571	Py_XDECREF(args);
1572	PyErr_Format(StructError,
1573		"unpack requires a string argument of length %zd",
1574		soself->s_size);
1575	return NULL;
1576}
1577
1578PyDoc_STRVAR(s_unpack_from__doc__,
1579"S.unpack_from(buffer[, offset]) -> (v1, v2, ...)\n\
1580\n\
1581Return tuple containing values unpacked according to this Struct's format.\n\
1582Unlike unpack, unpack_from can unpack values from any object supporting\n\
1583the buffer API, not just str. Requires len(buffer[offset:]) >= self.size.\n\
1584See struct.__doc__ for more on format strings.");
1585
1586static PyObject *
1587s_unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
1588{
1589	static char *kwlist[] = {"buffer", "offset", 0};
1590#if (PY_VERSION_HEX < 0x02050000)
1591	static char *fmt = "z#|i:unpack_from";
1592#else
1593	static char *fmt = "z#|n:unpack_from";
1594#endif
1595	Py_ssize_t buffer_len = 0, offset = 0;
1596	char *buffer = NULL;
1597	PyStructObject *soself = (PyStructObject *)self;
1598	assert(PyStruct_Check(self));
1599	assert(soself->s_codes != NULL);
1600
1601	if (!PyArg_ParseTupleAndKeywords(args, kwds, fmt, kwlist,
1602					 &buffer, &buffer_len, &offset))
1603		return NULL;
1604
1605	if (buffer == NULL) {
1606		PyErr_Format(StructError,
1607			"unpack_from requires a buffer argument");
1608		return NULL;
1609	}
1610
1611	if (offset < 0)
1612		offset += buffer_len;
1613
1614	if (offset < 0 || (buffer_len - offset) < soself->s_size) {
1615		PyErr_Format(StructError,
1616			"unpack_from requires a buffer of at least %zd bytes",
1617			soself->s_size);
1618		return NULL;
1619	}
1620	return s_unpack_internal(soself, buffer + offset);
1621}
1622
1623
1624/*
1625 * Guts of the pack function.
1626 *
1627 * Takes a struct object, a tuple of arguments, and offset in that tuple of
1628 * argument for where to start processing the arguments for packing, and a
1629 * character buffer for writing the packed string.  The caller must insure
1630 * that the buffer may contain the required length for packing the arguments.
1631 * 0 is returned on success, 1 is returned if there is an error.
1632 *
1633 */
1634static int
1635s_pack_internal(PyStructObject *soself, PyObject *args, int offset, char* buf)
1636{
1637	formatcode *code;
1638	/* XXX(nnorwitz): why does i need to be a local?  can we use
1639	   the offset parameter or do we need the wider width? */
1640	Py_ssize_t i;
1641
1642	memset(buf, '\0', soself->s_size);
1643	i = offset;
1644	for (code = soself->s_codes; code->fmtdef != NULL; code++) {
1645		Py_ssize_t n;
1646		PyObject *v = PyTuple_GET_ITEM(args, i++);
1647		const formatdef *e = code->fmtdef;
1648		char *res = buf + code->offset;
1649		if (e->format == 's') {
1650			if (!PyString_Check(v)) {
1651				PyErr_SetString(StructError,
1652						"argument for 's' must be a string");
1653				return -1;
1654			}
1655			n = PyString_GET_SIZE(v);
1656			if (n > code->size)
1657				n = code->size;
1658			if (n > 0)
1659				memcpy(res, PyString_AS_STRING(v), n);
1660		} else if (e->format == 'p') {
1661			if (!PyString_Check(v)) {
1662				PyErr_SetString(StructError,
1663						"argument for 'p' must be a string");
1664				return -1;
1665			}
1666			n = PyString_GET_SIZE(v);
1667			if (n > (code->size - 1))
1668				n = code->size - 1;
1669			if (n > 0)
1670				memcpy(res + 1, PyString_AS_STRING(v), n);
1671			if (n > 255)
1672				n = 255;
1673			*res = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
1674		} else {
1675			if (e->pack(res, v, e) < 0) {
1676				if (PyLong_Check(v) && PyErr_ExceptionMatches(PyExc_OverflowError))
1677					PyErr_SetString(StructError,
1678							"long too large to convert to int");
1679				return -1;
1680			}
1681		}
1682	}
1683
1684	/* Success */
1685	return 0;
1686}
1687
1688
1689PyDoc_STRVAR(s_pack__doc__,
1690"S.pack(v1, v2, ...) -> string\n\
1691\n\
1692Return a string containing values v1, v2, ... packed according to this\n\
1693Struct's format. See struct.__doc__ for more on format strings.");
1694
1695static PyObject *
1696s_pack(PyObject *self, PyObject *args)
1697{
1698	PyStructObject *soself;
1699	PyObject *result;
1700
1701	/* Validate arguments. */
1702	soself = (PyStructObject *)self;
1703	assert(PyStruct_Check(self));
1704	assert(soself->s_codes != NULL);
1705	if (PyTuple_GET_SIZE(args) != soself->s_len)
1706	{
1707		PyErr_Format(StructError,
1708			"pack requires exactly %zd arguments", soself->s_len);
1709		return NULL;
1710	}
1711
1712	/* Allocate a new string */
1713	result = PyString_FromStringAndSize((char *)NULL, soself->s_size);
1714	if (result == NULL)
1715		return NULL;
1716
1717	/* Call the guts */
1718	if ( s_pack_internal(soself, args, 0, PyString_AS_STRING(result)) != 0 ) {
1719		Py_DECREF(result);
1720		return NULL;
1721	}
1722
1723	return result;
1724}
1725
1726PyDoc_STRVAR(s_pack_into__doc__,
1727"S.pack_into(buffer, offset, v1, v2, ...)\n\
1728\n\
1729Pack the values v1, v2, ... according to this Struct's format, write \n\
1730the packed bytes into the writable buffer buf starting at offset.  Note\n\
1731that the offset is not an optional argument.  See struct.__doc__ for \n\
1732more on format strings.");
1733
1734static PyObject *
1735s_pack_into(PyObject *self, PyObject *args)
1736{
1737	PyStructObject *soself;
1738	char *buffer;
1739	Py_ssize_t buffer_len, offset;
1740
1741	/* Validate arguments.  +1 is for the first arg as buffer. */
1742	soself = (PyStructObject *)self;
1743	assert(PyStruct_Check(self));
1744	assert(soself->s_codes != NULL);
1745	if (PyTuple_GET_SIZE(args) != (soself->s_len + 2))
1746	{
1747		PyErr_Format(StructError,
1748			     "pack_into requires exactly %zd arguments",
1749			     (soself->s_len + 2));
1750		return NULL;
1751	}
1752
1753	/* Extract a writable memory buffer from the first argument */
1754	if ( PyObject_AsWriteBuffer(PyTuple_GET_ITEM(args, 0),
1755								(void**)&buffer, &buffer_len) == -1 ) {
1756		return NULL;
1757	}
1758	assert( buffer_len >= 0 );
1759
1760	/* Extract the offset from the first argument */
1761	offset = PyInt_AsSsize_t(PyTuple_GET_ITEM(args, 1));
1762	if (offset == -1 && PyErr_Occurred())
1763		return NULL;
1764
1765	/* Support negative offsets. */
1766	if (offset < 0)
1767		offset += buffer_len;
1768
1769	/* Check boundaries */
1770	if (offset < 0 || (buffer_len - offset) < soself->s_size) {
1771		PyErr_Format(StructError,
1772			     "pack_into requires a buffer of at least %zd bytes",
1773			     soself->s_size);
1774		return NULL;
1775	}
1776
1777	/* Call the guts */
1778	if ( s_pack_internal(soself, args, 2, buffer + offset) != 0 ) {
1779		return NULL;
1780	}
1781
1782	Py_RETURN_NONE;
1783}
1784
1785static PyObject *
1786s_get_format(PyStructObject *self, void *unused)
1787{
1788	Py_INCREF(self->s_format);
1789	return self->s_format;
1790}
1791
1792static PyObject *
1793s_get_size(PyStructObject *self, void *unused)
1794{
1795    return PyInt_FromSsize_t(self->s_size);
1796}
1797
1798/* List of functions */
1799
1800static struct PyMethodDef s_methods[] = {
1801	{"pack",	s_pack,		METH_VARARGS, s_pack__doc__},
1802	{"pack_into",	s_pack_into,	METH_VARARGS, s_pack_into__doc__},
1803	{"unpack",	s_unpack,       METH_O, s_unpack__doc__},
1804	{"unpack_from",	(PyCFunction)s_unpack_from, METH_VARARGS|METH_KEYWORDS,
1805			s_unpack_from__doc__},
1806	{NULL,	 NULL}		/* sentinel */
1807};
1808
1809PyDoc_STRVAR(s__doc__, "Compiled struct object");
1810
1811#define OFF(x) offsetof(PyStructObject, x)
1812
1813static PyGetSetDef s_getsetlist[] = {
1814	{"format", (getter)s_get_format, (setter)NULL, "struct format string", NULL},
1815	{"size", (getter)s_get_size, (setter)NULL, "struct size in bytes", NULL},
1816	{NULL} /* sentinel */
1817};
1818
1819static
1820PyTypeObject PyStructType = {
1821	PyVarObject_HEAD_INIT(NULL, 0)
1822	"Struct",
1823	sizeof(PyStructObject),
1824	0,
1825	(destructor)s_dealloc,	/* tp_dealloc */
1826	0,					/* tp_print */
1827	0,					/* tp_getattr */
1828	0,					/* tp_setattr */
1829	0,					/* tp_compare */
1830	0,					/* tp_repr */
1831	0,					/* tp_as_number */
1832	0,					/* tp_as_sequence */
1833	0,					/* tp_as_mapping */
1834	0,					/* tp_hash */
1835	0,					/* tp_call */
1836	0,					/* tp_str */
1837	PyObject_GenericGetAttr,	/* tp_getattro */
1838	PyObject_GenericSetAttr,	/* tp_setattro */
1839	0,					/* tp_as_buffer */
1840	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS,/* tp_flags */
1841	s__doc__,			/* tp_doc */
1842	0,					/* tp_traverse */
1843	0,					/* tp_clear */
1844	0,					/* tp_richcompare */
1845	offsetof(PyStructObject, weakreflist),	/* tp_weaklistoffset */
1846	0,					/* tp_iter */
1847	0,					/* tp_iternext */
1848	s_methods,			/* tp_methods */
1849	NULL,				/* tp_members */
1850	s_getsetlist,		/* tp_getset */
1851	0,					/* tp_base */
1852	0,					/* tp_dict */
1853	0,					/* tp_descr_get */
1854	0,					/* tp_descr_set */
1855	0,					/* tp_dictoffset */
1856	s_init,				/* tp_init */
1857	PyType_GenericAlloc,/* tp_alloc */
1858	s_new,				/* tp_new */
1859	PyObject_Del,		/* tp_free */
1860};
1861
1862
1863/* ---- Standalone functions  ---- */
1864
1865#define MAXCACHE 100
1866static PyObject *cache = NULL;
1867
1868static PyObject *
1869cache_struct(PyObject *fmt)
1870{
1871	PyObject * s_object;
1872
1873	if (cache == NULL) {
1874		cache = PyDict_New();
1875		if (cache == NULL)
1876			return NULL;
1877	}
1878
1879	s_object = PyDict_GetItem(cache, fmt);
1880	if (s_object != NULL) {
1881		Py_INCREF(s_object);
1882		return s_object;
1883	}
1884
1885	s_object = PyObject_CallFunctionObjArgs((PyObject *)(&PyStructType), fmt, NULL);
1886	if (s_object != NULL) {
1887		if (PyDict_Size(cache) >= MAXCACHE)
1888			PyDict_Clear(cache);
1889		/* Attempt to cache the result */
1890		if (PyDict_SetItem(cache, fmt, s_object) == -1)
1891			PyErr_Clear();
1892	}
1893	return s_object;
1894}
1895
1896PyDoc_STRVAR(clearcache_doc,
1897"Clear the internal cache.");
1898
1899static PyObject *
1900clearcache(PyObject *self)
1901{
1902	Py_CLEAR(cache);
1903	Py_RETURN_NONE;
1904}
1905
1906PyDoc_STRVAR(calcsize_doc,
1907"Return size of C struct described by format string fmt.");
1908
1909static PyObject *
1910calcsize(PyObject *self, PyObject *fmt)
1911{
1912	Py_ssize_t n;
1913	PyObject *s_object = cache_struct(fmt);
1914	if (s_object == NULL)
1915		return NULL;
1916	n = ((PyStructObject *)s_object)->s_size;
1917	Py_DECREF(s_object);
1918    	return PyInt_FromSsize_t(n);
1919}
1920
1921PyDoc_STRVAR(pack_doc,
1922"Return string containing values v1, v2, ... packed according to fmt.");
1923
1924static PyObject *
1925pack(PyObject *self, PyObject *args)
1926{
1927	PyObject *s_object, *fmt, *newargs, *result;
1928	Py_ssize_t n = PyTuple_GET_SIZE(args);
1929
1930	if (n == 0) {
1931		PyErr_SetString(PyExc_TypeError, "missing format argument");
1932		return NULL;
1933	}
1934	fmt = PyTuple_GET_ITEM(args, 0);
1935	newargs = PyTuple_GetSlice(args, 1, n);
1936	if (newargs == NULL)
1937		return NULL;
1938
1939	s_object = cache_struct(fmt);
1940	if (s_object == NULL) {
1941		Py_DECREF(newargs);
1942		return NULL;
1943	}
1944    	result = s_pack(s_object, newargs);
1945	Py_DECREF(newargs);
1946	Py_DECREF(s_object);
1947	return result;
1948}
1949
1950PyDoc_STRVAR(pack_into_doc,
1951"Pack the values v1, v2, ... according to fmt.\n\
1952Write the packed bytes into the writable buffer buf starting at offset.");
1953
1954static PyObject *
1955pack_into(PyObject *self, PyObject *args)
1956{
1957	PyObject *s_object, *fmt, *newargs, *result;
1958	Py_ssize_t n = PyTuple_GET_SIZE(args);
1959
1960	if (n == 0) {
1961		PyErr_SetString(PyExc_TypeError, "missing format argument");
1962		return NULL;
1963	}
1964	fmt = PyTuple_GET_ITEM(args, 0);
1965	newargs = PyTuple_GetSlice(args, 1, n);
1966	if (newargs == NULL)
1967		return NULL;
1968
1969	s_object = cache_struct(fmt);
1970	if (s_object == NULL) {
1971		Py_DECREF(newargs);
1972		return NULL;
1973	}
1974    	result = s_pack_into(s_object, newargs);
1975	Py_DECREF(newargs);
1976	Py_DECREF(s_object);
1977	return result;
1978}
1979
1980PyDoc_STRVAR(unpack_doc,
1981"Unpack the string containing packed C structure data, according to fmt.\n\
1982Requires len(string) == calcsize(fmt).");
1983
1984static PyObject *
1985unpack(PyObject *self, PyObject *args)
1986{
1987	PyObject *s_object, *fmt, *inputstr, *result;
1988
1989	if (!PyArg_UnpackTuple(args, "unpack", 2, 2, &fmt, &inputstr))
1990		return NULL;
1991
1992	s_object = cache_struct(fmt);
1993	if (s_object == NULL)
1994		return NULL;
1995    	result = s_unpack(s_object, inputstr);
1996	Py_DECREF(s_object);
1997	return result;
1998}
1999
2000PyDoc_STRVAR(unpack_from_doc,
2001"Unpack the buffer, containing packed C structure data, according to\n\
2002fmt, starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt).");
2003
2004static PyObject *
2005unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
2006{
2007	PyObject *s_object, *fmt, *newargs, *result;
2008	Py_ssize_t n = PyTuple_GET_SIZE(args);
2009
2010	if (n == 0) {
2011		PyErr_SetString(PyExc_TypeError, "missing format argument");
2012		return NULL;
2013	}
2014	fmt = PyTuple_GET_ITEM(args, 0);
2015	newargs = PyTuple_GetSlice(args, 1, n);
2016	if (newargs == NULL)
2017		return NULL;
2018
2019	s_object = cache_struct(fmt);
2020	if (s_object == NULL) {
2021		Py_DECREF(newargs);
2022		return NULL;
2023	}
2024    	result = s_unpack_from(s_object, newargs, kwds);
2025	Py_DECREF(newargs);
2026	Py_DECREF(s_object);
2027	return result;
2028}
2029
2030static struct PyMethodDef module_functions[] = {
2031	{"_clearcache",	(PyCFunction)clearcache,	METH_NOARGS, 	clearcache_doc},
2032	{"calcsize",	calcsize,	METH_O, 	calcsize_doc},
2033	{"pack",	pack,		METH_VARARGS, 	pack_doc},
2034	{"pack_into",	pack_into,	METH_VARARGS, 	pack_into_doc},
2035	{"unpack",	unpack,       	METH_VARARGS, 	unpack_doc},
2036	{"unpack_from",	(PyCFunction)unpack_from, 	
2037			METH_VARARGS|METH_KEYWORDS, 	unpack_from_doc},
2038	{NULL,	 NULL}		/* sentinel */
2039};
2040
2041
2042/* Module initialization */
2043
2044PyDoc_STRVAR(module_doc,
2045"Functions to convert between Python values and C structs.\n\
2046Python strings are used to hold the data representing the C struct\n\
2047and also as format strings to describe the layout of data in the C struct.\n\
2048\n\
2049The optional first format char indicates byte order, size and alignment:\n\
2050 @: native order, size & alignment (default)\n\
2051 =: native order, std. size & alignment\n\
2052 <: little-endian, std. size & alignment\n\
2053 >: big-endian, std. size & alignment\n\
2054 !: same as >\n\
2055\n\
2056The remaining chars indicate types of args and must match exactly;\n\
2057these can be preceded by a decimal repeat count:\n\
2058  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n\
2059  h:short; H:unsigned short; i:int; I:unsigned int;\n\
2060  l:long; L:unsigned long; f:float; d:double.\n\
2061Special cases (preceding decimal count indicates length):\n\
2062  s:string (array of char); p: pascal string (with count byte).\n\
2063Special case (only available in native format):\n\
2064  P:an integer type that is wide enough to hold a pointer.\n\
2065Special case (not in native mode unless 'long long' in platform C):\n\
2066  q:long long; Q:unsigned long long\n\
2067Whitespace between formats is ignored.\n\
2068\n\
2069The variable struct.error is an exception raised on errors.\n");
2070
2071PyMODINIT_FUNC
2072init_struct(void)
2073{
2074	PyObject *ver, *m;
2075
2076	ver = PyString_FromString("0.2");
2077	if (ver == NULL)
2078		return;
2079
2080	m = Py_InitModule3("_struct", module_functions, module_doc);
2081	if (m == NULL)
2082		return;
2083
2084	Py_TYPE(&PyStructType) = &PyType_Type;
2085	if (PyType_Ready(&PyStructType) < 0)
2086		return;
2087
2088#ifdef PY_STRUCT_OVERFLOW_MASKING
2089	if (pyint_zero == NULL) {
2090		pyint_zero = PyInt_FromLong(0);
2091		if (pyint_zero == NULL)
2092			return;
2093	}
2094	if (pylong_ulong_mask == NULL) {
2095#if (SIZEOF_LONG == 4)
2096		pylong_ulong_mask = PyLong_FromString("FFFFFFFF", NULL, 16);
2097#else
2098		pylong_ulong_mask = PyLong_FromString("FFFFFFFFFFFFFFFF", NULL, 16);
2099#endif
2100		if (pylong_ulong_mask == NULL)
2101			return;
2102	}
2103
2104#else
2105	/* This speed trick can't be used until overflow masking goes away, because
2106	   native endian always raises exceptions instead of overflow masking. */
2107
2108	/* Check endian and swap in faster functions */
2109	{
2110		int one = 1;
2111		formatdef *native = native_table;
2112		formatdef *other, *ptr;
2113		if ((int)*(unsigned char*)&one)
2114			other = lilendian_table;
2115		else
2116			other = bigendian_table;
2117		/* Scan through the native table, find a matching
2118		   entry in the endian table and swap in the
2119		   native implementations whenever possible
2120		   (64-bit platforms may not have "standard" sizes) */
2121		while (native->format != '\0' && other->format != '\0') {
2122			ptr = other;
2123			while (ptr->format != '\0') {
2124				if (ptr->format == native->format) {
2125					/* Match faster when formats are
2126					   listed in the same order */
2127					if (ptr == other)
2128						other++;
2129					/* Only use the trick if the
2130					   size matches */
2131					if (ptr->size != native->size)
2132						break;
2133					/* Skip float and double, could be
2134					   "unknown" float format */
2135					if (ptr->format == 'd' || ptr->format == 'f')
2136						break;
2137					ptr->pack = native->pack;
2138					ptr->unpack = native->unpack;
2139					break;
2140				}
2141				ptr++;
2142			}
2143			native++;
2144		}
2145	}
2146#endif
2147
2148	/* Add some symbolic constants to the module */
2149	if (StructError == 

Large files files are truncated, but you can click here to view the full file