mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-05-23 13:52:28 +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

40
third_party/python/Modules/_collectionsmodule.c vendored
View file

@ -936,12 +936,18 @@ done:
}
static PyObject *
deque_rotate(dequeobject *deque, PyObject *args)
deque_rotate(dequeobject *deque, PyObject **args, Py_ssize_t nargs,
PyObject *kwnames)
{
Py_ssize_t n=1;
if (!PyArg_ParseTuple(args, "|n:rotate", &n))
if (!_PyArg_NoStackKeywords("rotate", kwnames)) {
return NULL;
}
if (!_PyArg_ParseStack(args, nargs, "|n:rotate", &n)) {
return NULL;
}
if (!_deque_rotate(deque, n))
Py_RETURN_NONE;
return NULL;
@ -1070,7 +1076,8 @@ deque_len(dequeobject *deque)
}
static PyObject *
deque_index(dequeobject *deque, PyObject *args)
deque_index(dequeobject *deque, PyObject **args, Py_ssize_t nargs,
PyObject *kwnames)
{
Py_ssize_t i, n, start=0, stop=Py_SIZE(deque);
PyObject *v, *item;
@ -1079,10 +1086,15 @@ deque_index(dequeobject *deque, PyObject *args)
size_t start_state = deque->state;
int cmp;
if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
_PyEval_SliceIndexNotNone, &start,
_PyEval_SliceIndexNotNone, &stop))
if (!_PyArg_NoStackKeywords("index", kwnames)) {
return NULL;
}
if (!_PyArg_ParseStack(args, nargs, "O|O&O&:index", &v,
_PyEval_SliceIndex, &start,
_PyEval_SliceIndex, &stop)) {
return NULL;
}
if (start < 0) {
start += Py_SIZE(deque);
if (start < 0)
@ -1145,15 +1157,21 @@ PyDoc_STRVAR(index_doc,
*/
static PyObject *
deque_insert(dequeobject *deque, PyObject *args)
deque_insert(dequeobject *deque, PyObject **args, Py_ssize_t nargs,
PyObject *kwnames)
{
Py_ssize_t index;
Py_ssize_t n = Py_SIZE(deque);
PyObject *value;
PyObject *rv;
if (!PyArg_ParseTuple(args, "nO:insert", &index, &value))
if (!_PyArg_NoStackKeywords("insert", kwnames)) {
return NULL;
}
if (!_PyArg_ParseStack(args, nargs, "nO:insert", &index, &value)) {
return NULL;
}
if (deque->maxlen == Py_SIZE(deque)) {
PyErr_SetString(PyExc_IndexError, "deque already at its maximum size");
return NULL;
@ -1623,9 +1641,9 @@ static PyMethodDef deque_methods[] = {
{"extendleft", (PyCFunction)deque_extendleft,
METH_O, extendleft_doc},
{"index", (PyCFunction)deque_index,
METH_VARARGS, index_doc},
METH_FASTCALL, index_doc},
{"insert", (PyCFunction)deque_insert,
METH_VARARGS, insert_doc},
METH_FASTCALL, insert_doc},
{"pop", (PyCFunction)deque_pop,
METH_NOARGS, pop_doc},
{"popleft", (PyCFunction)deque_popleft,
@ -1639,7 +1657,7 @@ static PyMethodDef deque_methods[] = {
{"reverse", (PyCFunction)deque_reverse,
METH_NOARGS, reverse_doc},
{"rotate", (PyCFunction)deque_rotate,
METH_VARARGS, rotate_doc},
METH_FASTCALL, rotate_doc},
{"__sizeof__", (PyCFunction)deque_sizeof,
METH_NOARGS, sizeof_doc},
{NULL, NULL} /* sentinel */

3
third_party/python/Modules/_elementtree.c vendored
View file

@ -2807,7 +2807,8 @@ typedef struct {
} XMLParserObject;
static PyObject*
_elementtree_XMLParser_doctype(XMLParserObject* self, PyObject* args);
_elementtree_XMLParser_doctype(XMLParserObject* self, PyObject** args,
Py_ssize_t nargs, PyObject* kwnames);
static PyObject *
_elementtree_XMLParser_doctype_impl(XMLParserObject *self, PyObject *name,
PyObject *pubid, PyObject *system);

9
third_party/python/Modules/_io/clinic/_iomodule.inc vendored
View file

@ -130,6 +130,11 @@ PyDoc_STRVAR(_io_open__doc__,
#define _IO_OPEN_METHODDEF \
{"open", (PyCFunction)_io_open, METH_FASTCALL, _io_open__doc__},
static PyObject *
_io_open_impl(PyObject *module, PyObject *file, const char *mode,
int buffering, const char *encoding, const char *errors,
const char *newline, int closefd, PyObject *opener);
static PyObject *
_io_open(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
@ -145,7 +150,7 @@ _io_open(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
int closefd = 1;
PyObject *opener = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&file, &mode, &buffering, &encoding, &errors, &newline, &closefd, &opener)) {
goto exit;
}
@ -154,4 +159,4 @@ _io_open(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
exit:
return return_value;
}
/*[clinic end generated code: output=c5b8fc8b83102bbf input=a9049054013a1b77]*/
/*[clinic end generated code: output=79fd04d9c9d8f28f input=a9049054013a1b77]*/

54
third_party/python/Modules/_io/clinic/bufferedio.inc vendored
View file

@ -11,6 +11,8 @@ PyDoc_STRVAR(_io__BufferedIOBase_readinto__doc__,
#define _IO__BUFFEREDIOBASE_READINTO_METHODDEF \
{"readinto", (PyCFunction)_io__BufferedIOBase_readinto, METH_O, _io__BufferedIOBase_readinto__doc__},
static PyObject *
_io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer);
static PyObject *
_io__BufferedIOBase_readinto(PyObject *self, PyObject *arg)
@ -90,21 +92,25 @@ PyDoc_STRVAR(_io__Buffered_peek__doc__,
"\n");
#define _IO__BUFFERED_PEEK_METHODDEF \
{"peek", (PyCFunction)_io__Buffered_peek, METH_VARARGS, _io__Buffered_peek__doc__},
{"peek", (PyCFunction)_io__Buffered_peek, METH_FASTCALL, _io__Buffered_peek__doc__},
static PyObject *
_io__Buffered_peek_impl(buffered *self, Py_ssize_t size);
static PyObject *
_io__Buffered_peek(buffered *self, PyObject *args)
_io__Buffered_peek(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t size = 0;
if (!PyArg_ParseTuple(args, "|n:peek",
if (!_PyArg_ParseStack(args, nargs, "|n:peek",
&size)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("peek", kwnames)) {
goto exit;
}
return_value = _io__Buffered_peek_impl(self, size);
exit:
@ -117,21 +123,25 @@ PyDoc_STRVAR(_io__Buffered_read__doc__,
"\n");
#define _IO__BUFFERED_READ_METHODDEF \
{"read", (PyCFunction)_io__Buffered_read, METH_VARARGS, _io__Buffered_read__doc__},
{"read", (PyCFunction)_io__Buffered_read, METH_FASTCALL, _io__Buffered_read__doc__},
static PyObject *
_io__Buffered_read_impl(buffered *self, Py_ssize_t n);
static PyObject *
_io__Buffered_read(buffered *self, PyObject *args)
_io__Buffered_read(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t n = -1;
if (!PyArg_ParseTuple(args, "|O&:read",
if (!_PyArg_ParseStack(args, nargs, "|O&:read",
_PyIO_ConvertSsize_t, &n)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io__Buffered_read_impl(self, n);
exit:
@ -232,21 +242,25 @@ PyDoc_STRVAR(_io__Buffered_readline__doc__,
"\n");
#define _IO__BUFFERED_READLINE_METHODDEF \
{"readline", (PyCFunction)_io__Buffered_readline, METH_VARARGS, _io__Buffered_readline__doc__},
{"readline", (PyCFunction)_io__Buffered_readline, METH_FASTCALL, _io__Buffered_readline__doc__},
static PyObject *
_io__Buffered_readline_impl(buffered *self, Py_ssize_t size);
static PyObject *
_io__Buffered_readline(buffered *self, PyObject *args)
_io__Buffered_readline(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|O&:readline",
if (!_PyArg_ParseStack(args, nargs, "|O&:readline",
_PyIO_ConvertSsize_t, &size)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readline", kwnames)) {
goto exit;
}
return_value = _io__Buffered_readline_impl(self, size);
exit:
@ -259,22 +273,26 @@ PyDoc_STRVAR(_io__Buffered_seek__doc__,
"\n");
#define _IO__BUFFERED_SEEK_METHODDEF \
{"seek", (PyCFunction)_io__Buffered_seek, METH_VARARGS, _io__Buffered_seek__doc__},
{"seek", (PyCFunction)_io__Buffered_seek, METH_FASTCALL, _io__Buffered_seek__doc__},
static PyObject *
_io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence);
static PyObject *
_io__Buffered_seek(buffered *self, PyObject *args)
_io__Buffered_seek(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *targetobj;
int whence = 0;
if (!PyArg_ParseTuple(args, "O|i:seek",
if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
&targetobj, &whence)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("seek", kwnames)) {
goto exit;
}
return_value = _io__Buffered_seek_impl(self, targetobj, whence);
exit:
@ -287,22 +305,26 @@ PyDoc_STRVAR(_io__Buffered_truncate__doc__,
"\n");
#define _IO__BUFFERED_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io__Buffered_truncate, METH_VARARGS, _io__Buffered_truncate__doc__},
{"truncate", (PyCFunction)_io__Buffered_truncate, METH_FASTCALL, _io__Buffered_truncate__doc__},
static PyObject *
_io__Buffered_truncate_impl(buffered *self, PyObject *pos);
static PyObject *
_io__Buffered_truncate(buffered *self, PyObject *args)
_io__Buffered_truncate(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *pos = Py_None;
if (!PyArg_UnpackTuple(args, "truncate",
if (!_PyArg_UnpackStack(args, nargs, "truncate",
0, 1,
&pos)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("truncate", kwnames)) {
goto exit;
}
return_value = _io__Buffered_truncate_impl(self, pos);
exit:
@ -474,4 +496,4 @@ _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=a956f394ecde4cf9 input=a9049054013a1b77]*/
/*[clinic end generated code: output=c526190c51a616c8 input=a9049054013a1b77]*/

52
third_party/python/Modules/_io/clinic/bytesio.inc vendored
View file

@ -159,22 +159,26 @@ PyDoc_STRVAR(_io_BytesIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READ_METHODDEF \
{"read", (PyCFunction)_io_BytesIO_read, METH_VARARGS, _io_BytesIO_read__doc__},
{"read", (PyCFunction)_io_BytesIO_read, METH_FASTCALL, _io_BytesIO_read__doc__},
static PyObject *
_io_BytesIO_read_impl(bytesio *self, PyObject *arg);
static PyObject *
_io_BytesIO_read(bytesio *self, PyObject *args)
_io_BytesIO_read(bytesio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "read",
if (!_PyArg_UnpackStack(args, nargs, "read",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io_BytesIO_read_impl(self, arg);
exit:
@ -204,22 +208,26 @@ PyDoc_STRVAR(_io_BytesIO_readline__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READLINE_METHODDEF \
{"readline", (PyCFunction)_io_BytesIO_readline, METH_VARARGS, _io_BytesIO_readline__doc__},
{"readline", (PyCFunction)_io_BytesIO_readline, METH_FASTCALL, _io_BytesIO_readline__doc__},
static PyObject *
_io_BytesIO_readline_impl(bytesio *self, PyObject *arg);
static PyObject *
_io_BytesIO_readline(bytesio *self, PyObject *args)
_io_BytesIO_readline(bytesio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "readline",
if (!_PyArg_UnpackStack(args, nargs, "readline",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readline", kwnames)) {
goto exit;
}
return_value = _io_BytesIO_readline_impl(self, arg);
exit:
@ -237,22 +245,26 @@ PyDoc_STRVAR(_io_BytesIO_readlines__doc__,
"total number of bytes in the lines returned.");
#define _IO_BYTESIO_READLINES_METHODDEF \
{"readlines", (PyCFunction)_io_BytesIO_readlines, METH_VARARGS, _io_BytesIO_readlines__doc__},
{"readlines", (PyCFunction)_io_BytesIO_readlines, METH_FASTCALL, _io_BytesIO_readlines__doc__},
static PyObject *
_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg);
static PyObject *
_io_BytesIO_readlines(bytesio *self, PyObject *args)
_io_BytesIO_readlines(bytesio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "readlines",
if (!_PyArg_UnpackStack(args, nargs, "readlines",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readlines", kwnames)) {
goto exit;
}
return_value = _io_BytesIO_readlines_impl(self, arg);
exit:
@ -304,22 +316,26 @@ PyDoc_STRVAR(_io_BytesIO_truncate__doc__,
"The current file position is unchanged. Returns the new size.");
#define _IO_BYTESIO_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_BytesIO_truncate, METH_VARARGS, _io_BytesIO_truncate__doc__},
{"truncate", (PyCFunction)_io_BytesIO_truncate, METH_FASTCALL, _io_BytesIO_truncate__doc__},
static PyObject *
_io_BytesIO_truncate_impl(bytesio *self, PyObject *arg);
static PyObject *
_io_BytesIO_truncate(bytesio *self, PyObject *args)
_io_BytesIO_truncate(bytesio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "truncate",
if (!_PyArg_UnpackStack(args, nargs, "truncate",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("truncate", kwnames)) {
goto exit;
}
return_value = _io_BytesIO_truncate_impl(self, arg);
exit:
@ -339,22 +355,26 @@ PyDoc_STRVAR(_io_BytesIO_seek__doc__,
"Returns the new absolute position.");
#define _IO_BYTESIO_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_BytesIO_seek, METH_VARARGS, _io_BytesIO_seek__doc__},
{"seek", (PyCFunction)_io_BytesIO_seek, METH_FASTCALL, _io_BytesIO_seek__doc__},
static PyObject *
_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence);
static PyObject *
_io_BytesIO_seek(bytesio *self, PyObject *args)
_io_BytesIO_seek(bytesio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t pos;
int whence = 0;
if (!PyArg_ParseTuple(args, "n|i:seek",
if (!_PyArg_ParseStack(args, nargs, "n|i:seek",
&pos, &whence)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("seek", kwnames)) {
goto exit;
}
return_value = _io_BytesIO_seek_impl(self, pos, whence);
exit:
@ -429,4 +449,4 @@ _io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=6382e8eb578eea64 input=a9049054013a1b77]*/
/*[clinic end generated code: output=08139186b009ec47 input=a9049054013a1b77]*/

39
third_party/python/Modules/_io/clinic/fileio.inc vendored
View file

@ -15,6 +15,9 @@ PyDoc_STRVAR(_io_FileIO_close__doc__,
#define _IO_FILEIO_CLOSE_METHODDEF \
{"close", (PyCFunction)_io_FileIO_close, METH_NOARGS, _io_FileIO_close__doc__},
static PyObject *
_io_FileIO_close_impl(fileio *self);
static PyObject *
_io_FileIO_close(fileio *self, PyObject *Py_UNUSED(ignored))
{
@ -39,6 +42,10 @@ PyDoc_STRVAR(_io_FileIO___init____doc__,
"*opener* must return an open file descriptor (passing os.open as *opener*\n"
"results in functionality similar to passing None).");
static int
_io_FileIO___init___impl(fileio *self, PyObject *nameobj, const char *mode,
int closefd, PyObject *opener);
static int
_io_FileIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
{
@ -196,21 +203,25 @@ PyDoc_STRVAR(_io_FileIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO_FILEIO_READ_METHODDEF \
{"read", (PyCFunction)_io_FileIO_read, METH_VARARGS, _io_FileIO_read__doc__},
{"read", (PyCFunction)_io_FileIO_read, METH_FASTCALL, _io_FileIO_read__doc__},
static PyObject *
_io_FileIO_read_impl(fileio *self, Py_ssize_t size);
static PyObject *
_io_FileIO_read(fileio *self, PyObject *args)
_io_FileIO_read(fileio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|O&:read",
if (!_PyArg_ParseStack(args, nargs, "|O&:read",
_PyIO_ConvertSsize_t, &size)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io_FileIO_read_impl(self, size);
exit:
@ -268,22 +279,26 @@ PyDoc_STRVAR(_io_FileIO_seek__doc__,
"Note that not all file objects are seekable.");
#define _IO_FILEIO_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_FileIO_seek, METH_VARARGS, _io_FileIO_seek__doc__},
{"seek", (PyCFunction)_io_FileIO_seek, METH_FASTCALL, _io_FileIO_seek__doc__},
static PyObject *
_io_FileIO_seek_impl(fileio *self, PyObject *pos, int whence);
static PyObject *
_io_FileIO_seek(fileio *self, PyObject *args)
_io_FileIO_seek(fileio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *pos;
int whence = 0;
if (!PyArg_ParseTuple(args, "O|i:seek",
if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
&pos, &whence)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("seek", kwnames)) {
goto exit;
}
return_value = _io_FileIO_seek_impl(self, pos, whence);
exit:
@ -322,22 +337,26 @@ PyDoc_STRVAR(_io_FileIO_truncate__doc__,
"The current file position is changed to the value of size.");
#define _IO_FILEIO_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_FileIO_truncate, METH_VARARGS, _io_FileIO_truncate__doc__},
{"truncate", (PyCFunction)_io_FileIO_truncate, METH_FASTCALL, _io_FileIO_truncate__doc__},
static PyObject *
_io_FileIO_truncate_impl(fileio *self, PyObject *posobj);
static PyObject *
_io_FileIO_truncate(fileio *self, PyObject *args)
_io_FileIO_truncate(fileio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *posobj = NULL;
if (!PyArg_UnpackTuple(args, "truncate",
if (!_PyArg_UnpackStack(args, nargs, "truncate",
0, 1,
&posobj)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("truncate", kwnames)) {
goto exit;
}
return_value = _io_FileIO_truncate_impl(self, posobj);
exit:
@ -367,4 +386,4 @@ _io_FileIO_isatty(fileio *self, PyObject *Py_UNUSED(ignored))
#ifndef _IO_FILEIO_TRUNCATE_METHODDEF
#define _IO_FILEIO_TRUNCATE_METHODDEF
#endif /* !defined(_IO_FILEIO_TRUNCATE_METHODDEF) */
/*[clinic end generated code: output=51924bc0ee11d58e input=a9049054013a1b77]*/
/*[clinic end generated code: output=034d782a0daa82bd input=a9049054013a1b77]*/

62
third_party/python/Modules/_io/clinic/iobase.inc vendored
View file

@ -12,6 +12,9 @@ PyDoc_STRVAR(_io__IOBase_tell__doc__,
#define _IO__IOBASE_TELL_METHODDEF \
{"tell", (PyCFunction)_io__IOBase_tell, METH_NOARGS, _io__IOBase_tell__doc__},
static PyObject *
_io__IOBase_tell_impl(PyObject *self);
static PyObject *
_io__IOBase_tell(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -29,6 +32,9 @@ PyDoc_STRVAR(_io__IOBase_flush__doc__,
#define _IO__IOBASE_FLUSH_METHODDEF \
{"flush", (PyCFunction)_io__IOBase_flush, METH_NOARGS, _io__IOBase_flush__doc__},
static PyObject *
_io__IOBase_flush_impl(PyObject *self);
static PyObject *
_io__IOBase_flush(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -46,6 +52,9 @@ PyDoc_STRVAR(_io__IOBase_close__doc__,
#define _IO__IOBASE_CLOSE_METHODDEF \
{"close", (PyCFunction)_io__IOBase_close, METH_NOARGS, _io__IOBase_close__doc__},
static PyObject *
_io__IOBase_close_impl(PyObject *self);
static PyObject *
_io__IOBase_close(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -64,6 +73,9 @@ PyDoc_STRVAR(_io__IOBase_seekable__doc__,
#define _IO__IOBASE_SEEKABLE_METHODDEF \
{"seekable", (PyCFunction)_io__IOBase_seekable, METH_NOARGS, _io__IOBase_seekable__doc__},
static PyObject *
_io__IOBase_seekable_impl(PyObject *self);
static PyObject *
_io__IOBase_seekable(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -81,6 +93,9 @@ PyDoc_STRVAR(_io__IOBase_readable__doc__,
#define _IO__IOBASE_READABLE_METHODDEF \
{"readable", (PyCFunction)_io__IOBase_readable, METH_NOARGS, _io__IOBase_readable__doc__},
static PyObject *
_io__IOBase_readable_impl(PyObject *self);
static PyObject *
_io__IOBase_readable(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -98,6 +113,9 @@ PyDoc_STRVAR(_io__IOBase_writable__doc__,
#define _IO__IOBASE_WRITABLE_METHODDEF \
{"writable", (PyCFunction)_io__IOBase_writable, METH_NOARGS, _io__IOBase_writable__doc__},
static PyObject *
_io__IOBase_writable_impl(PyObject *self);
static PyObject *
_io__IOBase_writable(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -115,6 +133,9 @@ PyDoc_STRVAR(_io__IOBase_fileno__doc__,
#define _IO__IOBASE_FILENO_METHODDEF \
{"fileno", (PyCFunction)_io__IOBase_fileno, METH_NOARGS, _io__IOBase_fileno__doc__},
static PyObject *
_io__IOBase_fileno_impl(PyObject *self);
static PyObject *
_io__IOBase_fileno(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -132,6 +153,9 @@ PyDoc_STRVAR(_io__IOBase_isatty__doc__,
#define _IO__IOBASE_ISATTY_METHODDEF \
{"isatty", (PyCFunction)_io__IOBase_isatty, METH_NOARGS, _io__IOBase_isatty__doc__},
static PyObject *
_io__IOBase_isatty_impl(PyObject *self);
static PyObject *
_io__IOBase_isatty(PyObject *self, PyObject *Py_UNUSED(ignored))
{
@ -151,18 +175,25 @@ PyDoc_STRVAR(_io__IOBase_readline__doc__,
"terminator(s) recognized.");
#define _IO__IOBASE_READLINE_METHODDEF \
{"readline", (PyCFunction)_io__IOBase_readline, METH_VARARGS, _io__IOBase_readline__doc__},
{"readline", (PyCFunction)_io__IOBase_readline, METH_FASTCALL, _io__IOBase_readline__doc__},
static PyObject *
_io__IOBase_readline(PyObject *self, PyObject *args)
_io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit);
static PyObject *
_io__IOBase_readline(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t limit = -1;
if (!PyArg_ParseTuple(args, "|O&:readline",
if (!_PyArg_ParseStack(args, nargs, "|O&:readline",
_PyIO_ConvertSsize_t, &limit)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readline", kwnames)) {
goto exit;
}
return_value = _io__IOBase_readline_impl(self, limit);
exit:
@ -180,18 +211,25 @@ PyDoc_STRVAR(_io__IOBase_readlines__doc__,
"lines so far exceeds hint.");
#define _IO__IOBASE_READLINES_METHODDEF \
{"readlines", (PyCFunction)_io__IOBase_readlines, METH_VARARGS, _io__IOBase_readlines__doc__},
{"readlines", (PyCFunction)_io__IOBase_readlines, METH_FASTCALL, _io__IOBase_readlines__doc__},
static PyObject *
_io__IOBase_readlines(PyObject *self, PyObject *args)
_io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint);
static PyObject *
_io__IOBase_readlines(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t hint = -1;
if (!PyArg_ParseTuple(args, "|O&:readlines",
if (!_PyArg_ParseStack(args, nargs, "|O&:readlines",
_PyIO_ConvertSsize_t, &hint)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readlines", kwnames)) {
goto exit;
}
return_value = _io__IOBase_readlines_impl(self, hint);
exit:
@ -212,21 +250,25 @@ PyDoc_STRVAR(_io__RawIOBase_read__doc__,
"\n");
#define _IO__RAWIOBASE_READ_METHODDEF \
{"read", (PyCFunction)_io__RawIOBase_read, METH_VARARGS, _io__RawIOBase_read__doc__},
{"read", (PyCFunction)_io__RawIOBase_read, METH_FASTCALL, _io__RawIOBase_read__doc__},
static PyObject *
_io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n);
static PyObject *
_io__RawIOBase_read(PyObject *self, PyObject *args)
_io__RawIOBase_read(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t n = -1;
if (!PyArg_ParseTuple(args, "|n:read",
if (!_PyArg_ParseStack(args, nargs, "|n:read",
&n)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io__RawIOBase_read_impl(self, n);
exit:
@ -250,4 +292,4 @@ _io__RawIOBase_readall(PyObject *self, PyObject *Py_UNUSED(ignored))
{
return _io__RawIOBase_readall_impl(self);
}
/*[clinic end generated code: output=0f53fed928d8e02f input=a9049054013a1b77]*/
/*[clinic end generated code: output=1bcece367fc7b0cd input=a9049054013a1b77]*/

45
third_party/python/Modules/_io/clinic/stringio.inc vendored
View file

@ -12,6 +12,9 @@ PyDoc_STRVAR(_io_StringIO_getvalue__doc__,
#define _IO_STRINGIO_GETVALUE_METHODDEF \
{"getvalue", (PyCFunction)_io_StringIO_getvalue, METH_NOARGS, _io_StringIO_getvalue__doc__},
static PyObject *
_io_StringIO_getvalue_impl(stringio *self);
static PyObject *
_io_StringIO_getvalue(stringio *self, PyObject *Py_UNUSED(ignored))
{
@ -46,22 +49,26 @@ PyDoc_STRVAR(_io_StringIO_read__doc__,
"is reached. Return an empty string at EOF.");
#define _IO_STRINGIO_READ_METHODDEF \
{"read", (PyCFunction)_io_StringIO_read, METH_VARARGS, _io_StringIO_read__doc__},
{"read", (PyCFunction)_io_StringIO_read, METH_FASTCALL, _io_StringIO_read__doc__},
static PyObject *
_io_StringIO_read_impl(stringio *self, PyObject *arg);
static PyObject *
_io_StringIO_read(stringio *self, PyObject *args)
_io_StringIO_read(stringio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "read",
if (!_PyArg_UnpackStack(args, nargs, "read",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io_StringIO_read_impl(self, arg);
exit:
@ -77,22 +84,26 @@ PyDoc_STRVAR(_io_StringIO_readline__doc__,
"Returns an empty string if EOF is hit immediately.");
#define _IO_STRINGIO_READLINE_METHODDEF \
{"readline", (PyCFunction)_io_StringIO_readline, METH_VARARGS, _io_StringIO_readline__doc__},
{"readline", (PyCFunction)_io_StringIO_readline, METH_FASTCALL, _io_StringIO_readline__doc__},
static PyObject *
_io_StringIO_readline_impl(stringio *self, PyObject *arg);
static PyObject *
_io_StringIO_readline(stringio *self, PyObject *args)
_io_StringIO_readline(stringio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "readline",
if (!_PyArg_UnpackStack(args, nargs, "readline",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readline", kwnames)) {
goto exit;
}
return_value = _io_StringIO_readline_impl(self, arg);
exit:
@ -110,22 +121,26 @@ PyDoc_STRVAR(_io_StringIO_truncate__doc__,
"Returns the new absolute position.");
#define _IO_STRINGIO_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_StringIO_truncate, METH_VARARGS, _io_StringIO_truncate__doc__},
{"truncate", (PyCFunction)_io_StringIO_truncate, METH_FASTCALL, _io_StringIO_truncate__doc__},
static PyObject *
_io_StringIO_truncate_impl(stringio *self, PyObject *arg);
static PyObject *
_io_StringIO_truncate(stringio *self, PyObject *args)
_io_StringIO_truncate(stringio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *arg = Py_None;
if (!PyArg_UnpackTuple(args, "truncate",
if (!_PyArg_UnpackStack(args, nargs, "truncate",
0, 1,
&arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("truncate", kwnames)) {
goto exit;
}
return_value = _io_StringIO_truncate_impl(self, arg);
exit:
@ -145,22 +160,26 @@ PyDoc_STRVAR(_io_StringIO_seek__doc__,
"Returns the new absolute position.");
#define _IO_STRINGIO_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_StringIO_seek, METH_VARARGS, _io_StringIO_seek__doc__},
{"seek", (PyCFunction)_io_StringIO_seek, METH_FASTCALL, _io_StringIO_seek__doc__},
static PyObject *
_io_StringIO_seek_impl(stringio *self, Py_ssize_t pos, int whence);
static PyObject *
_io_StringIO_seek(stringio *self, PyObject *args)
_io_StringIO_seek(stringio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t pos;
int whence = 0;
if (!PyArg_ParseTuple(args, "n|i:seek",
if (!_PyArg_ParseStack(args, nargs, "n|i:seek",
&pos, &whence)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("seek", kwnames)) {
goto exit;
}
return_value = _io_StringIO_seek_impl(self, pos, whence);
exit:
@ -287,4 +306,4 @@ _io_StringIO_seekable(stringio *self, PyObject *Py_UNUSED(ignored))
{
return _io_StringIO_seekable_impl(self);
}
/*[clinic end generated code: output=5dd5c2a213e75405 input=a9049054013a1b77]*/
/*[clinic end generated code: output=ce8018ec29def422 input=a9049054013a1b77]*/

50
third_party/python/Modules/_io/clinic/textio.inc vendored
View file

@ -1,9 +1,3 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Python 3 │
│ https://docs.python.org/3/license.html │
╚─────────────────────────────────────────────────────────────────────────────*/
/* clang-format off */
/*[clinic input]
preserve
@ -68,7 +62,7 @@ _io_IncrementalNewlineDecoder_decode(nldecoder_object *self, PyObject **args, Py
PyObject *input;
int final = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &final)) {
goto exit;
}
@ -232,21 +226,25 @@ PyDoc_STRVAR(_io_TextIOWrapper_read__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_READ_METHODDEF \
{"read", (PyCFunction)_io_TextIOWrapper_read, METH_VARARGS, _io_TextIOWrapper_read__doc__},
{"read", (PyCFunction)_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
static PyObject *
_io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n);
static PyObject *
_io_TextIOWrapper_read(textio *self, PyObject *args)
_io_TextIOWrapper_read(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t n = -1;
if (!PyArg_ParseTuple(args, "|O&:read",
if (!_PyArg_ParseStack(args, nargs, "|O&:read",
_PyIO_ConvertSsize_t, &n)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io_TextIOWrapper_read_impl(self, n);
exit:
@ -259,21 +257,25 @@ PyDoc_STRVAR(_io_TextIOWrapper_readline__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_READLINE_METHODDEF \
{"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_VARARGS, _io_TextIOWrapper_readline__doc__},
{"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
static PyObject *
_io_TextIOWrapper_readline_impl(textio *self, Py_ssize_t size);
static PyObject *
_io_TextIOWrapper_readline(textio *self, PyObject *args)
_io_TextIOWrapper_readline(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|n:readline",
if (!_PyArg_ParseStack(args, nargs, "|n:readline",
&size)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("readline", kwnames)) {
goto exit;
}
return_value = _io_TextIOWrapper_readline_impl(self, size);
exit:
@ -286,22 +288,26 @@ PyDoc_STRVAR(_io_TextIOWrapper_seek__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_VARARGS, _io_TextIOWrapper_seek__doc__},
{"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
static PyObject *
_io_TextIOWrapper_seek_impl(textio *self, PyObject *cookieObj, int whence);
static PyObject *
_io_TextIOWrapper_seek(textio *self, PyObject *args)
_io_TextIOWrapper_seek(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *cookieObj;
int whence = 0;
if (!PyArg_ParseTuple(args, "O|i:seek",
if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
&cookieObj, &whence)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("seek", kwnames)) {
goto exit;
}
return_value = _io_TextIOWrapper_seek_impl(self, cookieObj, whence);
exit:
@ -331,22 +337,26 @@ PyDoc_STRVAR(_io_TextIOWrapper_truncate__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_TextIOWrapper_truncate, METH_VARARGS, _io_TextIOWrapper_truncate__doc__},
{"truncate", (PyCFunction)_io_TextIOWrapper_truncate, METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
static PyObject *
_io_TextIOWrapper_truncate_impl(textio *self, PyObject *pos);
static PyObject *
_io_TextIOWrapper_truncate(textio *self, PyObject *args)
_io_TextIOWrapper_truncate(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *pos = Py_None;
if (!PyArg_UnpackTuple(args, "truncate",
if (!_PyArg_UnpackStack(args, nargs, "truncate",
0, 1,
&pos)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("truncate", kwnames)) {
goto exit;
}
return_value = _io_TextIOWrapper_truncate_impl(self, pos);
exit:
@ -471,4 +481,4 @@ _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
{
return _io_TextIOWrapper_close_impl(self);
}
/*[clinic end generated code: output=78ad14eba1667254 input=a9049054013a1b77]*/
/*[clinic end generated code: output=67eba50449900a96 input=a9049054013a1b77]*/

88
third_party/python/Modules/_io/clinic/winconsoleio.inc vendored
View file

@ -3,8 +3,6 @@
preserve
[clinic start generated code]*/
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_close__doc__,
"close($self, /)\n"
"--\n"
@ -26,10 +24,6 @@ _io__WindowsConsoleIO_close(winconsoleio *self, PyObject *Py_UNUSED(ignored))
return _io__WindowsConsoleIO_close_impl(self);
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO___init____doc__,
"_WindowsConsoleIO(file, mode=\'r\', closefd=True, opener=None)\n"
"--\n"
@ -66,10 +60,6 @@ exit:
return return_value;
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_fileno__doc__,
"fileno($self, /)\n"
"--\n"
@ -91,10 +81,6 @@ _io__WindowsConsoleIO_fileno(winconsoleio *self, PyObject *Py_UNUSED(ignored))
return _io__WindowsConsoleIO_fileno_impl(self);
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_readable__doc__,
"readable($self, /)\n"
"--\n"
@ -113,10 +99,6 @@ _io__WindowsConsoleIO_readable(winconsoleio *self, PyObject *Py_UNUSED(ignored))
return _io__WindowsConsoleIO_readable_impl(self);
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_writable__doc__,
"writable($self, /)\n"
"--\n"
@ -135,10 +117,6 @@ _io__WindowsConsoleIO_writable(winconsoleio *self, PyObject *Py_UNUSED(ignored))
return _io__WindowsConsoleIO_writable_impl(self);
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_readinto__doc__,
"readinto($self, buffer, /)\n"
"--\n"
@ -171,10 +149,6 @@ exit:
return return_value;
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_readall__doc__,
"readall($self, /)\n"
"--\n"
@ -195,10 +169,6 @@ _io__WindowsConsoleIO_readall(winconsoleio *self, PyObject *Py_UNUSED(ignored))
return _io__WindowsConsoleIO_readall_impl(self);
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_read__doc__,
"read($self, size=-1, /)\n"
"--\n"
@ -210,31 +180,31 @@ PyDoc_STRVAR(_io__WindowsConsoleIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO__WINDOWSCONSOLEIO_READ_METHODDEF \
{"read", (PyCFunction)_io__WindowsConsoleIO_read, METH_VARARGS, _io__WindowsConsoleIO_read__doc__},
{"read", (PyCFunction)_io__WindowsConsoleIO_read, METH_FASTCALL, _io__WindowsConsoleIO_read__doc__},
static PyObject *
_io__WindowsConsoleIO_read_impl(winconsoleio *self, Py_ssize_t size);
static PyObject *
_io__WindowsConsoleIO_read(winconsoleio *self, PyObject *args)
_io__WindowsConsoleIO_read(winconsoleio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t size = -1;
if (!PyArg_ParseTuple(args, "|O&:read",
if (!_PyArg_ParseStack(args, nargs, "|O&:read",
_PyIO_ConvertSsize_t, &size)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("read", kwnames)) {
goto exit;
}
return_value = _io__WindowsConsoleIO_read_impl(self, size);
exit:
return return_value;
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_write__doc__,
"write($self, b, /)\n"
"--\n"
@ -270,10 +240,6 @@ exit:
return return_value;
}
#endif /* defined(MS_WINDOWS) */
#if defined(MS_WINDOWS)
PyDoc_STRVAR(_io__WindowsConsoleIO_isatty__doc__,
"isatty($self, /)\n"
"--\n"
@ -291,42 +257,4 @@ _io__WindowsConsoleIO_isatty(winconsoleio *self, PyObject *Py_UNUSED(ignored))
{
return _io__WindowsConsoleIO_isatty_impl(self);
}
#endif /* defined(MS_WINDOWS) */
#ifndef _IO__WINDOWSCONSOLEIO_CLOSE_METHODDEF
#define _IO__WINDOWSCONSOLEIO_CLOSE_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_CLOSE_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_FILENO_METHODDEF
#define _IO__WINDOWSCONSOLEIO_FILENO_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_FILENO_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_READABLE_METHODDEF
#define _IO__WINDOWSCONSOLEIO_READABLE_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_READABLE_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_WRITABLE_METHODDEF
#define _IO__WINDOWSCONSOLEIO_WRITABLE_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_WRITABLE_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_READINTO_METHODDEF
#define _IO__WINDOWSCONSOLEIO_READINTO_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_READINTO_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_READALL_METHODDEF
#define _IO__WINDOWSCONSOLEIO_READALL_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_READALL_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_READ_METHODDEF
#define _IO__WINDOWSCONSOLEIO_READ_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_READ_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_WRITE_METHODDEF
#define _IO__WINDOWSCONSOLEIO_WRITE_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_WRITE_METHODDEF) */
#ifndef _IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF
#define _IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF) */
/*[clinic end generated code: output=9eba916f8537fff7 input=a9049054013a1b77]*/
/*[clinic end generated code: output=b097ceeb54d6e15e input=a9049054013a1b77]*/

2
third_party/python/Modules/_io/winconsoleio.c vendored
View file

@ -1179,5 +1179,3 @@ PyTypeObject PyWindowsConsoleIO_Type = {
};
PyAPI_DATA(PyObject *) _PyWindowsConsoleIO_Type = (PyObject*)&PyWindowsConsoleIO_Type;
#endif /* MS_WINDOWS */

57
third_party/python/Modules/_pickle.c vendored
View file

@ -5946,6 +5946,8 @@ static int
do_append(UnpicklerObject *self, Py_ssize_t x)
{
PyObject *value;
PyObject *slice;
PyObject *result;
PyObject *list;
Py_ssize_t len, i;
@ -5957,8 +5959,7 @@ do_append(UnpicklerObject *self, Py_ssize_t x)
list = self->stack->data[x - 1];
if (PyList_Check(list)) {
PyObject *slice;
if (PyList_CheckExact(list)) {
Py_ssize_t list_len;
int ret;
@ -5971,27 +5972,47 @@ do_append(UnpicklerObject *self, Py_ssize_t x)
return ret;
}
else {
PyObject *append_func;
_Py_IDENTIFIER(append);
PyObject *extend_func;
_Py_IDENTIFIER(extend);
append_func = _PyObject_GetAttrId(list, &PyId_append);
if (append_func == NULL)
return -1;
for (i = x; i < len; i++) {
PyObject *result;
value = self->stack->data[i];
result = _Pickle_FastCall(append_func, value);
if (result == NULL) {
Pdata_clear(self->stack, i + 1);
Py_SIZE(self->stack) = x;
Py_DECREF(append_func);
extend_func = _PyObject_GetAttrId(list, &PyId_extend);
if (extend_func != NULL) {
slice = Pdata_poplist(self->stack, x);
if (!slice) {
Py_DECREF(extend_func);
return -1;
}
result = _Pickle_FastCall(extend_func, slice);
Py_DECREF(extend_func);
if (result == NULL)
return -1;
Py_DECREF(result);
}
Py_SIZE(self->stack) = x;
Py_DECREF(append_func);
else {
PyObject *append_func;
_Py_IDENTIFIER(append);
/* Even if the PEP 307 requires extend() and append() methods,
fall back on append() if the object has no extend() method
for backward compatibility. */
PyErr_Clear();
append_func = _PyObject_GetAttrId(list, &PyId_append);
if (append_func == NULL)
return -1;
for (i = x; i < len; i++) {
value = self->stack->data[i];
result = _Pickle_FastCall(append_func, value);
if (result == NULL) {
Pdata_clear(self->stack, i + 1);
Py_SIZE(self->stack) = x;
Py_DECREF(append_func);
return -1;
}
Py_DECREF(result);
}
Py_SIZE(self->stack) = x;
Py_DECREF(append_func);
}
}
return 0;

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;

1
third_party/python/Modules/audioop.c vendored
View file

@ -7,6 +7,7 @@
#define PY_SSIZE_T_CLEAN
#include "dsp/core/core.h"
#include "libc/math.h"
#include "third_party/python/Include/abstract.h"
#include "third_party/python/Include/dictobject.h"
#include "third_party/python/Include/floatobject.h"
#include "third_party/python/Include/import.h"

8
third_party/python/Modules/cjkcodecs/clinic/multibytecodec.inc vendored
View file

@ -31,7 +31,7 @@ _multibytecodec_MultibyteCodec_encode(MultibyteCodecObject *self, PyObject **arg
PyObject *input;
const char *errors = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &errors)) {
goto exit;
}
@ -69,7 +69,7 @@ _multibytecodec_MultibyteCodec_decode(MultibyteCodecObject *self, PyObject **arg
Py_buffer input = {NULL, NULL};
const char *errors = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &errors)) {
goto exit;
}
@ -106,7 +106,7 @@ _multibytecodec_MultibyteIncrementalEncoder_encode(MultibyteIncrementalEncoderOb
PyObject *input;
int final = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &final)) {
goto exit;
}
@ -155,7 +155,7 @@ _multibytecodec_MultibyteIncrementalDecoder_decode(MultibyteIncrementalDecoderOb
Py_buffer input = {NULL, NULL};
int final = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&input, &final)) {
goto exit;
}

14
third_party/python/Modules/clinic/_asynciomodule.inc vendored
View file

@ -281,7 +281,7 @@ _asyncio_Task_current_task(PyTypeObject *type, PyObject **args, Py_ssize_t nargs
static _PyArg_Parser _parser = {"|O:current_task", _keywords, 0};
PyObject *loop = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&loop)) {
goto exit;
}
@ -313,7 +313,7 @@ _asyncio_Task_all_tasks(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, P
static _PyArg_Parser _parser = {"|O:all_tasks", _keywords, 0};
PyObject *loop = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&loop)) {
goto exit;
}
@ -413,7 +413,7 @@ _asyncio_Task_get_stack(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObje
static _PyArg_Parser _parser = {"|$O:get_stack", _keywords, 0};
PyObject *limit = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&limit)) {
goto exit;
}
@ -451,7 +451,7 @@ _asyncio_Task_print_stack(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyOb
PyObject *limit = Py_None;
PyObject *file = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&limit, &file)) {
goto exit;
}
@ -480,7 +480,7 @@ _asyncio_Task__step(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject *
static _PyArg_Parser _parser = {"|O:_step", _keywords, 0};
PyObject *exc = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&exc)) {
goto exit;
}
@ -509,7 +509,7 @@ _asyncio_Task__wakeup(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject
static _PyArg_Parser _parser = {"O:_wakeup", _keywords, 0};
PyObject *fut;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&fut)) {
goto exit;
}
@ -518,4 +518,4 @@ _asyncio_Task__wakeup(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject
exit:
return return_value;
}
/*[clinic end generated code: output=7441872b13652085 input=a9049054013a1b77]*/
/*[clinic end generated code: output=1f2f5bbc35bc3c4e input=a9049054013a1b77]*/

4
third_party/python/Modules/clinic/_bz2module.inc vendored
View file

@ -131,7 +131,7 @@ _bz2_BZ2Decompressor_decompress(BZ2Decompressor *self, PyObject **args, Py_ssize
Py_buffer data = {NULL, NULL};
Py_ssize_t max_length = -1;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &max_length)) {
goto exit;
}
@ -175,4 +175,4 @@ _bz2_BZ2Decompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=7e57af0b368d3e55 input=a9049054013a1b77]*/
/*[clinic end generated code: output=0e97a1d716b35a14 input=a9049054013a1b77]*/

406
third_party/python/Modules/clinic/_codecsmodule.inc vendored
View file

File diff suppressed because it is too large Load diff

12
third_party/python/Modules/clinic/_cryptmodule.inc vendored
View file

@ -15,25 +15,29 @@ PyDoc_STRVAR(crypt_crypt__doc__,
"results for a given *word*.");
#define CRYPT_CRYPT_METHODDEF \
{"crypt", (PyCFunction)crypt_crypt, METH_VARARGS, crypt_crypt__doc__},
{"crypt", (PyCFunction)crypt_crypt, METH_FASTCALL, crypt_crypt__doc__},
static PyObject *
crypt_crypt_impl(PyObject *module, const char *word, const char *salt);
static PyObject *
crypt_crypt(PyObject *module, PyObject *args)
crypt_crypt(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
const char *word;
const char *salt;
if (!PyArg_ParseTuple(args, "ss:crypt",
if (!_PyArg_ParseStack(args, nargs, "ss:crypt",
&word, &salt)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("crypt", kwnames)) {
goto exit;
}
return_value = crypt_crypt_impl(module, word, salt);
exit:
return return_value;
}
/*[clinic end generated code: output=8dfc88264e662df4 input=a9049054013a1b77]*/
/*[clinic end generated code: output=3fd5d3625a6f32fe input=a9049054013a1b77]*/

4
third_party/python/Modules/clinic/_datetimemodule.inc vendored
View file

@ -28,7 +28,7 @@ datetime_datetime_now(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, PyO
static _PyArg_Parser _parser = {"|O:now", _keywords, 0};
PyObject *tz = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&tz)) {
goto exit;
}
@ -37,4 +37,4 @@ datetime_datetime_now(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, PyO
exit:
return return_value;
}
/*[clinic end generated code: output=8aaac0705add61ca input=a9049054013a1b77]*/
/*[clinic end generated code: output=ff78f2f51687e9a9 input=a9049054013a1b77]*/

32
third_party/python/Modules/clinic/_dbmmodule.inc vendored
View file

@ -46,24 +46,28 @@ PyDoc_STRVAR(_dbm_dbm_get__doc__,
"Return the value for key if present, otherwise default.");
#define _DBM_DBM_GET_METHODDEF \
{"get", (PyCFunction)_dbm_dbm_get, METH_VARARGS, _dbm_dbm_get__doc__},
{"get", (PyCFunction)_dbm_dbm_get, METH_FASTCALL, _dbm_dbm_get__doc__},
static PyObject *
_dbm_dbm_get_impl(dbmobject *self, const char *key,
Py_ssize_clean_t key_length, PyObject *default_value);
static PyObject *
_dbm_dbm_get(dbmobject *self, PyObject *args)
_dbm_dbm_get(dbmobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
const char *key;
Py_ssize_clean_t key_length;
PyObject *default_value = Py_None;
if (!PyArg_ParseTuple(args, "s#|O:get",
if (!_PyArg_ParseStack(args, nargs, "s#|O:get",
&key, &key_length, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("get", kwnames)) {
goto exit;
}
return_value = _dbm_dbm_get_impl(self, key, key_length, default_value);
exit:
@ -79,7 +83,7 @@ PyDoc_STRVAR(_dbm_dbm_setdefault__doc__,
"If key is not in the database, it is inserted with default as the value.");
#define _DBM_DBM_SETDEFAULT_METHODDEF \
{"setdefault", (PyCFunction)_dbm_dbm_setdefault, METH_VARARGS, _dbm_dbm_setdefault__doc__},
{"setdefault", (PyCFunction)_dbm_dbm_setdefault, METH_FASTCALL, _dbm_dbm_setdefault__doc__},
static PyObject *
_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
@ -87,17 +91,21 @@ _dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
PyObject *default_value);
static PyObject *
_dbm_dbm_setdefault(dbmobject *self, PyObject *args)
_dbm_dbm_setdefault(dbmobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
const char *key;
Py_ssize_clean_t key_length;
PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "s#|O:setdefault",
if (!_PyArg_ParseStack(args, nargs, "s#|O:setdefault",
&key, &key_length, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("setdefault", kwnames)) {
goto exit;
}
return_value = _dbm_dbm_setdefault_impl(self, key, key_length, default_value);
exit:
@ -119,27 +127,31 @@ PyDoc_STRVAR(dbmopen__doc__,
" (e.g. os.O_RDWR).");
#define DBMOPEN_METHODDEF \
{"open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
{"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
static PyObject *
dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
int mode);
static PyObject *
dbmopen(PyObject *module, PyObject *args)
dbmopen(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *filename;
const char *flags = "r";
int mode = 438;
if (!PyArg_ParseTuple(args, "U|si:open",
if (!_PyArg_ParseStack(args, nargs, "U|si:open",
&filename, &flags, &mode)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("open", kwnames)) {
goto exit;
}
return_value = dbmopen_impl(module, filename, flags, mode);
exit:
return return_value;
}
/*[clinic end generated code: output=919cc4337be4a5d3 input=a9049054013a1b77]*/
/*[clinic end generated code: output=60482e924110a70a input=a9049054013a1b77]*/

74
third_party/python/Modules/clinic/_elementtree.inc vendored
View file

@ -152,7 +152,7 @@ _elementtree_Element_find(ElementObject *self, PyObject **args, Py_ssize_t nargs
PyObject *path;
PyObject *namespaces = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&path, &namespaces)) {
goto exit;
}
@ -185,7 +185,7 @@ _elementtree_Element_findtext(ElementObject *self, PyObject **args, Py_ssize_t n
PyObject *default_value = Py_None;
PyObject *namespaces = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&path, &default_value, &namespaces)) {
goto exit;
}
@ -216,7 +216,7 @@ _elementtree_Element_findall(ElementObject *self, PyObject **args, Py_ssize_t na
PyObject *path;
PyObject *namespaces = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&path, &namespaces)) {
goto exit;
}
@ -247,7 +247,7 @@ _elementtree_Element_iterfind(ElementObject *self, PyObject **args, Py_ssize_t n
PyObject *path;
PyObject *namespaces = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&path, &namespaces)) {
goto exit;
}
@ -278,7 +278,7 @@ _elementtree_Element_get(ElementObject *self, PyObject **args, Py_ssize_t nargs,
PyObject *key;
PyObject *default_value = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&key, &default_value)) {
goto exit;
}
@ -324,7 +324,7 @@ _elementtree_Element_iter(ElementObject *self, PyObject **args, Py_ssize_t nargs
static _PyArg_Parser _parser = {"|O:iter", _keywords, 0};
PyObject *tag = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&tag)) {
goto exit;
}
@ -357,23 +357,27 @@ PyDoc_STRVAR(_elementtree_Element_insert__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF \
{"insert", (PyCFunction)_elementtree_Element_insert, METH_VARARGS, _elementtree_Element_insert__doc__},
{"insert", (PyCFunction)_elementtree_Element_insert, METH_FASTCALL, _elementtree_Element_insert__doc__},
static PyObject *
_elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,
PyObject *subelement);
static PyObject *
_elementtree_Element_insert(ElementObject *self, PyObject *args)
_elementtree_Element_insert(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t index;
PyObject *subelement;
if (!PyArg_ParseTuple(args, "nO!:insert",
if (!_PyArg_ParseStack(args, nargs, "nO!:insert",
&index, &Element_Type, &subelement)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("insert", kwnames)) {
goto exit;
}
return_value = _elementtree_Element_insert_impl(self, index, subelement);
exit:
@ -420,24 +424,28 @@ PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
{"makeelement", (PyCFunction)_elementtree_Element_makeelement, METH_VARARGS, _elementtree_Element_makeelement__doc__},
{"makeelement", (PyCFunction)_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__},
static PyObject *
_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
PyObject *attrib);
static PyObject *
_elementtree_Element_makeelement(ElementObject *self, PyObject *args)
_elementtree_Element_makeelement(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *tag;
PyObject *attrib;
if (!PyArg_UnpackTuple(args, "makeelement",
if (!_PyArg_UnpackStack(args, nargs, "makeelement",
2, 2,
&tag, &attrib)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("makeelement", kwnames)) {
goto exit;
}
return_value = _elementtree_Element_makeelement_impl(self, tag, attrib);
exit:
@ -476,24 +484,28 @@ PyDoc_STRVAR(_elementtree_Element_set__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_SET_METHODDEF \
{"set", (PyCFunction)_elementtree_Element_set, METH_VARARGS, _elementtree_Element_set__doc__},
{"set", (PyCFunction)_elementtree_Element_set, METH_FASTCALL, _elementtree_Element_set__doc__},
static PyObject *
_elementtree_Element_set_impl(ElementObject *self, PyObject *key,
PyObject *value);
static PyObject *
_elementtree_Element_set(ElementObject *self, PyObject *args)
_elementtree_Element_set(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *key;
PyObject *value;
if (!PyArg_UnpackTuple(args, "set",
if (!_PyArg_UnpackStack(args, nargs, "set",
2, 2,
&key, &value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("set", kwnames)) {
goto exit;
}
return_value = _elementtree_Element_set_impl(self, key, value);
exit:
@ -561,24 +573,28 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
"\n");
#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
{"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_VARARGS, _elementtree_TreeBuilder_start__doc__},
{"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
static PyObject *
_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
PyObject *attrs);
static PyObject *
_elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject *args)
_elementtree_TreeBuilder_start(TreeBuilderObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *tag;
PyObject *attrs = Py_None;
if (!PyArg_UnpackTuple(args, "start",
if (!_PyArg_UnpackStack(args, nargs, "start",
1, 2,
&tag, &attrs)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("start", kwnames)) {
goto exit;
}
return_value = _elementtree_TreeBuilder_start_impl(self, tag, attrs);
exit:
@ -648,25 +664,29 @@ PyDoc_STRVAR(_elementtree_XMLParser_doctype__doc__,
"\n");
#define _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF \
{"doctype", (PyCFunction)_elementtree_XMLParser_doctype, METH_VARARGS, _elementtree_XMLParser_doctype__doc__},
{"doctype", (PyCFunction)_elementtree_XMLParser_doctype, METH_FASTCALL, _elementtree_XMLParser_doctype__doc__},
static PyObject *
_elementtree_XMLParser_doctype_impl(XMLParserObject *self, PyObject *name,
PyObject *pubid, PyObject *system);
static PyObject *
_elementtree_XMLParser_doctype(XMLParserObject *self, PyObject *args)
_elementtree_XMLParser_doctype(XMLParserObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *name;
PyObject *pubid;
PyObject *system;
if (!PyArg_UnpackTuple(args, "doctype",
if (!_PyArg_UnpackStack(args, nargs, "doctype",
3, 3,
&name, &pubid, &system)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("doctype", kwnames)) {
goto exit;
}
return_value = _elementtree_XMLParser_doctype_impl(self, name, pubid, system);
exit:
@ -679,7 +699,7 @@ PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
"\n");
#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
{"_setevents", (PyCFunction)_elementtree_XMLParser__setevents, METH_VARARGS, _elementtree_XMLParser__setevents__doc__},
{"_setevents", (PyCFunction)_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
static PyObject *
_elementtree_XMLParser__setevents_impl(XMLParserObject *self,
@ -687,20 +707,24 @@ _elementtree_XMLParser__setevents_impl(XMLParserObject *self,
PyObject *events_to_report);
static PyObject *
_elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *args)
_elementtree_XMLParser__setevents(XMLParserObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *events_queue;
PyObject *events_to_report = Py_None;
if (!PyArg_UnpackTuple(args, "_setevents",
if (!_PyArg_UnpackStack(args, nargs, "_setevents",
1, 2,
&events_queue, &events_to_report)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("_setevents", kwnames)) {
goto exit;
}
return_value = _elementtree_XMLParser__setevents_impl(self, events_queue, events_to_report);
exit:
return return_value;
}
/*[clinic end generated code: output=b4a571a98ced3163 input=a9049054013a1b77]*/
/*[clinic end generated code: output=b69fa98c40917f58 input=a9049054013a1b77]*/

32
third_party/python/Modules/clinic/_gdbmmodule.inc vendored
View file

@ -10,23 +10,27 @@ PyDoc_STRVAR(_gdbm_gdbm_get__doc__,
"Get the value for key, or default if not present.");
#define _GDBM_GDBM_GET_METHODDEF \
{"get", (PyCFunction)_gdbm_gdbm_get, METH_VARARGS, _gdbm_gdbm_get__doc__},
{"get", (PyCFunction)_gdbm_gdbm_get, METH_FASTCALL, _gdbm_gdbm_get__doc__},
static PyObject *
_gdbm_gdbm_get_impl(dbmobject *self, PyObject *key, PyObject *default_value);
static PyObject *
_gdbm_gdbm_get(dbmobject *self, PyObject *args)
_gdbm_gdbm_get(dbmobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *key;
PyObject *default_value = Py_None;
if (!PyArg_UnpackTuple(args, "get",
if (!_PyArg_UnpackStack(args, nargs, "get",
1, 2,
&key, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("get", kwnames)) {
goto exit;
}
return_value = _gdbm_gdbm_get_impl(self, key, default_value);
exit:
@ -40,24 +44,28 @@ PyDoc_STRVAR(_gdbm_gdbm_setdefault__doc__,
"Get value for key, or set it to default and return default if not present.");
#define _GDBM_GDBM_SETDEFAULT_METHODDEF \
{"setdefault", (PyCFunction)_gdbm_gdbm_setdefault, METH_VARARGS, _gdbm_gdbm_setdefault__doc__},
{"setdefault", (PyCFunction)_gdbm_gdbm_setdefault, METH_FASTCALL, _gdbm_gdbm_setdefault__doc__},
static PyObject *
_gdbm_gdbm_setdefault_impl(dbmobject *self, PyObject *key,
PyObject *default_value);
static PyObject *
_gdbm_gdbm_setdefault(dbmobject *self, PyObject *args)
_gdbm_gdbm_setdefault(dbmobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *key;
PyObject *default_value = Py_None;
if (!PyArg_UnpackTuple(args, "setdefault",
if (!_PyArg_UnpackStack(args, nargs, "setdefault",
1, 2,
&key, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("setdefault", kwnames)) {
goto exit;
}
return_value = _gdbm_gdbm_setdefault_impl(self, key, default_value);
exit:
@ -232,27 +240,31 @@ PyDoc_STRVAR(dbmopen__doc__,
"when the database has to be created. It defaults to octal 0o666.");
#define DBMOPEN_METHODDEF \
{"open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
{"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
static PyObject *
dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
int mode);
static PyObject *
dbmopen(PyObject *module, PyObject *args)
dbmopen(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *filename;
const char *flags = "r";
int mode = 438;
if (!PyArg_ParseTuple(args, "U|si:open",
if (!_PyArg_ParseStack(args, nargs, "U|si:open",
&filename, &flags, &mode)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("open", kwnames)) {
goto exit;
}
return_value = dbmopen_impl(module, filename, flags, mode);
exit:
return return_value;
}
/*[clinic end generated code: output=afb99364ac420d10 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d12de247acddccc3 input=a9049054013a1b77]*/

14
third_party/python/Modules/clinic/_lzmamodule.inc vendored
View file

@ -97,7 +97,7 @@ _lzma_LZMADecompressor_decompress(Decompressor *self, PyObject **args, Py_ssize_
Py_buffer data = {NULL, NULL};
Py_ssize_t max_length = -1;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &max_length)) {
goto exit;
}
@ -230,23 +230,27 @@ PyDoc_STRVAR(_lzma__decode_filter_properties__doc__,
"The result does not include the filter ID itself, only the options.");
#define _LZMA__DECODE_FILTER_PROPERTIES_METHODDEF \
{"_decode_filter_properties", (PyCFunction)_lzma__decode_filter_properties, METH_VARARGS, _lzma__decode_filter_properties__doc__},
{"_decode_filter_properties", (PyCFunction)_lzma__decode_filter_properties, METH_FASTCALL, _lzma__decode_filter_properties__doc__},
static PyObject *
_lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
Py_buffer *encoded_props);
static PyObject *
_lzma__decode_filter_properties(PyObject *module, PyObject *args)
_lzma__decode_filter_properties(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
lzma_vli filter_id;
Py_buffer encoded_props = {NULL, NULL};
if (!PyArg_ParseTuple(args, "O&y*:_decode_filter_properties",
if (!_PyArg_ParseStack(args, nargs, "O&y*:_decode_filter_properties",
lzma_vli_converter, &filter_id, &encoded_props)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("_decode_filter_properties", kwnames)) {
goto exit;
}
return_value = _lzma__decode_filter_properties_impl(module, filter_id, &encoded_props);
exit:
@ -257,4 +261,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=f27abae460122706 input=a9049054013a1b77]*/
/*[clinic end generated code: output=5f7a915fb7e41453 input=a9049054013a1b77]*/

12
third_party/python/Modules/clinic/_opcode.inc vendored
View file

@ -10,23 +10,27 @@ PyDoc_STRVAR(_opcode_stack_effect__doc__,
"Compute the stack effect of the opcode.");
#define _OPCODE_STACK_EFFECT_METHODDEF \
{"stack_effect", (PyCFunction)_opcode_stack_effect, METH_VARARGS, _opcode_stack_effect__doc__},
{"stack_effect", (PyCFunction)_opcode_stack_effect, METH_FASTCALL, _opcode_stack_effect__doc__},
static int
_opcode_stack_effect_impl(PyObject *module, int opcode, PyObject *oparg);
static PyObject *
_opcode_stack_effect(PyObject *module, PyObject *args)
_opcode_stack_effect(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int opcode;
PyObject *oparg = Py_None;
int _return_value;
if (!PyArg_ParseTuple(args, "i|O:stack_effect",
if (!_PyArg_ParseStack(args, nargs, "i|O:stack_effect",
&opcode, &oparg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("stack_effect", kwnames)) {
goto exit;
}
_return_value = _opcode_stack_effect_impl(module, opcode, oparg);
if ((_return_value == -1) && PyErr_Occurred()) {
goto exit;
@ -36,4 +40,4 @@ _opcode_stack_effect(PyObject *module, PyObject *args)
exit:
return return_value;
}
/*[clinic end generated code: output=4d91c6a765097853 input=a9049054013a1b77]*/
/*[clinic end generated code: output=62858005ac85baa9 input=a9049054013a1b77]*/

20
third_party/python/Modules/clinic/_pickle.inc vendored
View file

@ -200,7 +200,7 @@ PyDoc_STRVAR(_pickle_Unpickler_find_class__doc__,
"needed. Both arguments passed are str objects.");
#define _PICKLE_UNPICKLER_FIND_CLASS_METHODDEF \
{"find_class", (PyCFunction)_pickle_Unpickler_find_class, METH_VARARGS, _pickle_Unpickler_find_class__doc__},
{"find_class", (PyCFunction)_pickle_Unpickler_find_class, METH_FASTCALL, _pickle_Unpickler_find_class__doc__},
static PyObject *
_pickle_Unpickler_find_class_impl(UnpicklerObject *self,
@ -208,17 +208,21 @@ _pickle_Unpickler_find_class_impl(UnpicklerObject *self,
PyObject *global_name);
static PyObject *
_pickle_Unpickler_find_class(UnpicklerObject *self, PyObject *args)
_pickle_Unpickler_find_class(UnpicklerObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *module_name;
PyObject *global_name;
if (!PyArg_UnpackTuple(args, "find_class",
if (!_PyArg_UnpackStack(args, nargs, "find_class",
2, 2,
&module_name, &global_name)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("find_class", kwnames)) {
goto exit;
}
return_value = _pickle_Unpickler_find_class_impl(self, module_name, global_name);
exit:
@ -402,7 +406,7 @@ _pickle_dump(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
PyObject *protocol = NULL;
int fix_imports = 1;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&obj, &file, &protocol, &fix_imports)) {
goto exit;
}
@ -447,7 +451,7 @@ _pickle_dumps(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
PyObject *protocol = NULL;
int fix_imports = 1;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&obj, &protocol, &fix_imports)) {
goto exit;
}
@ -504,7 +508,7 @@ _pickle_load(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
const char *encoding = "ASCII";
const char *errors = "strict";
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&file, &fix_imports, &encoding, &errors)) {
goto exit;
}
@ -552,7 +556,7 @@ _pickle_loads(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
const char *encoding = "ASCII";
const char *errors = "strict";
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &fix_imports, &encoding, &errors)) {
goto exit;
}
@ -561,4 +565,4 @@ _pickle_loads(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
exit:
return return_value;
}
/*[clinic end generated code: output=82be137b3c09cb9f input=a9049054013a1b77]*/
/*[clinic end generated code: output=b921d325b2f7a096 input=a9049054013a1b77]*/

72
third_party/python/Modules/clinic/_sre.inc vendored
View file

@ -36,23 +36,27 @@ PyDoc_STRVAR(_sre_getlower__doc__,
"\n");
#define _SRE_GETLOWER_METHODDEF \
{"getlower", (PyCFunction)_sre_getlower, METH_VARARGS, _sre_getlower__doc__},
{"getlower", (PyCFunction)_sre_getlower, METH_FASTCALL, _sre_getlower__doc__},
static int
_sre_getlower_impl(PyObject *module, int character, int flags);
static PyObject *
_sre_getlower(PyObject *module, PyObject *args)
_sre_getlower(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int character;
int flags;
int _return_value;
if (!PyArg_ParseTuple(args, "ii:getlower",
if (!_PyArg_ParseStack(args, nargs, "ii:getlower",
&character, &flags)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("getlower", kwnames)) {
goto exit;
}
_return_value = _sre_getlower_impl(module, character, flags);
if ((_return_value == -1) && PyErr_Occurred()) {
goto exit;
@ -88,7 +92,7 @@ _sre_SRE_Pattern_match(PatternObject *self, PyObject **args, Py_ssize_t nargs, P
Py_ssize_t endpos = PY_SSIZE_T_MAX;
PyObject *pattern = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &pos, &endpos, &pattern)) {
goto exit;
}
@ -124,7 +128,7 @@ _sre_SRE_Pattern_fullmatch(PatternObject *self, PyObject **args, Py_ssize_t narg
Py_ssize_t endpos = PY_SSIZE_T_MAX;
PyObject *pattern = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &pos, &endpos, &pattern)) {
goto exit;
}
@ -162,7 +166,7 @@ _sre_SRE_Pattern_search(PatternObject *self, PyObject **args, Py_ssize_t nargs,
Py_ssize_t endpos = PY_SSIZE_T_MAX;
PyObject *pattern = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &pos, &endpos, &pattern)) {
goto exit;
}
@ -198,7 +202,7 @@ _sre_SRE_Pattern_findall(PatternObject *self, PyObject **args, Py_ssize_t nargs,
Py_ssize_t endpos = PY_SSIZE_T_MAX;
PyObject *source = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &pos, &endpos, &source)) {
goto exit;
}
@ -233,7 +237,7 @@ _sre_SRE_Pattern_finditer(PatternObject *self, PyObject **args, Py_ssize_t nargs
Py_ssize_t pos = 0;
Py_ssize_t endpos = PY_SSIZE_T_MAX;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &pos, &endpos)) {
goto exit;
}
@ -265,7 +269,7 @@ _sre_SRE_Pattern_scanner(PatternObject *self, PyObject **args, Py_ssize_t nargs,
Py_ssize_t pos = 0;
Py_ssize_t endpos = PY_SSIZE_T_MAX;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &pos, &endpos)) {
goto exit;
}
@ -298,7 +302,7 @@ _sre_SRE_Pattern_split(PatternObject *self, PyObject **args, Py_ssize_t nargs, P
Py_ssize_t maxsplit = 0;
PyObject *source = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&string, &maxsplit, &source)) {
goto exit;
}
@ -331,7 +335,7 @@ _sre_SRE_Pattern_sub(PatternObject *self, PyObject **args, Py_ssize_t nargs, PyO
PyObject *string;
Py_ssize_t count = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&repl, &string, &count)) {
goto exit;
}
@ -364,7 +368,7 @@ _sre_SRE_Pattern_subn(PatternObject *self, PyObject **args, Py_ssize_t nargs, Py
PyObject *string;
Py_ssize_t count = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&repl, &string, &count)) {
goto exit;
}
@ -410,7 +414,7 @@ _sre_SRE_Pattern___deepcopy__(PatternObject *self, PyObject **args, Py_ssize_t n
static _PyArg_Parser _parser = {"O:__deepcopy__", _keywords, 0};
PyObject *memo;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&memo)) {
goto exit;
}
@ -447,7 +451,7 @@ _sre_compile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
PyObject *groupindex;
PyObject *indexgroup;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&pattern, &flags, &PyList_Type, &code, &groups, &groupindex, &indexgroup)) {
goto exit;
}
@ -477,7 +481,7 @@ _sre_SRE_Match_expand(MatchObject *self, PyObject **args, Py_ssize_t nargs, PyOb
static _PyArg_Parser _parser = {"O:expand", _keywords, 0};
PyObject *template;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&template)) {
goto exit;
}
@ -510,7 +514,7 @@ _sre_SRE_Match_groups(MatchObject *self, PyObject **args, Py_ssize_t nargs, PyOb
static _PyArg_Parser _parser = {"|O:groups", _keywords, 0};
PyObject *default_value = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&default_value)) {
goto exit;
}
@ -543,7 +547,7 @@ _sre_SRE_Match_groupdict(MatchObject *self, PyObject **args, Py_ssize_t nargs, P
static _PyArg_Parser _parser = {"|O:groupdict", _keywords, 0};
PyObject *default_value = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&default_value)) {
goto exit;
}
@ -560,23 +564,27 @@ PyDoc_STRVAR(_sre_SRE_Match_start__doc__,
"Return index of the start of the substring matched by group.");
#define _SRE_SRE_MATCH_START_METHODDEF \
{"start", (PyCFunction)_sre_SRE_Match_start, METH_VARARGS, _sre_SRE_Match_start__doc__},
{"start", (PyCFunction)_sre_SRE_Match_start, METH_FASTCALL, _sre_SRE_Match_start__doc__},
static Py_ssize_t
_sre_SRE_Match_start_impl(MatchObject *self, PyObject *group);
static PyObject *
_sre_SRE_Match_start(MatchObject *self, PyObject *args)
_sre_SRE_Match_start(MatchObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *group = NULL;
Py_ssize_t _return_value;
if (!PyArg_UnpackTuple(args, "start",
if (!_PyArg_UnpackStack(args, nargs, "start",
0, 1,
&group)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("start", kwnames)) {
goto exit;
}
_return_value = _sre_SRE_Match_start_impl(self, group);
if ((_return_value == -1) && PyErr_Occurred()) {
goto exit;
@ -594,23 +602,27 @@ PyDoc_STRVAR(_sre_SRE_Match_end__doc__,
"Return index of the end of the substring matched by group.");
#define _SRE_SRE_MATCH_END_METHODDEF \
{"end", (PyCFunction)_sre_SRE_Match_end, METH_VARARGS, _sre_SRE_Match_end__doc__},
{"end", (PyCFunction)_sre_SRE_Match_end, METH_FASTCALL, _sre_SRE_Match_end__doc__},
static Py_ssize_t
_sre_SRE_Match_end_impl(MatchObject *self, PyObject *group);
static PyObject *
_sre_SRE_Match_end(MatchObject *self, PyObject *args)
_sre_SRE_Match_end(MatchObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *group = NULL;
Py_ssize_t _return_value;
if (!PyArg_UnpackTuple(args, "end",
if (!_PyArg_UnpackStack(args, nargs, "end",
0, 1,
&group)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("end", kwnames)) {
goto exit;
}
_return_value = _sre_SRE_Match_end_impl(self, group);
if ((_return_value == -1) && PyErr_Occurred()) {
goto exit;
@ -628,22 +640,26 @@ PyDoc_STRVAR(_sre_SRE_Match_span__doc__,
"For MatchObject m, return the 2-tuple (m.start(group), m.end(group)).");
#define _SRE_SRE_MATCH_SPAN_METHODDEF \
{"span", (PyCFunction)_sre_SRE_Match_span, METH_VARARGS, _sre_SRE_Match_span__doc__},
{"span", (PyCFunction)_sre_SRE_Match_span, METH_FASTCALL, _sre_SRE_Match_span__doc__},
static PyObject *
_sre_SRE_Match_span_impl(MatchObject *self, PyObject *group);
static PyObject *
_sre_SRE_Match_span(MatchObject *self, PyObject *args)
_sre_SRE_Match_span(MatchObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *group = NULL;
if (!PyArg_UnpackTuple(args, "span",
if (!_PyArg_UnpackStack(args, nargs, "span",
0, 1,
&group)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("span", kwnames)) {
goto exit;
}
return_value = _sre_SRE_Match_span_impl(self, group);
exit:
@ -686,7 +702,7 @@ _sre_SRE_Match___deepcopy__(MatchObject *self, PyObject **args, Py_ssize_t nargs
static _PyArg_Parser _parser = {"O:__deepcopy__", _keywords, 0};
PyObject *memo;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&memo)) {
goto exit;
}
@ -729,4 +745,4 @@ _sre_SRE_Scanner_search(ScannerObject *self, PyObject *Py_UNUSED(ignored))
{
return _sre_SRE_Scanner_search_impl(self);
}
/*[clinic end generated code: output=a4a246bca1963bc9 input=a9049054013a1b77]*/
/*[clinic end generated code: output=ddfd6158e7ca39a3 input=a9049054013a1b77]*/

16
third_party/python/Modules/clinic/_ssl.inc vendored
View file

@ -504,7 +504,7 @@ _ssl__SSLContext_load_cert_chain(PySSLContext *self, PyObject **args, Py_ssize_t
PyObject *keyfile = NULL;
PyObject *password = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&certfile, &keyfile, &password)) {
goto exit;
}
@ -538,7 +538,7 @@ _ssl__SSLContext_load_verify_locations(PySSLContext *self, PyObject **args, Py_s
PyObject *capath = NULL;
PyObject *cadata = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&cafile, &capath, &cadata)) {
goto exit;
}
@ -578,7 +578,7 @@ _ssl__SSLContext__wrap_socket(PySSLContext *self, PyObject **args, Py_ssize_t na
int server_side;
PyObject *hostname_obj = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
PySocketModule.Sock_Type, &sock, &server_side, &hostname_obj)) {
goto exit;
}
@ -613,7 +613,7 @@ _ssl__SSLContext__wrap_bio(PySSLContext *self, PyObject **args, Py_ssize_t nargs
int server_side;
PyObject *hostname_obj = Py_None;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&PySSLMemoryBIO_Type, &incoming, &PySSLMemoryBIO_Type, &outgoing, &server_side, &hostname_obj)) {
goto exit;
}
@ -732,7 +732,7 @@ _ssl__SSLContext_get_ca_certs(PySSLContext *self, PyObject **args, Py_ssize_t na
static _PyArg_Parser _parser = {"|p:get_ca_certs", _keywords, 0};
int binary_form = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&binary_form)) {
goto exit;
}
@ -1044,7 +1044,7 @@ _ssl_txt2obj(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
const char *txt;
int name = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&txt, &name)) {
goto exit;
}
@ -1109,7 +1109,7 @@ _ssl_enum_certificates(PyObject *module, PyObject **args, Py_ssize_t nargs, PyOb
static _PyArg_Parser _parser = {"s:enum_certificates", _keywords, 0};
const char *store_name;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&store_name)) {
goto exit;
}
@ -1148,7 +1148,7 @@ _ssl_enum_crls(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kw
static _PyArg_Parser _parser = {"s:enum_crls", _keywords, 0};
const char *store_name;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&store_name)) {
goto exit;
}

277
third_party/python/Modules/clinic/_struct.inc vendored Normal file
View file

@ -0,0 +1,277 @@
/* clang-format off */
/*[clinic input]
preserve
[clinic start generated code]*/
PyDoc_STRVAR(Struct___init____doc__,
"Struct(format)\n"
"--\n"
"\n"
"Create a compiled struct object.\n"
"\n"
"Return a new Struct object which writes and reads binary data according to\n"
"the format string.\n"
"\n"
"See help(struct) for more on format strings.");
static int
Struct___init___impl(PyStructObject *self, PyObject *format);
static int
Struct___init__(PyObject *self, PyObject *args, PyObject *kwargs)
{
int return_value = -1;
static const char * const _keywords[] = {"format", NULL};
static _PyArg_Parser _parser = {"O:Struct", _keywords, 0};
PyObject *format;
if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
&format)) {
goto exit;
}
return_value = Struct___init___impl((PyStructObject *)self, format);
exit:
return return_value;
}
PyDoc_STRVAR(Struct_unpack__doc__,
"unpack($self, buffer, /)\n"
"--\n"
"\n"
"Return a tuple containing unpacked values.\n"
"\n"
"Unpack according to the format string Struct.format. The buffer\'s size\n"
"in bytes must be Struct.size.\n"
"\n"
"See help(struct) for more on format strings.");
#define STRUCT_UNPACK_METHODDEF \
{"unpack", (PyCFunction)Struct_unpack, METH_O, Struct_unpack__doc__},
static PyObject *
Struct_unpack_impl(PyStructObject *self, Py_buffer *buffer);
static PyObject *
Struct_unpack(PyStructObject *self, PyObject *arg)
{
PyObject *return_value = NULL;
Py_buffer buffer = {NULL, NULL};
if (!PyArg_Parse(arg, "y*:unpack", &buffer)) {
goto exit;
}
return_value = Struct_unpack_impl(self, &buffer);
exit:
/* Cleanup for buffer */
if (buffer.obj) {
PyBuffer_Release(&buffer);
}
return return_value;
}
PyDoc_STRVAR(Struct_unpack_from__doc__,
"unpack_from($self, /, buffer, offset=0)\n"
"--\n"
"\n"
"Return a tuple containing unpacked values.\n"
"\n"
"Values are unpacked according to the format string Struct.format.\n"
"\n"
"The buffer\'s size in bytes, minus offset, must be at least Struct.size.\n"
"\n"
"See help(struct) for more on format strings.");
#define STRUCT_UNPACK_FROM_METHODDEF \
{"unpack_from", (PyCFunction)Struct_unpack_from, METH_FASTCALL, Struct_unpack_from__doc__},
static PyObject *
Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
Py_ssize_t offset);
static PyObject *
Struct_unpack_from(PyStructObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"buffer", "offset", NULL};
static _PyArg_Parser _parser = {"y*|n:unpack_from", _keywords, 0};
Py_buffer buffer = {NULL, NULL};
Py_ssize_t offset = 0;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&buffer, &offset)) {
goto exit;
}
return_value = Struct_unpack_from_impl(self, &buffer, offset);
exit:
/* Cleanup for buffer */
if (buffer.obj) {
PyBuffer_Release(&buffer);
}
return return_value;
}
PyDoc_STRVAR(Struct_iter_unpack__doc__,
"iter_unpack($self, buffer, /)\n"
"--\n"
"\n"
"Return an iterator yielding tuples.\n"
"\n"
"Tuples are unpacked from the given bytes source, like a repeated\n"
"invocation of unpack_from().\n"
"\n"
"Requires that the bytes length be a multiple of the struct size.");
#define STRUCT_ITER_UNPACK_METHODDEF \
{"iter_unpack", (PyCFunction)Struct_iter_unpack, METH_O, Struct_iter_unpack__doc__},
PyDoc_STRVAR(_clearcache__doc__,
"_clearcache($module, /)\n"
"--\n"
"\n"
"Clear the internal cache.");
#define _CLEARCACHE_METHODDEF \
{"_clearcache", (PyCFunction)_clearcache, METH_NOARGS, _clearcache__doc__},
static PyObject *
_clearcache_impl(PyObject *module);
static PyObject *
_clearcache(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _clearcache_impl(module);
}
PyDoc_STRVAR(calcsize__doc__,
"calcsize($module, format, /)\n"
"--\n"
"\n"
"Return size in bytes of the struct described by the format string.");
#define CALCSIZE_METHODDEF \
{"calcsize", (PyCFunction)calcsize, METH_O, calcsize__doc__},
PyDoc_STRVAR(unpack__doc__,
"unpack($module, format, inputstr, /)\n"
"--\n"
"\n"
"Return a tuple containing values unpacked according to the format string.\n"
"\n"
"The buffer\'s size in bytes must be calcsize(format).\n"
"\n"
"See help(struct) for more on format strings.");
#define UNPACK_METHODDEF \
{"unpack", (PyCFunction)unpack, METH_FASTCALL, unpack__doc__},
static PyObject *
unpack_impl(PyObject *module, PyObject *format, PyObject *inputstr);
static PyObject *
unpack(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *format;
PyObject *inputstr;
if (!_PyArg_UnpackStack(args, nargs, "unpack",
2, 2,
&format, &inputstr)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("unpack", kwnames)) {
goto exit;
}
return_value = unpack_impl(module, format, inputstr);
exit:
return return_value;
}
PyDoc_STRVAR(unpack_from__doc__,
"unpack_from($module, format, /, buffer, offset=0)\n"
"--\n"
"\n"
"Return a tuple containing values unpacked according to the format string.\n"
"\n"
"The buffer\'s size, minus offset, must be at least calcsize(format).\n"
"\n"
"See help(struct) for more on format strings.");
#define UNPACK_FROM_METHODDEF \
{"unpack_from", (PyCFunction)unpack_from, METH_FASTCALL, unpack_from__doc__},
static PyObject *
unpack_from_impl(PyObject *module, PyObject *format, Py_buffer *buffer,
Py_ssize_t offset);
static PyObject *
unpack_from(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"", "buffer", "offset", NULL};
static _PyArg_Parser _parser = {"Oy*|n:unpack_from", _keywords, 0};
PyObject *format;
Py_buffer buffer = {NULL, NULL};
Py_ssize_t offset = 0;
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&format, &buffer, &offset)) {
goto exit;
}
return_value = unpack_from_impl(module, format, &buffer, offset);
exit:
/* Cleanup for buffer */
if (buffer.obj) {
PyBuffer_Release(&buffer);
}
return return_value;
}
PyDoc_STRVAR(iter_unpack__doc__,
"iter_unpack($module, format, buffer, /)\n"
"--\n"
"\n"
"Return an iterator yielding tuples unpacked from the given bytes.\n"
"\n"
"The bytes are unpacked according to the format string, like\n"
"a repeated invocation of unpack_from().\n"
"\n"
"Requires that the bytes length be a multiple of the format struct size.");
#define ITER_UNPACK_METHODDEF \
{"iter_unpack", (PyCFunction)iter_unpack, METH_FASTCALL, iter_unpack__doc__},
static PyObject *
iter_unpack_impl(PyObject *module, PyObject *format, PyObject *buffer);
static PyObject *
iter_unpack(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *format;
PyObject *buffer;
if (!_PyArg_UnpackStack(args, nargs, "iter_unpack",
2, 2,
&format, &buffer)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("iter_unpack", kwnames)) {
goto exit;
}
return_value = iter_unpack_impl(module, format, buffer);
exit:
return return_value;
}
/*[clinic end generated code: output=db8152ad222fa3d0 input=a9049054013a1b77]*/

12
third_party/python/Modules/clinic/_weakref.inc vendored
View file

@ -38,26 +38,30 @@ PyDoc_STRVAR(_weakref__remove_dead_weakref__doc__,
"Atomically remove key from dict if it points to a dead weakref.");
#define _WEAKREF__REMOVE_DEAD_WEAKREF_METHODDEF \
{"_remove_dead_weakref", (PyCFunction)_weakref__remove_dead_weakref, METH_VARARGS, _weakref__remove_dead_weakref__doc__},
{"_remove_dead_weakref", (PyCFunction)_weakref__remove_dead_weakref, METH_FASTCALL, _weakref__remove_dead_weakref__doc__},
static PyObject *
_weakref__remove_dead_weakref_impl(PyObject *module, PyObject *dct,
PyObject *key);
static PyObject *
_weakref__remove_dead_weakref(PyObject *module, PyObject *args)
_weakref__remove_dead_weakref(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *dct;
PyObject *key;
if (!PyArg_ParseTuple(args, "O!O:_remove_dead_weakref",
if (!_PyArg_ParseStack(args, nargs, "O!O:_remove_dead_weakref",
&PyDict_Type, &dct, &key)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("_remove_dead_weakref", kwnames)) {
goto exit;
}
return_value = _weakref__remove_dead_weakref_impl(module, dct, key);
exit:
return return_value;
}
/*[clinic end generated code: output=e860dd818a44bc9b input=a9049054013a1b77]*/
/*[clinic end generated code: output=b686303486bdfefd input=a9049054013a1b77]*/

6
third_party/python/Modules/clinic/_winapi.inc vendored
View file

@ -111,7 +111,7 @@ _winapi_ConnectNamedPipe(PyObject *module, PyObject **args, Py_ssize_t nargs, Py
int64_t handle;
int use_overlapped = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&handle, &use_overlapped)) {
goto exit;
}
@ -685,7 +685,7 @@ _winapi_ReadFile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *
uint32_t size;
int use_overlapped = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&handle, &size, &use_overlapped)) {
goto exit;
}
@ -879,7 +879,7 @@ _winapi_WriteFile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject
PyObject *buffer;
int use_overlapped = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&handle, &buffer, &use_overlapped)) {
goto exit;
}

42
third_party/python/Modules/clinic/arraymodule.inc vendored
View file

@ -66,21 +66,25 @@ PyDoc_STRVAR(array_array_pop__doc__,
"i defaults to -1.");
#define ARRAY_ARRAY_POP_METHODDEF \
{"pop", (PyCFunction)array_array_pop, METH_VARARGS, array_array_pop__doc__},
{"pop", (PyCFunction)array_array_pop, METH_FASTCALL, array_array_pop__doc__},
static PyObject *
array_array_pop_impl(arrayobject *self, Py_ssize_t i);
static PyObject *
array_array_pop(arrayobject *self, PyObject *args)
array_array_pop(arrayobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t i = -1;
if (!PyArg_ParseTuple(args, "|n:pop",
if (!_PyArg_ParseStack(args, nargs, "|n:pop",
&i)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("pop", kwnames)) {
goto exit;
}
return_value = array_array_pop_impl(self, i);
exit:
@ -103,22 +107,26 @@ PyDoc_STRVAR(array_array_insert__doc__,
"Insert a new item v into the array before position i.");
#define ARRAY_ARRAY_INSERT_METHODDEF \
{"insert", (PyCFunction)array_array_insert, METH_VARARGS, array_array_insert__doc__},
{"insert", (PyCFunction)array_array_insert, METH_FASTCALL, array_array_insert__doc__},
static PyObject *
array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v);
static PyObject *
array_array_insert(arrayobject *self, PyObject *args)
array_array_insert(arrayobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t i;
PyObject *v;
if (!PyArg_ParseTuple(args, "nO:insert",
if (!_PyArg_ParseStack(args, nargs, "nO:insert",
&i, &v)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("insert", kwnames)) {
goto exit;
}
return_value = array_array_insert_impl(self, i, v);
exit:
@ -201,22 +209,26 @@ PyDoc_STRVAR(array_array_fromfile__doc__,
"Read n objects from the file object f and append them to the end of the array.");
#define ARRAY_ARRAY_FROMFILE_METHODDEF \
{"fromfile", (PyCFunction)array_array_fromfile, METH_VARARGS, array_array_fromfile__doc__},
{"fromfile", (PyCFunction)array_array_fromfile, METH_FASTCALL, array_array_fromfile__doc__},
static PyObject *
array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n);
static PyObject *
array_array_fromfile(arrayobject *self, PyObject *args)
array_array_fromfile(arrayobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *f;
Py_ssize_t n;
if (!PyArg_ParseTuple(args, "On:fromfile",
if (!_PyArg_ParseStack(args, nargs, "On:fromfile",
&f, &n)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("fromfile", kwnames)) {
goto exit;
}
return_value = array_array_fromfile_impl(self, f, n);
exit:
@ -444,7 +456,7 @@ PyDoc_STRVAR(array__array_reconstructor__doc__,
"Internal. Used for pickling support.");
#define ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF \
{"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_VARARGS, array__array_reconstructor__doc__},
{"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_FASTCALL, array__array_reconstructor__doc__},
static PyObject *
array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
@ -453,7 +465,7 @@ array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
PyObject *items);
static PyObject *
array__array_reconstructor(PyObject *module, PyObject *args)
array__array_reconstructor(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyTypeObject *arraytype;
@ -461,10 +473,14 @@ array__array_reconstructor(PyObject *module, PyObject *args)
enum machine_format_code mformat_code;
PyObject *items;
if (!PyArg_ParseTuple(args, "OCiO:_array_reconstructor",
if (!_PyArg_ParseStack(args, nargs, "OCiO:_array_reconstructor",
&arraytype, &typecode, &mformat_code, &items)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("_array_reconstructor", kwnames)) {
goto exit;
}
return_value = array__array_reconstructor_impl(module, arraytype, typecode, mformat_code, items);
exit:
@ -506,4 +522,4 @@ PyDoc_STRVAR(array_arrayiterator___setstate____doc__,
#define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF \
{"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__},
/*[clinic end generated code: output=b2054fb764c8cc64 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d186a7553c1f1a41 input=a9049054013a1b77]*/

267
third_party/python/Modules/clinic/audioop.inc vendored
View file

@ -2,7 +2,6 @@
/*[clinic input]
preserve
[clinic start generated code]*/
#include "third_party/python/Include/abstract.h"
PyDoc_STRVAR(audioop_getsample__doc__,
"getsample($module, fragment, width, index, /)\n"
@ -11,24 +10,28 @@ PyDoc_STRVAR(audioop_getsample__doc__,
"Return the value of sample index from the fragment.");
#define AUDIOOP_GETSAMPLE_METHODDEF \
{"getsample", (PyCFunction)audioop_getsample, METH_VARARGS, audioop_getsample__doc__},
{"getsample", (PyCFunction)audioop_getsample, METH_FASTCALL, audioop_getsample__doc__},
static PyObject *
audioop_getsample_impl(PyObject *module, Py_buffer *fragment, int width,
Py_ssize_t index);
static PyObject *
audioop_getsample(PyObject *module, PyObject *args)
audioop_getsample(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
Py_ssize_t index;
if (!PyArg_ParseTuple(args, "y*in:getsample",
if (!_PyArg_ParseStack(args, nargs, "y*in:getsample",
&fragment, &width, &index)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("getsample", kwnames)) {
goto exit;
}
return_value = audioop_getsample_impl(module, &fragment, width, index);
exit:
@ -47,22 +50,26 @@ PyDoc_STRVAR(audioop_max__doc__,
"Return the maximum of the absolute value of all samples in a fragment.");
#define AUDIOOP_MAX_METHODDEF \
{"max", (PyCFunction)audioop_max, METH_VARARGS, audioop_max__doc__},
{"max", (PyCFunction)audioop_max, METH_FASTCALL, audioop_max__doc__},
static PyObject *
audioop_max_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_max(PyObject *module, PyObject *args)
audioop_max(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:max",
if (!_PyArg_ParseStack(args, nargs, "y*i:max",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("max", kwnames)) {
goto exit;
}
return_value = audioop_max_impl(module, &fragment, width);
exit:
@ -81,22 +88,26 @@ PyDoc_STRVAR(audioop_minmax__doc__,
"Return the minimum and maximum values of all samples in the sound fragment.");
#define AUDIOOP_MINMAX_METHODDEF \
{"minmax", (PyCFunction)audioop_minmax, METH_VARARGS, audioop_minmax__doc__},
{"minmax", (PyCFunction)audioop_minmax, METH_FASTCALL, audioop_minmax__doc__},
static PyObject *
audioop_minmax_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_minmax(PyObject *module, PyObject *args)
audioop_minmax(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:minmax",
if (!_PyArg_ParseStack(args, nargs, "y*i:minmax",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("minmax", kwnames)) {
goto exit;
}
return_value = audioop_minmax_impl(module, &fragment, width);
exit:
@ -115,22 +126,26 @@ PyDoc_STRVAR(audioop_avg__doc__,
"Return the average over all samples in the fragment.");
#define AUDIOOP_AVG_METHODDEF \
{"avg", (PyCFunction)audioop_avg, METH_VARARGS, audioop_avg__doc__},
{"avg", (PyCFunction)audioop_avg, METH_FASTCALL, audioop_avg__doc__},
static PyObject *
audioop_avg_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_avg(PyObject *module, PyObject *args)
audioop_avg(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:avg",
if (!_PyArg_ParseStack(args, nargs, "y*i:avg",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("avg", kwnames)) {
goto exit;
}
return_value = audioop_avg_impl(module, &fragment, width);
exit:
@ -149,22 +164,26 @@ PyDoc_STRVAR(audioop_rms__doc__,
"Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n).");
#define AUDIOOP_RMS_METHODDEF \
{"rms", (PyCFunction)audioop_rms, METH_VARARGS, audioop_rms__doc__},
{"rms", (PyCFunction)audioop_rms, METH_FASTCALL, audioop_rms__doc__},
static PyObject *
audioop_rms_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_rms(PyObject *module, PyObject *args)
audioop_rms(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:rms",
if (!_PyArg_ParseStack(args, nargs, "y*i:rms",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("rms", kwnames)) {
goto exit;
}
return_value = audioop_rms_impl(module, &fragment, width);
exit:
@ -183,23 +202,27 @@ PyDoc_STRVAR(audioop_findfit__doc__,
"Try to match reference as well as possible to a portion of fragment.");
#define AUDIOOP_FINDFIT_METHODDEF \
{"findfit", (PyCFunction)audioop_findfit, METH_VARARGS, audioop_findfit__doc__},
{"findfit", (PyCFunction)audioop_findfit, METH_FASTCALL, audioop_findfit__doc__},
static PyObject *
audioop_findfit_impl(PyObject *module, Py_buffer *fragment,
Py_buffer *reference);
static PyObject *
audioop_findfit(PyObject *module, PyObject *args)
audioop_findfit(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
Py_buffer reference = {NULL, NULL};
if (!PyArg_ParseTuple(args, "y*y*:findfit",
if (!_PyArg_ParseStack(args, nargs, "y*y*:findfit",
&fragment, &reference)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("findfit", kwnames)) {
goto exit;
}
return_value = audioop_findfit_impl(module, &fragment, &reference);
exit:
@ -222,23 +245,27 @@ PyDoc_STRVAR(audioop_findfactor__doc__,
"Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal.");
#define AUDIOOP_FINDFACTOR_METHODDEF \
{"findfactor", (PyCFunction)audioop_findfactor, METH_VARARGS, audioop_findfactor__doc__},
{"findfactor", (PyCFunction)audioop_findfactor, METH_FASTCALL, audioop_findfactor__doc__},
static PyObject *
audioop_findfactor_impl(PyObject *module, Py_buffer *fragment,
Py_buffer *reference);
static PyObject *
audioop_findfactor(PyObject *module, PyObject *args)
audioop_findfactor(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
Py_buffer reference = {NULL, NULL};
if (!PyArg_ParseTuple(args, "y*y*:findfactor",
if (!_PyArg_ParseStack(args, nargs, "y*y*:findfactor",
&fragment, &reference)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("findfactor", kwnames)) {
goto exit;
}
return_value = audioop_findfactor_impl(module, &fragment, &reference);
exit:
@ -261,23 +288,27 @@ PyDoc_STRVAR(audioop_findmax__doc__,
"Search fragment for a slice of specified number of samples with maximum energy.");
#define AUDIOOP_FINDMAX_METHODDEF \
{"findmax", (PyCFunction)audioop_findmax, METH_VARARGS, audioop_findmax__doc__},
{"findmax", (PyCFunction)audioop_findmax, METH_FASTCALL, audioop_findmax__doc__},
static PyObject *
audioop_findmax_impl(PyObject *module, Py_buffer *fragment,
Py_ssize_t length);
static PyObject *
audioop_findmax(PyObject *module, PyObject *args)
audioop_findmax(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
Py_ssize_t length;
if (!PyArg_ParseTuple(args, "y*n:findmax",
if (!_PyArg_ParseStack(args, nargs, "y*n:findmax",
&fragment, &length)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("findmax", kwnames)) {
goto exit;
}
return_value = audioop_findmax_impl(module, &fragment, length);
exit:
@ -296,22 +327,26 @@ PyDoc_STRVAR(audioop_avgpp__doc__,
"Return the average peak-peak value over all samples in the fragment.");
#define AUDIOOP_AVGPP_METHODDEF \
{"avgpp", (PyCFunction)audioop_avgpp, METH_VARARGS, audioop_avgpp__doc__},
{"avgpp", (PyCFunction)audioop_avgpp, METH_FASTCALL, audioop_avgpp__doc__},
static PyObject *
audioop_avgpp_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_avgpp(PyObject *module, PyObject *args)
audioop_avgpp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:avgpp",
if (!_PyArg_ParseStack(args, nargs, "y*i:avgpp",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("avgpp", kwnames)) {
goto exit;
}
return_value = audioop_avgpp_impl(module, &fragment, width);
exit:
@ -330,22 +365,26 @@ PyDoc_STRVAR(audioop_maxpp__doc__,
"Return the maximum peak-peak value in the sound fragment.");
#define AUDIOOP_MAXPP_METHODDEF \
{"maxpp", (PyCFunction)audioop_maxpp, METH_VARARGS, audioop_maxpp__doc__},
{"maxpp", (PyCFunction)audioop_maxpp, METH_FASTCALL, audioop_maxpp__doc__},
static PyObject *
audioop_maxpp_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_maxpp(PyObject *module, PyObject *args)
audioop_maxpp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:maxpp",
if (!_PyArg_ParseStack(args, nargs, "y*i:maxpp",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("maxpp", kwnames)) {
goto exit;
}
return_value = audioop_maxpp_impl(module, &fragment, width);
exit:
@ -364,22 +403,26 @@ PyDoc_STRVAR(audioop_cross__doc__,
"Return the number of zero crossings in the fragment passed as an argument.");
#define AUDIOOP_CROSS_METHODDEF \
{"cross", (PyCFunction)audioop_cross, METH_VARARGS, audioop_cross__doc__},
{"cross", (PyCFunction)audioop_cross, METH_FASTCALL, audioop_cross__doc__},
static PyObject *
audioop_cross_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_cross(PyObject *module, PyObject *args)
audioop_cross(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:cross",
if (!_PyArg_ParseStack(args, nargs, "y*i:cross",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("cross", kwnames)) {
goto exit;
}
return_value = audioop_cross_impl(module, &fragment, width);
exit:
@ -398,24 +441,28 @@ PyDoc_STRVAR(audioop_mul__doc__,
"Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor.");
#define AUDIOOP_MUL_METHODDEF \
{"mul", (PyCFunction)audioop_mul, METH_VARARGS, audioop_mul__doc__},
{"mul", (PyCFunction)audioop_mul, METH_FASTCALL, audioop_mul__doc__},
static PyObject *
audioop_mul_impl(PyObject *module, Py_buffer *fragment, int width,
double factor);
static PyObject *
audioop_mul(PyObject *module, PyObject *args)
audioop_mul(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
double factor;
if (!PyArg_ParseTuple(args, "y*id:mul",
if (!_PyArg_ParseStack(args, nargs, "y*id:mul",
&fragment, &width, &factor)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("mul", kwnames)) {
goto exit;
}
return_value = audioop_mul_impl(module, &fragment, width, factor);
exit:
@ -434,14 +481,14 @@ PyDoc_STRVAR(audioop_tomono__doc__,
"Convert a stereo fragment to a mono fragment.");
#define AUDIOOP_TOMONO_METHODDEF \
{"tomono", (PyCFunction)audioop_tomono, METH_VARARGS, audioop_tomono__doc__},
{"tomono", (PyCFunction)audioop_tomono, METH_FASTCALL, audioop_tomono__doc__},
static PyObject *
audioop_tomono_impl(PyObject *module, Py_buffer *fragment, int width,
double lfactor, double rfactor);
static PyObject *
audioop_tomono(PyObject *module, PyObject *args)
audioop_tomono(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
@ -449,10 +496,14 @@ audioop_tomono(PyObject *module, PyObject *args)
double lfactor;
double rfactor;
if (!PyArg_ParseTuple(args, "y*idd:tomono",
if (!_PyArg_ParseStack(args, nargs, "y*idd:tomono",
&fragment, &width, &lfactor, &rfactor)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("tomono", kwnames)) {
goto exit;
}
return_value = audioop_tomono_impl(module, &fragment, width, lfactor, rfactor);
exit:
@ -471,14 +522,14 @@ PyDoc_STRVAR(audioop_tostereo__doc__,
"Generate a stereo fragment from a mono fragment.");
#define AUDIOOP_TOSTEREO_METHODDEF \
{"tostereo", (PyCFunction)audioop_tostereo, METH_VARARGS, audioop_tostereo__doc__},
{"tostereo", (PyCFunction)audioop_tostereo, METH_FASTCALL, audioop_tostereo__doc__},
static PyObject *
audioop_tostereo_impl(PyObject *module, Py_buffer *fragment, int width,
double lfactor, double rfactor);
static PyObject *
audioop_tostereo(PyObject *module, PyObject *args)
audioop_tostereo(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
@ -486,10 +537,14 @@ audioop_tostereo(PyObject *module, PyObject *args)
double lfactor;
double rfactor;
if (!PyArg_ParseTuple(args, "y*idd:tostereo",
if (!_PyArg_ParseStack(args, nargs, "y*idd:tostereo",
&fragment, &width, &lfactor, &rfactor)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("tostereo", kwnames)) {
goto exit;
}
return_value = audioop_tostereo_impl(module, &fragment, width, lfactor, rfactor);
exit:
@ -508,24 +563,28 @@ PyDoc_STRVAR(audioop_add__doc__,
"Return a fragment which is the addition of the two samples passed as parameters.");
#define AUDIOOP_ADD_METHODDEF \
{"add", (PyCFunction)audioop_add, METH_VARARGS, audioop_add__doc__},
{"add", (PyCFunction)audioop_add, METH_FASTCALL, audioop_add__doc__},
static PyObject *
audioop_add_impl(PyObject *module, Py_buffer *fragment1,
Py_buffer *fragment2, int width);
static PyObject *
audioop_add(PyObject *module, PyObject *args)
audioop_add(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment1 = {NULL, NULL};
Py_buffer fragment2 = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*y*i:add",
if (!_PyArg_ParseStack(args, nargs, "y*y*i:add",
&fragment1, &fragment2, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("add", kwnames)) {
goto exit;
}
return_value = audioop_add_impl(module, &fragment1, &fragment2, width);
exit:
@ -548,23 +607,27 @@ PyDoc_STRVAR(audioop_bias__doc__,
"Return a fragment that is the original fragment with a bias added to each sample.");
#define AUDIOOP_BIAS_METHODDEF \
{"bias", (PyCFunction)audioop_bias, METH_VARARGS, audioop_bias__doc__},
{"bias", (PyCFunction)audioop_bias, METH_FASTCALL, audioop_bias__doc__},
static PyObject *
audioop_bias_impl(PyObject *module, Py_buffer *fragment, int width, int bias);
static PyObject *
audioop_bias(PyObject *module, PyObject *args)
audioop_bias(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
int bias;
if (!PyArg_ParseTuple(args, "y*ii:bias",
if (!_PyArg_ParseStack(args, nargs, "y*ii:bias",
&fragment, &width, &bias)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("bias", kwnames)) {
goto exit;
}
return_value = audioop_bias_impl(module, &fragment, width, bias);
exit:
@ -583,22 +646,26 @@ PyDoc_STRVAR(audioop_reverse__doc__,
"Reverse the samples in a fragment and returns the modified fragment.");
#define AUDIOOP_REVERSE_METHODDEF \
{"reverse", (PyCFunction)audioop_reverse, METH_VARARGS, audioop_reverse__doc__},
{"reverse", (PyCFunction)audioop_reverse, METH_FASTCALL, audioop_reverse__doc__},
static PyObject *
audioop_reverse_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_reverse(PyObject *module, PyObject *args)
audioop_reverse(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:reverse",
if (!_PyArg_ParseStack(args, nargs, "y*i:reverse",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("reverse", kwnames)) {
goto exit;
}
return_value = audioop_reverse_impl(module, &fragment, width);
exit:
@ -617,22 +684,26 @@ PyDoc_STRVAR(audioop_byteswap__doc__,
"Convert big-endian samples to little-endian and vice versa.");
#define AUDIOOP_BYTESWAP_METHODDEF \
{"byteswap", (PyCFunction)audioop_byteswap, METH_VARARGS, audioop_byteswap__doc__},
{"byteswap", (PyCFunction)audioop_byteswap, METH_FASTCALL, audioop_byteswap__doc__},
static PyObject *
audioop_byteswap_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_byteswap(PyObject *module, PyObject *args)
audioop_byteswap(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:byteswap",
if (!_PyArg_ParseStack(args, nargs, "y*i:byteswap",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("byteswap", kwnames)) {
goto exit;
}
return_value = audioop_byteswap_impl(module, &fragment, width);
exit:
@ -651,24 +722,28 @@ PyDoc_STRVAR(audioop_lin2lin__doc__,
"Convert samples between 1-, 2-, 3- and 4-byte formats.");
#define AUDIOOP_LIN2LIN_METHODDEF \
{"lin2lin", (PyCFunction)audioop_lin2lin, METH_VARARGS, audioop_lin2lin__doc__},
{"lin2lin", (PyCFunction)audioop_lin2lin, METH_FASTCALL, audioop_lin2lin__doc__},
static PyObject *
audioop_lin2lin_impl(PyObject *module, Py_buffer *fragment, int width,
int newwidth);
static PyObject *
audioop_lin2lin(PyObject *module, PyObject *args)
audioop_lin2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
int newwidth;
if (!PyArg_ParseTuple(args, "y*ii:lin2lin",
if (!_PyArg_ParseStack(args, nargs, "y*ii:lin2lin",
&fragment, &width, &newwidth)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("lin2lin", kwnames)) {
goto exit;
}
return_value = audioop_lin2lin_impl(module, &fragment, width, newwidth);
exit:
@ -688,7 +763,7 @@ PyDoc_STRVAR(audioop_ratecv__doc__,
"Convert the frame rate of the input fragment.");
#define AUDIOOP_RATECV_METHODDEF \
{"ratecv", (PyCFunction)audioop_ratecv, METH_VARARGS, audioop_ratecv__doc__},
{"ratecv", (PyCFunction)audioop_ratecv, METH_FASTCALL, audioop_ratecv__doc__},
static PyObject *
audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
@ -696,7 +771,7 @@ audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
int weightA, int weightB);
static PyObject *
audioop_ratecv(PyObject *module, PyObject *args)
audioop_ratecv(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
@ -708,10 +783,14 @@ audioop_ratecv(PyObject *module, PyObject *args)
int weightA = 1;
int weightB = 0;
if (!PyArg_ParseTuple(args, "y*iiiiO|ii:ratecv",
if (!_PyArg_ParseStack(args, nargs, "y*iiiiO|ii:ratecv",
&fragment, &width, &nchannels, &inrate, &outrate, &state, &weightA, &weightB)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("ratecv", kwnames)) {
goto exit;
}
return_value = audioop_ratecv_impl(module, &fragment, width, nchannels, inrate, outrate, state, weightA, weightB);
exit:
@ -730,22 +809,26 @@ PyDoc_STRVAR(audioop_lin2ulaw__doc__,
"Convert samples in the audio fragment to u-LAW encoding.");
#define AUDIOOP_LIN2ULAW_METHODDEF \
{"lin2ulaw", (PyCFunction)audioop_lin2ulaw, METH_VARARGS, audioop_lin2ulaw__doc__},
{"lin2ulaw", (PyCFunction)audioop_lin2ulaw, METH_FASTCALL, audioop_lin2ulaw__doc__},
static PyObject *
audioop_lin2ulaw_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_lin2ulaw(PyObject *module, PyObject *args)
audioop_lin2ulaw(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:lin2ulaw",
if (!_PyArg_ParseStack(args, nargs, "y*i:lin2ulaw",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("lin2ulaw", kwnames)) {
goto exit;
}
return_value = audioop_lin2ulaw_impl(module, &fragment, width);
exit:
@ -764,22 +847,26 @@ PyDoc_STRVAR(audioop_ulaw2lin__doc__,
"Convert sound fragments in u-LAW encoding to linearly encoded sound fragments.");
#define AUDIOOP_ULAW2LIN_METHODDEF \
{"ulaw2lin", (PyCFunction)audioop_ulaw2lin, METH_VARARGS, audioop_ulaw2lin__doc__},
{"ulaw2lin", (PyCFunction)audioop_ulaw2lin, METH_FASTCALL, audioop_ulaw2lin__doc__},
static PyObject *
audioop_ulaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_ulaw2lin(PyObject *module, PyObject *args)
audioop_ulaw2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:ulaw2lin",
if (!_PyArg_ParseStack(args, nargs, "y*i:ulaw2lin",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("ulaw2lin", kwnames)) {
goto exit;
}
return_value = audioop_ulaw2lin_impl(module, &fragment, width);
exit:
@ -798,22 +885,26 @@ PyDoc_STRVAR(audioop_lin2alaw__doc__,
"Convert samples in the audio fragment to a-LAW encoding.");
#define AUDIOOP_LIN2ALAW_METHODDEF \
{"lin2alaw", (PyCFunction)audioop_lin2alaw, METH_VARARGS, audioop_lin2alaw__doc__},
{"lin2alaw", (PyCFunction)audioop_lin2alaw, METH_FASTCALL, audioop_lin2alaw__doc__},
static PyObject *
audioop_lin2alaw_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_lin2alaw(PyObject *module, PyObject *args)
audioop_lin2alaw(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:lin2alaw",
if (!_PyArg_ParseStack(args, nargs, "y*i:lin2alaw",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("lin2alaw", kwnames)) {
goto exit;
}
return_value = audioop_lin2alaw_impl(module, &fragment, width);
exit:
@ -832,26 +923,34 @@ PyDoc_STRVAR(audioop_alaw2lin__doc__,
"Convert sound fragments in a-LAW encoding to linearly encoded sound fragments.");
#define AUDIOOP_ALAW2LIN_METHODDEF \
{"alaw2lin", (PyCFunction)audioop_alaw2lin, METH_VARARGS, audioop_alaw2lin__doc__},
{"alaw2lin", (PyCFunction)audioop_alaw2lin, METH_FASTCALL, audioop_alaw2lin__doc__},
static PyObject *
audioop_alaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
static PyObject *
audioop_alaw2lin(PyObject *module, PyObject *args)
audioop_alaw2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
if (!PyArg_ParseTuple(args, "y*i:alaw2lin", &fragment, &width)) {
if (!_PyArg_ParseStack(args, nargs, "y*i:alaw2lin",
&fragment, &width)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("alaw2lin", kwnames)) {
goto exit;
}
return_value = audioop_alaw2lin_impl(module, &fragment, width);
exit:
/* Cleanup for fragment */
if (fragment.obj) {
PyBuffer_Release(&fragment);
}
return return_value;
}
@ -862,24 +961,28 @@ PyDoc_STRVAR(audioop_lin2adpcm__doc__,
"Convert samples to 4 bit Intel/DVI ADPCM encoding.");
#define AUDIOOP_LIN2ADPCM_METHODDEF \
{"lin2adpcm", (PyCFunction)audioop_lin2adpcm, METH_VARARGS, audioop_lin2adpcm__doc__},
{"lin2adpcm", (PyCFunction)audioop_lin2adpcm, METH_FASTCALL, audioop_lin2adpcm__doc__},
static PyObject *
audioop_lin2adpcm_impl(PyObject *module, Py_buffer *fragment, int width,
PyObject *state);
static PyObject *
audioop_lin2adpcm(PyObject *module, PyObject *args)
audioop_lin2adpcm(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
PyObject *state;
if (!PyArg_ParseTuple(args, "y*iO:lin2adpcm",
if (!_PyArg_ParseStack(args, nargs, "y*iO:lin2adpcm",
&fragment, &width, &state)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("lin2adpcm", kwnames)) {
goto exit;
}
return_value = audioop_lin2adpcm_impl(module, &fragment, width, state);
exit:
@ -898,24 +1001,28 @@ PyDoc_STRVAR(audioop_adpcm2lin__doc__,
"Decode an Intel/DVI ADPCM coded fragment to a linear fragment.");
#define AUDIOOP_ADPCM2LIN_METHODDEF \
{"adpcm2lin", (PyCFunction)audioop_adpcm2lin, METH_VARARGS, audioop_adpcm2lin__doc__},
{"adpcm2lin", (PyCFunction)audioop_adpcm2lin, METH_FASTCALL, audioop_adpcm2lin__doc__},
static PyObject *
audioop_adpcm2lin_impl(PyObject *module, Py_buffer *fragment, int width,
PyObject *state);
static PyObject *
audioop_adpcm2lin(PyObject *module, PyObject *args)
audioop_adpcm2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer fragment = {NULL, NULL};
int width;
PyObject *state;
if (!PyArg_ParseTuple(args, "y*iO:adpcm2lin",
if (!_PyArg_ParseStack(args, nargs, "y*iO:adpcm2lin",
&fragment, &width, &state)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("adpcm2lin", kwnames)) {
goto exit;
}
return_value = audioop_adpcm2lin_impl(module, &fragment, width, state);
exit:
@ -926,4 +1033,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=e0ab74c3fa57c39c input=a9049054013a1b77]*/
/*[clinic end generated code: output=ee7c63ec28a11b78 input=a9049054013a1b77]*/

28
third_party/python/Modules/clinic/binascii.inc vendored
View file

@ -118,7 +118,7 @@ binascii_b2a_base64(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObjec
Py_buffer data = {NULL, NULL};
int newline = 1;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &newline)) {
goto exit;
}
@ -267,23 +267,27 @@ PyDoc_STRVAR(binascii_crc_hqx__doc__,
"Compute CRC-CCITT incrementally.");
#define BINASCII_CRC_HQX_METHODDEF \
{"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_VARARGS, binascii_crc_hqx__doc__},
{"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
static unsigned int
binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
static PyObject *
binascii_crc_hqx(PyObject *module, PyObject *args)
binascii_crc_hqx(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL};
unsigned int crc;
unsigned int _return_value;
if (!PyArg_ParseTuple(args, "y*I:crc_hqx",
if (!_PyArg_ParseStack(args, nargs, "y*I:crc_hqx",
&data, &crc)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("crc_hqx", kwnames)) {
goto exit;
}
_return_value = binascii_crc_hqx_impl(module, &data, crc);
if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
goto exit;
@ -306,23 +310,27 @@ PyDoc_STRVAR(binascii_crc32__doc__,
"Compute CRC-32 incrementally.");
#define BINASCII_CRC32_METHODDEF \
{"crc32", (PyCFunction)binascii_crc32, METH_VARARGS, binascii_crc32__doc__},
{"crc32", (PyCFunction)binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
static unsigned int
binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
static PyObject *
binascii_crc32(PyObject *module, PyObject *args)
binascii_crc32(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL};
unsigned int crc = 0;
unsigned int _return_value;
if (!PyArg_ParseTuple(args, "y*|I:crc32",
if (!_PyArg_ParseStack(args, nargs, "y*|I:crc32",
&data, &crc)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("crc32", kwnames)) {
goto exit;
}
_return_value = binascii_crc32_impl(module, &data, crc);
if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
goto exit;
@ -495,7 +503,7 @@ binascii_a2b_qp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *k
Py_buffer data = {NULL, NULL};
int header = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
ascii_buffer_converter, &data, &header)) {
goto exit;
}
@ -537,7 +545,7 @@ binascii_b2a_qp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *k
int istext = 1;
int header = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &quotetabs, &istext, &header)) {
goto exit;
}
@ -551,4 +559,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=458eb09731cb7877 input=a9049054013a1b77]*/
/*[clinic end generated code: output=4a418f883ccc79fe input=a9049054013a1b77]*/

24
third_party/python/Modules/clinic/cmathmodule.inc vendored
View file

@ -642,22 +642,26 @@ PyDoc_STRVAR(cmath_log__doc__,
"If the base not specified, returns the natural logarithm (base e) of z.");
#define CMATH_LOG_METHODDEF \
{"log", (PyCFunction)cmath_log, METH_VARARGS, cmath_log__doc__},
{"log", (PyCFunction)cmath_log, METH_FASTCALL, cmath_log__doc__},
static PyObject *
cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj);
static PyObject *
cmath_log(PyObject *module, PyObject *args)
cmath_log(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_complex x;
PyObject *y_obj = NULL;
if (!PyArg_ParseTuple(args, "D|O:log",
if (!_PyArg_ParseStack(args, nargs, "D|O:log",
&x, &y_obj)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("log", kwnames)) {
goto exit;
}
return_value = cmath_log_impl(module, x, y_obj);
exit:
@ -727,22 +731,26 @@ PyDoc_STRVAR(cmath_rect__doc__,
"Convert from polar coordinates to rectangular coordinates.");
#define CMATH_RECT_METHODDEF \
{"rect", (PyCFunction)cmath_rect, METH_VARARGS, cmath_rect__doc__},
{"rect", (PyCFunction)cmath_rect, METH_FASTCALL, cmath_rect__doc__},
static PyObject *
cmath_rect_impl(PyObject *module, double r, double phi);
static PyObject *
cmath_rect(PyObject *module, PyObject *args)
cmath_rect(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
double r;
double phi;
if (!PyArg_ParseTuple(args, "dd:rect",
if (!_PyArg_ParseStack(args, nargs, "dd:rect",
&r, &phi)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("rect", kwnames)) {
goto exit;
}
return_value = cmath_rect_impl(module, r, phi);
exit:
@ -870,7 +878,7 @@ cmath_isclose(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
double abs_tol = 0.0;
int _return_value;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&a, &b, &rel_tol, &abs_tol)) {
goto exit;
}
@ -883,4 +891,4 @@ cmath_isclose(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
exit:
return return_value;
}
/*[clinic end generated code: output=978f59702b41655f input=a9049054013a1b77]*/
/*[clinic end generated code: output=93eff5d4c242ee57 input=a9049054013a1b77]*/

42
third_party/python/Modules/clinic/fcntlmodule.inc vendored
View file

@ -20,23 +20,27 @@ PyDoc_STRVAR(fcntl_fcntl__doc__,
"corresponding to the return value of the fcntl call in the C code.");
#define FCNTL_FCNTL_METHODDEF \
{"fcntl", (PyCFunction)fcntl_fcntl, METH_VARARGS, fcntl_fcntl__doc__},
{"fcntl", (PyCFunction)fcntl_fcntl, METH_FASTCALL, fcntl_fcntl__doc__},
static PyObject *
fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg);
static PyObject *
fcntl_fcntl(PyObject *module, PyObject *args)
fcntl_fcntl(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int fd;
int code;
PyObject *arg = NULL;
if (!PyArg_ParseTuple(args, "O&i|O:fcntl",
if (!_PyArg_ParseStack(args, nargs, "O&i|O:fcntl",
conv_descriptor, &fd, &code, &arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("fcntl", kwnames)) {
goto exit;
}
return_value = fcntl_fcntl_impl(module, fd, code, arg);
exit:
@ -77,14 +81,14 @@ PyDoc_STRVAR(fcntl_ioctl__doc__,
"code.");
#define FCNTL_IOCTL_METHODDEF \
{"ioctl", (PyCFunction)fcntl_ioctl, METH_VARARGS, fcntl_ioctl__doc__},
{"ioctl", (PyCFunction)fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
static PyObject *
fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,
PyObject *ob_arg, int mutate_arg);
static PyObject *
fcntl_ioctl(PyObject *module, PyObject *args)
fcntl_ioctl(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int fd;
@ -92,10 +96,14 @@ fcntl_ioctl(PyObject *module, PyObject *args)
PyObject *ob_arg = NULL;
int mutate_arg = 1;
if (!PyArg_ParseTuple(args, "O&I|Op:ioctl",
if (!_PyArg_ParseStack(args, nargs, "O&I|Op:ioctl",
conv_descriptor, &fd, &code, &ob_arg, &mutate_arg)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("ioctl", kwnames)) {
goto exit;
}
return_value = fcntl_ioctl_impl(module, fd, code, ob_arg, mutate_arg);
exit:
@ -112,22 +120,26 @@ PyDoc_STRVAR(fcntl_flock__doc__,
"function is emulated using fcntl()).");
#define FCNTL_FLOCK_METHODDEF \
{"flock", (PyCFunction)fcntl_flock, METH_VARARGS, fcntl_flock__doc__},
{"flock", (PyCFunction)fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
static PyObject *
fcntl_flock_impl(PyObject *module, int fd, int code);
static PyObject *
fcntl_flock(PyObject *module, PyObject *args)
fcntl_flock(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int fd;
int code;
if (!PyArg_ParseTuple(args, "O&i:flock",
if (!_PyArg_ParseStack(args, nargs, "O&i:flock",
conv_descriptor, &fd, &code)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("flock", kwnames)) {
goto exit;
}
return_value = fcntl_flock_impl(module, fd, code);
exit:
@ -162,14 +174,14 @@ PyDoc_STRVAR(fcntl_lockf__doc__,
" 2 - relative to the end of the file (SEEK_END)");
#define FCNTL_LOCKF_METHODDEF \
{"lockf", (PyCFunction)fcntl_lockf, METH_VARARGS, fcntl_lockf__doc__},
{"lockf", (PyCFunction)fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
static PyObject *
fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
PyObject *startobj, int whence);
static PyObject *
fcntl_lockf(PyObject *module, PyObject *args)
fcntl_lockf(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int fd;
@ -178,13 +190,17 @@ fcntl_lockf(PyObject *module, PyObject *args)
PyObject *startobj = NULL;
int whence = 0;
if (!PyArg_ParseTuple(args, "O&i|OOi:lockf",
if (!_PyArg_ParseStack(args, nargs, "O&i|OOi:lockf",
conv_descriptor, &fd, &code, &lenobj, &startobj, &whence)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("lockf", kwnames)) {
goto exit;
}
return_value = fcntl_lockf_impl(module, fd, code, lenobj, startobj, whence);
exit:
return return_value;
}
/*[clinic end generated code: output=36cff76a8fb2c9a6 input=a9049054013a1b77]*/
/*[clinic end generated code: output=b67e9579722e6d4f input=a9049054013a1b77]*/

6
third_party/python/Modules/clinic/grpmodule.inc vendored
View file

@ -25,7 +25,7 @@ grp_getgrgid(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
static _PyArg_Parser _parser = {"O:getgrgid", _keywords, 0};
PyObject *id;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&id)) {
goto exit;
}
@ -57,7 +57,7 @@ grp_getgrnam(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwna
static _PyArg_Parser _parser = {"U:getgrnam", _keywords, 0};
PyObject *name;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&name)) {
goto exit;
}
@ -87,4 +87,4 @@ grp_getgrall(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return grp_getgrall_impl(module);
}
/*[clinic end generated code: output=d6417ae0a7298e0e input=a9049054013a1b77]*/
/*[clinic end generated code: output=fb690db5e676d378 input=a9049054013a1b77]*/

575
third_party/python/Modules/clinic/posixmodule.inc vendored
View file

File diff suppressed because it is too large Load diff

34
third_party/python/Modules/clinic/pyexpat.inc vendored
View file

@ -12,23 +12,27 @@ PyDoc_STRVAR(pyexpat_xmlparser_Parse__doc__,
"`isfinal\' should be true at end of input.");
#define PYEXPAT_XMLPARSER_PARSE_METHODDEF \
{"Parse", (PyCFunction)pyexpat_xmlparser_Parse, METH_VARARGS, pyexpat_xmlparser_Parse__doc__},
{"Parse", (PyCFunction)pyexpat_xmlparser_Parse, METH_FASTCALL, pyexpat_xmlparser_Parse__doc__},
static PyObject *
pyexpat_xmlparser_Parse_impl(xmlparseobject *self, PyObject *data,
int isfinal);
static PyObject *
pyexpat_xmlparser_Parse(xmlparseobject *self, PyObject *args)
pyexpat_xmlparser_Parse(xmlparseobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *data;
int isfinal = 0;
if (!PyArg_ParseTuple(args, "O|i:Parse",
if (!_PyArg_ParseStack(args, nargs, "O|i:Parse",
&data, &isfinal)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("Parse", kwnames)) {
goto exit;
}
return_value = pyexpat_xmlparser_Parse_impl(self, data, isfinal);
exit:
@ -117,7 +121,7 @@ PyDoc_STRVAR(pyexpat_xmlparser_ExternalEntityParserCreate__doc__,
"Create a parser for parsing an external entity based on the information passed to the ExternalEntityRefHandler.");
#define PYEXPAT_XMLPARSER_EXTERNALENTITYPARSERCREATE_METHODDEF \
{"ExternalEntityParserCreate", (PyCFunction)pyexpat_xmlparser_ExternalEntityParserCreate, METH_VARARGS, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
{"ExternalEntityParserCreate", (PyCFunction)pyexpat_xmlparser_ExternalEntityParserCreate, METH_FASTCALL, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
static PyObject *
pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
@ -125,16 +129,20 @@ pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
const char *encoding);
static PyObject *
pyexpat_xmlparser_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)
pyexpat_xmlparser_ExternalEntityParserCreate(xmlparseobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
const char *context;
const char *encoding = NULL;
if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",
if (!_PyArg_ParseStack(args, nargs, "z|s:ExternalEntityParserCreate",
&context, &encoding)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("ExternalEntityParserCreate", kwnames)) {
goto exit;
}
return_value = pyexpat_xmlparser_ExternalEntityParserCreate_impl(self, context, encoding);
exit:
@ -186,21 +194,25 @@ PyDoc_STRVAR(pyexpat_xmlparser_UseForeignDTD__doc__,
"information to the parser. \'flag\' defaults to True if not provided.");
#define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF \
{"UseForeignDTD", (PyCFunction)pyexpat_xmlparser_UseForeignDTD, METH_VARARGS, pyexpat_xmlparser_UseForeignDTD__doc__},
{"UseForeignDTD", (PyCFunction)pyexpat_xmlparser_UseForeignDTD, METH_FASTCALL, pyexpat_xmlparser_UseForeignDTD__doc__},
static PyObject *
pyexpat_xmlparser_UseForeignDTD_impl(xmlparseobject *self, int flag);
static PyObject *
pyexpat_xmlparser_UseForeignDTD(xmlparseobject *self, PyObject *args)
pyexpat_xmlparser_UseForeignDTD(xmlparseobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int flag = 1;
if (!PyArg_ParseTuple(args, "|p:UseForeignDTD",
if (!_PyArg_ParseStack(args, nargs, "|p:UseForeignDTD",
&flag)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("UseForeignDTD", kwnames)) {
goto exit;
}
return_value = pyexpat_xmlparser_UseForeignDTD_impl(self, flag);
exit:
@ -250,7 +262,7 @@ pyexpat_ParserCreate(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObje
const char *namespace_separator = NULL;
PyObject *intern = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&encoding, &namespace_separator, &intern)) {
goto exit;
}
@ -290,4 +302,4 @@ exit:
#ifndef PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
#define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
#endif /* !defined(PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF) */
/*[clinic end generated code: output=e889f7c6af6cc42f input=a9049054013a1b77]*/
/*[clinic end generated code: output=0548a6b12157e29b input=a9049054013a1b77]*/

62
third_party/python/Modules/clinic/signalmodule.inc vendored
View file

@ -75,22 +75,26 @@ PyDoc_STRVAR(signal_signal__doc__,
"the first is the signal number, the second is the interrupted stack frame.");
#define SIGNAL_SIGNAL_METHODDEF \
{"signal", (PyCFunction)signal_signal, METH_VARARGS, signal_signal__doc__},
{"signal", (PyCFunction)signal_signal, METH_FASTCALL, signal_signal__doc__},
static PyObject *
signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
static PyObject *
signal_signal(PyObject *module, PyObject *args)
signal_signal(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int signalnum;
PyObject *handler;
if (!PyArg_ParseTuple(args, "iO:signal",
if (!_PyArg_ParseStack(args, nargs, "iO:signal",
&signalnum, &handler)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("signal", kwnames)) {
goto exit;
}
return_value = signal_signal_impl(module, signalnum, handler);
exit:
@ -142,22 +146,26 @@ PyDoc_STRVAR(signal_siginterrupt__doc__,
"signal sig, else system calls will be interrupted.");
#define SIGNAL_SIGINTERRUPT_METHODDEF \
{"siginterrupt", (PyCFunction)signal_siginterrupt, METH_VARARGS, signal_siginterrupt__doc__},
{"siginterrupt", (PyCFunction)signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
static PyObject *
signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
static PyObject *
signal_siginterrupt(PyObject *module, PyObject *args)
signal_siginterrupt(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int signalnum;
int flag;
if (!PyArg_ParseTuple(args, "ii:siginterrupt",
if (!_PyArg_ParseStack(args, nargs, "ii:siginterrupt",
&signalnum, &flag)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("siginterrupt", kwnames)) {
goto exit;
}
return_value = signal_siginterrupt_impl(module, signalnum, flag);
exit:
@ -180,24 +188,28 @@ PyDoc_STRVAR(signal_setitimer__doc__,
"Returns old values as a tuple: (delay, interval).");
#define SIGNAL_SETITIMER_METHODDEF \
{"setitimer", (PyCFunction)signal_setitimer, METH_VARARGS, signal_setitimer__doc__},
{"setitimer", (PyCFunction)signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
static PyObject *
signal_setitimer_impl(PyObject *module, int which, double seconds,
double interval);
static PyObject *
signal_setitimer(PyObject *module, PyObject *args)
signal_setitimer(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int which;
double seconds;
double interval = 0.0;
if (!PyArg_ParseTuple(args, "id|d:setitimer",
if (!_PyArg_ParseStack(args, nargs, "id|d:setitimer",
&which, &seconds, &interval)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("setitimer", kwnames)) {
goto exit;
}
return_value = signal_setitimer_impl(module, which, seconds, interval);
exit:
@ -246,22 +258,26 @@ PyDoc_STRVAR(signal_pthread_sigmask__doc__,
"Fetch and/or change the signal mask of the calling thread.");
#define SIGNAL_PTHREAD_SIGMASK_METHODDEF \
{"pthread_sigmask", (PyCFunction)signal_pthread_sigmask, METH_VARARGS, signal_pthread_sigmask__doc__},
{"pthread_sigmask", (PyCFunction)signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
static PyObject *
signal_pthread_sigmask_impl(PyObject *module, int how, PyObject *mask);
static PyObject *
signal_pthread_sigmask(PyObject *module, PyObject *args)
signal_pthread_sigmask(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int how;
PyObject *mask;
if (!PyArg_ParseTuple(args, "iO:pthread_sigmask",
if (!_PyArg_ParseStack(args, nargs, "iO:pthread_sigmask",
&how, &mask)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("pthread_sigmask", kwnames)) {
goto exit;
}
return_value = signal_pthread_sigmask_impl(module, how, mask);
exit:
@ -338,24 +354,28 @@ PyDoc_STRVAR(signal_sigtimedwait__doc__,
"The timeout is specified in seconds, with floating point numbers allowed.");
#define SIGNAL_SIGTIMEDWAIT_METHODDEF \
{"sigtimedwait", (PyCFunction)signal_sigtimedwait, METH_VARARGS, signal_sigtimedwait__doc__},
{"sigtimedwait", (PyCFunction)signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
static PyObject *
signal_sigtimedwait_impl(PyObject *module, PyObject *sigset,
PyObject *timeout_obj);
static PyObject *
signal_sigtimedwait(PyObject *module, PyObject *args)
signal_sigtimedwait(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
PyObject *sigset;
PyObject *timeout_obj;
if (!PyArg_UnpackTuple(args, "sigtimedwait",
if (!_PyArg_UnpackStack(args, nargs, "sigtimedwait",
2, 2,
&sigset, &timeout_obj)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("sigtimedwait", kwnames)) {
goto exit;
}
return_value = signal_sigtimedwait_impl(module, sigset, timeout_obj);
exit:
@ -373,22 +393,26 @@ PyDoc_STRVAR(signal_pthread_kill__doc__,
"Send a signal to a thread.");
#define SIGNAL_PTHREAD_KILL_METHODDEF \
{"pthread_kill", (PyCFunction)signal_pthread_kill, METH_VARARGS, signal_pthread_kill__doc__},
{"pthread_kill", (PyCFunction)signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
static PyObject *
signal_pthread_kill_impl(PyObject *module, long thread_id, int signalnum);
static PyObject *
signal_pthread_kill(PyObject *module, PyObject *args)
signal_pthread_kill(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
long thread_id;
int signalnum;
if (!PyArg_ParseTuple(args, "li:pthread_kill",
if (!_PyArg_ParseStack(args, nargs, "li:pthread_kill",
&thread_id, &signalnum)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("pthread_kill", kwnames)) {
goto exit;
}
return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
exit:
@ -440,4 +464,4 @@ exit:
#ifndef SIGNAL_PTHREAD_KILL_METHODDEF
#define SIGNAL_PTHREAD_KILL_METHODDEF
#endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
/*[clinic end generated code: output=c6990ef0d0ba72b6 input=a9049054013a1b77]*/
/*[clinic end generated code: output=fab3dba32c058588 input=a9049054013a1b77]*/

52
third_party/python/Modules/clinic/unicodedata.inc vendored
View file

@ -14,23 +14,27 @@ PyDoc_STRVAR(unicodedata_UCD_decimal__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_DECIMAL_METHODDEF \
{"decimal", (PyCFunction)unicodedata_UCD_decimal, METH_VARARGS, unicodedata_UCD_decimal__doc__},
{"decimal", (PyCFunction)unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__},
static PyObject *
unicodedata_UCD_decimal_impl(PyObject *self, int chr,
PyObject *default_value);
static PyObject *
unicodedata_UCD_decimal(PyObject *self, PyObject *args)
unicodedata_UCD_decimal(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int chr;
PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:decimal",
if (!_PyArg_ParseStack(args, nargs, "C|O:decimal",
&chr, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("decimal", kwnames)) {
goto exit;
}
return_value = unicodedata_UCD_decimal_impl(self, chr, default_value);
exit:
@ -48,22 +52,26 @@ PyDoc_STRVAR(unicodedata_UCD_digit__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_DIGIT_METHODDEF \
{"digit", (PyCFunction)unicodedata_UCD_digit, METH_VARARGS, unicodedata_UCD_digit__doc__},
{"digit", (PyCFunction)unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__},
static PyObject *
unicodedata_UCD_digit_impl(PyObject *self, int chr, PyObject *default_value);
static PyObject *
unicodedata_UCD_digit(PyObject *self, PyObject *args)
unicodedata_UCD_digit(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int chr;
PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:digit",
if (!_PyArg_ParseStack(args, nargs, "C|O:digit",
&chr, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("digit", kwnames)) {
goto exit;
}
return_value = unicodedata_UCD_digit_impl(self, chr, default_value);
exit:
@ -81,23 +89,27 @@ PyDoc_STRVAR(unicodedata_UCD_numeric__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_NUMERIC_METHODDEF \
{"numeric", (PyCFunction)unicodedata_UCD_numeric, METH_VARARGS, unicodedata_UCD_numeric__doc__},
{"numeric", (PyCFunction)unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__},
static PyObject *
unicodedata_UCD_numeric_impl(PyObject *self, int chr,
PyObject *default_value);
static PyObject *
unicodedata_UCD_numeric(PyObject *self, PyObject *args)
unicodedata_UCD_numeric(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int chr;
PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:numeric",
if (!_PyArg_ParseStack(args, nargs, "C|O:numeric",
&chr, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("numeric", kwnames)) {
goto exit;
}
return_value = unicodedata_UCD_numeric_impl(self, chr, default_value);
exit:
@ -294,23 +306,27 @@ PyDoc_STRVAR(unicodedata_UCD_normalize__doc__,
"Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'.");
#define UNICODEDATA_UCD_NORMALIZE_METHODDEF \
{"normalize", (PyCFunction)unicodedata_UCD_normalize, METH_VARARGS, unicodedata_UCD_normalize__doc__},
{"normalize", (PyCFunction)unicodedata_UCD_normalize, METH_FASTCALL, unicodedata_UCD_normalize__doc__},
static PyObject *
unicodedata_UCD_normalize_impl(PyObject *self, const char *form,
PyObject *input);
static PyObject *
unicodedata_UCD_normalize(PyObject *self, PyObject *args)
unicodedata_UCD_normalize(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
const char *form;
PyObject *input;
if (!PyArg_ParseTuple(args, "sO!:normalize",
if (!_PyArg_ParseStack(args, nargs, "sO!:normalize",
&form, &PyUnicode_Type, &input)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("normalize", kwnames)) {
goto exit;
}
return_value = unicodedata_UCD_normalize_impl(self, form, input);
exit:
@ -327,22 +343,26 @@ PyDoc_STRVAR(unicodedata_UCD_name__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_NAME_METHODDEF \
{"name", (PyCFunction)unicodedata_UCD_name, METH_VARARGS, unicodedata_UCD_name__doc__},
{"name", (PyCFunction)unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__},
static PyObject *
unicodedata_UCD_name_impl(PyObject *self, int chr, PyObject *default_value);
static PyObject *
unicodedata_UCD_name(PyObject *self, PyObject *args)
unicodedata_UCD_name(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int chr;
PyObject *default_value = NULL;
if (!PyArg_ParseTuple(args, "C|O:name",
if (!_PyArg_ParseStack(args, nargs, "C|O:name",
&chr, &default_value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("name", kwnames)) {
goto exit;
}
return_value = unicodedata_UCD_name_impl(self, chr, default_value);
exit:
@ -380,4 +400,4 @@ unicodedata_UCD_lookup(PyObject *self, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=5313ce129da87b2f input=a9049054013a1b77]*/
/*[clinic end generated code: output=badeb811d1caec40 input=a9049054013a1b77]*/

61
third_party/python/Modules/clinic/zlibmodule.inc vendored
View file

@ -17,6 +17,9 @@ PyDoc_STRVAR(zlib_compress__doc__,
#define ZLIB_COMPRESS_METHODDEF \
{"compress", (PyCFunction)zlib_compress, METH_FASTCALL, zlib_compress__doc__},
static PyObject *
zlib_compress_impl(PyObject *module, Py_buffer *data, int level);
static PyObject *
zlib_compress(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
@ -26,7 +29,7 @@ zlib_compress(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
Py_buffer data = {NULL, NULL};
int level = Z_DEFAULT_COMPRESSION;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &level)) {
goto exit;
}
@ -71,7 +74,7 @@ zlib_decompress(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *k
int wbits = MAX_WBITS;
Py_ssize_t bufsize = DEF_BUF_SIZE;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, &wbits, ssize_t_converter, &bufsize)) {
goto exit;
}
@ -110,7 +113,7 @@ PyDoc_STRVAR(zlib_compressobj__doc__,
" Valid values range from 1 to 9. Higher values result in higher memory\n"
" usage, faster compression, and smaller output.\n"
" strategy\n"
" Used to tune the compression algorithm. Possible values are\n"
" Used to tune the compression algorithm. Possible values are\n"
" Z_DEFAULT_STRATEGY, Z_RLE, Z_HUFFMAN_ONLY, Z_FILTERED, and\n"
" Z_FIXED.\n"
" zdict\n"
@ -137,7 +140,7 @@ zlib_compressobj(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *
int strategy = Z_DEFAULT_STRATEGY;
Py_buffer zdict = {NULL, NULL};
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&level, &method, &wbits, &memLevel, &strategy, &zdict)) {
goto exit;
}
@ -179,7 +182,7 @@ zlib_decompressobj(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject
int wbits = MAX_WBITS;
PyObject *zdict = NULL;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&wbits, &zdict)) {
goto exit;
}
@ -261,7 +264,7 @@ zlib_Decompress_decompress(compobject *self, PyObject **args, Py_ssize_t nargs,
Py_buffer data = {NULL, NULL};
Py_ssize_t max_length = 0;
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,
&data, ssize_t_converter, &max_length)) {
goto exit;
}
@ -289,21 +292,25 @@ PyDoc_STRVAR(zlib_Compress_flush__doc__,
" can still be compressed.");
#define ZLIB_COMPRESS_FLUSH_METHODDEF \
{"flush", (PyCFunction)zlib_Compress_flush, METH_VARARGS, zlib_Compress_flush__doc__},
{"flush", (PyCFunction)zlib_Compress_flush, METH_FASTCALL, zlib_Compress_flush__doc__},
static PyObject *
zlib_Compress_flush_impl(compobject *self, int mode);
static PyObject *
zlib_Compress_flush(compobject *self, PyObject *args)
zlib_Compress_flush(compobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
int mode = Z_FINISH;
if (!PyArg_ParseTuple(args, "|i:flush",
if (!_PyArg_ParseStack(args, nargs, "|i:flush",
&mode)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("flush", kwnames)) {
goto exit;
}
return_value = zlib_Compress_flush_impl(self, mode);
exit:
@ -364,21 +371,25 @@ PyDoc_STRVAR(zlib_Decompress_flush__doc__,
" the initial size of the output buffer.");
#define ZLIB_DECOMPRESS_FLUSH_METHODDEF \
{"flush", (PyCFunction)zlib_Decompress_flush, METH_VARARGS, zlib_Decompress_flush__doc__},
{"flush", (PyCFunction)zlib_Decompress_flush, METH_FASTCALL, zlib_Decompress_flush__doc__},
static PyObject *
zlib_Decompress_flush_impl(compobject *self, Py_ssize_t length);
static PyObject *
zlib_Decompress_flush(compobject *self, PyObject *args)
zlib_Decompress_flush(compobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_ssize_t length = DEF_BUF_SIZE;
if (!PyArg_ParseTuple(args, "|O&:flush",
if (!_PyArg_ParseStack(args, nargs, "|O&:flush",
ssize_t_converter, &length)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("flush", kwnames)) {
goto exit;
}
return_value = zlib_Decompress_flush_impl(self, length);
exit:
@ -397,22 +408,26 @@ PyDoc_STRVAR(zlib_adler32__doc__,
"The returned checksum is an integer.");
#define ZLIB_ADLER32_METHODDEF \
{"adler32", (PyCFunction)zlib_adler32, METH_VARARGS, zlib_adler32__doc__},
{"adler32", (PyCFunction)zlib_adler32, METH_FASTCALL, zlib_adler32__doc__},
static PyObject *
zlib_adler32_impl(PyObject *module, Py_buffer *data, unsigned int value);
static PyObject *
zlib_adler32(PyObject *module, PyObject *args)
zlib_adler32(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL};
unsigned int value = 1;
if (!PyArg_ParseTuple(args, "y*|I:adler32",
if (!_PyArg_ParseStack(args, nargs, "y*|I:adler32",
&data, &value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("adler32", kwnames)) {
goto exit;
}
return_value = zlib_adler32_impl(module, &data, value);
exit:
@ -436,22 +451,26 @@ PyDoc_STRVAR(zlib_crc32__doc__,
"The returned checksum is an integer.");
#define ZLIB_CRC32_METHODDEF \
{"crc32", (PyCFunction)zlib_crc32, METH_VARARGS, zlib_crc32__doc__},
{"crc32", (PyCFunction)zlib_crc32, METH_FASTCALL, zlib_crc32__doc__},
static PyObject *
zlib_crc32_impl(PyObject *module, Py_buffer *data, unsigned int value);
static PyObject *
zlib_crc32(PyObject *module, PyObject *args)
zlib_crc32(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
Py_buffer data = {NULL, NULL};
unsigned int value = 0;
if (!PyArg_ParseTuple(args, "y*|I:crc32",
if (!_PyArg_ParseStack(args, nargs, "y*|I:crc32",
&data, &value)) {
goto exit;
}
if (!_PyArg_NoStackKeywords("crc32", kwnames)) {
goto exit;
}
return_value = zlib_crc32_impl(module, &data, value);
exit:
@ -466,8 +485,4 @@ exit:
#ifndef ZLIB_COMPRESS_COPY_METHODDEF
#define ZLIB_COMPRESS_COPY_METHODDEF
#endif /* !defined(ZLIB_COMPRESS_COPY_METHODDEF) */
#ifndef ZLIB_DECOMPRESS_COPY_METHODDEF
#define ZLIB_DECOMPRESS_COPY_METHODDEF
#endif /* !defined(ZLIB_DECOMPRESS_COPY_METHODDEF) */
/*[clinic end generated code: output=497dad1132c962e2 input=a9049054013a1b77]*/
/*[clinic end generated code: output=c6cb10ed66f226b2 input=a9049054013a1b77]*/

12
third_party/python/Modules/socketmodule.c vendored
View file

@ -3867,11 +3867,15 @@ sock_sendto(PySocketSockObject *s, PyObject *args)
arglen = PyTuple_Size(args);
switch (arglen) {
case 2:
PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro);
if (!PyArg_ParseTuple(args, "y*O:sendto", &pbuf, &addro)) {
return NULL;
}
break;
case 3:
PyArg_ParseTuple(args, "y*iO:sendto",
&pbuf, &flags, &addro);
if (!PyArg_ParseTuple(args, "y*iO:sendto",
&pbuf, &flags, &addro)) {
return NULL;
}
break;
default:
PyErr_Format(PyExc_TypeError,
@ -3879,8 +3883,6 @@ sock_sendto(PySocketSockObject *s, PyObject *args)
arglen);
return NULL;
}
if (PyErr_Occurred())
return NULL;
if (!IS_SELECTABLE(s)) {
PyBuffer_Release(&pbuf);

2
third_party/python/Modules/zlibmodule.c vendored
View file

@ -503,7 +503,7 @@ Return a compressor object.
static PyObject *
zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,
int memLevel, int strategy, Py_buffer *zdict)
/*[clinic end generated code: output=8b5bed9c8fc3814d input=2fa3d026f90ab8d5]*/
/*[clinic end generated code: output=8b5bed9c8fc3814d input=b5a08c304c3bae52]*/
{
compobject *self = NULL;
int err;