Run Argument Clinic: METH_VARARGS=>METH_FASTCALL
Issue #29286. Run Argument Clinic to get the new faster METH_FASTCALL calling convention for functions using only positional arguments.
This commit is contained in:
parent
0c8c3893ae
commit
259f0e4437
|
@ -158,4 +158,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]*/
|
||||
|
|
|
@ -91,21 +91,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:
|
||||
|
@ -118,21 +122,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:
|
||||
|
@ -145,21 +153,25 @@ PyDoc_STRVAR(_io__Buffered_read1__doc__,
|
|||
"\n");
|
||||
|
||||
#define _IO__BUFFERED_READ1_METHODDEF \
|
||||
{"read1", (PyCFunction)_io__Buffered_read1, METH_VARARGS, _io__Buffered_read1__doc__},
|
||||
{"read1", (PyCFunction)_io__Buffered_read1, METH_FASTCALL, _io__Buffered_read1__doc__},
|
||||
|
||||
static PyObject *
|
||||
_io__Buffered_read1_impl(buffered *self, Py_ssize_t n);
|
||||
|
||||
static PyObject *
|
||||
_io__Buffered_read1(buffered *self, PyObject *args)
|
||||
_io__Buffered_read1(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_ssize_t n = -1;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|n:read1",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|n:read1",
|
||||
&n)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("read1", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _io__Buffered_read1_impl(self, n);
|
||||
|
||||
exit:
|
||||
|
@ -234,21 +246,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:
|
||||
|
@ -261,22 +277,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:
|
||||
|
@ -476,4 +496,4 @@ _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=490c97bfcfd92c51 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=e6e584216a10d67e input=a9049054013a1b77]*/
|
||||
|
|
|
@ -358,22 +358,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:
|
||||
|
@ -448,4 +452,4 @@ _io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=8f469431da1b3857 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=056f24eece495a8f input=a9049054013a1b77]*/
|
||||
|
|
|
@ -202,21 +202,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:
|
||||
|
@ -274,22 +278,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:
|
||||
|
@ -373,4 +381,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=5c2a0b493c0af58b input=a9049054013a1b77]*/
|
||||
|
|
|
@ -174,21 +174,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_impl(PyObject *self, Py_ssize_t limit);
|
||||
|
||||
static PyObject *
|
||||
_io__IOBase_readline(PyObject *self, PyObject *args)
|
||||
_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:
|
||||
|
@ -206,21 +210,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_impl(PyObject *self, Py_ssize_t hint);
|
||||
|
||||
static PyObject *
|
||||
_io__IOBase_readlines(PyObject *self, PyObject *args)
|
||||
_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:
|
||||
|
@ -241,21 +249,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:
|
||||
|
@ -279,4 +291,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]*/
|
||||
|
|
|
@ -147,22 +147,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:
|
||||
|
@ -289,4 +293,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=69bf262268745061 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -225,21 +225,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:
|
||||
|
@ -252,21 +256,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:
|
||||
|
@ -279,22 +287,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:
|
||||
|
@ -464,4 +476,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=1f8367c7a3301670 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -209,21 +209,25 @@ 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:
|
||||
|
@ -328,4 +332,4 @@ _io__WindowsConsoleIO_isatty(winconsoleio *self, PyObject *Py_UNUSED(ignored))
|
|||
#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=04dab03363f5e304 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -151,4 +151,4 @@ _sha3_shake_128_hexdigest(SHA3object *self, PyObject **args, Py_ssize_t nargs, P
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=9888beab45136a56 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=f2278bf0852a7850 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -330,4 +330,4 @@ PyDoc_STRVAR(_multibytecodec___create_codec__doc__,
|
|||
|
||||
#define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \
|
||||
{"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__},
|
||||
/*[clinic end generated code: output=134b9e36cb985939 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=7d6a05b0a581fd17 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -517,4 +517,4 @@ _asyncio_Task__wakeup(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=8f036321bb083066 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=07a15bbb28d03edc input=a9049054013a1b77]*/
|
||||
|
|
|
@ -174,4 +174,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]*/
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -14,25 +14,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]*/
|
||||
|
|
|
@ -36,4 +36,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]*/
|
||||
|
|
|
@ -45,24 +45,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 = NULL;
|
||||
|
||||
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:
|
||||
|
@ -78,7 +82,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,
|
||||
|
@ -86,17 +90,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:
|
||||
|
@ -118,27 +126,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, const char *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;
|
||||
const char *filename;
|
||||
const char *flags = "r";
|
||||
int mode = 438;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s|si:open",
|
||||
if (!_PyArg_ParseStack(args, nargs, "s|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=99adf966ef0475ff input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=4fdb7be8bd03cbce input=a9049054013a1b77]*/
|
||||
|
|
|
@ -356,23 +356,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:
|
||||
|
@ -702,4 +706,4 @@ _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *args)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=b4a571a98ced3163 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=4e3d22c6f6d832b2 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -231,26 +231,30 @@ 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, const char *name, 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;
|
||||
const char *name;
|
||||
const char *flags = "r";
|
||||
int mode = 438;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s|si:open",
|
||||
if (!_PyArg_ParseStack(args, nargs, "s|si:open",
|
||||
&name, &flags, &mode)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("open", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = dbmopen_impl(module, name, flags, mode);
|
||||
|
||||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=ed0f5d4e3d79b80c input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=1e47d62a35eeba8b input=a9049054013a1b77]*/
|
||||
|
|
|
@ -57,4 +57,4 @@ exit:
|
|||
#ifndef _HASHLIB_SCRYPT_METHODDEF
|
||||
#define _HASHLIB_SCRYPT_METHODDEF
|
||||
#endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */
|
||||
/*[clinic end generated code: output=118cd7036fa0fb52 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=71f1e033efe4ac9a input=a9049054013a1b77]*/
|
||||
|
|
|
@ -229,23 +229,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:
|
||||
|
@ -256,4 +260,4 @@ exit:
|
|||
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=f27abae460122706 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=5f7a915fb7e41453 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -9,23 +9,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;
|
||||
|
@ -35,4 +39,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]*/
|
||||
|
|
|
@ -560,4 +560,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=d7222d1219039fbd input=a9049054013a1b77]*/
|
||||
|
|
|
@ -35,23 +35,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;
|
||||
|
@ -716,4 +720,4 @@ _sre_SRE_Scanner_search(ScannerObject *self, PyObject *Py_UNUSED(ignored))
|
|||
{
|
||||
return _sre_SRE_Scanner_search_impl(self);
|
||||
}
|
||||
/*[clinic end generated code: output=586a4132fbe8c6a7 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=3dff18d3b6110b86 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -60,21 +60,25 @@ PyDoc_STRVAR(_ssl__SSLSocket_peer_certificate__doc__,
|
|||
"return the certificate even if it wasn\'t validated.");
|
||||
|
||||
#define _SSL__SSLSOCKET_PEER_CERTIFICATE_METHODDEF \
|
||||
{"peer_certificate", (PyCFunction)_ssl__SSLSocket_peer_certificate, METH_VARARGS, _ssl__SSLSocket_peer_certificate__doc__},
|
||||
{"peer_certificate", (PyCFunction)_ssl__SSLSocket_peer_certificate, METH_FASTCALL, _ssl__SSLSocket_peer_certificate__doc__},
|
||||
|
||||
static PyObject *
|
||||
_ssl__SSLSocket_peer_certificate_impl(PySSLSocket *self, int binary_mode);
|
||||
|
||||
static PyObject *
|
||||
_ssl__SSLSocket_peer_certificate(PySSLSocket *self, PyObject *args)
|
||||
_ssl__SSLSocket_peer_certificate(PySSLSocket *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int binary_mode = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|p:peer_certificate",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|p:peer_certificate",
|
||||
&binary_mode)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("peer_certificate", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _ssl__SSLSocket_peer_certificate_impl(self, binary_mode);
|
||||
|
||||
exit:
|
||||
|
@ -757,21 +761,25 @@ PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__,
|
|||
"distinguish between the two.");
|
||||
|
||||
#define _SSL_MEMORYBIO_READ_METHODDEF \
|
||||
{"read", (PyCFunction)_ssl_MemoryBIO_read, METH_VARARGS, _ssl_MemoryBIO_read__doc__},
|
||||
{"read", (PyCFunction)_ssl_MemoryBIO_read, METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
|
||||
|
||||
static PyObject *
|
||||
_ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len);
|
||||
|
||||
static PyObject *
|
||||
_ssl_MemoryBIO_read(PySSLMemoryBIO *self, PyObject *args)
|
||||
_ssl_MemoryBIO_read(PySSLMemoryBIO *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int len = -1;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i:read",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|i:read",
|
||||
&len)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("read", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _ssl_MemoryBIO_read_impl(self, len);
|
||||
|
||||
exit:
|
||||
|
@ -842,22 +850,26 @@ PyDoc_STRVAR(_ssl_RAND_add__doc__,
|
|||
"string. See RFC 1750.");
|
||||
|
||||
#define _SSL_RAND_ADD_METHODDEF \
|
||||
{"RAND_add", (PyCFunction)_ssl_RAND_add, METH_VARARGS, _ssl_RAND_add__doc__},
|
||||
{"RAND_add", (PyCFunction)_ssl_RAND_add, METH_FASTCALL, _ssl_RAND_add__doc__},
|
||||
|
||||
static PyObject *
|
||||
_ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy);
|
||||
|
||||
static PyObject *
|
||||
_ssl_RAND_add(PyObject *module, PyObject *args)
|
||||
_ssl_RAND_add(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_buffer view = {NULL, NULL};
|
||||
double entropy;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "s*d:RAND_add",
|
||||
if (!_PyArg_ParseStack(args, nargs, "s*d:RAND_add",
|
||||
&view, &entropy)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("RAND_add", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _ssl_RAND_add_impl(module, &view, entropy);
|
||||
|
||||
exit:
|
||||
|
@ -1168,4 +1180,4 @@ exit:
|
|||
#ifndef _SSL_ENUM_CRLS_METHODDEF
|
||||
#define _SSL_ENUM_CRLS_METHODDEF
|
||||
#endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */
|
||||
/*[clinic end generated code: output=a859b21fe68a6115 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=53cd9100580b45a2 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -256,23 +256,27 @@ PyDoc_STRVAR(_tkinter_tkapp_createcommand__doc__,
|
|||
"\n");
|
||||
|
||||
#define _TKINTER_TKAPP_CREATECOMMAND_METHODDEF \
|
||||
{"createcommand", (PyCFunction)_tkinter_tkapp_createcommand, METH_VARARGS, _tkinter_tkapp_createcommand__doc__},
|
||||
{"createcommand", (PyCFunction)_tkinter_tkapp_createcommand, METH_FASTCALL, _tkinter_tkapp_createcommand__doc__},
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
|
||||
PyObject *func);
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_createcommand(TkappObject *self, PyObject *args)
|
||||
_tkinter_tkapp_createcommand(TkappObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
const char *name;
|
||||
PyObject *func;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "sO:createcommand",
|
||||
if (!_PyArg_ParseStack(args, nargs, "sO:createcommand",
|
||||
&name, &func)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("createcommand", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _tkinter_tkapp_createcommand_impl(self, name, func);
|
||||
|
||||
exit:
|
||||
|
@ -313,24 +317,28 @@ PyDoc_STRVAR(_tkinter_tkapp_createfilehandler__doc__,
|
|||
"\n");
|
||||
|
||||
#define _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF \
|
||||
{"createfilehandler", (PyCFunction)_tkinter_tkapp_createfilehandler, METH_VARARGS, _tkinter_tkapp_createfilehandler__doc__},
|
||||
{"createfilehandler", (PyCFunction)_tkinter_tkapp_createfilehandler, METH_FASTCALL, _tkinter_tkapp_createfilehandler__doc__},
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_createfilehandler_impl(TkappObject *self, PyObject *file,
|
||||
int mask, PyObject *func);
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_createfilehandler(TkappObject *self, PyObject *args)
|
||||
_tkinter_tkapp_createfilehandler(TkappObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *file;
|
||||
int mask;
|
||||
PyObject *func;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "OiO:createfilehandler",
|
||||
if (!_PyArg_ParseStack(args, nargs, "OiO:createfilehandler",
|
||||
&file, &mask, &func)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("createfilehandler", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _tkinter_tkapp_createfilehandler_impl(self, file, mask, func);
|
||||
|
||||
exit:
|
||||
|
@ -374,23 +382,27 @@ PyDoc_STRVAR(_tkinter_tkapp_createtimerhandler__doc__,
|
|||
"\n");
|
||||
|
||||
#define _TKINTER_TKAPP_CREATETIMERHANDLER_METHODDEF \
|
||||
{"createtimerhandler", (PyCFunction)_tkinter_tkapp_createtimerhandler, METH_VARARGS, _tkinter_tkapp_createtimerhandler__doc__},
|
||||
{"createtimerhandler", (PyCFunction)_tkinter_tkapp_createtimerhandler, METH_FASTCALL, _tkinter_tkapp_createtimerhandler__doc__},
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_createtimerhandler_impl(TkappObject *self, int milliseconds,
|
||||
PyObject *func);
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_createtimerhandler(TkappObject *self, PyObject *args)
|
||||
_tkinter_tkapp_createtimerhandler(TkappObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int milliseconds;
|
||||
PyObject *func;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iO:createtimerhandler",
|
||||
if (!_PyArg_ParseStack(args, nargs, "iO:createtimerhandler",
|
||||
&milliseconds, &func)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("createtimerhandler", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _tkinter_tkapp_createtimerhandler_impl(self, milliseconds, func);
|
||||
|
||||
exit:
|
||||
|
@ -403,21 +415,25 @@ PyDoc_STRVAR(_tkinter_tkapp_mainloop__doc__,
|
|||
"\n");
|
||||
|
||||
#define _TKINTER_TKAPP_MAINLOOP_METHODDEF \
|
||||
{"mainloop", (PyCFunction)_tkinter_tkapp_mainloop, METH_VARARGS, _tkinter_tkapp_mainloop__doc__},
|
||||
{"mainloop", (PyCFunction)_tkinter_tkapp_mainloop, METH_FASTCALL, _tkinter_tkapp_mainloop__doc__},
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_mainloop_impl(TkappObject *self, int threshold);
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_mainloop(TkappObject *self, PyObject *args)
|
||||
_tkinter_tkapp_mainloop(TkappObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int threshold = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i:mainloop",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|i:mainloop",
|
||||
&threshold)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("mainloop", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _tkinter_tkapp_mainloop_impl(self, threshold);
|
||||
|
||||
exit:
|
||||
|
@ -430,21 +446,25 @@ PyDoc_STRVAR(_tkinter_tkapp_dooneevent__doc__,
|
|||
"\n");
|
||||
|
||||
#define _TKINTER_TKAPP_DOONEEVENT_METHODDEF \
|
||||
{"dooneevent", (PyCFunction)_tkinter_tkapp_dooneevent, METH_VARARGS, _tkinter_tkapp_dooneevent__doc__},
|
||||
{"dooneevent", (PyCFunction)_tkinter_tkapp_dooneevent, METH_FASTCALL, _tkinter_tkapp_dooneevent__doc__},
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_dooneevent_impl(TkappObject *self, int flags);
|
||||
|
||||
static PyObject *
|
||||
_tkinter_tkapp_dooneevent(TkappObject *self, PyObject *args)
|
||||
_tkinter_tkapp_dooneevent(TkappObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int flags = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i:dooneevent",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|i:dooneevent",
|
||||
&flags)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("dooneevent", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _tkinter_tkapp_dooneevent_impl(self, flags);
|
||||
|
||||
exit:
|
||||
|
@ -543,7 +563,7 @@ PyDoc_STRVAR(_tkinter_create__doc__,
|
|||
" if not None, then pass -use to wish");
|
||||
|
||||
#define _TKINTER_CREATE_METHODDEF \
|
||||
{"create", (PyCFunction)_tkinter_create, METH_VARARGS, _tkinter_create__doc__},
|
||||
{"create", (PyCFunction)_tkinter_create, METH_FASTCALL, _tkinter_create__doc__},
|
||||
|
||||
static PyObject *
|
||||
_tkinter_create_impl(PyObject *module, const char *screenName,
|
||||
|
@ -552,7 +572,7 @@ _tkinter_create_impl(PyObject *module, const char *screenName,
|
|||
const char *use);
|
||||
|
||||
static PyObject *
|
||||
_tkinter_create(PyObject *module, PyObject *args)
|
||||
_tkinter_create(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
const char *screenName = NULL;
|
||||
|
@ -564,10 +584,14 @@ _tkinter_create(PyObject *module, PyObject *args)
|
|||
int sync = 0;
|
||||
const char *use = NULL;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|zssiiiiz:create",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|zssiiiiz:create",
|
||||
&screenName, &baseName, &className, &interactive, &wantobjects, &wantTk, &sync, &use)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("create", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _tkinter_create_impl(module, screenName, baseName, className, interactive, wantobjects, wantTk, sync, use);
|
||||
|
||||
exit:
|
||||
|
@ -638,4 +662,4 @@ exit:
|
|||
#ifndef _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
|
||||
#define _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
|
||||
#endif /* !defined(_TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF) */
|
||||
/*[clinic end generated code: output=836c578b71d69097 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=328e29a146c4a63b input=a9049054013a1b77]*/
|
||||
|
|
|
@ -37,26 +37,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]*/
|
||||
|
|
|
@ -128,7 +128,7 @@ PyDoc_STRVAR(_winapi_CreateFile__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_CREATEFILE_METHODDEF \
|
||||
{"CreateFile", (PyCFunction)_winapi_CreateFile, METH_VARARGS, _winapi_CreateFile__doc__},
|
||||
{"CreateFile", (PyCFunction)_winapi_CreateFile, METH_FASTCALL, _winapi_CreateFile__doc__},
|
||||
|
||||
static HANDLE
|
||||
_winapi_CreateFile_impl(PyObject *module, LPCTSTR file_name,
|
||||
|
@ -138,7 +138,7 @@ _winapi_CreateFile_impl(PyObject *module, LPCTSTR file_name,
|
|||
DWORD flags_and_attributes, HANDLE template_file);
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreateFile(PyObject *module, PyObject *args)
|
||||
_winapi_CreateFile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
LPCTSTR file_name;
|
||||
|
@ -150,10 +150,14 @@ _winapi_CreateFile(PyObject *module, PyObject *args)
|
|||
HANDLE template_file;
|
||||
HANDLE _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "skk" F_POINTER "kk" F_HANDLE ":CreateFile",
|
||||
if (!_PyArg_ParseStack(args, nargs, "skk" F_POINTER "kk" F_HANDLE ":CreateFile",
|
||||
&file_name, &desired_access, &share_mode, &security_attributes, &creation_disposition, &flags_and_attributes, &template_file)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CreateFile", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = _winapi_CreateFile_impl(module, file_name, desired_access, share_mode, security_attributes, creation_disposition, flags_and_attributes, template_file);
|
||||
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -173,23 +177,27 @@ PyDoc_STRVAR(_winapi_CreateJunction__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_CREATEJUNCTION_METHODDEF \
|
||||
{"CreateJunction", (PyCFunction)_winapi_CreateJunction, METH_VARARGS, _winapi_CreateJunction__doc__},
|
||||
{"CreateJunction", (PyCFunction)_winapi_CreateJunction, METH_FASTCALL, _winapi_CreateJunction__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreateJunction_impl(PyObject *module, LPWSTR src_path,
|
||||
LPWSTR dst_path);
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreateJunction(PyObject *module, PyObject *args)
|
||||
_winapi_CreateJunction(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
LPWSTR src_path;
|
||||
LPWSTR dst_path;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "uu:CreateJunction",
|
||||
if (!_PyArg_ParseStack(args, nargs, "uu:CreateJunction",
|
||||
&src_path, &dst_path)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CreateJunction", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_CreateJunction_impl(module, src_path, dst_path);
|
||||
|
||||
exit:
|
||||
|
@ -204,7 +212,7 @@ PyDoc_STRVAR(_winapi_CreateNamedPipe__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_CREATENAMEDPIPE_METHODDEF \
|
||||
{"CreateNamedPipe", (PyCFunction)_winapi_CreateNamedPipe, METH_VARARGS, _winapi_CreateNamedPipe__doc__},
|
||||
{"CreateNamedPipe", (PyCFunction)_winapi_CreateNamedPipe, METH_FASTCALL, _winapi_CreateNamedPipe__doc__},
|
||||
|
||||
static HANDLE
|
||||
_winapi_CreateNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD open_mode,
|
||||
|
@ -214,7 +222,7 @@ _winapi_CreateNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD open_mode,
|
|||
LPSECURITY_ATTRIBUTES security_attributes);
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreateNamedPipe(PyObject *module, PyObject *args)
|
||||
_winapi_CreateNamedPipe(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
LPCTSTR name;
|
||||
|
@ -227,10 +235,14 @@ _winapi_CreateNamedPipe(PyObject *module, PyObject *args)
|
|||
LPSECURITY_ATTRIBUTES security_attributes;
|
||||
HANDLE _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "skkkkkk" F_POINTER ":CreateNamedPipe",
|
||||
if (!_PyArg_ParseStack(args, nargs, "skkkkkk" F_POINTER ":CreateNamedPipe",
|
||||
&name, &open_mode, &pipe_mode, &max_instances, &out_buffer_size, &in_buffer_size, &default_timeout, &security_attributes)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CreateNamedPipe", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = _winapi_CreateNamedPipe_impl(module, name, open_mode, pipe_mode, max_instances, out_buffer_size, in_buffer_size, default_timeout, security_attributes);
|
||||
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -256,22 +268,26 @@ PyDoc_STRVAR(_winapi_CreatePipe__doc__,
|
|||
"Returns a 2-tuple of handles, to the read and write ends of the pipe.");
|
||||
|
||||
#define _WINAPI_CREATEPIPE_METHODDEF \
|
||||
{"CreatePipe", (PyCFunction)_winapi_CreatePipe, METH_VARARGS, _winapi_CreatePipe__doc__},
|
||||
{"CreatePipe", (PyCFunction)_winapi_CreatePipe, METH_FASTCALL, _winapi_CreatePipe__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreatePipe_impl(PyObject *module, PyObject *pipe_attrs, DWORD size);
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreatePipe(PyObject *module, PyObject *args)
|
||||
_winapi_CreatePipe(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *pipe_attrs;
|
||||
DWORD size;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "Ok:CreatePipe",
|
||||
if (!_PyArg_ParseStack(args, nargs, "Ok:CreatePipe",
|
||||
&pipe_attrs, &size)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CreatePipe", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_CreatePipe_impl(module, pipe_attrs, size);
|
||||
|
||||
exit:
|
||||
|
@ -295,7 +311,7 @@ PyDoc_STRVAR(_winapi_CreateProcess__doc__,
|
|||
"process ID, and thread ID.");
|
||||
|
||||
#define _WINAPI_CREATEPROCESS_METHODDEF \
|
||||
{"CreateProcess", (PyCFunction)_winapi_CreateProcess, METH_VARARGS, _winapi_CreateProcess__doc__},
|
||||
{"CreateProcess", (PyCFunction)_winapi_CreateProcess, METH_FASTCALL, _winapi_CreateProcess__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreateProcess_impl(PyObject *module, Py_UNICODE *application_name,
|
||||
|
@ -306,7 +322,7 @@ _winapi_CreateProcess_impl(PyObject *module, Py_UNICODE *application_name,
|
|||
PyObject *startup_info);
|
||||
|
||||
static PyObject *
|
||||
_winapi_CreateProcess(PyObject *module, PyObject *args)
|
||||
_winapi_CreateProcess(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_UNICODE *application_name;
|
||||
|
@ -319,10 +335,14 @@ _winapi_CreateProcess(PyObject *module, PyObject *args)
|
|||
Py_UNICODE *current_directory;
|
||||
PyObject *startup_info;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ZZOOikOZO:CreateProcess",
|
||||
if (!_PyArg_ParseStack(args, nargs, "ZZOOikOZO:CreateProcess",
|
||||
&application_name, &command_line, &proc_attrs, &thread_attrs, &inherit_handles, &creation_flags, &env_mapping, ¤t_directory, &startup_info)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CreateProcess", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_CreateProcess_impl(module, application_name, command_line, proc_attrs, thread_attrs, inherit_handles, creation_flags, env_mapping, current_directory, startup_info);
|
||||
|
||||
exit:
|
||||
|
@ -342,7 +362,7 @@ PyDoc_STRVAR(_winapi_DuplicateHandle__doc__,
|
|||
"through both handles.");
|
||||
|
||||
#define _WINAPI_DUPLICATEHANDLE_METHODDEF \
|
||||
{"DuplicateHandle", (PyCFunction)_winapi_DuplicateHandle, METH_VARARGS, _winapi_DuplicateHandle__doc__},
|
||||
{"DuplicateHandle", (PyCFunction)_winapi_DuplicateHandle, METH_FASTCALL, _winapi_DuplicateHandle__doc__},
|
||||
|
||||
static HANDLE
|
||||
_winapi_DuplicateHandle_impl(PyObject *module, HANDLE source_process_handle,
|
||||
|
@ -352,7 +372,7 @@ _winapi_DuplicateHandle_impl(PyObject *module, HANDLE source_process_handle,
|
|||
DWORD options);
|
||||
|
||||
static PyObject *
|
||||
_winapi_DuplicateHandle(PyObject *module, PyObject *args)
|
||||
_winapi_DuplicateHandle(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE source_process_handle;
|
||||
|
@ -363,10 +383,14 @@ _winapi_DuplicateHandle(PyObject *module, PyObject *args)
|
|||
DWORD options = 0;
|
||||
HANDLE _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "" F_HANDLE "" F_HANDLE "" F_HANDLE "ki|k:DuplicateHandle",
|
||||
if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "" F_HANDLE "" F_HANDLE "ki|k:DuplicateHandle",
|
||||
&source_process_handle, &source_handle, &target_process_handle, &desired_access, &inherit_handle, &options)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("DuplicateHandle", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = _winapi_DuplicateHandle_impl(module, source_process_handle, source_handle, target_process_handle, desired_access, inherit_handle, options);
|
||||
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -604,14 +628,14 @@ PyDoc_STRVAR(_winapi_OpenProcess__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_OPENPROCESS_METHODDEF \
|
||||
{"OpenProcess", (PyCFunction)_winapi_OpenProcess, METH_VARARGS, _winapi_OpenProcess__doc__},
|
||||
{"OpenProcess", (PyCFunction)_winapi_OpenProcess, METH_FASTCALL, _winapi_OpenProcess__doc__},
|
||||
|
||||
static HANDLE
|
||||
_winapi_OpenProcess_impl(PyObject *module, DWORD desired_access,
|
||||
BOOL inherit_handle, DWORD process_id);
|
||||
|
||||
static PyObject *
|
||||
_winapi_OpenProcess(PyObject *module, PyObject *args)
|
||||
_winapi_OpenProcess(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
DWORD desired_access;
|
||||
|
@ -619,10 +643,14 @@ _winapi_OpenProcess(PyObject *module, PyObject *args)
|
|||
DWORD process_id;
|
||||
HANDLE _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "kik:OpenProcess",
|
||||
if (!_PyArg_ParseStack(args, nargs, "kik:OpenProcess",
|
||||
&desired_access, &inherit_handle, &process_id)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("OpenProcess", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = _winapi_OpenProcess_impl(module, desired_access, inherit_handle, process_id);
|
||||
if ((_return_value == INVALID_HANDLE_VALUE) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -642,22 +670,26 @@ PyDoc_STRVAR(_winapi_PeekNamedPipe__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_PEEKNAMEDPIPE_METHODDEF \
|
||||
{"PeekNamedPipe", (PyCFunction)_winapi_PeekNamedPipe, METH_VARARGS, _winapi_PeekNamedPipe__doc__},
|
||||
{"PeekNamedPipe", (PyCFunction)_winapi_PeekNamedPipe, METH_FASTCALL, _winapi_PeekNamedPipe__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_PeekNamedPipe_impl(PyObject *module, HANDLE handle, int size);
|
||||
|
||||
static PyObject *
|
||||
_winapi_PeekNamedPipe(PyObject *module, PyObject *args)
|
||||
_winapi_PeekNamedPipe(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
int size = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "" F_HANDLE "|i:PeekNamedPipe",
|
||||
if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "|i:PeekNamedPipe",
|
||||
&handle, &size)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("PeekNamedPipe", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_PeekNamedPipe_impl(module, handle, size);
|
||||
|
||||
exit:
|
||||
|
@ -703,7 +735,7 @@ PyDoc_STRVAR(_winapi_SetNamedPipeHandleState__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_SETNAMEDPIPEHANDLESTATE_METHODDEF \
|
||||
{"SetNamedPipeHandleState", (PyCFunction)_winapi_SetNamedPipeHandleState, METH_VARARGS, _winapi_SetNamedPipeHandleState__doc__},
|
||||
{"SetNamedPipeHandleState", (PyCFunction)_winapi_SetNamedPipeHandleState, METH_FASTCALL, _winapi_SetNamedPipeHandleState__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_SetNamedPipeHandleState_impl(PyObject *module, HANDLE named_pipe,
|
||||
|
@ -712,7 +744,7 @@ _winapi_SetNamedPipeHandleState_impl(PyObject *module, HANDLE named_pipe,
|
|||
PyObject *collect_data_timeout);
|
||||
|
||||
static PyObject *
|
||||
_winapi_SetNamedPipeHandleState(PyObject *module, PyObject *args)
|
||||
_winapi_SetNamedPipeHandleState(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE named_pipe;
|
||||
|
@ -720,10 +752,14 @@ _winapi_SetNamedPipeHandleState(PyObject *module, PyObject *args)
|
|||
PyObject *max_collection_count;
|
||||
PyObject *collect_data_timeout;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "" F_HANDLE "OOO:SetNamedPipeHandleState",
|
||||
if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "OOO:SetNamedPipeHandleState",
|
||||
&named_pipe, &mode, &max_collection_count, &collect_data_timeout)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("SetNamedPipeHandleState", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_SetNamedPipeHandleState_impl(module, named_pipe, mode, max_collection_count, collect_data_timeout);
|
||||
|
||||
exit:
|
||||
|
@ -737,23 +773,27 @@ PyDoc_STRVAR(_winapi_TerminateProcess__doc__,
|
|||
"Terminate the specified process and all of its threads.");
|
||||
|
||||
#define _WINAPI_TERMINATEPROCESS_METHODDEF \
|
||||
{"TerminateProcess", (PyCFunction)_winapi_TerminateProcess, METH_VARARGS, _winapi_TerminateProcess__doc__},
|
||||
{"TerminateProcess", (PyCFunction)_winapi_TerminateProcess, METH_FASTCALL, _winapi_TerminateProcess__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_TerminateProcess_impl(PyObject *module, HANDLE handle,
|
||||
UINT exit_code);
|
||||
|
||||
static PyObject *
|
||||
_winapi_TerminateProcess(PyObject *module, PyObject *args)
|
||||
_winapi_TerminateProcess(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
UINT exit_code;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "" F_HANDLE "I:TerminateProcess",
|
||||
if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "I:TerminateProcess",
|
||||
&handle, &exit_code)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("TerminateProcess", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_TerminateProcess_impl(module, handle, exit_code);
|
||||
|
||||
exit:
|
||||
|
@ -766,22 +806,26 @@ PyDoc_STRVAR(_winapi_WaitNamedPipe__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_WAITNAMEDPIPE_METHODDEF \
|
||||
{"WaitNamedPipe", (PyCFunction)_winapi_WaitNamedPipe, METH_VARARGS, _winapi_WaitNamedPipe__doc__},
|
||||
{"WaitNamedPipe", (PyCFunction)_winapi_WaitNamedPipe, METH_FASTCALL, _winapi_WaitNamedPipe__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_WaitNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD timeout);
|
||||
|
||||
static PyObject *
|
||||
_winapi_WaitNamedPipe(PyObject *module, PyObject *args)
|
||||
_winapi_WaitNamedPipe(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
LPCTSTR name;
|
||||
DWORD timeout;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "sk:WaitNamedPipe",
|
||||
if (!_PyArg_ParseStack(args, nargs, "sk:WaitNamedPipe",
|
||||
&name, &timeout)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("WaitNamedPipe", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_WaitNamedPipe_impl(module, name, timeout);
|
||||
|
||||
exit:
|
||||
|
@ -795,24 +839,28 @@ PyDoc_STRVAR(_winapi_WaitForMultipleObjects__doc__,
|
|||
"\n");
|
||||
|
||||
#define _WINAPI_WAITFORMULTIPLEOBJECTS_METHODDEF \
|
||||
{"WaitForMultipleObjects", (PyCFunction)_winapi_WaitForMultipleObjects, METH_VARARGS, _winapi_WaitForMultipleObjects__doc__},
|
||||
{"WaitForMultipleObjects", (PyCFunction)_winapi_WaitForMultipleObjects, METH_FASTCALL, _winapi_WaitForMultipleObjects__doc__},
|
||||
|
||||
static PyObject *
|
||||
_winapi_WaitForMultipleObjects_impl(PyObject *module, PyObject *handle_seq,
|
||||
BOOL wait_flag, DWORD milliseconds);
|
||||
|
||||
static PyObject *
|
||||
_winapi_WaitForMultipleObjects(PyObject *module, PyObject *args)
|
||||
_winapi_WaitForMultipleObjects(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *handle_seq;
|
||||
BOOL wait_flag;
|
||||
DWORD milliseconds = INFINITE;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "Oi|k:WaitForMultipleObjects",
|
||||
if (!_PyArg_ParseStack(args, nargs, "Oi|k:WaitForMultipleObjects",
|
||||
&handle_seq, &wait_flag, &milliseconds)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("WaitForMultipleObjects", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _winapi_WaitForMultipleObjects_impl(module, handle_seq, wait_flag, milliseconds);
|
||||
|
||||
exit:
|
||||
|
@ -830,24 +878,28 @@ PyDoc_STRVAR(_winapi_WaitForSingleObject__doc__,
|
|||
"in milliseconds.");
|
||||
|
||||
#define _WINAPI_WAITFORSINGLEOBJECT_METHODDEF \
|
||||
{"WaitForSingleObject", (PyCFunction)_winapi_WaitForSingleObject, METH_VARARGS, _winapi_WaitForSingleObject__doc__},
|
||||
{"WaitForSingleObject", (PyCFunction)_winapi_WaitForSingleObject, METH_FASTCALL, _winapi_WaitForSingleObject__doc__},
|
||||
|
||||
static long
|
||||
_winapi_WaitForSingleObject_impl(PyObject *module, HANDLE handle,
|
||||
DWORD milliseconds);
|
||||
|
||||
static PyObject *
|
||||
_winapi_WaitForSingleObject(PyObject *module, PyObject *args)
|
||||
_winapi_WaitForSingleObject(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HANDLE handle;
|
||||
DWORD milliseconds;
|
||||
long _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "" F_HANDLE "k:WaitForSingleObject",
|
||||
if (!_PyArg_ParseStack(args, nargs, "" F_HANDLE "k:WaitForSingleObject",
|
||||
&handle, &milliseconds)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("WaitForSingleObject", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = _winapi_WaitForSingleObject_impl(module, handle, milliseconds);
|
||||
if ((_return_value == -1) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -889,4 +941,4 @@ _winapi_WriteFile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=46d6382a6662c4a9 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=2beb984508fb040a input=a9049054013a1b77]*/
|
||||
|
|
|
@ -65,21 +65,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:
|
||||
|
@ -102,22 +106,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:
|
||||
|
@ -200,22 +208,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:
|
||||
|
@ -443,7 +455,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,
|
||||
|
@ -452,7 +464,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;
|
||||
|
@ -460,10 +472,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:
|
||||
|
@ -505,4 +521,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]*/
|
||||
|
|
|
@ -9,24 +9,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:
|
||||
|
@ -45,22 +49,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:
|
||||
|
@ -79,22 +87,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:
|
||||
|
@ -113,22 +125,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:
|
||||
|
@ -147,22 +163,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:
|
||||
|
@ -181,23 +201,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:
|
||||
|
@ -220,23 +244,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:
|
||||
|
@ -259,23 +287,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:
|
||||
|
@ -294,22 +326,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:
|
||||
|
@ -328,22 +364,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:
|
||||
|
@ -362,22 +402,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:
|
||||
|
@ -396,24 +440,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:
|
||||
|
@ -432,14 +480,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};
|
||||
|
@ -447,10 +495,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:
|
||||
|
@ -469,14 +521,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};
|
||||
|
@ -484,10 +536,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:
|
||||
|
@ -506,24 +562,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:
|
||||
|
@ -546,23 +606,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:
|
||||
|
@ -581,22 +645,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:
|
||||
|
@ -615,22 +683,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:
|
||||
|
@ -649,24 +721,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:
|
||||
|
@ -686,7 +762,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,
|
||||
|
@ -694,7 +770,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};
|
||||
|
@ -706,10 +782,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:
|
||||
|
@ -728,22 +808,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:
|
||||
|
@ -762,22 +846,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:
|
||||
|
@ -796,22 +884,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:
|
||||
|
@ -830,22 +922,26 @@ 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",
|
||||
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:
|
||||
|
@ -864,24 +960,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:
|
||||
|
@ -900,24 +1000,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:
|
||||
|
@ -928,4 +1032,4 @@ exit:
|
|||
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=e0ab74c3fa57c39c input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=ee7c63ec28a11b78 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -266,23 +266,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;
|
||||
|
@ -305,23 +309,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;
|
||||
|
@ -550,4 +558,4 @@ exit:
|
|||
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=458eb09731cb7877 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=4a418f883ccc79fe input=a9049054013a1b77]*/
|
||||
|
|
|
@ -641,22 +641,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:
|
||||
|
@ -726,22 +730,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:
|
||||
|
@ -882,4 +890,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]*/
|
||||
|
|
|
@ -19,23 +19,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:
|
||||
|
@ -76,14 +80,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;
|
||||
|
@ -91,10 +95,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:
|
||||
|
@ -111,22 +119,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:
|
||||
|
@ -161,14 +173,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;
|
||||
|
@ -177,13 +189,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]*/
|
||||
|
|
|
@ -86,4 +86,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]*/
|
||||
|
|
|
@ -94,4 +94,4 @@ _md5_md5(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=54cd50db050f2589 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=0a975e22cf33f833 input=a9049054013a1b77]*/
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -11,23 +11,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:
|
||||
|
@ -116,7 +120,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,
|
||||
|
@ -124,16 +128,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:
|
||||
|
@ -185,21 +193,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:
|
||||
|
@ -289,4 +301,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]*/
|
||||
|
|
|
@ -94,4 +94,4 @@ _sha1_sha1(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwname
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=1430450f3f806895 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=8e6b04c7e0407be2 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -124,4 +124,4 @@ _sha256_sha224(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kw
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=19439d70db7ead5c input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=7ef4927ee2a3aac4 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -124,4 +124,4 @@ _sha512_sha384(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kw
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=18f15598c3487045 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=7bb7a49159e9b469 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -74,22 +74,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:
|
||||
|
@ -141,22 +145,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:
|
||||
|
@ -179,24 +187,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:
|
||||
|
@ -245,22 +257,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:
|
||||
|
@ -372,22 +388,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:
|
||||
|
@ -439,4 +459,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=b49f7bfff44d1256 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -13,23 +13,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:
|
||||
|
@ -47,22 +51,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:
|
||||
|
@ -80,23 +88,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:
|
||||
|
@ -293,23 +305,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, "sU:normalize",
|
||||
if (!_PyArg_ParseStack(args, nargs, "sU:normalize",
|
||||
&form, &input)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("normalize", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = unicodedata_UCD_normalize_impl(self, form, input);
|
||||
|
||||
exit:
|
||||
|
@ -326,22 +342,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:
|
||||
|
@ -379,4 +399,4 @@ unicodedata_UCD_lookup(PyObject *self, PyObject *arg)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=07e93c267323a576 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=fcb86aaa3fa40876 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -290,21 +290,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:
|
||||
|
@ -365,21 +369,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:
|
||||
|
@ -398,22 +406,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:
|
||||
|
@ -437,22 +449,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:
|
||||
|
@ -467,4 +483,4 @@ exit:
|
|||
#ifndef ZLIB_COMPRESS_COPY_METHODDEF
|
||||
#define ZLIB_COMPRESS_COPY_METHODDEF
|
||||
#endif /* !defined(ZLIB_COMPRESS_COPY_METHODDEF) */
|
||||
/*[clinic end generated code: output=3a4e2bfe750423a3 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=fa1b5f4a6208c342 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -88,22 +88,26 @@ PyDoc_STRVAR(bytearray_maketrans__doc__,
|
|||
"The bytes objects frm and to must be of the same length.");
|
||||
|
||||
#define BYTEARRAY_MAKETRANS_METHODDEF \
|
||||
{"maketrans", (PyCFunction)bytearray_maketrans, METH_VARARGS|METH_STATIC, bytearray_maketrans__doc__},
|
||||
{"maketrans", (PyCFunction)bytearray_maketrans, METH_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to);
|
||||
|
||||
static PyObject *
|
||||
bytearray_maketrans(void *null, PyObject *args)
|
||||
bytearray_maketrans(void *null, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_buffer frm = {NULL, NULL};
|
||||
Py_buffer to = {NULL, NULL};
|
||||
|
||||
if (!PyArg_ParseTuple(args, "y*y*:maketrans",
|
||||
if (!_PyArg_ParseStack(args, nargs, "y*y*:maketrans",
|
||||
&frm, &to)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("maketrans", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytearray_maketrans_impl(&frm, &to);
|
||||
|
||||
exit:
|
||||
|
@ -133,24 +137,28 @@ PyDoc_STRVAR(bytearray_replace__doc__,
|
|||
"replaced.");
|
||||
|
||||
#define BYTEARRAY_REPLACE_METHODDEF \
|
||||
{"replace", (PyCFunction)bytearray_replace, METH_VARARGS, bytearray_replace__doc__},
|
||||
{"replace", (PyCFunction)bytearray_replace, METH_FASTCALL, bytearray_replace__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytearray_replace_impl(PyByteArrayObject *self, Py_buffer *old,
|
||||
Py_buffer *new, Py_ssize_t count);
|
||||
|
||||
static PyObject *
|
||||
bytearray_replace(PyByteArrayObject *self, PyObject *args)
|
||||
bytearray_replace(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_buffer old = {NULL, NULL};
|
||||
Py_buffer new = {NULL, NULL};
|
||||
Py_ssize_t count = -1;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "y*y*|n:replace",
|
||||
if (!_PyArg_ParseStack(args, nargs, "y*y*|n:replace",
|
||||
&old, &new, &count)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("replace", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytearray_replace_impl(self, &old, &new, count);
|
||||
|
||||
exit:
|
||||
|
@ -310,22 +318,26 @@ PyDoc_STRVAR(bytearray_insert__doc__,
|
|||
" The item to be inserted.");
|
||||
|
||||
#define BYTEARRAY_INSERT_METHODDEF \
|
||||
{"insert", (PyCFunction)bytearray_insert, METH_VARARGS, bytearray_insert__doc__},
|
||||
{"insert", (PyCFunction)bytearray_insert, METH_FASTCALL, bytearray_insert__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytearray_insert_impl(PyByteArrayObject *self, Py_ssize_t index, int item);
|
||||
|
||||
static PyObject *
|
||||
bytearray_insert(PyByteArrayObject *self, PyObject *args)
|
||||
bytearray_insert(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_ssize_t index;
|
||||
int item;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "nO&:insert",
|
||||
if (!_PyArg_ParseStack(args, nargs, "nO&:insert",
|
||||
&index, _getbytevalue, &item)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("insert", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytearray_insert_impl(self, index, item);
|
||||
|
||||
exit:
|
||||
|
@ -387,21 +399,25 @@ PyDoc_STRVAR(bytearray_pop__doc__,
|
|||
"If no index argument is given, will pop the last item.");
|
||||
|
||||
#define BYTEARRAY_POP_METHODDEF \
|
||||
{"pop", (PyCFunction)bytearray_pop, METH_VARARGS, bytearray_pop__doc__},
|
||||
{"pop", (PyCFunction)bytearray_pop, METH_FASTCALL, bytearray_pop__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index);
|
||||
|
||||
static PyObject *
|
||||
bytearray_pop(PyByteArrayObject *self, PyObject *args)
|
||||
bytearray_pop(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_ssize_t index = -1;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|n:pop",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|n:pop",
|
||||
&index)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("pop", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytearray_pop_impl(self, index);
|
||||
|
||||
exit:
|
||||
|
@ -673,21 +689,25 @@ PyDoc_STRVAR(bytearray_reduce_ex__doc__,
|
|||
"Return state information for pickling.");
|
||||
|
||||
#define BYTEARRAY_REDUCE_EX_METHODDEF \
|
||||
{"__reduce_ex__", (PyCFunction)bytearray_reduce_ex, METH_VARARGS, bytearray_reduce_ex__doc__},
|
||||
{"__reduce_ex__", (PyCFunction)bytearray_reduce_ex, METH_FASTCALL, bytearray_reduce_ex__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytearray_reduce_ex_impl(PyByteArrayObject *self, int proto);
|
||||
|
||||
static PyObject *
|
||||
bytearray_reduce_ex(PyByteArrayObject *self, PyObject *args)
|
||||
bytearray_reduce_ex(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int proto = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "|i:__reduce_ex__",
|
||||
if (!_PyArg_ParseStack(args, nargs, "|i:__reduce_ex__",
|
||||
&proto)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("__reduce_ex__", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytearray_reduce_ex_impl(self, proto);
|
||||
|
||||
exit:
|
||||
|
@ -711,4 +731,4 @@ bytearray_sizeof(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
|
|||
{
|
||||
return bytearray_sizeof_impl(self);
|
||||
}
|
||||
/*[clinic end generated code: output=225342a680391b9c input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=e6c057d1cd7c2496 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -318,22 +318,26 @@ PyDoc_STRVAR(bytes_maketrans__doc__,
|
|||
"The bytes objects frm and to must be of the same length.");
|
||||
|
||||
#define BYTES_MAKETRANS_METHODDEF \
|
||||
{"maketrans", (PyCFunction)bytes_maketrans, METH_VARARGS|METH_STATIC, bytes_maketrans__doc__},
|
||||
{"maketrans", (PyCFunction)bytes_maketrans, METH_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytes_maketrans_impl(Py_buffer *frm, Py_buffer *to);
|
||||
|
||||
static PyObject *
|
||||
bytes_maketrans(void *null, PyObject *args)
|
||||
bytes_maketrans(void *null, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_buffer frm = {NULL, NULL};
|
||||
Py_buffer to = {NULL, NULL};
|
||||
|
||||
if (!PyArg_ParseTuple(args, "y*y*:maketrans",
|
||||
if (!_PyArg_ParseStack(args, nargs, "y*y*:maketrans",
|
||||
&frm, &to)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("maketrans", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytes_maketrans_impl(&frm, &to);
|
||||
|
||||
exit:
|
||||
|
@ -363,24 +367,28 @@ PyDoc_STRVAR(bytes_replace__doc__,
|
|||
"replaced.");
|
||||
|
||||
#define BYTES_REPLACE_METHODDEF \
|
||||
{"replace", (PyCFunction)bytes_replace, METH_VARARGS, bytes_replace__doc__},
|
||||
{"replace", (PyCFunction)bytes_replace, METH_FASTCALL, bytes_replace__doc__},
|
||||
|
||||
static PyObject *
|
||||
bytes_replace_impl(PyBytesObject *self, Py_buffer *old, Py_buffer *new,
|
||||
Py_ssize_t count);
|
||||
|
||||
static PyObject *
|
||||
bytes_replace(PyBytesObject *self, PyObject *args)
|
||||
bytes_replace(PyBytesObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_buffer old = {NULL, NULL};
|
||||
Py_buffer new = {NULL, NULL};
|
||||
Py_ssize_t count = -1;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "y*y*|n:replace",
|
||||
if (!_PyArg_ParseStack(args, nargs, "y*y*|n:replace",
|
||||
&old, &new, &count)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("replace", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = bytes_replace_impl(self, &old, &new, count);
|
||||
|
||||
exit:
|
||||
|
@ -499,4 +507,4 @@ bytes_fromhex(PyTypeObject *type, PyObject *arg)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=2dc3c93cfd2dc440 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=2b8d3cff7e11045e input=a9049054013a1b77]*/
|
||||
|
|
|
@ -71,22 +71,26 @@ PyDoc_STRVAR(unicode_center__doc__,
|
|||
"Padding is done using the specified fill character (default is a space).");
|
||||
|
||||
#define UNICODE_CENTER_METHODDEF \
|
||||
{"center", (PyCFunction)unicode_center, METH_VARARGS, unicode_center__doc__},
|
||||
{"center", (PyCFunction)unicode_center, METH_FASTCALL, unicode_center__doc__},
|
||||
|
||||
static PyObject *
|
||||
unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
|
||||
|
||||
static PyObject *
|
||||
unicode_center(PyObject *self, PyObject *args)
|
||||
unicode_center(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_ssize_t width;
|
||||
Py_UCS4 fillchar = ' ';
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n|O&:center",
|
||||
if (!_PyArg_ParseStack(args, nargs, "n|O&:center",
|
||||
&width, convert_uc, &fillchar)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("center", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = unicode_center_impl(self, width, fillchar);
|
||||
|
||||
exit:
|
||||
|
@ -419,22 +423,26 @@ PyDoc_STRVAR(unicode_ljust__doc__,
|
|||
"Padding is done using the specified fill character (default is a space).");
|
||||
|
||||
#define UNICODE_LJUST_METHODDEF \
|
||||
{"ljust", (PyCFunction)unicode_ljust, METH_VARARGS, unicode_ljust__doc__},
|
||||
{"ljust", (PyCFunction)unicode_ljust, METH_FASTCALL, unicode_ljust__doc__},
|
||||
|
||||
static PyObject *
|
||||
unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
|
||||
|
||||
static PyObject *
|
||||
unicode_ljust(PyObject *self, PyObject *args)
|
||||
unicode_ljust(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_ssize_t width;
|
||||
Py_UCS4 fillchar = ' ';
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n|O&:ljust",
|
||||
if (!_PyArg_ParseStack(args, nargs, "n|O&:ljust",
|
||||
&width, convert_uc, &fillchar)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("ljust", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = unicode_ljust_impl(self, width, fillchar);
|
||||
|
||||
exit:
|
||||
|
@ -566,24 +574,28 @@ PyDoc_STRVAR(unicode_replace__doc__,
|
|||
"replaced.");
|
||||
|
||||
#define UNICODE_REPLACE_METHODDEF \
|
||||
{"replace", (PyCFunction)unicode_replace, METH_VARARGS, unicode_replace__doc__},
|
||||
{"replace", (PyCFunction)unicode_replace, METH_FASTCALL, unicode_replace__doc__},
|
||||
|
||||
static PyObject *
|
||||
unicode_replace_impl(PyObject *self, PyObject *old, PyObject *new,
|
||||
Py_ssize_t count);
|
||||
|
||||
static PyObject *
|
||||
unicode_replace(PyObject *self, PyObject *args)
|
||||
unicode_replace(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *old;
|
||||
PyObject *new;
|
||||
Py_ssize_t count = -1;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "UU|n:replace",
|
||||
if (!_PyArg_ParseStack(args, nargs, "UU|n:replace",
|
||||
&old, &new, &count)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("replace", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = unicode_replace_impl(self, old, new, count);
|
||||
|
||||
exit:
|
||||
|
@ -599,22 +611,26 @@ PyDoc_STRVAR(unicode_rjust__doc__,
|
|||
"Padding is done using the specified fill character (default is a space).");
|
||||
|
||||
#define UNICODE_RJUST_METHODDEF \
|
||||
{"rjust", (PyCFunction)unicode_rjust, METH_VARARGS, unicode_rjust__doc__},
|
||||
{"rjust", (PyCFunction)unicode_rjust, METH_FASTCALL, unicode_rjust__doc__},
|
||||
|
||||
static PyObject *
|
||||
unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
|
||||
|
||||
static PyObject *
|
||||
unicode_rjust(PyObject *self, PyObject *args)
|
||||
unicode_rjust(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_ssize_t width;
|
||||
Py_UCS4 fillchar = ' ';
|
||||
|
||||
if (!PyArg_ParseTuple(args, "n|O&:rjust",
|
||||
if (!_PyArg_ParseStack(args, nargs, "n|O&:rjust",
|
||||
&width, convert_uc, &fillchar)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("rjust", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = unicode_rjust_impl(self, width, fillchar);
|
||||
|
||||
exit:
|
||||
|
@ -799,23 +815,27 @@ PyDoc_STRVAR(unicode_maketrans__doc__,
|
|||
"must be a string, whose characters will be mapped to None in the result.");
|
||||
|
||||
#define UNICODE_MAKETRANS_METHODDEF \
|
||||
{"maketrans", (PyCFunction)unicode_maketrans, METH_VARARGS|METH_STATIC, unicode_maketrans__doc__},
|
||||
{"maketrans", (PyCFunction)unicode_maketrans, METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
|
||||
|
||||
static PyObject *
|
||||
unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z);
|
||||
|
||||
static PyObject *
|
||||
unicode_maketrans(void *null, PyObject *args)
|
||||
unicode_maketrans(void *null, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *x;
|
||||
PyObject *y = NULL;
|
||||
PyObject *z = NULL;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O|UU:maketrans",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O|UU:maketrans",
|
||||
&x, &y, &z)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("maketrans", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = unicode_maketrans_impl(x, y, z);
|
||||
|
||||
exit:
|
||||
|
@ -930,4 +950,4 @@ unicode_sizeof(PyObject *self, PyObject *Py_UNUSED(ignored))
|
|||
{
|
||||
return unicode_sizeof_impl(self);
|
||||
}
|
||||
/*[clinic end generated code: output=3b9b1e1f71ba3b00 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=eb6a3ae361a1a379 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -79,4 +79,4 @@ exit:
|
|||
#ifndef _TESTCONSOLE_READ_OUTPUT_METHODDEF
|
||||
#define _TESTCONSOLE_READ_OUTPUT_METHODDEF
|
||||
#endif /* !defined(_TESTCONSOLE_READ_OUTPUT_METHODDEF) */
|
||||
/*[clinic end generated code: output=3a8dc0c421807c41 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=30d2a80143b65e6f input=a9049054013a1b77]*/
|
||||
|
|
|
@ -37,23 +37,27 @@ PyDoc_STRVAR(msvcrt_locking__doc__,
|
|||
"individually.");
|
||||
|
||||
#define MSVCRT_LOCKING_METHODDEF \
|
||||
{"locking", (PyCFunction)msvcrt_locking, METH_VARARGS, msvcrt_locking__doc__},
|
||||
{"locking", (PyCFunction)msvcrt_locking, METH_FASTCALL, msvcrt_locking__doc__},
|
||||
|
||||
static PyObject *
|
||||
msvcrt_locking_impl(PyObject *module, int fd, int mode, long nbytes);
|
||||
|
||||
static PyObject *
|
||||
msvcrt_locking(PyObject *module, PyObject *args)
|
||||
msvcrt_locking(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int fd;
|
||||
int mode;
|
||||
long nbytes;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "iil:locking",
|
||||
if (!_PyArg_ParseStack(args, nargs, "iil:locking",
|
||||
&fd, &mode, &nbytes)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("locking", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = msvcrt_locking_impl(module, fd, mode, nbytes);
|
||||
|
||||
exit:
|
||||
|
@ -72,23 +76,27 @@ PyDoc_STRVAR(msvcrt_setmode__doc__,
|
|||
"Return value is the previous mode.");
|
||||
|
||||
#define MSVCRT_SETMODE_METHODDEF \
|
||||
{"setmode", (PyCFunction)msvcrt_setmode, METH_VARARGS, msvcrt_setmode__doc__},
|
||||
{"setmode", (PyCFunction)msvcrt_setmode, METH_FASTCALL, msvcrt_setmode__doc__},
|
||||
|
||||
static long
|
||||
msvcrt_setmode_impl(PyObject *module, int fd, int flags);
|
||||
|
||||
static PyObject *
|
||||
msvcrt_setmode(PyObject *module, PyObject *args)
|
||||
msvcrt_setmode(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int fd;
|
||||
int flags;
|
||||
long _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ii:setmode",
|
||||
if (!_PyArg_ParseStack(args, nargs, "ii:setmode",
|
||||
&fd, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("setmode", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = msvcrt_setmode_impl(module, fd, flags);
|
||||
if ((_return_value == -1) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -110,23 +118,27 @@ PyDoc_STRVAR(msvcrt_open_osfhandle__doc__,
|
|||
"to os.fdopen() to create a file object.");
|
||||
|
||||
#define MSVCRT_OPEN_OSFHANDLE_METHODDEF \
|
||||
{"open_osfhandle", (PyCFunction)msvcrt_open_osfhandle, METH_VARARGS, msvcrt_open_osfhandle__doc__},
|
||||
{"open_osfhandle", (PyCFunction)msvcrt_open_osfhandle, METH_FASTCALL, msvcrt_open_osfhandle__doc__},
|
||||
|
||||
static long
|
||||
msvcrt_open_osfhandle_impl(PyObject *module, intptr_t handle, int flags);
|
||||
|
||||
static PyObject *
|
||||
msvcrt_open_osfhandle(PyObject *module, PyObject *args)
|
||||
msvcrt_open_osfhandle(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
intptr_t handle;
|
||||
int flags;
|
||||
long _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, ""_Py_PARSE_INTPTR"i:open_osfhandle",
|
||||
if (!_PyArg_ParseStack(args, nargs, ""_Py_PARSE_INTPTR"i:open_osfhandle",
|
||||
&handle, &flags)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("open_osfhandle", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = msvcrt_open_osfhandle_impl(module, handle, flags);
|
||||
if ((_return_value == -1) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -424,23 +436,27 @@ PyDoc_STRVAR(msvcrt_CrtSetReportFile__doc__,
|
|||
"Only available on Debug builds.");
|
||||
|
||||
#define MSVCRT_CRTSETREPORTFILE_METHODDEF \
|
||||
{"CrtSetReportFile", (PyCFunction)msvcrt_CrtSetReportFile, METH_VARARGS, msvcrt_CrtSetReportFile__doc__},
|
||||
{"CrtSetReportFile", (PyCFunction)msvcrt_CrtSetReportFile, METH_FASTCALL, msvcrt_CrtSetReportFile__doc__},
|
||||
|
||||
static long
|
||||
msvcrt_CrtSetReportFile_impl(PyObject *module, int type, int file);
|
||||
|
||||
static PyObject *
|
||||
msvcrt_CrtSetReportFile(PyObject *module, PyObject *args)
|
||||
msvcrt_CrtSetReportFile(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int type;
|
||||
int file;
|
||||
long _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ii:CrtSetReportFile",
|
||||
if (!_PyArg_ParseStack(args, nargs, "ii:CrtSetReportFile",
|
||||
&type, &file)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CrtSetReportFile", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = msvcrt_CrtSetReportFile_impl(module, type, file);
|
||||
if ((_return_value == -1) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -464,23 +480,27 @@ PyDoc_STRVAR(msvcrt_CrtSetReportMode__doc__,
|
|||
"Only available on Debug builds.");
|
||||
|
||||
#define MSVCRT_CRTSETREPORTMODE_METHODDEF \
|
||||
{"CrtSetReportMode", (PyCFunction)msvcrt_CrtSetReportMode, METH_VARARGS, msvcrt_CrtSetReportMode__doc__},
|
||||
{"CrtSetReportMode", (PyCFunction)msvcrt_CrtSetReportMode, METH_FASTCALL, msvcrt_CrtSetReportMode__doc__},
|
||||
|
||||
static long
|
||||
msvcrt_CrtSetReportMode_impl(PyObject *module, int type, int mode);
|
||||
|
||||
static PyObject *
|
||||
msvcrt_CrtSetReportMode(PyObject *module, PyObject *args)
|
||||
msvcrt_CrtSetReportMode(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
int type;
|
||||
int mode;
|
||||
long _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ii:CrtSetReportMode",
|
||||
if (!_PyArg_ParseStack(args, nargs, "ii:CrtSetReportMode",
|
||||
&type, &mode)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CrtSetReportMode", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = msvcrt_CrtSetReportMode_impl(module, type, mode);
|
||||
if ((_return_value == -1) && PyErr_Occurred()) {
|
||||
goto exit;
|
||||
|
@ -569,4 +589,4 @@ exit:
|
|||
#ifndef MSVCRT_SET_ERROR_MODE_METHODDEF
|
||||
#define MSVCRT_SET_ERROR_MODE_METHODDEF
|
||||
#endif /* !defined(MSVCRT_SET_ERROR_MODE_METHODDEF) */
|
||||
/*[clinic end generated code: output=ae04e2b50eef8b63 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=36f1e78ca8bd3944 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -134,24 +134,28 @@ PyDoc_STRVAR(winreg_ConnectRegistry__doc__,
|
|||
"If the function fails, an OSError exception is raised.");
|
||||
|
||||
#define WINREG_CONNECTREGISTRY_METHODDEF \
|
||||
{"ConnectRegistry", (PyCFunction)winreg_ConnectRegistry, METH_VARARGS, winreg_ConnectRegistry__doc__},
|
||||
{"ConnectRegistry", (PyCFunction)winreg_ConnectRegistry, METH_FASTCALL, winreg_ConnectRegistry__doc__},
|
||||
|
||||
static HKEY
|
||||
winreg_ConnectRegistry_impl(PyObject *module, Py_UNICODE *computer_name,
|
||||
HKEY key);
|
||||
|
||||
static PyObject *
|
||||
winreg_ConnectRegistry(PyObject *module, PyObject *args)
|
||||
winreg_ConnectRegistry(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
Py_UNICODE *computer_name;
|
||||
HKEY key;
|
||||
HKEY _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "ZO&:ConnectRegistry",
|
||||
if (!_PyArg_ParseStack(args, nargs, "ZO&:ConnectRegistry",
|
||||
&computer_name, clinic_HKEY_converter, &key)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("ConnectRegistry", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = winreg_ConnectRegistry_impl(module, computer_name, key);
|
||||
if (_return_value == NULL) {
|
||||
goto exit;
|
||||
|
@ -182,23 +186,27 @@ PyDoc_STRVAR(winreg_CreateKey__doc__,
|
|||
"If the function fails, an OSError exception is raised.");
|
||||
|
||||
#define WINREG_CREATEKEY_METHODDEF \
|
||||
{"CreateKey", (PyCFunction)winreg_CreateKey, METH_VARARGS, winreg_CreateKey__doc__},
|
||||
{"CreateKey", (PyCFunction)winreg_CreateKey, METH_FASTCALL, winreg_CreateKey__doc__},
|
||||
|
||||
static HKEY
|
||||
winreg_CreateKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
|
||||
|
||||
static PyObject *
|
||||
winreg_CreateKey(PyObject *module, PyObject *args)
|
||||
winreg_CreateKey(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *sub_key;
|
||||
HKEY _return_value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&Z:CreateKey",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&Z:CreateKey",
|
||||
clinic_HKEY_converter, &key, &sub_key)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("CreateKey", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
_return_value = winreg_CreateKey_impl(module, key, sub_key);
|
||||
if (_return_value == NULL) {
|
||||
goto exit;
|
||||
|
@ -286,22 +294,26 @@ PyDoc_STRVAR(winreg_DeleteKey__doc__,
|
|||
"is removed. If the function fails, an OSError exception is raised.");
|
||||
|
||||
#define WINREG_DELETEKEY_METHODDEF \
|
||||
{"DeleteKey", (PyCFunction)winreg_DeleteKey, METH_VARARGS, winreg_DeleteKey__doc__},
|
||||
{"DeleteKey", (PyCFunction)winreg_DeleteKey, METH_FASTCALL, winreg_DeleteKey__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_DeleteKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
|
||||
|
||||
static PyObject *
|
||||
winreg_DeleteKey(PyObject *module, PyObject *args)
|
||||
winreg_DeleteKey(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *sub_key;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&u:DeleteKey",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&u:DeleteKey",
|
||||
clinic_HKEY_converter, &key, &sub_key)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("DeleteKey", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_DeleteKey_impl(module, key, sub_key);
|
||||
|
||||
exit:
|
||||
|
@ -373,22 +385,26 @@ PyDoc_STRVAR(winreg_DeleteValue__doc__,
|
|||
" A string that identifies the value to remove.");
|
||||
|
||||
#define WINREG_DELETEVALUE_METHODDEF \
|
||||
{"DeleteValue", (PyCFunction)winreg_DeleteValue, METH_VARARGS, winreg_DeleteValue__doc__},
|
||||
{"DeleteValue", (PyCFunction)winreg_DeleteValue, METH_FASTCALL, winreg_DeleteValue__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_DeleteValue_impl(PyObject *module, HKEY key, Py_UNICODE *value);
|
||||
|
||||
static PyObject *
|
||||
winreg_DeleteValue(PyObject *module, PyObject *args)
|
||||
winreg_DeleteValue(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&Z:DeleteValue",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&Z:DeleteValue",
|
||||
clinic_HKEY_converter, &key, &value)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("DeleteValue", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_DeleteValue_impl(module, key, value);
|
||||
|
||||
exit:
|
||||
|
@ -411,22 +427,26 @@ PyDoc_STRVAR(winreg_EnumKey__doc__,
|
|||
"raised, indicating no more values are available.");
|
||||
|
||||
#define WINREG_ENUMKEY_METHODDEF \
|
||||
{"EnumKey", (PyCFunction)winreg_EnumKey, METH_VARARGS, winreg_EnumKey__doc__},
|
||||
{"EnumKey", (PyCFunction)winreg_EnumKey, METH_FASTCALL, winreg_EnumKey__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_EnumKey_impl(PyObject *module, HKEY key, int index);
|
||||
|
||||
static PyObject *
|
||||
winreg_EnumKey(PyObject *module, PyObject *args)
|
||||
winreg_EnumKey(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
int index;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&i:EnumKey",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&i:EnumKey",
|
||||
clinic_HKEY_converter, &key, &index)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("EnumKey", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_EnumKey_impl(module, key, index);
|
||||
|
||||
exit:
|
||||
|
@ -458,22 +478,26 @@ PyDoc_STRVAR(winreg_EnumValue__doc__,
|
|||
" An integer that identifies the type of the value data.");
|
||||
|
||||
#define WINREG_ENUMVALUE_METHODDEF \
|
||||
{"EnumValue", (PyCFunction)winreg_EnumValue, METH_VARARGS, winreg_EnumValue__doc__},
|
||||
{"EnumValue", (PyCFunction)winreg_EnumValue, METH_FASTCALL, winreg_EnumValue__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_EnumValue_impl(PyObject *module, HKEY key, int index);
|
||||
|
||||
static PyObject *
|
||||
winreg_EnumValue(PyObject *module, PyObject *args)
|
||||
winreg_EnumValue(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
int index;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&i:EnumValue",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&i:EnumValue",
|
||||
clinic_HKEY_converter, &key, &index)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("EnumValue", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_EnumValue_impl(module, key, index);
|
||||
|
||||
exit:
|
||||
|
@ -576,24 +600,28 @@ PyDoc_STRVAR(winreg_LoadKey__doc__,
|
|||
"tree.");
|
||||
|
||||
#define WINREG_LOADKEY_METHODDEF \
|
||||
{"LoadKey", (PyCFunction)winreg_LoadKey, METH_VARARGS, winreg_LoadKey__doc__},
|
||||
{"LoadKey", (PyCFunction)winreg_LoadKey, METH_FASTCALL, winreg_LoadKey__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_LoadKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
||||
Py_UNICODE *file_name);
|
||||
|
||||
static PyObject *
|
||||
winreg_LoadKey(PyObject *module, PyObject *args)
|
||||
winreg_LoadKey(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *sub_key;
|
||||
Py_UNICODE *file_name;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&uu:LoadKey",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&uu:LoadKey",
|
||||
clinic_HKEY_converter, &key, &sub_key, &file_name)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("LoadKey", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_LoadKey_impl(module, key, sub_key, file_name);
|
||||
|
||||
exit:
|
||||
|
@ -761,22 +789,26 @@ PyDoc_STRVAR(winreg_QueryValue__doc__,
|
|||
"completeness.");
|
||||
|
||||
#define WINREG_QUERYVALUE_METHODDEF \
|
||||
{"QueryValue", (PyCFunction)winreg_QueryValue, METH_VARARGS, winreg_QueryValue__doc__},
|
||||
{"QueryValue", (PyCFunction)winreg_QueryValue, METH_FASTCALL, winreg_QueryValue__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_QueryValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
|
||||
|
||||
static PyObject *
|
||||
winreg_QueryValue(PyObject *module, PyObject *args)
|
||||
winreg_QueryValue(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *sub_key;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&Z:QueryValue",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&Z:QueryValue",
|
||||
clinic_HKEY_converter, &key, &sub_key)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("QueryValue", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_QueryValue_impl(module, key, sub_key);
|
||||
|
||||
exit:
|
||||
|
@ -800,22 +832,26 @@ PyDoc_STRVAR(winreg_QueryValueEx__doc__,
|
|||
"The return value is a tuple of the value and the type_id.");
|
||||
|
||||
#define WINREG_QUERYVALUEEX_METHODDEF \
|
||||
{"QueryValueEx", (PyCFunction)winreg_QueryValueEx, METH_VARARGS, winreg_QueryValueEx__doc__},
|
||||
{"QueryValueEx", (PyCFunction)winreg_QueryValueEx, METH_FASTCALL, winreg_QueryValueEx__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_QueryValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *name);
|
||||
|
||||
static PyObject *
|
||||
winreg_QueryValueEx(PyObject *module, PyObject *args)
|
||||
winreg_QueryValueEx(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *name;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&Z:QueryValueEx",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&Z:QueryValueEx",
|
||||
clinic_HKEY_converter, &key, &name)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("QueryValueEx", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_QueryValueEx_impl(module, key, name);
|
||||
|
||||
exit:
|
||||
|
@ -844,22 +880,26 @@ PyDoc_STRVAR(winreg_SaveKey__doc__,
|
|||
"to the API.");
|
||||
|
||||
#define WINREG_SAVEKEY_METHODDEF \
|
||||
{"SaveKey", (PyCFunction)winreg_SaveKey, METH_VARARGS, winreg_SaveKey__doc__},
|
||||
{"SaveKey", (PyCFunction)winreg_SaveKey, METH_FASTCALL, winreg_SaveKey__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_SaveKey_impl(PyObject *module, HKEY key, Py_UNICODE *file_name);
|
||||
|
||||
static PyObject *
|
||||
winreg_SaveKey(PyObject *module, PyObject *args)
|
||||
winreg_SaveKey(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
Py_UNICODE *file_name;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&u:SaveKey",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&u:SaveKey",
|
||||
clinic_HKEY_converter, &key, &file_name)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("SaveKey", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_SaveKey_impl(module, key, file_name);
|
||||
|
||||
exit:
|
||||
|
@ -893,7 +933,7 @@ PyDoc_STRVAR(winreg_SetValue__doc__,
|
|||
"KEY_SET_VALUE access.");
|
||||
|
||||
#define WINREG_SETVALUE_METHODDEF \
|
||||
{"SetValue", (PyCFunction)winreg_SetValue, METH_VARARGS, winreg_SetValue__doc__},
|
||||
{"SetValue", (PyCFunction)winreg_SetValue, METH_FASTCALL, winreg_SetValue__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_SetValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
||||
|
@ -901,7 +941,7 @@ winreg_SetValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
|
|||
Py_ssize_clean_t value_length);
|
||||
|
||||
static PyObject *
|
||||
winreg_SetValue(PyObject *module, PyObject *args)
|
||||
winreg_SetValue(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
|
@ -910,10 +950,14 @@ winreg_SetValue(PyObject *module, PyObject *args)
|
|||
Py_UNICODE *value;
|
||||
Py_ssize_clean_t value_length;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&Zku#:SetValue",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&Zku#:SetValue",
|
||||
clinic_HKEY_converter, &key, &sub_key, &type, &value, &value_length)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("SetValue", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_SetValue_impl(module, key, sub_key, type, value, value_length);
|
||||
|
||||
exit:
|
||||
|
@ -964,14 +1008,14 @@ PyDoc_STRVAR(winreg_SetValueEx__doc__,
|
|||
"the configuration registry to help the registry perform efficiently.");
|
||||
|
||||
#define WINREG_SETVALUEEX_METHODDEF \
|
||||
{"SetValueEx", (PyCFunction)winreg_SetValueEx, METH_VARARGS, winreg_SetValueEx__doc__},
|
||||
{"SetValueEx", (PyCFunction)winreg_SetValueEx, METH_FASTCALL, winreg_SetValueEx__doc__},
|
||||
|
||||
static PyObject *
|
||||
winreg_SetValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *value_name,
|
||||
PyObject *reserved, DWORD type, PyObject *value);
|
||||
|
||||
static PyObject *
|
||||
winreg_SetValueEx(PyObject *module, PyObject *args)
|
||||
winreg_SetValueEx(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
HKEY key;
|
||||
|
@ -980,10 +1024,14 @@ winreg_SetValueEx(PyObject *module, PyObject *args)
|
|||
DWORD type;
|
||||
PyObject *value;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O&ZOkO:SetValueEx",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O&ZOkO:SetValueEx",
|
||||
clinic_HKEY_converter, &key, &value_name, &reserved, &type, &value)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("SetValueEx", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = winreg_SetValueEx_impl(module, key, value_name, reserved, type, value);
|
||||
|
||||
exit:
|
||||
|
@ -1091,4 +1139,4 @@ winreg_QueryReflectionKey(PyObject *module, PyObject *arg)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=16dd06be6e14b86e input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=ddc72b006143d33d input=a9049054013a1b77]*/
|
||||
|
|
|
@ -106,4 +106,4 @@ winsound_MessageBeep(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObje
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=bfe16b2b8b490cb1 input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=102a556c665a277d input=a9049054013a1b77]*/
|
||||
|
|
|
@ -35,4 +35,4 @@ warnings_warn(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=b3c5297c2c55778c input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=acadf1788059034c input=a9049054013a1b77]*/
|
||||
|
|
|
@ -80,22 +80,26 @@ PyDoc_STRVAR(builtin_format__doc__,
|
|||
"format_spec defaults to the empty string");
|
||||
|
||||
#define BUILTIN_FORMAT_METHODDEF \
|
||||
{"format", (PyCFunction)builtin_format, METH_VARARGS, builtin_format__doc__},
|
||||
{"format", (PyCFunction)builtin_format, METH_FASTCALL, builtin_format__doc__},
|
||||
|
||||
static PyObject *
|
||||
builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec);
|
||||
|
||||
static PyObject *
|
||||
builtin_format(PyObject *module, PyObject *args)
|
||||
builtin_format(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyObject *value;
|
||||
PyObject *format_spec = NULL;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O|U:format",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O|U:format",
|
||||
&value, &format_spec)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("format", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = builtin_format_impl(module, value, format_spec);
|
||||
|
||||
exit:
|
||||
|
@ -674,4 +678,4 @@ builtin_issubclass(PyObject *module, PyObject *args)
|
|||
exit:
|
||||
return return_value;
|
||||
}
|
||||
/*[clinic end generated code: output=63483deb75805f7c input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=66818a69d6d23181 input=a9049054013a1b77]*/
|
||||
|
|
|
@ -75,23 +75,27 @@ PyDoc_STRVAR(_imp__fix_co_filename__doc__,
|
|||
" File path to use.");
|
||||
|
||||
#define _IMP__FIX_CO_FILENAME_METHODDEF \
|
||||
{"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_VARARGS, _imp__fix_co_filename__doc__},
|
||||
{"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_FASTCALL, _imp__fix_co_filename__doc__},
|
||||
|
||||
static PyObject *
|
||||
_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
|
||||
PyObject *path);
|
||||
|
||||
static PyObject *
|
||||
_imp__fix_co_filename(PyObject *module, PyObject *args)
|
||||
_imp__fix_co_filename(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
|
||||
{
|
||||
PyObject *return_value = NULL;
|
||||
PyCodeObject *code;
|
||||
PyObject *path;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O!U:_fix_co_filename",
|
||||
if (!_PyArg_ParseStack(args, nargs, "O!U:_fix_co_filename",
|
||||
&PyCode_Type, &code, &path)) {
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!_PyArg_NoStackKeywords("_fix_co_filename", kwnames)) {
|
||||
goto exit;
|
||||
}
|
||||
return_value = _imp__fix_co_filename_impl(module, code, path);
|
||||
|
||||
exit:
|
||||
|
@ -361,4 +365,4 @@ exit:
|
|||
#ifndef _IMP_EXEC_DYNAMIC_METHODDEF
|
||||
#define _IMP_EXEC_DYNAMIC_METHODDEF
|
||||
#endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
|
||||
/*[clinic end generated code: output=d24d7f73702a907f input=a9049054013a1b77]*/
|
||||
/*[clinic end generated code: output=5a3f012344950548 input=a9049054013a1b77]*/
|
||||
|
|
Loading…
Reference in New Issue