cpython-lru_cache-weakref: Modules/structmodule.c annotate

annotate Modules/structmodule.c @ 11518:cc412dfd79f7 legacy-trunk

New examples by Tony Ingraldi, using dns-lookup in stead of the funny interslip module.

author	Jack Jansen <jack.jansen@cwi.nl>
date	Fri, 03 Dec 1999 15:15:28 +0000
parents	38023a425e48
children	dc65c5f6ad7c

rev	line source
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1 /***********************************************************
2061 172ba04a5191 Added 1995 to copyright message. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
172ba04a5191 Added 1995 to copyright message. Guido van Rossum <guido@python.org> parents: 1746 diff changeset	3 The Netherlands.
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	4
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	5 All Rights Reserved
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	6
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	7 Permission to use, copy, modify, and distribute this software and its
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	8 documentation for any purpose and without fee is hereby granted,
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	9 provided that the above copyright notice appear in all copies and that
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	10 both that copyright notice and this permission notice appear in
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	11 supporting documentation, and that the names of Stichting Mathematisch
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	12 Centrum or CWI or Corporation for National Research Initiatives or
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	13 CNRI not be used in advertising or publicity pertaining to
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	14 distribution of the software without specific, written prior
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	15 permission.
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	16
4503 65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	17 While CWI is the initial source for this software, a modified version
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	18 is made available by the Corporation for National Research Initiatives
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	19 (CNRI) at the Internet address ftp://ftp.python.org.
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	20
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
65d2d8e67da3 New permission notice, includes CNRI. Guido van Rossum <guido@python.org> parents: 2278 diff changeset	28 PERFORMANCE OF THIS SOFTWARE.
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	29
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	30 ******************************************************************/
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	31
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	32 /* struct module -- pack values into and (out of) strings */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	33
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	34 /* New version supporting byte order, alignment and size options,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	35 character strings, and unsigned numbers */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	36
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	37 static char struct__doc__[] = "\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	38 Functions to convert between Python values and C structs.\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	39 Python strings are used to hold the data representing the C struct\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	40 and also as format strings to describe the layout of data in the C struct.\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	41 \n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	42 The optional first format char indicates byte ordering and alignment:\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	43 @: native w/native alignment(default)\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	44 =: native w/standard alignment\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	45 <: little-endian, std. alignment\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	46 >: big-endian, std. alignment\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	47 !: network, std (same as >)\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	48 \n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	49 The remaining chars indicate types of args and must match exactly;\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	50 these can be preceded by a decimal repeat count:\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	51 x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	52 h:short; H:unsigned short; i:int; I:unsigned int;\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	53 l:long; L:unsigned long; f:float; d:double.\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	54 Special cases (preceding decimal count indicates length):\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	55 s:string (array of char); p: pascal string (w. count byte).\n\
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	56 Special case (only available in native format):\n\
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	57 P:an integer type that is wide enough to hold a pointer.\n\
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	58 Whitespace between formats is ignored.\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	59 \n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	60 The variable struct.error is an exception raised on errors.";
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	61
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	62 #include "Python.h"
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	63 #include "mymath.h"
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	64
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	65 #include <limits.h>
6167 9e432468f756 Ignore whitespace between formats (not internal to a count+format). Guido van Rossum <guido@python.org> parents: 5318 diff changeset	66 #include <ctype.h>
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	67
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	68
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	69 /* Exception */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	70
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	71 static PyObject *StructError;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	72
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	73
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	74 /* Define various structs to figure out the alignments of types */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	75
2278 65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	76 #ifdef __MWERKS__
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	77 /*
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	78 ** XXXX We have a problem here. There are no unique alignment rules
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	79 ** on the PowerPC mac.
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	80 */
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	81 #ifdef __powerc
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	82 #pragma options align=mac68k
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	83 #endif
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	84 #endif /* __MWERKS__ */
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	85
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	86 typedef struct { char c; short x; } s_short;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	87 typedef struct { char c; int x; } s_int;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	88 typedef struct { char c; long x; } s_long;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	89 typedef struct { char c; float x; } s_float;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	90 typedef struct { char c; double x; } s_double;
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	91 typedef struct { char c; void *x; } s_void_p;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	92
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	93 #define SHORT_ALIGN (sizeof(s_short) - sizeof(short))
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	94 #define INT_ALIGN (sizeof(s_int) - sizeof(int))
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	95 #define LONG_ALIGN (sizeof(s_long) - sizeof(long))
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	96 #define FLOAT_ALIGN (sizeof(s_float) - sizeof(float))
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	97 #define DOUBLE_ALIGN (sizeof(s_double) - sizeof(double))
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	98 #define VOID_P_ALIGN (sizeof(s_void_p) - sizeof(void *))
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	99
2278 65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	100 #ifdef __powerc
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	101 #pragma options align=reset
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	102 #endif
65644766158a Quick hack so PowerPC macs can access system structures Jack Jansen <jack.jansen@cwi.nl> parents: 2061 diff changeset	103
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	104 /* Helper routine to get a Python integer and raise the appropriate error
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	105 if it isn't one */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	106
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	107 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	108 get_long(v, p)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	109 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	110 long *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	111 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	112 long x = PyInt_AsLong(v);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	113 if (x == -1 && PyErr_Occurred()) {
8434 ae746eab2a96 get_long(): Use PyErr_ExceptionMatches(...) instead of PyErr_Occurred(...). Fred Drake <fdrake@acm.org> parents: 7982 diff changeset	114 if (PyErr_ExceptionMatches(PyExc_TypeError))
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	115 PyErr_SetString(StructError,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	116 "required argument is not an integer");
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	117 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	118 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	119 *p = x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	120 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	121 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	122
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	123
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	124 /* Same, but handling unsigned long */
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	125
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	126 static int
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	127 get_ulong(v, p)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	128 PyObject *v;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	129 unsigned long *p;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	130 {
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	131 if (PyLong_Check(v)) {
03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	132 unsigned long x = PyLong_AsUnsignedLong(v);
03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	133 if (x == (unsigned long)(-1) && PyErr_Occurred())
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	134 return -1;
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	135 *p = x;
03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	136 return 0;
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	137 }
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	138 else {
03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	139 return get_long(v, (long *)p);
03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	140 }
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	141 }
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	142
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	143
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	144 /* Floating point helpers */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	145
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	146 /* These use ANSI/IEEE Standard 754-1985 (Standard for Binary Floating
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	147 Point Arithmetic). See the following URL:
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	148 http://www.psc.edu/general/software/packages/ieee/ieee.html */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	149
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	150 /* XXX Inf/NaN are not handled quite right (but underflow is!) */
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	151
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	152 static int
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	153 pack_float(x, p, incr)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	154 double x; /* The number to pack */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	155 char p; / Where to pack the high order byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	156 int incr; /* 1 for big-endian; -1 for little-endian */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	157 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	158 int s;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	159 int e;
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	160 double f;
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	161 long fbits;
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	162
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	163 if (x < 0) {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	164 s = 1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	165 x = -x;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	166 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	167 else
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	168 s = 0;
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	169
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	170 f = frexp(x, &e);
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	171
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	172 /* Normalize f to be in the range [1.0, 2.0) */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	173 if (0.5 <= f && f < 1.0) {
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	174 f *= 2.0;
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	175 e--;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	176 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	177 else if (f == 0.0) {
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	178 e = 0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	179 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	180 else {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	181 PyErr_SetString(PyExc_SystemError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	182 "frexp() result out of range");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	183 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	184 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	185
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	186 if (e >= 128) {
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	187 /* XXX 128 itself is reserved for Inf/NaN */
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	188 PyErr_SetString(PyExc_OverflowError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	189 "float too large to pack with f format");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	190 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	191 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	192 else if (e < -126) {
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	193 /* Gradual underflow */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	194 f = ldexp(f, 126 + e);
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	195 e = 0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	196 }
6551 bdd4cb2a83b5 Fix due to Bill Noon for problem discovered by Ken Manheimer: packing Guido van Rossum <guido@python.org> parents: 6367 diff changeset	197 else if (!(e == 0 && f == 0.0)) {
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	198 e += 127;
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	199 f -= 1.0; /* Get rid of leading 1 */
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	200 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	201
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	202 f = 8388608.0; / 2*23 /
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	203 fbits = (long) floor(f + 0.5); /* Round */
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	204
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	205 /* First byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	206 *p = (s<<7) \| (e>>1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	207 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	208
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	209 /* Second byte */
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	210 *p = (char) (((e&1)<<7) \| (fbits>>16));
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	211 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	212
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	213 /* Third byte */
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	214 *p = (fbits>>8) & 0xFF;
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	215 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	216
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	217 /* Fourth byte */
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	218 *p = fbits&0xFF;
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	219
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	220 /* Done */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	221 return 0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	222 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	223
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	224 static int
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	225 pack_double(x, p, incr)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	226 double x; /* The number to pack */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	227 char p; / Where to pack the high order byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	228 int incr; /* 1 for big-endian; -1 for little-endian */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	229 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	230 int s;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	231 int e;
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	232 double f;
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	233 long fhi, flo;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	234
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	235 if (x < 0) {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	236 s = 1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	237 x = -x;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	238 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	239 else
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	240 s = 0;
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	241
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	242 f = frexp(x, &e);
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	243
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	244 /* Normalize f to be in the range [1.0, 2.0) */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	245 if (0.5 <= f && f < 1.0) {
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	246 f *= 2.0;
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	247 e--;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	248 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	249 else if (f == 0.0) {
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	250 e = 0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	251 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	252 else {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	253 PyErr_SetString(PyExc_SystemError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	254 "frexp() result out of range");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	255 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	256 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	257
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	258 if (e >= 1024) {
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	259 /* XXX 1024 itself is reserved for Inf/NaN */
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	260 PyErr_SetString(PyExc_OverflowError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	261 "float too large to pack with d format");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	262 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	263 }
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	264 else if (e < -1022) {
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	265 /* Gradual underflow */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	266 f = ldexp(f, 1022 + e);
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	267 e = 0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	268 }
6551 bdd4cb2a83b5 Fix due to Bill Noon for problem discovered by Ken Manheimer: packing Guido van Rossum <guido@python.org> parents: 6367 diff changeset	269 else if (!(e == 0 && f == 0.0)) {
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	270 e += 1023;
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	271 f -= 1.0; /* Get rid of leading 1 */
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	272 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	273
4861 69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	274 /* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	275 f = 268435456.0; / 2*28 /
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	276 fhi = (long) floor(f); /* Truncate */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	277 f -= (double)fhi;
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	278 f = 16777216.0; / 2*24 /
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	279 flo = (long) floor(f + 0.5); /* Round */
69ca5e3ccc6d Ok, ok, I've fixed gradual underflow on packing too. Guido van Rossum <guido@python.org> parents: 4859 diff changeset	280
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	281 /* First byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	282 *p = (s<<7) \| (e>>4);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	283 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	284
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	285 /* Second byte */
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	286 *p = (char) (((e&0xF)<<4) \| (fhi>>24));
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	287 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	288
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	289 /* Third byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	290 *p = (fhi>>16) & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	291 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	292
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	293 /* Fourth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	294 *p = (fhi>>8) & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	295 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	296
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	297 /* Fifth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	298 *p = fhi & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	299 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	300
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	301 /* Sixth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	302 *p = (flo>>16) & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	303 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	304
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	305 /* Seventh byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	306 *p = (flo>>8) & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	307 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	308
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	309 /* Eighth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	310 *p = flo & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	311 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	312
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	313 /* Done */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	314 return 0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	315 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	316
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	317 static PyObject *
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	318 unpack_float(p, incr)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	319 char p; / Where the high order byte is */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	320 int incr; /* 1 for big-endian; -1 for little-endian */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	321 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	322 int s;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	323 int e;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	324 long f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	325 double x;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	326
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	327 /* First byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	328 s = (*p>>7) & 1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	329 e = (*p & 0x7F) << 1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	330 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	331
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	332 /* Second byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	333 e \|= (*p>>7) & 1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	334 f = (*p & 0x7F) << 16;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	335 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	336
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	337 /* Third byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	338 f \|= (*p & 0xFF) << 8;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	339 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	340
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	341 /* Fourth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	342 f \|= *p & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	343
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	344 x = (double)f / 8388608.0;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	345
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	346 /* XXX This sadly ignores Inf/NaN issues */
4859 ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	347 if (e == 0)
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	348 e = -126;
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	349 else {
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	350 x += 1.0;
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	351 e -= 127;
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	352 }
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	353 x = ldexp(x, e);
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	354
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	355 if (s)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	356 x = -x;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	357
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	358 return PyFloat_FromDouble(x);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	359 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	360
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	361 static PyObject *
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	362 unpack_double(p, incr)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	363 char p; / Where the high order byte is */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	364 int incr; /* 1 for big-endian; -1 for little-endian */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	365 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	366 int s;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	367 int e;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	368 long fhi, flo;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	369 double x;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	370
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	371 /* First byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	372 s = (*p>>7) & 1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	373 e = (*p & 0x7F) << 4;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	374 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	375
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	376 /* Second byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	377 e \|= (*p>>4) & 0xF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	378 fhi = (*p & 0xF) << 24;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	379 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	380
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	381 /* Third byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	382 fhi \|= (*p & 0xFF) << 16;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	383 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	384
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	385 /* Fourth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	386 fhi \|= (*p & 0xFF) << 8;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	387 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	388
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	389 /* Fifth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	390 fhi \|= *p & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	391 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	392
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	393 /* Sixth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	394 flo = (*p & 0xFF) << 16;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	395 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	396
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	397 /* Seventh byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	398 flo \|= (*p & 0xFF) << 8;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	399 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	400
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	401 /* Eighth byte */
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	402 flo \|= *p & 0xFF;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	403 p += incr;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	404
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	405 x = (double)fhi + (double)flo / 16777216.0; /* 2*24 /
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	406 x /= 268435456.0; /* 2*28 /
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	407
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	408 /* XXX This sadly ignores Inf/NaN */
4859 ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	409 if (e == 0)
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	410 e = -1022;
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	411 else {
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	412 x += 1.0;
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	413 e -= 1023;
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	414 }
ab461c762559 Oops -- unpack float/double didn't do the right thing if e==0. Guido van Rossum <guido@python.org> parents: 4858 diff changeset	415 x = ldexp(x, e);
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	416
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	417 if (s)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	418 x = -x;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	419
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	420 return PyFloat_FromDouble(x);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	421 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	422
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	423
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	424 /* The translation function for each format character is table driven */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	425
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	426 typedef struct _formatdef {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	427 char format;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	428 int size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	429 int alignment;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	430 PyObject* (unpack) Py_PROTO((const char ,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	431 const struct _formatdef *));
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	432 int (pack) Py_PROTO((char ,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	433 PyObject *,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	434 const struct _formatdef *));
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	435 } formatdef;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	436
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	437 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	438 nu_char(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	439 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	440 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	441 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	442 return PyString_FromStringAndSize(p, 1);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	443 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	444
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	445 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	446 nu_byte(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	447 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	448 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	449 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	450 return PyInt_FromLong((long) (signed char )p);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	451 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	452
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	453 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	454 nu_ubyte(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	455 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	456 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	457 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	458 return PyInt_FromLong((long) (unsigned char )p);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	459 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	460
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	461 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	462 nu_short(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	463 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	464 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	465 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	466 return PyInt_FromLong((long) (short )p);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	467 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	468
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	469 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	470 nu_ushort(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	471 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	472 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	473 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	474 return PyInt_FromLong((long) (unsigned short )p);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	475 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	476
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	477 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	478 nu_int(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	479 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	480 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	481 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	482 return PyInt_FromLong((long) (int )p);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	483 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	484
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	485 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	486 nu_uint(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	487 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	488 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	489 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	490 unsigned int x = (unsigned int )p;
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	491 return PyLong_FromUnsignedLong((unsigned long)x);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	492 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	493
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	494 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	495 nu_long(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	496 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	497 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	498 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	499 return PyInt_FromLong((long )p);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	500 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	501
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	502 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	503 nu_ulong(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	504 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	505 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	506 {
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	507 return PyLong_FromUnsignedLong((unsigned long )p);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	508 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	509
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	510 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	511 nu_float(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	512 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	513 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	514 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	515 float x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	516 memcpy((char *)&x, p, sizeof(float));
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	517 return PyFloat_FromDouble((double)x);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	518 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	519
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	520 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	521 nu_double(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	522 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	523 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	524 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	525 double x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	526 memcpy((char *)&x, p, sizeof(double));
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	527 return PyFloat_FromDouble(x);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	528 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	529
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	530 static PyObject *
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	531 nu_void_p(p, f)
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	532 const char *p;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	533 const formatdef *f;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	534 {
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	535 return PyLong_FromVoidPtr((void *)p);
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	536 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	537
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	538 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	539 np_byte(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	540 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	541 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	542 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	543 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	544 long x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	545 if (get_long(v, &x) < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	546 return -1;
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	547 *p = (char)x;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	548 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	549 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	550
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	551 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	552 np_char(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	553 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	554 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	555 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	556 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	557 if (!PyString_Check(v) \|\| PyString_Size(v) != 1) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	558 PyErr_SetString(StructError,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	559 "char format require string of length 1");
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	560 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	561 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	562 p = PyString_AsString(v);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	563 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	564 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	565
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	566 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	567 np_short(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	568 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	569 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	570 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	571 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	572 long x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	573 if (get_long(v, &x) < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	574 return -1;
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	575 * (short *)p = (short)x;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	576 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	577 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	578
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	579 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	580 np_int(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	581 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	582 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	583 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	584 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	585 long x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	586 if (get_long(v, &x) < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	587 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	588 * (int *)p = x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	589 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	590 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	591
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	592 static int
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	593 np_uint(p, v, f)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	594 char *p;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	595 PyObject *v;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	596 const formatdef *f;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	597 {
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	598 unsigned long x;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	599 if (get_ulong(v, &x) < 0)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	600 return -1;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	601 * (unsigned int *)p = x;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	602 return 0;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	603 }
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	604
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	605 static int
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	606 np_long(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	607 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	608 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	609 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	610 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	611 long x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	612 if (get_long(v, &x) < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	613 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	614 * (long *)p = x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	615 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	616 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	617
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	618 static int
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	619 np_ulong(p, v, f)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	620 char *p;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	621 PyObject *v;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	622 const formatdef *f;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	623 {
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	624 unsigned long x;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	625 if (get_ulong(v, &x) < 0)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	626 return -1;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	627 * (unsigned long *)p = x;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	628 return 0;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	629 }
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	630
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	631 static int
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	632 np_float(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	633 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	634 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	635 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	636 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	637 float x = (float)PyFloat_AsDouble(v);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	638 if (x == -1 && PyErr_Occurred()) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	639 PyErr_SetString(StructError,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	640 "required argument is not a float");
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	641 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	642 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	643 memcpy(p, (char *)&x, sizeof(float));
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	644 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	645 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	646
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	647 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	648 np_double(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	649 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	650 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	651 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	652 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	653 double x = PyFloat_AsDouble(v);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	654 if (x == -1 && PyErr_Occurred()) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	655 PyErr_SetString(StructError,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	656 "required argument is not a float");
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	657 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	658 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	659 memcpy(p, (char *)&x, sizeof(double));
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	660 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	661 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	662
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	663 static int
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	664 np_void_p(p, v, f)
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	665 char *p;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	666 PyObject *v;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	667 const formatdef *f;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	668 {
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	669 void *x = PyLong_AsVoidPtr(v);
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	670 if (x == NULL && PyErr_Occurred()) {
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	671 /* ### hrm. PyLong_AsVoidPtr raises SystemError */
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	672 if (PyErr_ExceptionMatches(PyExc_TypeError))
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	673 PyErr_SetString(StructError,
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	674 "required argument is not an integer");
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	675 return -1;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	676 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	677 (void *)p = x;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	678 return 0;
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	679 }
17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	680
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	681 static formatdef native_table[] = {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	682 {'x', sizeof(char), 0, NULL},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	683 {'b', sizeof(char), 0, nu_byte, np_byte},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	684 {'B', sizeof(char), 0, nu_ubyte, np_byte},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	685 {'c', sizeof(char), 0, nu_char, np_char},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	686 {'s', sizeof(char), 0, NULL},
6241 ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	687 {'p', sizeof(char), 0, NULL},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	688 {'h', sizeof(short), SHORT_ALIGN, nu_short, np_short},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	689 {'H', sizeof(short), SHORT_ALIGN, nu_ushort, np_short},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	690 {'i', sizeof(int), INT_ALIGN, nu_int, np_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	691 {'I', sizeof(int), INT_ALIGN, nu_uint, np_uint},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	692 {'l', sizeof(long), LONG_ALIGN, nu_long, np_long},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	693 {'L', sizeof(long), LONG_ALIGN, nu_ulong, np_ulong},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	694 {'f', sizeof(float), FLOAT_ALIGN, nu_float, np_float},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	695 {'d', sizeof(double), DOUBLE_ALIGN, nu_double, np_double},
9123 17d0c51e0887 Patches from Greg Stein to support 'P' format in struct module's Guido van Rossum <guido@python.org> parents: 8580 diff changeset	696 {'P', sizeof(void *), VOID_P_ALIGN, nu_void_p, np_void_p},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	697 {0}
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	698 };
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	699
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	700 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	701 bu_int(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	702 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	703 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	704 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	705 long x = 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	706 int i = f->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	707 do {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	708 x = (x<<8) \| (*p++ & 0xFF);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	709 } while (--i > 0);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	710 i = 8*(sizeof(long) - f->size);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	711 if (i) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	712 x <<= i;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	713 x >>= i;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	714 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	715 return PyInt_FromLong(x);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	716 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	717
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	718 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	719 bu_uint(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	720 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	721 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	722 {
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	723 unsigned long x = 0;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	724 int i = f->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	725 do {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	726 x = (x<<8) \| (*p++ & 0xFF);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	727 } while (--i > 0);
8580 1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	728 if (f->size >= 4)
1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	729 return PyLong_FromUnsignedLong(x);
1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	730 else
1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	731 return PyInt_FromLong((long)x);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	732 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	733
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	734 static PyObject *
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	735 bu_float(p, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	736 const char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	737 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	738 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	739 return unpack_float(p, 1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	740 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	741
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	742 static PyObject *
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	743 bu_double(p, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	744 const char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	745 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	746 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	747 return unpack_double(p, 1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	748 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	749
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	750 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	751 bp_int(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	752 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	753 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	754 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	755 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	756 long x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	757 int i;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	758 if (get_long(v, &x) < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	759 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	760 i = f->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	761 do {
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	762 p[--i] = (char)x;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	763 x >>= 8;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	764 } while (i > 0);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	765 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	766 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	767
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	768 static int
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	769 bp_uint(p, v, f)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	770 char *p;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	771 PyObject *v;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	772 const formatdef *f;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	773 {
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	774 unsigned long x;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	775 int i;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	776 if (get_ulong(v, &x) < 0)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	777 return -1;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	778 i = f->size;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	779 do {
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	780 p[--i] = (char)x;
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	781 x >>= 8;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	782 } while (i > 0);
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	783 return 0;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	784 }
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	785
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	786 static int
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	787 bp_float(p, v, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	788 char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	789 PyObject *v;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	790 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	791 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	792 double x = PyFloat_AsDouble(v);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	793 if (x == -1 && PyErr_Occurred()) {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	794 PyErr_SetString(StructError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	795 "required argument is not a float");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	796 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	797 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	798 return pack_float(x, p, 1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	799 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	800
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	801 static int
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	802 bp_double(p, v, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	803 char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	804 PyObject *v;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	805 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	806 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	807 double x = PyFloat_AsDouble(v);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	808 if (x == -1 && PyErr_Occurred()) {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	809 PyErr_SetString(StructError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	810 "required argument is not a float");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	811 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	812 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	813 return pack_double(x, p, 1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	814 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	815
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	816 static formatdef bigendian_table[] = {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	817 {'x', 1, 0, NULL},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	818 {'b', 1, 0, bu_int, bp_int},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	819 {'B', 1, 0, bu_uint, bp_int},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	820 {'c', 1, 0, nu_char, np_char},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	821 {'s', 1, 0, NULL},
6241 ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	822 {'p', 1, 0, NULL},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	823 {'h', 2, 0, bu_int, bp_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	824 {'H', 2, 0, bu_uint, bp_uint},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	825 {'i', 4, 0, bu_int, bp_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	826 {'I', 4, 0, bu_uint, bp_uint},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	827 {'l', 4, 0, bu_int, bp_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	828 {'L', 4, 0, bu_uint, bp_uint},
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	829 {'f', 4, 0, bu_float, bp_float},
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	830 {'d', 8, 0, bu_double, bp_double},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	831 {0}
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	832 };
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	833
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	834 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	835 lu_int(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	836 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	837 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	838 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	839 long x = 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	840 int i = f->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	841 do {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	842 x = (x<<8) \| (p[--i] & 0xFF);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	843 } while (i > 0);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	844 i = 8*(sizeof(long) - f->size);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	845 if (i) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	846 x <<= i;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	847 x >>= i;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	848 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	849 return PyInt_FromLong(x);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	850 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	851
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	852 static PyObject *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	853 lu_uint(p, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	854 const char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	855 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	856 {
4874 03bcdd22f6a4 Changed the ``add/sub_offset'' hacks for dealing with C's unsigned Guido van Rossum <guido@python.org> parents: 4867 diff changeset	857 unsigned long x = 0;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	858 int i = f->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	859 do {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	860 x = (x<<8) \| (p[--i] & 0xFF);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	861 } while (i > 0);
8580 1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	862 if (f->size >= 4)
1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	863 return PyLong_FromUnsignedLong(x);
1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	864 else
1ca6895024d9 Unsigned 1 and 2 byte sized formats shouldn't result in long integer values! Guido van Rossum <guido@python.org> parents: 8434 diff changeset	865 return PyInt_FromLong((long)x);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	866 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	867
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	868 static PyObject *
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	869 lu_float(p, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	870 const char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	871 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	872 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	873 return unpack_float(p+3, -1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	874 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	875
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	876 static PyObject *
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	877 lu_double(p, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	878 const char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	879 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	880 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	881 return unpack_double(p+7, -1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	882 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	883
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	884 static int
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	885 lp_int(p, v, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	886 char *p;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	887 PyObject *v;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	888 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	889 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	890 long x;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	891 int i;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	892 if (get_long(v, &x) < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	893 return -1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	894 i = f->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	895 do {
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	896 *p++ = (char)x;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	897 x >>= 8;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	898 } while (--i > 0);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	899 return 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	900 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	901
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	902 static int
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	903 lp_uint(p, v, f)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	904 char *p;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	905 PyObject *v;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	906 const formatdef *f;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	907 {
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	908 unsigned long x;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	909 int i;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	910 if (get_ulong(v, &x) < 0)
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	911 return -1;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	912 i = f->size;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	913 do {
5318 2c4b802a3b5d Keep Microsoft VC happy. Guido van Rossum <guido@python.org> parents: 4874 diff changeset	914 *p++ = (char)x;
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	915 x >>= 8;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	916 } while (--i > 0);
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	917 return 0;
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	918 }
972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	919
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	920 static int
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	921 lp_float(p, v, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	922 char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	923 PyObject *v;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	924 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	925 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	926 double x = PyFloat_AsDouble(v);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	927 if (x == -1 && PyErr_Occurred()) {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	928 PyErr_SetString(StructError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	929 "required argument is not a float");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	930 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	931 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	932 return pack_float(x, p+3, -1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	933 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	934
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	935 static int
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	936 lp_double(p, v, f)
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	937 char *p;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	938 PyObject *v;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	939 const formatdef *f;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	940 {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	941 double x = PyFloat_AsDouble(v);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	942 if (x == -1 && PyErr_Occurred()) {
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	943 PyErr_SetString(StructError,
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	944 "required argument is not a float");
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	945 return -1;
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	946 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	947 return pack_double(x, p+7, -1);
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	948 }
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	949
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	950 static formatdef lilendian_table[] = {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	951 {'x', 1, 0, NULL},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	952 {'b', 1, 0, lu_int, lp_int},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	953 {'B', 1, 0, lu_uint, lp_int},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	954 {'c', 1, 0, nu_char, np_char},
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	955 {'s', 1, 0, NULL},
6241 ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	956 {'p', 1, 0, NULL},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	957 {'h', 2, 0, lu_int, lp_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	958 {'H', 2, 0, lu_uint, lp_uint},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	959 {'i', 4, 0, lu_int, lp_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	960 {'I', 4, 0, lu_uint, lp_uint},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	961 {'l', 4, 0, lu_int, lp_int},
4846 972026d47274 Added better handling of unsigned longs -- a Python long returned by Guido van Rossum <guido@python.org> parents: 4842 diff changeset	962 {'L', 4, 0, lu_uint, lp_uint},
4858 198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	963 {'f', 4, 0, lu_float, lp_float},
198989ee36d5 Support float and double in non-native formats. Guido van Rossum <guido@python.org> parents: 4846 diff changeset	964 {'d', 8, 0, lu_double, lp_double},
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	965 {0}
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	966 };
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	967
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	968
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	969 static const formatdef *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	970 whichtable(pfmt)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	971 const char **pfmt;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	972 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	973 const char fmt = (pfmt)++; /* May be backed out of later */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	974 switch (*fmt) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	975 case '<':
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	976 return lilendian_table;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	977 case '>':
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	978 case '!': /* Network byte order is big-endian */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	979 return bigendian_table;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	980 case '=': { /* Host byte order -- different from native in aligment! */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	981 int n = 1;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	982 char p = (char ) &n;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	983 if (*p == 1)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	984 return lilendian_table;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	985 else
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	986 return bigendian_table;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	987 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	988 default:
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	989 --pfmt; / Back out of pointer increment */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	990 /* Fall through */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	991 case '@':
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	992 return native_table;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	993 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	994 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	995
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	996
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	997 /* Get the table entry for a format code */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	998
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	999 static const formatdef *
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1000 getentry(c, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1001 int c;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1002 const formatdef *f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1003 {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1004 for (; f->format != '\0'; f++) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1005 if (f->format == c) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1006 return f;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1007 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1008 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1009 PyErr_SetString(StructError, "bad char in struct format");
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1010 return NULL;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1011 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1012
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1013
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1014 /* Align a size according to a format code */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1015
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1016 static int
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1017 align(size, c, e)
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1018 int size;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1019 int c;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1020 const formatdef *e;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1021 {
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1022 if (e->format == c) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1023 if (e->alignment) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1024 size = ((size + e->alignment - 1)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1025 / e->alignment)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1026 * e->alignment;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1027 }
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1028 }
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1029 return size;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1030 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1031
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1032
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1033 /* calculate the size of a format string */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1034
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1035 static int
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1036 calcsize(fmt, f)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1037 const char *fmt;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1038 const formatdef *f;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1039 {
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1040 const formatdef *e;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1041 const char *s;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1042 char c;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1043 int size, num, itemsize, x;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1044
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1045 s = fmt;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1046 size = 0;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1047 while ((c = *s++) != '\0') {
7982 a909a2869ac5 Make new gcc -Wall happy Guido van Rossum <guido@python.org> parents: 6927 diff changeset	1048 if (isspace((int)c))
6167 9e432468f756 Ignore whitespace between formats (not internal to a count+format). Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1049 continue;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1050 if ('0' <= c && c <= '9') {
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1051 num = c - '0';
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1052 while ('0' <= (c = *s++) && c <= '9') {
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1053 x = num*10 + (c - '0');
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1054 if (x/10 != num) {
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1055 PyErr_SetString(
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1056 StructError,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1057 "overflow in item count");
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1058 return -1;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1059 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1060 num = x;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1061 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1062 if (c == '\0')
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1063 break;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1064 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1065 else
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1066 num = 1;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1067
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1068 e = getentry(c, f);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1069 if (e == NULL)
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1070 return -1;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1071 itemsize = e->size;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1072 size = align(size, c, e);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1073 x = num * itemsize;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1074 size += x;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1075 if (x/itemsize != num \|\| size < 0) {
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1076 PyErr_SetString(StructError,
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1077 "total struct size too long");
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1078 return -1;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1079 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1080 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1081
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1082 return size;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1083 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1084
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1085
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1086 static char calcsize__doc__[] = "\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1087 calcsize(fmt) -> int\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1088 Return size of C struct described by format string fmt.\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1089 See struct.__doc__ for more on format strings.";
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1090
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1091 static PyObject *
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1092 struct_calcsize(self, args)
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1093 PyObject self; / Not used */
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1094 PyObject *args;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1095 {
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1096 char *fmt;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1097 const formatdef *f;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1098 int size;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1099
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1100 if (!PyArg_ParseTuple(args, "s", &fmt))
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1101 return NULL;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1102 f = whichtable(&fmt);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1103 size = calcsize(fmt, f);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1104 if (size < 0)
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1105 return NULL;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1106 return PyInt_FromLong((long)size);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1107 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1108
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1109
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1110 static char pack__doc__[] = "\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1111 pack(fmt, v1, v2, ...) -> string\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1112 Return string containing values v1, v2, ... packed according to fmt.\n\
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1113 See struct.__doc__ for more on format strings.";
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1114
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1115 static PyObject *
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1116 struct_pack(self, args)
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1117 PyObject self; / Not used */
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1118 PyObject *args;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1119 {
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1120 const formatdef f, e;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1121 PyObject format, result, *v;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1122 char *fmt;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1123 int size, num;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1124 int i, n;
4867 e3f2ab0b0aa1 Fill pad bytes with zeros (fixing a bug dating from the very first version!). Guido van Rossum <guido@python.org> parents: 4865 diff changeset	1125 char s, res, restart, nres;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1126 char c;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1127
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1128 if (args == NULL \|\| !PyTuple_Check(args) \|\|
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1129 (n = PyTuple_Size(args)) < 1)
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1130 {
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1131 PyErr_BadArgument();
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1132 return NULL;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1133 }
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1134 format = PyTuple_GetItem(args, 0);
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1135 if (!PyArg_Parse(format, "s", &fmt))
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1136 return NULL;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1137 f = whichtable(&fmt);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1138 size = calcsize(fmt, f);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1139 if (size < 0)
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1140 return NULL;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1141 result = PyString_FromStringAndSize((char *)NULL, size);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1142 if (result == NULL)
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1143 return NULL;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1144
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1145 s = fmt;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1146 i = 1;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1147 res = restart = PyString_AsString(result);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1148
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1149 while ((c = *s++) != '\0') {
7982 a909a2869ac5 Make new gcc -Wall happy Guido van Rossum <guido@python.org> parents: 6927 diff changeset	1150 if (isspace((int)c))
6167 9e432468f756 Ignore whitespace between formats (not internal to a count+format). Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1151 continue;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1152 if ('0' <= c && c <= '9') {
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1153 num = c - '0';
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1154 while ('0' <= (c = *s++) && c <= '9')
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1155 num = num*10 + (c - '0');
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1156 if (c == '\0')
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1157 break;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1158 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1159 else
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1160 num = 1;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1161
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1162 e = getentry(c, f);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1163 if (e == NULL)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1164 goto fail;
4867 e3f2ab0b0aa1 Fill pad bytes with zeros (fixing a bug dating from the very first version!). Guido van Rossum <guido@python.org> parents: 4865 diff changeset	1165 nres = restart + align((int)(res-restart), c, e);
e3f2ab0b0aa1 Fill pad bytes with zeros (fixing a bug dating from the very first version!). Guido van Rossum <guido@python.org> parents: 4865 diff changeset	1166 /* Fill padd bytes with zeros */
e3f2ab0b0aa1 Fill pad bytes with zeros (fixing a bug dating from the very first version!). Guido van Rossum <guido@python.org> parents: 4865 diff changeset	1167 while (res < nres)
e3f2ab0b0aa1 Fill pad bytes with zeros (fixing a bug dating from the very first version!). Guido van Rossum <guido@python.org> parents: 4865 diff changeset	1168 *res++ = '\0';
4842 84679f7bbe6d Fix the first bugs... treatment of 0 count was wrong, and memchr() Guido van Rossum <guido@python.org> parents: 4841 diff changeset	1169 if (num == 0 && c != 's')
84679f7bbe6d Fix the first bugs... treatment of 0 count was wrong, and memchr() Guido van Rossum <guido@python.org> parents: 4841 diff changeset	1170 continue;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1171 do {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1172 if (c == 'x') {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1173 /* doesn't consume arguments */
4842 84679f7bbe6d Fix the first bugs... treatment of 0 count was wrong, and memchr() Guido van Rossum <guido@python.org> parents: 4841 diff changeset	1174 memset(res, '\0', num);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1175 res += num;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1176 break;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1177 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1178 if (i >= n) {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1179 PyErr_SetString(StructError,
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1180 "insufficient arguments to pack");
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1181 goto fail;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1182 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1183 v = PyTuple_GetItem(args, i++);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1184 if (v == NULL)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1185 goto fail;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1186 if (c == 's') {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1187 /* num is string size, not repeat count */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1188 int n;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1189 if (!PyString_Check(v)) {
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1190 PyErr_SetString(StructError,
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1191 "argument for 's' must be a string");
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1192 goto fail;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1193 }
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1194 n = PyString_Size(v);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1195 if (n > num)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1196 n = num;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1197 if (n > 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1198 memcpy(res, PyString_AsString(v), n);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1199 if (n < num)
4842 84679f7bbe6d Fix the first bugs... treatment of 0 count was wrong, and memchr() Guido van Rossum <guido@python.org> parents: 4841 diff changeset	1200 memset(res+n, '\0', num-n);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1201 res += num;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1202 break;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1203 }
6241 ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1204 else if (c == 'p') {
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1205 /* num is string size + 1,
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1206 to fit in the count byte */
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1207 int n;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1208 num--; /* now num is max string size */
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1209 if (!PyString_Check(v)) {
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1210 PyErr_SetString(StructError,
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1211 "argument for 'p' must be a string");
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1212 goto fail;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1213 }
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1214 n = PyString_Size(v);
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1215 if (n > num)
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1216 n = num;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1217 if (n > 0)
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1218 memcpy(res+1, PyString_AsString(v), n);
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1219 if (n < num)
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1220 /* no real need, just to be nice */
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1221 memset(res+1+n, '\0', num-n);
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1222 res++ = n; / store the length byte */
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1223 res += num;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1224 break;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1225 }
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1226 else {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1227 if (e->pack(res, v, e) < 0)
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1228 goto fail;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1229 res += e->size;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1230 }
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1231 } while (--num > 0);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1232 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1233
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1234 if (i < n) {
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1235 PyErr_SetString(StructError,
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1236 "too many arguments for pack format");
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1237 goto fail;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1238 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1239
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1240 return result;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1241
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1242 fail:
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1243 Py_DECREF(result);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1244 return NULL;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1245 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1246
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1247
6927 52125ce376a4 Oops, left in a non-standard multi-line doc string that GCC finds okay Guido van Rossum <guido@python.org> parents: 6922 diff changeset	1248 static char unpack__doc__[] = "\
52125ce376a4 Oops, left in a non-standard multi-line doc string that GCC finds okay Guido van Rossum <guido@python.org> parents: 6922 diff changeset	1249 unpack(fmt, string) -> (v1, v2, ...)\n\
52125ce376a4 Oops, left in a non-standard multi-line doc string that GCC finds okay Guido van Rossum <guido@python.org> parents: 6922 diff changeset	1250 Unpack the string, containing packed C structure data, according\n\
52125ce376a4 Oops, left in a non-standard multi-line doc string that GCC finds okay Guido van Rossum <guido@python.org> parents: 6922 diff changeset	1251 to fmt. Requires len(string)==calcsize(fmt).\n\
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1252 See struct.__doc__ for more on format strings.";
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1253
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1254 static PyObject *
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1255 struct_unpack(self, args)
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1256 PyObject self; / Not used */
cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1257 PyObject *args;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1258 {
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1259 const formatdef f, e;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1260 char str, start, fmt, s;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1261 char c;
4865 f5073e24147c Scratch the ears of gcc -Wall. Barry Warsaw <barry@python.org> parents: 4861 diff changeset	1262 int len, size, num;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1263 PyObject res, v;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1264
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1265 if (!PyArg_ParseTuple(args, "ss#", &fmt, &start, &len))
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1266 return NULL;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1267 f = whichtable(&fmt);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1268 size = calcsize(fmt, f);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1269 if (size < 0)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1270 return NULL;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1271 if (size != len) {
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1272 PyErr_SetString(StructError,
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1273 "unpack str size does not match format");
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1274 return NULL;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1275 }
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1276 res = PyList_New(0);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1277 if (res == NULL)
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1278 return NULL;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1279 str = start;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1280 s = fmt;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1281 while ((c = *s++) != '\0') {
7982 a909a2869ac5 Make new gcc -Wall happy Guido van Rossum <guido@python.org> parents: 6927 diff changeset	1282 if (isspace((int)c))
6167 9e432468f756 Ignore whitespace between formats (not internal to a count+format). Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1283 continue;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1284 if ('0' <= c && c <= '9') {
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1285 num = c - '0';
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1286 while ('0' <= (c = *s++) && c <= '9')
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1287 num = num*10 + (c - '0');
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1288 if (c == '\0')
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1289 break;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1290 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1291 else
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1292 num = 1;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1293
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1294 e = getentry(c, f);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1295 if (e == NULL)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1296 goto fail;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1297 str = start + align((int)(str-start), c, e);
4842 84679f7bbe6d Fix the first bugs... treatment of 0 count was wrong, and memchr() Guido van Rossum <guido@python.org> parents: 4841 diff changeset	1298 if (num == 0 && c != 's')
84679f7bbe6d Fix the first bugs... treatment of 0 count was wrong, and memchr() Guido van Rossum <guido@python.org> parents: 4841 diff changeset	1299 continue;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1300
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1301 do {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1302 if (c == 'x') {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1303 str += num;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1304 break;
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1305 }
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1306 if (c == 's') {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1307 /* num is string size, not repeat count */
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1308 v = PyString_FromStringAndSize(str, num);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1309 if (v == NULL)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1310 goto fail;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1311 str += num;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1312 num = 0;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1313 }
6241 ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1314 else if (c == 'p') {
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1315 /* num is string buffer size,
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1316 not repeat count */
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1317 int n = (unsigned char)str;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1318 /* first byte (unsigned) is string size */
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1319 if (n >= num)
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1320 n = num-1;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1321 v = PyString_FromStringAndSize(str+1, n);
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1322 if (v == NULL)
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1323 goto fail;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1324 str += num;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1325 num = 0;
ab64344e87db Contribution by Hannu Krosing (with some changes). Guido van Rossum <guido@python.org> parents: 6167 diff changeset	1326 }
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1327 else {
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1328 v = e->unpack(str, e);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1329 if (v == NULL)
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1330 goto fail;
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1331 str += e->size;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1332 }
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1333 if (v == NULL \|\| PyList_Append(res, v) < 0)
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1334 goto fail;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1335 Py_DECREF(v);
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1336 } while (--num > 0);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1337 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1338
4841 a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1339 v = PyList_AsTuple(res);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1340 Py_DECREF(res);
a7b9c7c81337 Pretty much rewritten to fulfull several long-standing wishes: Guido van Rossum <guido@python.org> parents: 4705 diff changeset	1341 return v;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1342
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1343 fail:
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1344 Py_DECREF(res);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1345 return NULL;
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1346 }
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1347
976 31b018bda7e2 unpack() now returns a tuple, not a list Guido van Rossum <guido@python.org> parents: 960 diff changeset	1348
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1349 /* List of functions */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1350
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1351 static PyMethodDef struct_methods[] = {
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1352 {"calcsize", struct_calcsize, METH_VARARGS, calcsize__doc__},
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1353 {"pack", struct_pack, METH_VARARGS, pack__doc__},
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1354 {"unpack", struct_unpack, METH_VARARGS, unpack__doc__},
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1355 {NULL, NULL} /* sentinel */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1356 };
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1357
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1358
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1359 /* Module initialization */
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1360
9588 38023a425e48 Add DL_EXPORT() to all modules that could possibly be used Guido van Rossum <guido@python.org> parents: 9123 diff changeset	1361 DL_EXPORT(void)
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1362 initstruct()
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1363 {
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1364 PyObject m, d;
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1365
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1366 /* Create the module and add the functions */
6922 7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1367 m = Py_InitModule4("struct", struct_methods, struct__doc__,
7629c4d985bc Added doc strings, suggested by Charles G. Waldman (but massaged quite a bit). Guido van Rossum <guido@python.org> parents: 6551 diff changeset	1368 (PyObject*)NULL, PYTHON_API_VERSION);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1369
7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1370 /* Add some symbolic constants to the module */
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1371 d = PyModule_GetDict(m);
6367 2c29b8982643 Apply two changes, systematically: Guido van Rossum <guido@python.org> parents: 6241 diff changeset	1372 StructError = PyErr_NewException("struct.error", NULL, NULL);
2c29b8982643 Apply two changes, systematically: Guido van Rossum <guido@python.org> parents: 6241 diff changeset	1373 if (StructError == NULL)
2c29b8982643 Apply two changes, systematically: Guido van Rossum <guido@python.org> parents: 6241 diff changeset	1374 return;
4705 cc525182bbb1 Renamed. Barry Warsaw <barry@python.org> parents: 4503 diff changeset	1375 PyDict_SetItemString(d, "error", StructError);
960 7d3a053c6765 struct: pack/unpack binary structs; fcntl: fcntl(), ioctl(). Guido van Rossum <guido@python.org> parents: diff changeset	1376 }

Mercurial > cpython-lru_cache-weakref

annotate Modules/structmodule.c @ 11518:cc412dfd79f7 legacy-trunk