mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-05-23 22:02:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Backporting METH_FASTCALL from Python 3.7 (#317)

Browse source 
* dict copy speedup

refer to bpo-31179 or python/cpython@boa7a037b8fde

* __build_class__() uses METH_FASTCALL

refer python/cpython@69de71b255
refer python/cpython@773dc6dd06

a single test related to __prepare__ fails.

* type_prepare uses METH_FASTCALL

refer python/cpython@d526cfe546
refer python/cpython@80ab22fa2c

the prepare-related test still fails.  It's just related to the error
message format though.

* separate into ParseStack and ParseStackAndKeywords

refer python/cpython@6518a93cb1
refer python/cpython@3e1fad6913
refer python/cpython@c0083fc47d

* Add _PyArg_NoStackKeywords

refer python/cpython@29d39cc8f5

* _PyStack_UnpackDict now returns int

refer python/cpython@998c20962c

* METH_FASTCALL changes to .inc files

done via python's Argument Clinic tool,
refer python/cpython@259f0e4437

* Added _PyArg_UnpackStack

refer python/cpython@fe54dda08

* Argument Clinic FASTCALL again

refer python/cpython@0c4a828ca

* Argument Clinic for ordered dictionary object

refer python/cpython@b05cbac052

* speed up getargs

refer python/cpython@1741441649

* FASTCALL for sorted, next, and getattr

refer python/cpython@5a60ecaa7a
refer python/cpython@fda6d0acf0
refer python/cpython@84b388bb80

* Optimize methoddescr_call

refer python/cpython@2a1b676d1f
refer python/cpython@c52572319c
refer python/cpython@35ecebe165
refer python/cpython@8128d5a491

* cleanup _PyMethodDef_RawFastCallDict

refer python/cpython@0a2e46835d
refer python/cpython@98ccba8344
refer python/cpython@c89ef828cf
refer python/cpython@250e4b0063

* print now uses METH_FASTCALL

refer python/cpython@c3858bd7c6
refer python/cpython@bd584f169f
refer python/cpython@06d34393c2

* _struct module now uses Argument Clinic

refer python/cpython@3f2d10132d

* make deque methods faster

refer python/cpython@dd407d5006

* recursive calls in PyObject_Call

refer python/cpython@7399a05965

only partially ported, because RawFastCallKeywords hasn't been ported

* add macros

refer python/cpython@68a001dd59

* all tests pass in MODE=dbg

* convert some internal functions to FASTCALL

__import__ might need to be changed later, if it is possible to backport
the METH_FASTCALL | METH_KEYWORDS flag distinction later.

* speed up unpickling

refer python/cpython@bee09aecc2

* added _PyMethodDef_RawFastCallKeywords

refer python/cpython@7399a05965

* PyCFunction_Call performance

refer python/cpython@12c5838dae

* avoid PyMethodObject in slots

main change in python/cpython@516b98161a
test_exceptions changed in python/cpython@331bbe6aaa
type_settattro changed in python/cpython@193f7e094f
_PyObject_CallFunctionVa changed in python/cpython@fe4ff83049

* fix refcount error found in MODE=dbg

all tests now pass in MODE=dbg
This commit is contained in:
Gautham 2021-11-13 04:56:57 +05:30 • committed by GitHub
parent 6f658f058b
commit 7fe9e70117
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
71 changed files with 4154 additions and 2450 deletions
Download patch file Download diff file Expand all files Collapse all files

512
third_party/python/Modules/_struct.c vendored
View file

@ -46,6 +46,12 @@ PYTHON_PROVIDE("_struct.unpack_from");
/* New version supporting byte order, alignment and size options,
character strings, and unsigned numbers */
/*[clinic input]
class Struct "PyStructObject *" "&PyStructType"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9b032058a83ed7c3]*/
static PyTypeObject PyStructType;
/* The translation function for each format character is table driven */
@ -117,6 +123,8 @@ typedef struct { char c; long long x; } s_long_long;
#pragma options align=reset
#endif
#include "third_party/python/Modules/clinic/_struct.inc"
/* Helper for integer format codes: converts an arbitrary Python object to a
PyLongObject if possible, otherwise fails. Caller should decref. */
@ -576,7 +584,7 @@ np_ubyte(char *p, PyObject *v, const formatdef *f)
"ubyte format requires 0 <= number <= 255");
return -1;
}
*(unsigned char *)p = (unsigned char)x;
*p = (char)x;
return 0;
}
@ -905,7 +913,6 @@ bp_int(char *p, PyObject *v, const formatdef *f)
{
long x;
Py_ssize_t i;
unsigned char *q = (unsigned char *)p;
if (get_long(v, &x) < 0)
return -1;
i = f->size;
@ -918,7 +925,7 @@ bp_int(char *p, PyObject *v, const formatdef *f)
#endif
}
do {
q[--i] = (unsigned char)(x & 0xffL);
p[--i] = (char)x;
x >>= 8;
} while (i > 0);
return 0;
@ -929,7 +936,6 @@ bp_uint(char *p, PyObject *v, const formatdef *f)
{
unsigned long x;
Py_ssize_t i;
unsigned char *q = (unsigned char *)p;
if (get_ulong(v, &x) < 0)
return -1;
i = f->size;
@ -940,7 +946,7 @@ bp_uint(char *p, PyObject *v, const formatdef *f)
RANGE_ERROR(x, f, 1, maxint - 1);
}
do {
q[--i] = (unsigned char)(x & 0xffUL);
p[--i] = (char)x;
x >>= 8;
} while (i > 0);
return 0;
@ -1126,7 +1132,6 @@ lp_int(char *p, PyObject *v, const formatdef *f)
{
long x;
Py_ssize_t i;
unsigned char *q = (unsigned char *)p;
if (get_long(v, &x) < 0)
return -1;
i = f->size;
@ -1139,7 +1144,7 @@ lp_int(char *p, PyObject *v, const formatdef *f)
#endif
}
do {
*q++ = (unsigned char)(x & 0xffL);
*p++ = (char)x;
x >>= 8;
} while (--i > 0);
return 0;
@ -1150,7 +1155,6 @@ lp_uint(char *p, PyObject *v, const formatdef *f)
{
unsigned long x;
Py_ssize_t i;
unsigned char *q = (unsigned char *)p;
if (get_ulong(v, &x) < 0)
return -1;
i = f->size;
@ -1161,7 +1165,7 @@ lp_uint(char *p, PyObject *v, const formatdef *f)
RANGE_ERROR(x, f, 1, maxint - 1);
}
do {
*q++ = (unsigned char)(x & 0xffUL);
*p++ = (char)x;
x >>= 8;
} while (--i > 0);
return 0;
@ -1340,7 +1344,7 @@ prepare_s(PyStructObject *self)
len = 0;
ncodes = 0;
while ((c = *s++) != '\0') {
if (Py_ISSPACE(c))
if (Py_ISSPACE(Py_CHARMASK(c)))
continue;
if ('0' <= c && c <= '9') {
num = c - '0';
@ -1405,7 +1409,7 @@ prepare_s(PyStructObject *self)
s = fmt;
size = 0;
while ((c = *s++) != '\0') {
if (Py_ISSPACE(c))
if (Py_ISSPACE(Py_CHARMASK(c)))
continue;
if ('0' <= c && c <= '9') {
num = c - '0';
@ -1470,42 +1474,46 @@ s_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return self;
}
/*[clinic input]
Struct.__init__
format: object
Create a compiled struct object.
Return a new Struct object which writes and reads binary data according to
the format string.
See help(struct) for more on format strings.
[clinic start generated code]*/
static int
s_init(PyObject *self, PyObject *args, PyObject *kwds)
Struct___init___impl(PyStructObject *self, PyObject *format)
/*[clinic end generated code: output=b8e80862444e92d0 input=192a4575a3dde802]*/
{
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, "O:Struct", kwlist,
&o_format))
return -1;
if (PyUnicode_Check(o_format)) {
o_format = PyUnicode_AsASCIIString(o_format);
if (o_format == NULL)
if (PyUnicode_Check(format)) {
format = PyUnicode_AsASCIIString(format);
if (format == NULL)
return -1;
}
/* XXX support buffer interface, too */
else {
Py_INCREF(o_format);
Py_INCREF(format);
}
if (!PyBytes_Check(o_format)) {
Py_DECREF(o_format);
if (!PyBytes_Check(format)) {
Py_DECREF(format);
PyErr_Format(PyExc_TypeError,
"Struct() argument 1 must be a str or bytes object, "
"not %.200s",
Py_TYPE(o_format)->tp_name);
"Struct() argument 1 must be a bytes object, not %.200s",
Py_TYPE(format)->tp_name);
return -1;
}
Py_XSETREF(soself->s_format, o_format);
Py_XSETREF(self->s_format, format);
ret = prepare_s(soself);
ret = prepare_s(self);
return ret;
}
@ -1559,78 +1567,69 @@ fail:
}
PyDoc_STRVAR(s_unpack__doc__,
"S.unpack(buffer) -> (v1, v2, ...)\n\
\n\
Return a tuple containing values unpacked according to the format\n\
string S.format. The buffer's size in bytes must be S.size. See\n\
help(struct) for more on format strings.");
/*[clinic input]
Struct.unpack
buffer: Py_buffer
/
Return a tuple containing unpacked values.
Unpack according to the format string Struct.format. The buffer's size
in bytes must be Struct.size.
See help(struct) for more on format strings.
[clinic start generated code]*/
static PyObject *
s_unpack(PyObject *self, PyObject *input)
Struct_unpack_impl(PyStructObject *self, Py_buffer *buffer)
/*[clinic end generated code: output=873a24faf02e848a input=3113f8e7038b2f6c]*/
{
Py_buffer vbuf;
PyObject *result;
PyStructObject *soself = (PyStructObject *)self;
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
if (PyObject_GetBuffer(input, &vbuf, PyBUF_SIMPLE) < 0)
return NULL;
if (vbuf.len != soself->s_size) {
assert(self->s_codes != NULL);
if (buffer->len != self->s_size) {
PyErr_Format(StructError,
"unpack requires a buffer of %zd bytes",
soself->s_size);
PyBuffer_Release(&vbuf);
"unpack requires a bytes object of length %zd",
self->s_size);
return NULL;
}
result = s_unpack_internal(soself, vbuf.buf);
PyBuffer_Release(&vbuf);
return result;
return s_unpack_internal(self, buffer->buf);
}
PyDoc_STRVAR(s_unpack_from__doc__,
"S.unpack_from(buffer, offset=0) -> (v1, v2, ...)\n\
\n\
Return a tuple containing values unpacked according to the format\n\
string S.format. The buffer's size in bytes, minus offset, must be at\n\
least S.size. See help(struct) for more on format strings.");
/*[clinic input]
Struct.unpack_from
buffer: Py_buffer
offset: Py_ssize_t = 0
Return a tuple containing unpacked values.
Values are unpacked according to the format string Struct.format.
The buffer's size in bytes, minus offset, must be at least Struct.size.
See help(struct) for more on format strings.
[clinic start generated code]*/
static PyObject *
s_unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
Py_ssize_t offset)
/*[clinic end generated code: output=57fac875e0977316 input=97ade52422f8962f]*/
{
static char *kwlist[] = {"buffer", "offset", 0};
assert(self->s_codes != NULL);
PyObject *input;
Py_ssize_t offset = 0;
Py_buffer vbuf;
PyObject *result;
PyStructObject *soself = (PyStructObject *)self;
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
if (!PyArg_ParseTupleAndKeywords(args, kwds,
"O|n:unpack_from", kwlist,
&input, &offset))
return NULL;
if (PyObject_GetBuffer(input, &vbuf, PyBUF_SIMPLE) < 0)
return NULL;
if (offset < 0)
offset += vbuf.len;
if (offset < 0 || vbuf.len - offset < soself->s_size) {
offset += buffer->len;
if (offset < 0 || buffer->len - offset < self->s_size) {
PyErr_Format(StructError,
"unpack_from requires a buffer of at least %zd bytes",
soself->s_size);
PyBuffer_Release(&vbuf);
self->s_size);
return NULL;
}
result = s_unpack_internal(soself, (char*)vbuf.buf + offset);
PyBuffer_Release(&vbuf);
return result;
return s_unpack_internal(self, (char*)buffer->buf + offset);
}
/* Unpack iterator type */
typedef struct {
@ -1643,8 +1642,6 @@ typedef struct {
static void
unpackiter_dealloc(unpackiterobject *self)
{
/* bpo-31095: UnTrack is needed before calling any callbacks */
PyObject_GC_UnTrack(self);
Py_XDECREF(self->so);
PyBuffer_Release(&self->buf);
PyObject_GC_Del(self);
@ -1694,7 +1691,7 @@ unpackiter_iternext(unpackiterobject *self)
}
static PyTypeObject unpackiter_type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
PyVarObject_HEAD_INIT(NULL, 0)
"unpack_iterator", /* tp_name */
sizeof(unpackiterobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -1724,48 +1721,54 @@ static PyTypeObject unpackiter_type = {
unpackiter_methods /* tp_methods */
};
PyDoc_STRVAR(s_iter_unpack__doc__,
"S.iter_unpack(buffer) -> iterator(v1, v2, ...)\n\
\n\
Return an iterator yielding tuples unpacked from the given bytes\n\
source, like a repeated invocation of unpack_from(). Requires\n\
that the bytes length be a multiple of the struct size.");
/*[clinic input]
Struct.iter_unpack
buffer: object
/
Return an iterator yielding tuples.
Tuples are unpacked from the given bytes source, like a repeated
invocation of unpack_from().
Requires that the bytes length be a multiple of the struct size.
[clinic start generated code]*/
static PyObject *
s_iter_unpack(PyObject *_so, PyObject *input)
Struct_iter_unpack(PyStructObject *self, PyObject *buffer)
/*[clinic end generated code: output=172d83d0cd15dbab input=6d65b3f3107dbc99]*/
{
PyStructObject *so = (PyStructObject *) _so;
unpackiterobject *self;
unpackiterobject *iter;
assert(PyStruct_Check(_so));
assert(so->s_codes != NULL);
assert(self->s_codes != NULL);
if (so->s_size == 0) {
if (self->s_size == 0) {
PyErr_Format(StructError,
"cannot iteratively unpack with a struct of length 0");
return NULL;
}
self = (unpackiterobject *) PyType_GenericAlloc(&unpackiter_type, 0);
if (self == NULL)
iter = (unpackiterobject *) PyType_GenericAlloc(&unpackiter_type, 0);
if (iter == NULL)
return NULL;
if (PyObject_GetBuffer(input, &self->buf, PyBUF_SIMPLE) < 0) {
Py_DECREF(self);
if (PyObject_GetBuffer(buffer, &iter->buf, PyBUF_SIMPLE) < 0) {
Py_DECREF(iter);
return NULL;
}
if (self->buf.len % so->s_size != 0) {
if (iter->buf.len % self->s_size != 0) {
PyErr_Format(StructError,
"iterative unpacking requires a buffer of "
"a multiple of %zd bytes",
so->s_size);
Py_DECREF(self);
"iterative unpacking requires a bytes length "
"multiple of %zd",
self->s_size);
Py_DECREF(iter);
return NULL;
}
Py_INCREF(so);
self->so = so;
self->index = 0;
return (PyObject *) self;
Py_INCREF(self);
iter->so = self;
iter->index = 0;
return (PyObject *)iter;
}
@ -1780,20 +1783,21 @@ s_iter_unpack(PyObject *_so, PyObject *input)
*
*/
static int
s_pack_internal(PyStructObject *soself, PyObject *args, int offset, char* buf)
s_pack_internal(PyStructObject *soself, PyObject **args, int offset, char* buf)
{
formatcode *code;
/* XXX(nnorwitz): why does i need to be a local? can we use
the offset parameter or do we need the wider width? */
Py_ssize_t i;
bzero(buf, soself->s_size);
memset(buf, '\0', soself->s_size);
i = offset;
for (code = soself->s_codes; code->fmtdef != NULL; code++) {
const formatdef *e = code->fmtdef;
char *res = buf + code->offset;
Py_ssize_t j = code->repeat;
while (j--) {
PyObject *v = PyTuple_GET_ITEM(args, i++);
PyObject *v = args[i++];
if (e->format == 's') {
Py_ssize_t n;
int isstring;
@ -1866,7 +1870,7 @@ to the format string S.format. See help(struct) for more on format\n\
strings.");
static PyObject *
s_pack(PyObject *self, PyObject *args)
s_pack(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyStructObject *soself;
PyObject *result;
@ -1875,10 +1879,13 @@ s_pack(PyObject *self, PyObject *args)
soself = (PyStructObject *)self;
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
if (PyTuple_GET_SIZE(args) != soself->s_len)
if (nargs != soself->s_len)
{
PyErr_Format(StructError,
"pack expected %zd items for packing (got %zd)", soself->s_len, PyTuple_GET_SIZE(args));
"pack expected %zd items for packing (got %zd)", soself->s_len, nargs);
return NULL;
}
if (!_PyArg_NoStackKeywords("pack", kwnames)) {
return NULL;
}
@ -1905,7 +1912,7 @@ offset. Note that the offset is a required argument. See\n\
help(struct) for more on format strings.");
static PyObject *
s_pack_into(PyObject *self, PyObject *args)
s_pack_into(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyStructObject *soself;
Py_buffer buffer;
@ -1915,31 +1922,34 @@ s_pack_into(PyObject *self, PyObject *args)
soself = (PyStructObject *)self;
assert(PyStruct_Check(self));
assert(soself->s_codes != NULL);
if (PyTuple_GET_SIZE(args) != (soself->s_len + 2))
if (nargs != (soself->s_len + 2))
{
if (PyTuple_GET_SIZE(args) == 0) {
if (nargs == 0) {
PyErr_Format(StructError,
"pack_into expected buffer argument");
}
else if (PyTuple_GET_SIZE(args) == 1) {
else if (nargs == 1) {
PyErr_Format(StructError,
"pack_into expected offset argument");
}
else {
PyErr_Format(StructError,
"pack_into expected %zd items for packing (got %zd)",
soself->s_len, (PyTuple_GET_SIZE(args) - 2));
soself->s_len, (nargs - 2));
}
return NULL;
}
if (!_PyArg_NoStackKeywords("pack_into", kwnames)) {
return NULL;
}
/* Extract a writable memory buffer from the first argument */
if (!PyArg_Parse(PyTuple_GET_ITEM(args, 0), "w*", &buffer))
if (!PyArg_Parse(args[0], "w*", &buffer))
return NULL;
assert(buffer.len >= 0);
/* Extract the offset from the first argument */
offset = PyNumber_AsSsize_t(PyTuple_GET_ITEM(args, 1), PyExc_IndexError);
offset = PyNumber_AsSsize_t(args[1], PyExc_IndexError);
if (offset == -1 && PyErr_Occurred()) {
PyBuffer_Release(&buffer);
return NULL;
@ -1999,22 +2009,15 @@ s_sizeof(PyStructObject *self, void *unused)
/* List of functions */
static struct PyMethodDef s_methods[] = {
{"iter_unpack", s_iter_unpack, METH_O, s_iter_unpack__doc__},
{"pack", s_pack, METH_VARARGS, s_pack__doc__},
{"pack_into", s_pack_into, METH_VARARGS, s_pack_into__doc__},
{"unpack", s_unpack, METH_O, s_unpack__doc__},
{"unpack_from", (PyCFunction)s_unpack_from, METH_VARARGS|METH_KEYWORDS,
s_unpack_from__doc__},
STRUCT_ITER_UNPACK_METHODDEF
{"pack", (PyCFunction)s_pack, METH_FASTCALL, s_pack__doc__},
{"pack_into", (PyCFunction)s_pack_into, METH_FASTCALL, s_pack_into__doc__},
STRUCT_UNPACK_METHODDEF
STRUCT_UNPACK_FROM_METHODDEF
{"__sizeof__", (PyCFunction)s_sizeof, METH_NOARGS, s_sizeof__doc__},
{NULL, NULL} /* sentinel */
};
PyDoc_STRVAR(s__doc__,
"Struct(fmt) --> compiled struct object\n"
"\n"
"Return a new Struct object which writes and reads binary data according to\n"
"the format string fmt. See help(struct) for more on format strings.");
#define OFF(x) offsetof(PyStructObject, x)
static PyGetSetDef s_getsetlist[] = {
@ -2041,29 +2044,29 @@ PyTypeObject PyStructType = {
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
PyObject_GenericSetAttr, /* tp_setattro */
PyObject_GenericGetAttr, /* tp_getattro */
PyObject_GenericSetAttr, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
s__doc__, /* tp_doc */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
Struct___init____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 */
NULL, /* tp_members */
s_getsetlist, /* tp_getset */
s_methods, /* tp_methods */
NULL, /* tp_members */
s_getsetlist, /* 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 */
Struct___init__, /* tp_init */
PyType_GenericAlloc, /* tp_alloc */
s_new, /* tp_new */
PyObject_Del, /* tp_free */
};
@ -2072,7 +2075,7 @@ PyTypeObject PyStructType = {
#define MAXCACHE 100
static PyObject *cache = NULL;
static PyObject *
static PyStructObject *
cache_struct(PyObject *fmt)
{
PyObject * s_object;
@ -2086,202 +2089,214 @@ cache_struct(PyObject *fmt)
s_object = PyDict_GetItem(cache, fmt);
if (s_object != NULL) {
Py_INCREF(s_object);
return s_object;
return (PyStructObject *)s_object;
}
s_object = PyObject_CallFunctionObjArgs((PyObject *)(&PyStructType), fmt, NULL);
if (s_object != NULL) {
if (PyDict_Size(cache) >= MAXCACHE)
if (PyDict_GET_SIZE(cache) >= MAXCACHE)
PyDict_Clear(cache);
/* Attempt to cache the result */
if (PyDict_SetItem(cache, fmt, s_object) == -1)
PyErr_Clear();
}
return s_object;
return (PyStructObject *)s_object;
}
PyDoc_STRVAR(clearcache_doc,
"Clear the internal cache.");
/*[clinic input]
_clearcache
Clear the internal cache.
[clinic start generated code]*/
static PyObject *
clearcache(PyObject *self)
_clearcache_impl(PyObject *module)
/*[clinic end generated code: output=ce4fb8a7bf7cb523 input=463eaae04bab3211]*/
{
Py_CLEAR(cache);
Py_RETURN_NONE;
}
PyDoc_STRVAR(calcsize_doc,
"calcsize(fmt) -> integer\n\
\n\
Return size in bytes of the struct described by the format string fmt.");
/*[clinic input]
calcsize
format: object
/
Return size in bytes of the struct described by the format string.
[clinic start generated code]*/
static PyObject *
calcsize(PyObject *self, PyObject *fmt)
calcsize(PyObject *module, PyObject *format)
/*[clinic end generated code: output=90fbcf191fe9470a input=55488303a06777fa]*/
{
Py_ssize_t n;
PyObject *s_object = cache_struct(fmt);
PyStructObject *s_object = cache_struct(format);
if (s_object == NULL)
return NULL;
n = ((PyStructObject *)s_object)->s_size;
n = s_object->s_size;
Py_DECREF(s_object);
return PyLong_FromSsize_t(n);
}
PyDoc_STRVAR(pack_doc,
"pack(fmt, v1, v2, ...) -> bytes\n\
"pack(format, v1, v2, ...) -> bytes\n\
\n\
Return a bytes object containing the values v1, v2, ... packed according\n\
to the format string fmt. See help(struct) for more on format strings.");
to the format string. See help(struct) for more on format strings.");
static PyObject *
pack(PyObject *self, PyObject *args)
pack(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *s_object, *fmt, *newargs, *result;
Py_ssize_t n = PyTuple_GET_SIZE(args);
PyStructObject *s_object;
PyObject *format, *result;
if (n == 0) {
if (nargs == 0) {
PyErr_SetString(PyExc_TypeError, "missing format argument");
return NULL;
}
fmt = PyTuple_GET_ITEM(args, 0);
newargs = PyTuple_GetSlice(args, 1, n);
if (newargs == NULL)
return NULL;
format = args[0];
s_object = cache_struct(fmt);
s_object = cache_struct(format);
if (s_object == NULL) {
Py_DECREF(newargs);
return NULL;
}
result = s_pack(s_object, newargs);
Py_DECREF(newargs);
result = s_pack((PyObject *)s_object, args + 1, nargs - 1, kwnames);
Py_DECREF(s_object);
return result;
}
PyDoc_STRVAR(pack_into_doc,
"pack_into(fmt, buffer, offset, v1, v2, ...)\n\
"pack_into(format, buffer, offset, v1, v2, ...)\n\
\n\
Pack the values v1, v2, ... according to the format string fmt and write\n\
Pack the values v1, v2, ... according to the format string and write\n\
the packed bytes into the writable buffer buf starting at offset. Note\n\
that the offset is a required argument. See help(struct) for more\n\
on format strings.");
static PyObject *
pack_into(PyObject *self, PyObject *args)
pack_into(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *s_object, *fmt, *newargs, *result;
Py_ssize_t n = PyTuple_GET_SIZE(args);
PyStructObject *s_object;
PyObject *format, *result;
if (n == 0) {
if (nargs == 0) {
PyErr_SetString(PyExc_TypeError, "missing format argument");
return NULL;
}
fmt = PyTuple_GET_ITEM(args, 0);
newargs = PyTuple_GetSlice(args, 1, n);
if (newargs == NULL)
return NULL;
format = args[0];
s_object = cache_struct(fmt);
s_object = cache_struct(format);
if (s_object == NULL) {
Py_DECREF(newargs);
return NULL;
}
result = s_pack_into(s_object, newargs);
Py_DECREF(newargs);
result = s_pack_into((PyObject *)s_object, args + 1, nargs - 1, kwnames);
Py_DECREF(s_object);
return result;
}
PyDoc_STRVAR(unpack_doc,
"unpack(fmt, buffer) -> (v1, v2, ...)\n\
\n\
Return a tuple containing values unpacked according to the format string\n\
fmt. The buffer's size in bytes must be calcsize(fmt). See help(struct)\n\
for more on format strings.");
/*[clinic input]
unpack
format: object
inputstr: object
/
Return a tuple containing values unpacked according to the format string.
The buffer's size in bytes must be calcsize(format).
See help(struct) for more on format strings.
[clinic start generated code]*/
static PyObject *
unpack(PyObject *self, PyObject *args)
unpack_impl(PyObject *module, PyObject *format, PyObject *inputstr)
/*[clinic end generated code: output=06951d66eae6d63b input=4b81d54988890f5e]*/
{
PyObject *s_object, *fmt, *inputstr, *result;
PyStructObject *s_object;
PyObject *result;
if (!PyArg_UnpackTuple(args, "unpack", 2, 2, &fmt, &inputstr))
return NULL;
s_object = cache_struct(fmt);
s_object = cache_struct(format);
if (s_object == NULL)
return NULL;
result = s_unpack(s_object, inputstr);
result = Struct_unpack(s_object, inputstr);
Py_DECREF(s_object);
return result;
}
PyDoc_STRVAR(unpack_from_doc,
"unpack_from(fmt, buffer, offset=0) -> (v1, v2, ...)\n\
\n\
Return a tuple containing values unpacked according to the format string\n\
fmt. The buffer's size, minus offset, must be at least calcsize(fmt).\n\
See help(struct) for more on format strings.");
/*[clinic input]
unpack_from
format: object
/
buffer: Py_buffer
offset: Py_ssize_t = 0
Return a tuple containing values unpacked according to the format string.
The buffer's size, minus offset, must be at least calcsize(format).
See help(struct) for more on format strings.
[clinic start generated code]*/
static PyObject *
unpack_from(PyObject *self, PyObject *args, PyObject *kwds)
unpack_from_impl(PyObject *module, PyObject *format, Py_buffer *buffer,
Py_ssize_t offset)
/*[clinic end generated code: output=2492f0c3a0b82577 input=9ead76c6ac7164f7]*/
{
PyObject *s_object, *fmt, *newargs, *result;
Py_ssize_t n = PyTuple_GET_SIZE(args);
PyStructObject *s_object;
PyObject *result;
if (n == 0) {
PyErr_SetString(PyExc_TypeError, "missing format argument");
return NULL;
}
fmt = PyTuple_GET_ITEM(args, 0);
newargs = PyTuple_GetSlice(args, 1, n);
if (newargs == NULL)
return NULL;
s_object = cache_struct(fmt);
s_object = cache_struct(format);
if (s_object == NULL) {
Py_DECREF(newargs);
return NULL;
}
result = s_unpack_from(s_object, newargs, kwds);
Py_DECREF(newargs);
result = Struct_unpack_from_impl(s_object, buffer, offset);
Py_DECREF(s_object);
return result;
}
PyDoc_STRVAR(iter_unpack_doc,
"iter_unpack(fmt, buffer) -> iterator(v1, v2, ...)\n\
\n\
Return an iterator yielding tuples unpacked from the given bytes\n\
source according to the format string, like a repeated invocation of\n\
unpack_from(). Requires that the bytes length be a multiple of the\n\
format struct size.");
/*[clinic input]
iter_unpack
format: object
buffer: object
/
Return an iterator yielding tuples unpacked from the given bytes.
The bytes are unpacked according to the format string, like
a repeated invocation of unpack_from().
Requires that the bytes length be a multiple of the format struct size.
[clinic start generated code]*/
static PyObject *
iter_unpack(PyObject *self, PyObject *args)
iter_unpack_impl(PyObject *module, PyObject *format, PyObject *buffer)
/*[clinic end generated code: output=b1291e97a6d4cf3c input=8674dfd2f0dae416]*/
{
PyObject *s_object, *fmt, *input, *result;
PyStructObject *s_object;
PyObject *result;
if (!PyArg_ParseTuple(args, "OO:iter_unpack", &fmt, &input))
return NULL;
s_object = cache_struct(fmt);
s_object = cache_struct(format);
if (s_object == NULL)
return NULL;
result = s_iter_unpack(s_object, input);
result = Struct_iter_unpack(s_object, buffer);
Py_DECREF(s_object);
return result;
}
static struct PyMethodDef module_functions[] = {
{"_clearcache", (PyCFunction)clearcache, METH_NOARGS, clearcache_doc},
{"calcsize", calcsize, METH_O, calcsize_doc},
{"iter_unpack", iter_unpack, METH_VARARGS, iter_unpack_doc},
{"pack", pack, METH_VARARGS, pack_doc},
{"pack_into", pack_into, METH_VARARGS, pack_into_doc},
{"unpack", unpack, METH_VARARGS, unpack_doc},
{"unpack_from", (PyCFunction)unpack_from,
METH_VARARGS|METH_KEYWORDS, unpack_from_doc},
_CLEARCACHE_METHODDEF
CALCSIZE_METHODDEF
ITER_UNPACK_METHODDEF
{"pack", (PyCFunction)pack, METH_FASTCALL, pack_doc},
{"pack_into", (PyCFunction)pack_into, METH_FASTCALL, pack_into_doc},
UNPACK_METHODDEF
UNPACK_FROM_METHODDEF
{NULL, NULL} /* sentinel */
};
@ -2344,6 +2359,9 @@ PyInit__struct(void)
if (PyType_Ready(&PyStructType) < 0)
return NULL;
if (PyType_Ready(&unpackiter_type) < 0)
return NULL;
/* Check endian and swap in faster functions */
{
const formatdef *native = native_table;