mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-01 07:33:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

revert #1493701

Browse source
This commit is contained in:
Bob Ippolito 2006-05-23 19:09:51 +00:00
parent 9deeeef092
commit 27abce5ba8
5 changed files with 287 additions and 427 deletions
Download patch file Download diff file Expand all files Collapse all files

76
Lib/struct.py
View file

@ -1,76 +0,0 @@
"""
Functions to convert between Python values and C structs.
Python strings are used to hold the data representing the C struct
and also as format strings to describe the layout of data in the C struct.
The optional first format char indicates byte order, size and alignment:
@: native order, size & alignment (default)
=: native order, std. size & alignment
<: little-endian, std. size & alignment
>: big-endian, std. size & alignment
!: same as >
The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
h:short; H:unsigned short; i:int; I:unsigned int;
l:long; L:unsigned long; f:float; d:double.
Special cases (preceding decimal count indicates length):
s:string (array of char); p: pascal string (with count byte).
Special case (only available in native format):
P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
q:long long; Q:unsigned long long
Whitespace between formats is ignored.
The variable struct.error is an exception raised on errors.
"""
__version__ = '0.1'
from _struct import Struct, error
_MAXCACHE = 100
_cache = {}
def _compile(fmt):
# Internal: compile struct pattern
if len(_cache) >= _MAXCACHE:
_cache.clear()
s = Struct(fmt)
_cache[fmt] = s
return s
def calcsize(fmt):
"""
Return size of C struct described by format string fmt.
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return o.size
def pack(fmt, *args):
"""
Return string containing values v1, v2, ... packed according to fmt.
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return o.pack(*args)
def unpack(fmt, s):
"""
Unpack the string, containing packed C structure data, according
to fmt. Requires len(string)==calcsize(fmt).
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return o.unpack(s)

2
Misc/NEWS
View file

@ -45,8 +45,6 @@ Core and builtins
Extension Modules Extension Modules
----------------- -----------------
- Patch #1493701: performance enhancements for struct module.
- Patch #1490224: time.altzone is now set correctly on Cygwin. - Patch #1490224: time.altzone is now set correctly on Cygwin.
- Patch #1435422: zlib's compress and decompress objects now have a - Patch #1435422: zlib's compress and decompress objects now have a

2
Modules/Setup.dist
View file

@ -167,7 +167,7 @@ GLHACK=-Dclear=__GLclear
#array arraymodule.c # array objects #array arraymodule.c # array objects
#cmath cmathmodule.c # -lm # complex math library functions #cmath cmathmodule.c # -lm # complex math library functions
#math mathmodule.c # -lm # math library functions, e.g. sin() #math mathmodule.c # -lm # math library functions, e.g. sin()
#_struct _struct.c # binary structure packing/unpacking #struct structmodule.c # binary structure packing/unpacking
#time timemodule.c # -lm # time operations and variables #time timemodule.c # -lm # time operations and variables
#operator operator.c # operator.add() and similar goodies #operator operator.c # operator.add() and similar goodies
#_weakref _weakref.c # basic weak reference support #_weakref _weakref.c # basic weak reference support

632
Modules/_struct.c → Modules/structmodule.c
View file

@ -4,51 +4,34 @@
character strings, and unsigned numbers */ character strings, and unsigned numbers */
#include "Python.h" #include "Python.h"
#include "structseq.h"
#include "structmember.h"
#include <ctype.h> #include <ctype.h>
PyDoc_STRVAR(struct__doc__,
/* compatibility macros */ "Functions to convert between Python values and C structs.\n\
#if (PY_VERSION_HEX < 0x02050000) Python strings are used to hold the data representing the C struct\n\
typedef int Py_ssize_t; and also as format strings to describe the layout of data in the C struct.\n\
#endif \n\
The optional first format char indicates byte order, size and alignment:\n\
@: native order, size & alignment (default)\n\
=: native order, std. size & alignment\n\
/* The translation function for each format character is table driven */ <: little-endian, std. size & alignment\n\
>: big-endian, std. size & alignment\n\
typedef struct _formatdef { !: same as >\n\
char format; \n\
int size; The remaining chars indicate types of args and must match exactly;\n\
int alignment; these can be preceded by a decimal repeat count:\n\
PyObject* (*unpack)(const char *, x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n\
const struct _formatdef *); h:short; H:unsigned short; i:int; I:unsigned int;\n\
int (*pack)(char *, PyObject *, l:long; L:unsigned long; f:float; d:double.\n\
const struct _formatdef *); Special cases (preceding decimal count indicates length):\n\
} formatdef; s:string (array of char); p: pascal string (with count byte).\n\
Special case (only available in native format):\n\
typedef struct _formatcode { P:an integer type that is wide enough to hold a pointer.\n\
const struct _formatdef *fmtdef; Special case (not in native mode unless 'long long' in platform C):\n\
int offset; q:long long; Q:unsigned long long\n\
int repeat; Whitespace between formats is ignored.\n\
} formatcode; \n\
The variable struct.error is an exception raised on errors.");
/* Struct object interface */
typedef struct {
PyObject_HEAD
int s_size;
int s_len;
formatcode *s_codes;
PyObject *s_format;
PyObject *weakreflist; /* List of weak references */
} PyStructObject;
PyAPI_DATA(PyTypeObject) PyStruct_Type;
#define PyStruct_Check(op) PyObject_TypeCheck(op, &PyStruct_Type)
#define PyStruct_CheckExact(op) ((op)->ob_type == &PyStruct_Type)
/* Exception */ /* Exception */
@ -218,6 +201,18 @@ unpack_double(const char *p, /* start of 8-byte string */
} }
/* The translation function for each format character is table driven */
typedef struct _formatdef {
char format;
int size;
int alignment;
PyObject* (*unpack)(const char *,
const struct _formatdef *);
int (*pack)(char *, PyObject *,
const struct _formatdef *);
} formatdef;
/* A large number of small routines follow, with names of the form /* A large number of small routines follow, with names of the form
[bln][up]_TYPE [bln][up]_TYPE
@ -954,25 +949,15 @@ align(int size, int c, const formatdef *e)
/* calculate the size of a format string */ /* calculate the size of a format string */
static int static int
prepare_s(PyStructObject *self) calcsize(const char *fmt, const formatdef *f)
{ {
const formatdef *f;
const formatdef *e; const formatdef *e;
formatcode *codes;
const char *s; const char *s;
const char *fmt;
char c; char c;
int size, len, numcodes, num, itemsize, x; int size, num, itemsize, x;
fmt = PyString_AS_STRING(self->s_format);
f = whichtable((char **)&fmt);
s = fmt; s = fmt;
size = 0; size = 0;
len = 0;
numcodes = 0;
while ((c = *s++) != '\0') { while ((c = *s++) != '\0') {
if (isspace(Py_CHARMASK(c))) if (isspace(Py_CHARMASK(c)))
continue; continue;
@ -997,15 +982,6 @@ prepare_s(PyStructObject *self)
e = getentry(c, f); e = getentry(c, f);
if (e == NULL) if (e == NULL)
return -1; return -1;
switch (c) {
case 's': /* fall through */
case 'p': len++; break;
case 'x': break;
default: len += num; break;
}
if (c != 'x') numcodes++;
itemsize = e->size; itemsize = e->size;
size = align(size, c, e); size = align(size, c, e);
x = num * itemsize; x = num * itemsize;
@ -1017,24 +993,78 @@ prepare_s(PyStructObject *self)
} }
} }
self->s_size = size; return size;
self->s_len = len; }
codes = PyMem_MALLOC((numcodes + 1) * sizeof(formatcode));
if (codes == NULL) {
PyErr_NoMemory(); PyDoc_STRVAR(calcsize__doc__,
return -1; "calcsize(fmt) -> int\n\
Return size of C struct described by format string fmt.\n\
See struct.__doc__ for more on format strings.");
static PyObject *
struct_calcsize(PyObject *self, PyObject *args)
{
char *fmt;
const formatdef *f;
int size;
if (!PyArg_ParseTuple(args, "s:calcsize", &fmt))
return NULL;
f = whichtable(&fmt);
size = calcsize(fmt, f);
if (size < 0)
return NULL;
return PyInt_FromLong((long)size);
}
PyDoc_STRVAR(pack__doc__,
"pack(fmt, v1, v2, ...) -> string\n\
Return string containing values v1, v2, ... packed according to fmt.\n\
See struct.__doc__ for more on format strings.");
static PyObject *
struct_pack(PyObject *self, PyObject *args)
{
const formatdef *f, *e;
PyObject *format, *result, *v;
char *fmt;
int size, num;
Py_ssize_t i, n;
char *s, *res, *restart, *nres;
char c;
if (args == NULL || !PyTuple_Check(args) ||
(n = PyTuple_Size(args)) < 1)
{
PyErr_SetString(PyExc_TypeError,
"struct.pack requires at least one argument");
return NULL;
} }
self->s_codes = codes; format = PyTuple_GetItem(args, 0);
fmt = PyString_AsString(format);
if (!fmt)
return NULL;
f = whichtable(&fmt);
size = calcsize(fmt, f);
if (size < 0)
return NULL;
result = PyString_FromStringAndSize((char *)NULL, size);
if (result == NULL)
return NULL;
s = fmt; s = fmt;
size = 0; i = 1;
res = restart = PyString_AsString(result);
while ((c = *s++) != '\0') { while ((c = *s++) != '\0') {
if (isspace(Py_CHARMASK(c))) if (isspace(Py_CHARMASK(c)))
continue; continue;
if ('0' <= c && c <= '9') { if ('0' <= c && c <= '9') {
num = c - '0'; num = c - '0';
while ('0' <= (c = *s++) && c <= '9') while ('0' <= (c = *s++) && c <= '9')
num = num*10 + (c - '0'); num = num*10 + (c - '0');
if (c == '\0') if (c == '\0')
break; break;
} }
@ -1042,303 +1072,213 @@ prepare_s(PyStructObject *self)
num = 1; num = 1;
e = getentry(c, f); e = getentry(c, f);
if (e == NULL)
size = align(size, c, e); goto fail;
if (c != 'x') { nres = restart + align((int)(res-restart), c, e);
codes->offset = size; /* Fill padd bytes with zeros */
codes->repeat = num; while (res < nres)
codes->fmtdef = e; *res++ = '\0';
codes++; if (num == 0 && c != 's')
} continue;
size += num * e->size; do {
} if (c == 'x') {
codes->fmtdef = NULL; /* doesn't consume arguments */
codes->offset = -1; memset(res, '\0', num);
codes->repeat = -1; res += num;
break;
return 0; }
} if (i >= n) {
PyErr_SetString(StructError,
static PyObject * "insufficient arguments to pack");
s_new(PyTypeObject *type, PyObject *args, PyObject *kwds) goto fail;
{ }
PyObject *self; v = PyTuple_GetItem(args, i++);
static PyObject *not_yet_string;
assert(type != NULL && type->tp_alloc != NULL);
self = type->tp_alloc(type, 0);
if (self != NULL) {
PyStructObject *s = (PyStructObject*)self;
Py_INCREF(Py_None);
s->s_format = Py_None;
s->s_codes = NULL;
s->s_size = -1;
s->s_len = -1;
}
return self;
}
static int
s_init(PyObject *self, PyObject *args, PyObject *kwds)
{
PyStructObject *soself = (PyStructObject *)self;
PyObject *o_format = NULL;
int ret = 0;
static char *kwlist[] = {"format", 0};
assert(PyStruct_Check(self));
if (!PyArg_ParseTupleAndKeywords(args, kwds, "S:Struct", kwlist,
&o_format))
return -1;
Py_INCREF(o_format);
Py_XDECREF(soself->s_format);
soself->s_format = o_format;
ret = prepare_s(soself);
return ret;
}
static void
s_dealloc(PyStructObject *s)
{
int sts = 0;
if (s->weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *)s);
if (s->s_codes != NULL) {
PyMem_FREE(s->s_codes);
}
Py_XDECREF(s->s_format);
s->ob_type->tp_free((PyObject *)s);
}
PyDoc_STRVAR(s_unpack__doc__,
"unpack(str) -> (v1, v2, ...)\n\
\n\
Return tuple containing values unpacked according to this Struct's format.\n\
Requires len(str) == self.size. See struct.__doc__ for more on format\n\
strings.");
static PyObject *
s_unpack(PyObject *self, PyObject *inputstr)
{
PyStructObject *soself;
PyObject *result;
char *restart;
formatcode *code;
Py_ssize_t i;
soself = (PyStructObject *)self;
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
if (inputstr == NULL || !PyString_Check(inputstr) ||
PyString_GET_SIZE(inputstr) != soself->s_size) {
PyErr_Format(StructError,
"unpack requires a string argument of length %d", soself->s_size);
return NULL;
}
result = PyTuple_New(soself->s_len);
if (result == NULL)
return NULL;
restart = PyString_AS_STRING(inputstr);
i = 0;
for (code = soself->s_codes; code->fmtdef != NULL; code++) {
Py_ssize_t n;
PyObject *v;
const formatdef *e = code->fmtdef;
const char *res = restart + code->offset;
if (e->format == 's') {
v = PyString_FromStringAndSize(res, code->repeat);
if (v == NULL) if (v == NULL)
goto fail; goto fail;
PyTuple_SET_ITEM(result, i++, v); if (c == 's') {
} else if (e->format == 'p') { /* num is string size, not repeat count */
n = *(unsigned char*)res; Py_ssize_t n;
if (n >= code->repeat) if (!PyString_Check(v)) {
n = code->repeat - 1; PyErr_SetString(StructError,
v = PyString_FromStringAndSize(res + 1, n); "argument for 's' must be a string");
if (v == NULL)
goto fail;
PyTuple_SET_ITEM(result, i++, v);
} else {
for (n = 0; n < code->repeat; n++) {
v = e->unpack(res, e);
if (v == NULL)
goto fail; goto fail;
PyTuple_SET_ITEM(result, i++, v); }
res += e->size; n = PyString_Size(v);
if (n > num)
n = num;
if (n > 0)
memcpy(res, PyString_AsString(v), n);
if (n < num)
memset(res+n, '\0', num-n);
res += num;
break;
} }
} else if (c == 'p') {
} /* num is string size + 1,
to fit in the count byte */
return result; Py_ssize_t n;
fail: num--; /* now num is max string size */
Py_DECREF(result); if (!PyString_Check(v)) {
return NULL; PyErr_SetString(StructError,
}; "argument for 'p' must be a string");
goto fail;
}
PyDoc_STRVAR(s_pack__doc__, n = PyString_Size(v);
"pack(v1, v2, ...) -> string\n\ if (n > num)
\n\ n = num;
Return a string containing values v1, v2, ... packed according to this\n\ if (n > 0)
Struct's format. See struct.__doc__ for more on format strings."); memcpy(res+1, PyString_AsString(v), n);
if (n < num)
static PyObject * /* no real need, just to be nice */
s_pack(PyObject *self, PyObject *args) memset(res+1+n, '\0', num-n);
{ if (n > 255)
PyStructObject *soself; n = 255;
PyObject *result; /* store the length byte */
char *restart; *res++ = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
formatcode *code; res += num;
Py_ssize_t i; break;
soself = (PyStructObject *)self;
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
if (args == NULL || !PyTuple_Check(args) ||
PyTuple_GET_SIZE(args) != soself->s_len)
{
PyErr_Format(StructError,
"pack requires exactly %d arguments", soself->s_len);
return NULL;
}
result = PyString_FromStringAndSize((char *)NULL, soself->s_size);
if (result == NULL)
return NULL;
restart = PyString_AS_STRING(result);
memset(restart, '\0', soself->s_size);
i = 0;
for (code = soself->s_codes; code->fmtdef != NULL; code++) {
Py_ssize_t n;
PyObject *v;
const formatdef *e = code->fmtdef;
char *res = restart + code->offset;
if (e->format == 's') {
v = PyTuple_GET_ITEM(args, i++);
if (!PyString_Check(v)) {
PyErr_SetString(StructError,
"argument for 's' must be a string");
goto fail;
} }
n = PyString_GET_SIZE(v); else {
if (n > code->repeat)
n = code->repeat;
if (n > 0)
memcpy(res, PyString_AS_STRING(v), n);
} else if (e->format == 'p') {
v = PyTuple_GET_ITEM(args, i++);
if (!PyString_Check(v)) {
PyErr_SetString(StructError,
"argument for 'p' must be a string");
goto fail;
}
n = PyString_GET_SIZE(v);
if (n > (code->repeat - 1))
n = code->repeat - 1;
if (n > 0)
memcpy(res + 1, PyString_AS_STRING(v), n);
if (n > 255)
n = 255;
*res = Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char);
} else {
for (n = 0; n < code->repeat; n++) {
v = PyTuple_GET_ITEM(args, i++);
if (e->pack(res, v, e) < 0) if (e->pack(res, v, e) < 0)
goto fail; goto fail;
res += e->size; res += e->size;
} }
} } while (--num > 0);
} }
if (i < n) {
PyErr_SetString(StructError,
"too many arguments for pack format");
goto fail;
}
return result; return result;
fail: fail:
Py_DECREF(result); Py_DECREF(result);
return NULL; return NULL;
}
PyDoc_STRVAR(unpack__doc__,
"unpack(fmt, string) -> (v1, v2, ...)\n\
Unpack the string, containing packed C structure data, according\n\
to fmt. Requires len(string)==calcsize(fmt).\n\
See struct.__doc__ for more on format strings.");
static PyObject *
struct_unpack(PyObject *self, PyObject *args)
{
const formatdef *f, *e;
char *str, *start, *fmt, *s;
char c;
int len, size, num;
PyObject *res, *v;
if (!PyArg_ParseTuple(args, "ss#:unpack", &fmt, &start, &len))
return NULL;
f = whichtable(&fmt);
size = calcsize(fmt, f);
if (size < 0)
return NULL;
if (size != len) {
PyErr_SetString(StructError,
"unpack str size does not match format");
return NULL;
}
res = PyList_New(0);
if (res == NULL)
return NULL;
str = start;
s = fmt;
while ((c = *s++) != '\0') {
if (isspace(Py_CHARMASK(c)))
continue;
if ('0' <= c && c <= '9') {
num = c - '0';
while ('0' <= (c = *s++) && c <= '9')
num = num*10 + (c - '0');
if (c == '\0')
break;
}
else
num = 1;
e = getentry(c, f);
if (e == NULL)
goto fail;
str = start + align((int)(str-start), c, e);
if (num == 0 && c != 's')
continue;
do {
if (c == 'x') {
str += num;
break;
}
if (c == 's') {
/* num is string size, not repeat count */
v = PyString_FromStringAndSize(str, num);
if (v == NULL)
goto fail;
str += num;
num = 0;
}
else if (c == 'p') {
/* num is string buffer size,
not repeat count */
int n = *(unsigned char*)str;
/* first byte (unsigned) is string size */
if (n >= num)
n = num-1;
v = PyString_FromStringAndSize(str+1, n);
if (v == NULL)
goto fail;
str += num;
num = 0;
}
else {
v = e->unpack(str, e);
if (v == NULL)
goto fail;
str += e->size;
}
if (v == NULL || PyList_Append(res, v) < 0)
goto fail;
Py_DECREF(v);
} while (--num > 0);
}
v = PyList_AsTuple(res);
Py_DECREF(res);
return v;
fail:
Py_DECREF(res);
return NULL;
} }
/* List of functions */ /* List of functions */
static struct PyMethodDef s_methods[] = { static PyMethodDef struct_methods[] = {
{"pack", s_pack, METH_VARARGS, s_pack__doc__}, {"calcsize", struct_calcsize, METH_VARARGS, calcsize__doc__},
{"unpack", s_unpack, METH_O, s_unpack__doc__}, {"pack", struct_pack, METH_VARARGS, pack__doc__},
{NULL, NULL} /* sentinel */ {"unpack", struct_unpack, METH_VARARGS, unpack__doc__},
{NULL, NULL} /* sentinel */
}; };
PyDoc_STRVAR(s__doc__, "Compiled struct object");
#define OFF(x) offsetof(PyStructObject, x)
static PyMemberDef s_memberlist[] = {
{"format", T_OBJECT, OFF(s_format), RO,
"struct format string"},
{"size", T_INT, OFF(s_size), RO,
"struct size in bytes"},
{"_len", T_INT, OFF(s_len), RO,
"number of items expected in tuple"},
{NULL} /* Sentinel */
};
static
PyTypeObject PyStructType = {
PyObject_HEAD_INIT(&PyType_Type)
0,
"Struct",
sizeof(PyStructObject),
0,
(destructor)s_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
PyObject_GenericSetAttr, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
s__doc__, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
offsetof(PyStructObject, weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
s_methods, /* tp_methods */
s_memberlist, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
s_init, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
s_new, /* tp_new */
PyObject_Del, /* tp_free */
};
/* Module initialization */ /* Module initialization */
PyMODINIT_FUNC PyMODINIT_FUNC
init_struct(void) initstruct(void)
{ {
PyObject *m = Py_InitModule("_struct", NULL); PyObject *m;
/* Create the module and add the functions */
m = Py_InitModule4("struct", struct_methods, struct__doc__,
(PyObject*)NULL, PYTHON_API_VERSION);
if (m == NULL) if (m == NULL)
return; return;
@ -1350,6 +1290,4 @@ init_struct(void)
} }
Py_INCREF(StructError); Py_INCREF(StructError);
PyModule_AddObject(m, "error", StructError); PyModule_AddObject(m, "error", StructError);
Py_INCREF((PyObject*)&PyStructType);
PyModule_AddObject(m, "Struct", (PyObject*)&PyStructType);
} }

2
setup.py
View file

@ -1444,7 +1444,7 @@ def main():
'install_lib':PyBuildInstallLib}, 'install_lib':PyBuildInstallLib},
# The struct module is defined here, because build_ext won't be # The struct module is defined here, because build_ext won't be
# called unless there's at least one extension module defined. # called unless there's at least one extension module defined.
ext_modules=[Extension('_struct', ['_struct.c'])], ext_modules=[Extension('struct', ['structmodule.c'])],
# Scripts to install # Scripts to install
scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle', scripts = ['Tools/scripts/pydoc', 'Tools/scripts/idle',