languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-07-19 19:54:39 +00:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity

bpo-33012: Fix invalid function cast warnings with gcc 8 in Argument Clinic. (GH-6748)

Browse source 
Fix invalid function cast warnings with gcc 8
for method conventions different from METH_NOARGS, METH_O and
METH_VARARGS in Argument Clinic generated code.
This commit is contained in:
Serhiy Storchaka 2018-11-27 11:27:36 +02:00 committed by GitHub
parent b619b09792
commit 4a934d490f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
77 changed files with 974 additions and 643 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Modules/_io/clinic/_iomodule.c.h
View file

@ -127,7 +127,7 @@ PyDoc_STRVAR(_io_open__doc__,
"opened in a binary mode.");
#define _IO_OPEN_METHODDEF \
{"open", (PyCFunction)_io_open, METH_FASTCALL|METH_KEYWORDS, _io_open__doc__},
{"open", (PyCFunction)(void(*)(void))_io_open, METH_FASTCALL|METH_KEYWORDS, _io_open__doc__},
static PyObject *
_io_open_impl(PyObject *module, PyObject *file, const char *mode,
@ -158,4 +158,4 @@ _io_open(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kw
exit:
return return_value;
}
/*[clinic end generated code: output=a9de1ae79c960e81 input=a9049054013a1b77]*/
/*[clinic end generated code: output=a2c1af38d943ccec input=a9049054013a1b77]*/

14
Modules/_io/clinic/bufferedio.c.h
View file

@ -91,7 +91,7 @@ PyDoc_STRVAR(_io__Buffered_peek__doc__,
"\n");
#define _IO__BUFFERED_PEEK_METHODDEF \
{"peek", (PyCFunction)_io__Buffered_peek, METH_FASTCALL, _io__Buffered_peek__doc__},
{"peek", (PyCFunction)(void(*)(void))_io__Buffered_peek, METH_FASTCALL, _io__Buffered_peek__doc__},
static PyObject *
_io__Buffered_peek_impl(buffered *self, Py_ssize_t size);
@ -118,7 +118,7 @@ PyDoc_STRVAR(_io__Buffered_read__doc__,
"\n");
#define _IO__BUFFERED_READ_METHODDEF \
{"read", (PyCFunction)_io__Buffered_read, METH_FASTCALL, _io__Buffered_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io__Buffered_read, METH_FASTCALL, _io__Buffered_read__doc__},
static PyObject *
_io__Buffered_read_impl(buffered *self, Py_ssize_t n);
@ -145,7 +145,7 @@ PyDoc_STRVAR(_io__Buffered_read1__doc__,
"\n");
#define _IO__BUFFERED_READ1_METHODDEF \
{"read1", (PyCFunction)_io__Buffered_read1, METH_FASTCALL, _io__Buffered_read1__doc__},
{"read1", (PyCFunction)(void(*)(void))_io__Buffered_read1, METH_FASTCALL, _io__Buffered_read1__doc__},
static PyObject *
_io__Buffered_read1_impl(buffered *self, Py_ssize_t n);
@ -234,7 +234,7 @@ PyDoc_STRVAR(_io__Buffered_readline__doc__,
"\n");
#define _IO__BUFFERED_READLINE_METHODDEF \
{"readline", (PyCFunction)_io__Buffered_readline, METH_FASTCALL, _io__Buffered_readline__doc__},
{"readline", (PyCFunction)(void(*)(void))_io__Buffered_readline, METH_FASTCALL, _io__Buffered_readline__doc__},
static PyObject *
_io__Buffered_readline_impl(buffered *self, Py_ssize_t size);
@ -261,7 +261,7 @@ PyDoc_STRVAR(_io__Buffered_seek__doc__,
"\n");
#define _IO__BUFFERED_SEEK_METHODDEF \
{"seek", (PyCFunction)_io__Buffered_seek, METH_FASTCALL, _io__Buffered_seek__doc__},
{"seek", (PyCFunction)(void(*)(void))_io__Buffered_seek, METH_FASTCALL, _io__Buffered_seek__doc__},
static PyObject *
_io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence);
@ -289,7 +289,7 @@ PyDoc_STRVAR(_io__Buffered_truncate__doc__,
"\n");
#define _IO__BUFFERED_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io__Buffered_truncate, METH_FASTCALL, _io__Buffered_truncate__doc__},
{"truncate", (PyCFunction)(void(*)(void))_io__Buffered_truncate, METH_FASTCALL, _io__Buffered_truncate__doc__},
static PyObject *
_io__Buffered_truncate_impl(buffered *self, PyObject *pos);
@ -476,4 +476,4 @@ _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=9a20dd4eaabb5d58 input=a9049054013a1b77]*/
/*[clinic end generated code: output=cb4bf8d50533953b input=a9049054013a1b77]*/

14
Modules/_io/clinic/bytesio.c.h
View file

@ -158,7 +158,7 @@ PyDoc_STRVAR(_io_BytesIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READ_METHODDEF \
{"read", (PyCFunction)_io_BytesIO_read, METH_FASTCALL, _io_BytesIO_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io_BytesIO_read, METH_FASTCALL, _io_BytesIO_read__doc__},
static PyObject *
_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size);
@ -189,7 +189,7 @@ PyDoc_STRVAR(_io_BytesIO_read1__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READ1_METHODDEF \
{"read1", (PyCFunction)_io_BytesIO_read1, METH_FASTCALL, _io_BytesIO_read1__doc__},
{"read1", (PyCFunction)(void(*)(void))_io_BytesIO_read1, METH_FASTCALL, _io_BytesIO_read1__doc__},
static PyObject *
_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size);
@ -221,7 +221,7 @@ PyDoc_STRVAR(_io_BytesIO_readline__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READLINE_METHODDEF \
{"readline", (PyCFunction)_io_BytesIO_readline, METH_FASTCALL, _io_BytesIO_readline__doc__},
{"readline", (PyCFunction)(void(*)(void))_io_BytesIO_readline, METH_FASTCALL, _io_BytesIO_readline__doc__},
static PyObject *
_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size);
@ -253,7 +253,7 @@ PyDoc_STRVAR(_io_BytesIO_readlines__doc__,
"total number of bytes in the lines returned.");
#define _IO_BYTESIO_READLINES_METHODDEF \
{"readlines", (PyCFunction)_io_BytesIO_readlines, METH_FASTCALL, _io_BytesIO_readlines__doc__},
{"readlines", (PyCFunction)(void(*)(void))_io_BytesIO_readlines, METH_FASTCALL, _io_BytesIO_readlines__doc__},
static PyObject *
_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg);
@ -320,7 +320,7 @@ PyDoc_STRVAR(_io_BytesIO_truncate__doc__,
"The current file position is unchanged. Returns the new size.");
#define _IO_BYTESIO_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_BytesIO_truncate, METH_FASTCALL, _io_BytesIO_truncate__doc__},
{"truncate", (PyCFunction)(void(*)(void))_io_BytesIO_truncate, METH_FASTCALL, _io_BytesIO_truncate__doc__},
static PyObject *
_io_BytesIO_truncate_impl(bytesio *self, Py_ssize_t size);
@ -354,7 +354,7 @@ PyDoc_STRVAR(_io_BytesIO_seek__doc__,
"Returns the new absolute position.");
#define _IO_BYTESIO_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_BytesIO_seek, METH_FASTCALL, _io_BytesIO_seek__doc__},
{"seek", (PyCFunction)(void(*)(void))_io_BytesIO_seek, METH_FASTCALL, _io_BytesIO_seek__doc__},
static PyObject *
_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence);
@ -444,4 +444,4 @@ _io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=9ba9a68c8c5669e7 input=a9049054013a1b77]*/
/*[clinic end generated code: output=89538a941ae1267a input=a9049054013a1b77]*/

8
Modules/_io/clinic/fileio.c.h
View file

@ -202,7 +202,7 @@ PyDoc_STRVAR(_io_FileIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO_FILEIO_READ_METHODDEF \
{"read", (PyCFunction)_io_FileIO_read, METH_FASTCALL, _io_FileIO_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io_FileIO_read, METH_FASTCALL, _io_FileIO_read__doc__},
static PyObject *
_io_FileIO_read_impl(fileio *self, Py_ssize_t size);
@ -274,7 +274,7 @@ 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_FASTCALL, _io_FileIO_seek__doc__},
{"seek", (PyCFunction)(void(*)(void))_io_FileIO_seek, METH_FASTCALL, _io_FileIO_seek__doc__},
static PyObject *
_io_FileIO_seek_impl(fileio *self, PyObject *pos, int whence);
@ -328,7 +328,7 @@ PyDoc_STRVAR(_io_FileIO_truncate__doc__,
"The current file position is changed to the value of size.");
#define _IO_FILEIO_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_FileIO_truncate, METH_FASTCALL, _io_FileIO_truncate__doc__},
{"truncate", (PyCFunction)(void(*)(void))_io_FileIO_truncate, METH_FASTCALL, _io_FileIO_truncate__doc__},
static PyObject *
_io_FileIO_truncate_impl(fileio *self, PyObject *posobj);
@ -373,4 +373,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=a8796438c8b7c49a input=a9049054013a1b77]*/
/*[clinic end generated code: output=9d44e7035bce105d input=a9049054013a1b77]*/

8
Modules/_io/clinic/iobase.c.h
View file

@ -174,7 +174,7 @@ PyDoc_STRVAR(_io__IOBase_readline__doc__,
"terminator(s) recognized.");
#define _IO__IOBASE_READLINE_METHODDEF \
{"readline", (PyCFunction)_io__IOBase_readline, METH_FASTCALL, _io__IOBase_readline__doc__},
{"readline", (PyCFunction)(void(*)(void))_io__IOBase_readline, METH_FASTCALL, _io__IOBase_readline__doc__},
static PyObject *
_io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit);
@ -206,7 +206,7 @@ PyDoc_STRVAR(_io__IOBase_readlines__doc__,
"lines so far exceeds hint.");
#define _IO__IOBASE_READLINES_METHODDEF \
{"readlines", (PyCFunction)_io__IOBase_readlines, METH_FASTCALL, _io__IOBase_readlines__doc__},
{"readlines", (PyCFunction)(void(*)(void))_io__IOBase_readlines, METH_FASTCALL, _io__IOBase_readlines__doc__},
static PyObject *
_io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint);
@ -241,7 +241,7 @@ PyDoc_STRVAR(_io__RawIOBase_read__doc__,
"\n");
#define _IO__RAWIOBASE_READ_METHODDEF \
{"read", (PyCFunction)_io__RawIOBase_read, METH_FASTCALL, _io__RawIOBase_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io__RawIOBase_read, METH_FASTCALL, _io__RawIOBase_read__doc__},
static PyObject *
_io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n);
@ -279,4 +279,4 @@ _io__RawIOBase_readall(PyObject *self, PyObject *Py_UNUSED(ignored))
{
return _io__RawIOBase_readall_impl(self);
}
/*[clinic end generated code: output=64989ec3dbf44a7c input=a9049054013a1b77]*/
/*[clinic end generated code: output=cde4b0e96a4e69e3 input=a9049054013a1b77]*/

10
Modules/_io/clinic/stringio.c.h
View file

@ -48,7 +48,7 @@ PyDoc_STRVAR(_io_StringIO_read__doc__,
"is reached. Return an empty string at EOF.");
#define _IO_STRINGIO_READ_METHODDEF \
{"read", (PyCFunction)_io_StringIO_read, METH_FASTCALL, _io_StringIO_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io_StringIO_read, METH_FASTCALL, _io_StringIO_read__doc__},
static PyObject *
_io_StringIO_read_impl(stringio *self, Py_ssize_t size);
@ -78,7 +78,7 @@ PyDoc_STRVAR(_io_StringIO_readline__doc__,
"Returns an empty string if EOF is hit immediately.");
#define _IO_STRINGIO_READLINE_METHODDEF \
{"readline", (PyCFunction)_io_StringIO_readline, METH_FASTCALL, _io_StringIO_readline__doc__},
{"readline", (PyCFunction)(void(*)(void))_io_StringIO_readline, METH_FASTCALL, _io_StringIO_readline__doc__},
static PyObject *
_io_StringIO_readline_impl(stringio *self, Py_ssize_t size);
@ -110,7 +110,7 @@ PyDoc_STRVAR(_io_StringIO_truncate__doc__,
"Returns the new absolute position.");
#define _IO_STRINGIO_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_StringIO_truncate, METH_FASTCALL, _io_StringIO_truncate__doc__},
{"truncate", (PyCFunction)(void(*)(void))_io_StringIO_truncate, METH_FASTCALL, _io_StringIO_truncate__doc__},
static PyObject *
_io_StringIO_truncate_impl(stringio *self, Py_ssize_t size);
@ -144,7 +144,7 @@ PyDoc_STRVAR(_io_StringIO_seek__doc__,
"Returns the new absolute position.");
#define _IO_STRINGIO_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_StringIO_seek, METH_FASTCALL, _io_StringIO_seek__doc__},
{"seek", (PyCFunction)(void(*)(void))_io_StringIO_seek, METH_FASTCALL, _io_StringIO_seek__doc__},
static PyObject *
_io_StringIO_seek_impl(stringio *self, Py_ssize_t pos, int whence);
@ -286,4 +286,4 @@ _io_StringIO_seekable(stringio *self, PyObject *Py_UNUSED(ignored))
{
return _io_StringIO_seekable_impl(self);
}
/*[clinic end generated code: output=73c4d6e5cc3b1a58 input=a9049054013a1b77]*/
/*[clinic end generated code: output=00c3c7a1c6ea6773 input=a9049054013a1b77]*/

14
Modules/_io/clinic/textio.c.h
View file

@ -46,7 +46,7 @@ PyDoc_STRVAR(_io_IncrementalNewlineDecoder_decode__doc__,
"\n");
#define _IO_INCREMENTALNEWLINEDECODER_DECODE_METHODDEF \
{"decode", (PyCFunction)_io_IncrementalNewlineDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _io_IncrementalNewlineDecoder_decode__doc__},
{"decode", (PyCFunction)(void(*)(void))_io_IncrementalNewlineDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _io_IncrementalNewlineDecoder_decode__doc__},
static PyObject *
_io_IncrementalNewlineDecoder_decode_impl(nldecoder_object *self,
@ -186,7 +186,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_reconfigure__doc__,
"This also does an implicit stream flush.");
#define _IO_TEXTIOWRAPPER_RECONFIGURE_METHODDEF \
{"reconfigure", (PyCFunction)_io_TextIOWrapper_reconfigure, METH_FASTCALL|METH_KEYWORDS, _io_TextIOWrapper_reconfigure__doc__},
{"reconfigure", (PyCFunction)(void(*)(void))_io_TextIOWrapper_reconfigure, METH_FASTCALL|METH_KEYWORDS, _io_TextIOWrapper_reconfigure__doc__},
static PyObject *
_io_TextIOWrapper_reconfigure_impl(textio *self, PyObject *encoding,
@ -265,7 +265,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_read__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_READ_METHODDEF \
{"read", (PyCFunction)_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
static PyObject *
_io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n);
@ -292,7 +292,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_readline__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_READLINE_METHODDEF \
{"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
{"readline", (PyCFunction)(void(*)(void))_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
static PyObject *
_io_TextIOWrapper_readline_impl(textio *self, Py_ssize_t size);
@ -319,7 +319,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_seek__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_SEEK_METHODDEF \
{"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
{"seek", (PyCFunction)(void(*)(void))_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
static PyObject *
_io_TextIOWrapper_seek_impl(textio *self, PyObject *cookieObj, int whence);
@ -364,7 +364,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_truncate__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)_io_TextIOWrapper_truncate, METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
{"truncate", (PyCFunction)(void(*)(void))_io_TextIOWrapper_truncate, METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
static PyObject *
_io_TextIOWrapper_truncate_impl(textio *self, PyObject *pos);
@ -504,4 +504,4 @@ _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
{
return _io_TextIOWrapper_close_impl(self);
}
/*[clinic end generated code: output=b5be870b0039d577 input=a9049054013a1b77]*/
/*[clinic end generated code: output=a811badd76bfe92e input=a9049054013a1b77]*/

4
Modules/_io/clinic/winconsoleio.c.h
View file

@ -209,7 +209,7 @@ PyDoc_STRVAR(_io__WindowsConsoleIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO__WINDOWSCONSOLEIO_READ_METHODDEF \
{"read", (PyCFunction)_io__WindowsConsoleIO_read, METH_FASTCALL, _io__WindowsConsoleIO_read__doc__},
{"read", (PyCFunction)(void(*)(void))_io__WindowsConsoleIO_read, METH_FASTCALL, _io__WindowsConsoleIO_read__doc__},
static PyObject *
_io__WindowsConsoleIO_read_impl(winconsoleio *self, Py_ssize_t size);
@ -328,4 +328,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=6d351a8200a8e848 input=a9049054013a1b77]*/
/*[clinic end generated code: output=080af41338394b49 input=a9049054013a1b77]*/

16
Modules/cjkcodecs/clinic/multibytecodec.c.h
View file

@ -14,7 +14,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteCodec_encode__doc__,
"registered with codecs.register_error that can handle UnicodeEncodeErrors.");
#define _MULTIBYTECODEC_MULTIBYTECODEC_ENCODE_METHODDEF \
{"encode", (PyCFunction)_multibytecodec_MultibyteCodec_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_encode__doc__},
{"encode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteCodec_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_encode__doc__},
static PyObject *
_multibytecodec_MultibyteCodec_encode_impl(MultibyteCodecObject *self,
@ -52,7 +52,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteCodec_decode__doc__,
"codecs.register_error that is able to handle UnicodeDecodeErrors.\"");
#define _MULTIBYTECODEC_MULTIBYTECODEC_DECODE_METHODDEF \
{"decode", (PyCFunction)_multibytecodec_MultibyteCodec_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_decode__doc__},
{"decode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteCodec_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_decode__doc__},
static PyObject *
_multibytecodec_MultibyteCodec_decode_impl(MultibyteCodecObject *self,
@ -89,7 +89,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_encode__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_ENCODE_METHODDEF \
{"encode", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalEncoder_encode__doc__},
{"encode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteIncrementalEncoder_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalEncoder_encode__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_encode_impl(MultibyteIncrementalEncoderObject *self,
@ -182,7 +182,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_decode__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_DECODE_METHODDEF \
{"decode", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
{"decode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteIncrementalDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_decode_impl(MultibyteIncrementalDecoderObject *self,
@ -280,7 +280,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_read__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READ_METHODDEF \
{"read", (PyCFunction)_multibytecodec_MultibyteStreamReader_read, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
{"read", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_read, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_read_impl(MultibyteStreamReaderObject *self,
@ -309,7 +309,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readline__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINE_METHODDEF \
{"readline", (PyCFunction)_multibytecodec_MultibyteStreamReader_readline, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
{"readline", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_readline, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_readline_impl(MultibyteStreamReaderObject *self,
@ -338,7 +338,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readlines__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINES_METHODDEF \
{"readlines", (PyCFunction)_multibytecodec_MultibyteStreamReader_readlines, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
{"readlines", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_readlines, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_readlines_impl(MultibyteStreamReaderObject *self,
@ -418,4 +418,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=2fa0a38494716b97 input=a9049054013a1b77]*/
/*[clinic end generated code: output=4c1dc8015ee5abb4 input=a9049054013a1b77]*/

8
Modules/clinic/_abc.c.h generated
View file

@ -53,7 +53,7 @@ PyDoc_STRVAR(_abc__abc_register__doc__,
"Internal ABC helper for subclasss registration. Should be never used outside abc module.");
#define _ABC__ABC_REGISTER_METHODDEF \
{"_abc_register", (PyCFunction)_abc__abc_register, METH_FASTCALL, _abc__abc_register__doc__},
{"_abc_register", (PyCFunction)(void(*)(void))_abc__abc_register, METH_FASTCALL, _abc__abc_register__doc__},
static PyObject *
_abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass);
@ -83,7 +83,7 @@ PyDoc_STRVAR(_abc__abc_instancecheck__doc__,
"Internal ABC helper for instance checks. Should be never used outside abc module.");
#define _ABC__ABC_INSTANCECHECK_METHODDEF \
{"_abc_instancecheck", (PyCFunction)_abc__abc_instancecheck, METH_FASTCALL, _abc__abc_instancecheck__doc__},
{"_abc_instancecheck", (PyCFunction)(void(*)(void))_abc__abc_instancecheck, METH_FASTCALL, _abc__abc_instancecheck__doc__},
static PyObject *
_abc__abc_instancecheck_impl(PyObject *module, PyObject *self,
@ -114,7 +114,7 @@ PyDoc_STRVAR(_abc__abc_subclasscheck__doc__,
"Internal ABC helper for subclasss checks. Should be never used outside abc module.");
#define _ABC__ABC_SUBCLASSCHECK_METHODDEF \
{"_abc_subclasscheck", (PyCFunction)_abc__abc_subclasscheck, METH_FASTCALL, _abc__abc_subclasscheck__doc__},
{"_abc_subclasscheck", (PyCFunction)(void(*)(void))_abc__abc_subclasscheck, METH_FASTCALL, _abc__abc_subclasscheck__doc__},
static PyObject *
_abc__abc_subclasscheck_impl(PyObject *module, PyObject *self,
@ -159,4 +159,4 @@ _abc_get_cache_token(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _abc_get_cache_token_impl(module);
}
/*[clinic end generated code: output=9d6f861a8f45bc6f input=a9049054013a1b77]*/
/*[clinic end generated code: output=606db3cb658d9240 input=a9049054013a1b77]*/

20
Modules/clinic/_asynciomodule.c.h generated
View file

@ -120,7 +120,7 @@ PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__,
"scheduled with call_soon.");
#define _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF \
{"add_done_callback", (PyCFunction)_asyncio_Future_add_done_callback, METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
{"add_done_callback", (PyCFunction)(void(*)(void))_asyncio_Future_add_done_callback, METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
static PyObject *
_asyncio_Future_add_done_callback_impl(FutureObj *self, PyObject *fn,
@ -293,7 +293,7 @@ PyDoc_STRVAR(_asyncio_Task_current_task__doc__,
"None is returned when called not in the context of a Task.");
#define _ASYNCIO_TASK_CURRENT_TASK_METHODDEF \
{"current_task", (PyCFunction)_asyncio_Task_current_task, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_current_task__doc__},
{"current_task", (PyCFunction)(void(*)(void))_asyncio_Task_current_task, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_current_task__doc__},
static PyObject *
_asyncio_Task_current_task_impl(PyTypeObject *type, PyObject *loop);
@ -325,7 +325,7 @@ PyDoc_STRVAR(_asyncio_Task_all_tasks__doc__,
"By default all tasks for the current event loop are returned.");
#define _ASYNCIO_TASK_ALL_TASKS_METHODDEF \
{"all_tasks", (PyCFunction)_asyncio_Task_all_tasks, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_all_tasks__doc__},
{"all_tasks", (PyCFunction)(void(*)(void))_asyncio_Task_all_tasks, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_all_tasks__doc__},
static PyObject *
_asyncio_Task_all_tasks_impl(PyTypeObject *type, PyObject *loop);
@ -425,7 +425,7 @@ PyDoc_STRVAR(_asyncio_Task_get_stack__doc__,
"returned for a suspended coroutine.");
#define _ASYNCIO_TASK_GET_STACK_METHODDEF \
{"get_stack", (PyCFunction)_asyncio_Task_get_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
{"get_stack", (PyCFunction)(void(*)(void))_asyncio_Task_get_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
static PyObject *
_asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit);
@ -461,7 +461,7 @@ PyDoc_STRVAR(_asyncio_Task_print_stack__doc__,
"to sys.stderr.");
#define _ASYNCIO_TASK_PRINT_STACK_METHODDEF \
{"print_stack", (PyCFunction)_asyncio_Task_print_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
{"print_stack", (PyCFunction)(void(*)(void))_asyncio_Task_print_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
static PyObject *
_asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit,
@ -614,7 +614,7 @@ PyDoc_STRVAR(_asyncio__register_task__doc__,
"Returns None.");
#define _ASYNCIO__REGISTER_TASK_METHODDEF \
{"_register_task", (PyCFunction)_asyncio__register_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__register_task__doc__},
{"_register_task", (PyCFunction)(void(*)(void))_asyncio__register_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__register_task__doc__},
static PyObject *
_asyncio__register_task_impl(PyObject *module, PyObject *task);
@ -646,7 +646,7 @@ PyDoc_STRVAR(_asyncio__unregister_task__doc__,
"Returns None.");
#define _ASYNCIO__UNREGISTER_TASK_METHODDEF \
{"_unregister_task", (PyCFunction)_asyncio__unregister_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__unregister_task__doc__},
{"_unregister_task", (PyCFunction)(void(*)(void))_asyncio__unregister_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__unregister_task__doc__},
static PyObject *
_asyncio__unregister_task_impl(PyObject *module, PyObject *task);
@ -680,7 +680,7 @@ PyDoc_STRVAR(_asyncio__enter_task__doc__,
"Returns None.");
#define _ASYNCIO__ENTER_TASK_METHODDEF \
{"_enter_task", (PyCFunction)_asyncio__enter_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__enter_task__doc__},
{"_enter_task", (PyCFunction)(void(*)(void))_asyncio__enter_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__enter_task__doc__},
static PyObject *
_asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task);
@ -715,7 +715,7 @@ PyDoc_STRVAR(_asyncio__leave_task__doc__,
"Returns None.");
#define _ASYNCIO__LEAVE_TASK_METHODDEF \
{"_leave_task", (PyCFunction)_asyncio__leave_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__leave_task__doc__},
{"_leave_task", (PyCFunction)(void(*)(void))_asyncio__leave_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__leave_task__doc__},
static PyObject *
_asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task);
@ -738,4 +738,4 @@ _asyncio__leave_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
/*[clinic end generated code: output=67da879c9f841505 input=a9049054013a1b77]*/
/*[clinic end generated code: output=fd474bdc8f03d5ae input=a9049054013a1b77]*/

4
Modules/clinic/_bz2module.c.h generated
View file

@ -115,7 +115,7 @@ PyDoc_STRVAR(_bz2_BZ2Decompressor_decompress__doc__,
"the unused_data attribute.");
#define _BZ2_BZ2DECOMPRESSOR_DECOMPRESS_METHODDEF \
{"decompress", (PyCFunction)_bz2_BZ2Decompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _bz2_BZ2Decompressor_decompress__doc__},
{"decompress", (PyCFunction)(void(*)(void))_bz2_BZ2Decompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _bz2_BZ2Decompressor_decompress__doc__},
static PyObject *
_bz2_BZ2Decompressor_decompress_impl(BZ2Decompressor *self, Py_buffer *data,
@ -174,4 +174,4 @@ _bz2_BZ2Decompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=564a0313177fff63 input=a9049054013a1b77]*/
/*[clinic end generated code: output=e47f4255d265b07d input=a9049054013a1b77]*/

86
Modules/clinic/_codecsmodule.c.h generated
View file

@ -55,7 +55,7 @@ PyDoc_STRVAR(_codecs_encode__doc__,
"codecs.register_error that can handle ValueErrors.");
#define _CODECS_ENCODE_METHODDEF \
{"encode", (PyCFunction)_codecs_encode, METH_FASTCALL|METH_KEYWORDS, _codecs_encode__doc__},
{"encode", (PyCFunction)(void(*)(void))_codecs_encode, METH_FASTCALL|METH_KEYWORDS, _codecs_encode__doc__},
static PyObject *
_codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,
@ -94,7 +94,7 @@ PyDoc_STRVAR(_codecs_decode__doc__,
"codecs.register_error that can handle ValueErrors.");
#define _CODECS_DECODE_METHODDEF \
{"decode", (PyCFunction)_codecs_decode, METH_FASTCALL|METH_KEYWORDS, _codecs_decode__doc__},
{"decode", (PyCFunction)(void(*)(void))_codecs_decode, METH_FASTCALL|METH_KEYWORDS, _codecs_decode__doc__},
static PyObject *
_codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,
@ -153,7 +153,7 @@ PyDoc_STRVAR(_codecs_escape_decode__doc__,
"\n");
#define _CODECS_ESCAPE_DECODE_METHODDEF \
{"escape_decode", (PyCFunction)_codecs_escape_decode, METH_FASTCALL, _codecs_escape_decode__doc__},
{"escape_decode", (PyCFunction)(void(*)(void))_codecs_escape_decode, METH_FASTCALL, _codecs_escape_decode__doc__},
static PyObject *
_codecs_escape_decode_impl(PyObject *module, Py_buffer *data,
@ -187,7 +187,7 @@ PyDoc_STRVAR(_codecs_escape_encode__doc__,
"\n");
#define _CODECS_ESCAPE_ENCODE_METHODDEF \
{"escape_encode", (PyCFunction)_codecs_escape_encode, METH_FASTCALL, _codecs_escape_encode__doc__},
{"escape_encode", (PyCFunction)(void(*)(void))_codecs_escape_encode, METH_FASTCALL, _codecs_escape_encode__doc__},
static PyObject *
_codecs_escape_encode_impl(PyObject *module, PyObject *data,
@ -216,7 +216,7 @@ PyDoc_STRVAR(_codecs_unicode_internal_decode__doc__,
"\n");
#define _CODECS_UNICODE_INTERNAL_DECODE_METHODDEF \
{"unicode_internal_decode", (PyCFunction)_codecs_unicode_internal_decode, METH_FASTCALL, _codecs_unicode_internal_decode__doc__},
{"unicode_internal_decode", (PyCFunction)(void(*)(void))_codecs_unicode_internal_decode, METH_FASTCALL, _codecs_unicode_internal_decode__doc__},
static PyObject *
_codecs_unicode_internal_decode_impl(PyObject *module, PyObject *obj,
@ -245,7 +245,7 @@ PyDoc_STRVAR(_codecs_utf_7_decode__doc__,
"\n");
#define _CODECS_UTF_7_DECODE_METHODDEF \
{"utf_7_decode", (PyCFunction)_codecs_utf_7_decode, METH_FASTCALL, _codecs_utf_7_decode__doc__},
{"utf_7_decode", (PyCFunction)(void(*)(void))_codecs_utf_7_decode, METH_FASTCALL, _codecs_utf_7_decode__doc__},
static PyObject *
_codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data,
@ -280,7 +280,7 @@ PyDoc_STRVAR(_codecs_utf_8_decode__doc__,
"\n");
#define _CODECS_UTF_8_DECODE_METHODDEF \
{"utf_8_decode", (PyCFunction)_codecs_utf_8_decode, METH_FASTCALL, _codecs_utf_8_decode__doc__},
{"utf_8_decode", (PyCFunction)(void(*)(void))_codecs_utf_8_decode, METH_FASTCALL, _codecs_utf_8_decode__doc__},
static PyObject *
_codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data,
@ -315,7 +315,7 @@ PyDoc_STRVAR(_codecs_utf_16_decode__doc__,
"\n");
#define _CODECS_UTF_16_DECODE_METHODDEF \
{"utf_16_decode", (PyCFunction)_codecs_utf_16_decode, METH_FASTCALL, _codecs_utf_16_decode__doc__},
{"utf_16_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_decode, METH_FASTCALL, _codecs_utf_16_decode__doc__},
static PyObject *
_codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data,
@ -350,7 +350,7 @@ PyDoc_STRVAR(_codecs_utf_16_le_decode__doc__,
"\n");
#define _CODECS_UTF_16_LE_DECODE_METHODDEF \
{"utf_16_le_decode", (PyCFunction)_codecs_utf_16_le_decode, METH_FASTCALL, _codecs_utf_16_le_decode__doc__},
{"utf_16_le_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_le_decode, METH_FASTCALL, _codecs_utf_16_le_decode__doc__},
static PyObject *
_codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data,
@ -385,7 +385,7 @@ PyDoc_STRVAR(_codecs_utf_16_be_decode__doc__,
"\n");
#define _CODECS_UTF_16_BE_DECODE_METHODDEF \
{"utf_16_be_decode", (PyCFunction)_codecs_utf_16_be_decode, METH_FASTCALL, _codecs_utf_16_be_decode__doc__},
{"utf_16_be_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_be_decode, METH_FASTCALL, _codecs_utf_16_be_decode__doc__},
static PyObject *
_codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data,
@ -421,7 +421,7 @@ PyDoc_STRVAR(_codecs_utf_16_ex_decode__doc__,
"\n");
#define _CODECS_UTF_16_EX_DECODE_METHODDEF \
{"utf_16_ex_decode", (PyCFunction)_codecs_utf_16_ex_decode, METH_FASTCALL, _codecs_utf_16_ex_decode__doc__},
{"utf_16_ex_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_ex_decode, METH_FASTCALL, _codecs_utf_16_ex_decode__doc__},
static PyObject *
_codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data,
@ -457,7 +457,7 @@ PyDoc_STRVAR(_codecs_utf_32_decode__doc__,
"\n");
#define _CODECS_UTF_32_DECODE_METHODDEF \
{"utf_32_decode", (PyCFunction)_codecs_utf_32_decode, METH_FASTCALL, _codecs_utf_32_decode__doc__},
{"utf_32_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_decode, METH_FASTCALL, _codecs_utf_32_decode__doc__},
static PyObject *
_codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data,
@ -492,7 +492,7 @@ PyDoc_STRVAR(_codecs_utf_32_le_decode__doc__,
"\n");
#define _CODECS_UTF_32_LE_DECODE_METHODDEF \
{"utf_32_le_decode", (PyCFunction)_codecs_utf_32_le_decode, METH_FASTCALL, _codecs_utf_32_le_decode__doc__},
{"utf_32_le_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_le_decode, METH_FASTCALL, _codecs_utf_32_le_decode__doc__},
static PyObject *
_codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data,
@ -527,7 +527,7 @@ PyDoc_STRVAR(_codecs_utf_32_be_decode__doc__,
"\n");
#define _CODECS_UTF_32_BE_DECODE_METHODDEF \
{"utf_32_be_decode", (PyCFunction)_codecs_utf_32_be_decode, METH_FASTCALL, _codecs_utf_32_be_decode__doc__},
{"utf_32_be_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_be_decode, METH_FASTCALL, _codecs_utf_32_be_decode__doc__},
static PyObject *
_codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data,
@ -563,7 +563,7 @@ PyDoc_STRVAR(_codecs_utf_32_ex_decode__doc__,
"\n");
#define _CODECS_UTF_32_EX_DECODE_METHODDEF \
{"utf_32_ex_decode", (PyCFunction)_codecs_utf_32_ex_decode, METH_FASTCALL, _codecs_utf_32_ex_decode__doc__},
{"utf_32_ex_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_ex_decode, METH_FASTCALL, _codecs_utf_32_ex_decode__doc__},
static PyObject *
_codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data,
@ -599,7 +599,7 @@ PyDoc_STRVAR(_codecs_unicode_escape_decode__doc__,
"\n");
#define _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF \
{"unicode_escape_decode", (PyCFunction)_codecs_unicode_escape_decode, METH_FASTCALL, _codecs_unicode_escape_decode__doc__},
{"unicode_escape_decode", (PyCFunction)(void(*)(void))_codecs_unicode_escape_decode, METH_FASTCALL, _codecs_unicode_escape_decode__doc__},
static PyObject *
_codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
@ -633,7 +633,7 @@ PyDoc_STRVAR(_codecs_raw_unicode_escape_decode__doc__,
"\n");
#define _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF \
{"raw_unicode_escape_decode", (PyCFunction)_codecs_raw_unicode_escape_decode, METH_FASTCALL, _codecs_raw_unicode_escape_decode__doc__},
{"raw_unicode_escape_decode", (PyCFunction)(void(*)(void))_codecs_raw_unicode_escape_decode, METH_FASTCALL, _codecs_raw_unicode_escape_decode__doc__},
static PyObject *
_codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
@ -667,7 +667,7 @@ PyDoc_STRVAR(_codecs_latin_1_decode__doc__,
"\n");
#define _CODECS_LATIN_1_DECODE_METHODDEF \
{"latin_1_decode", (PyCFunction)_codecs_latin_1_decode, METH_FASTCALL, _codecs_latin_1_decode__doc__},
{"latin_1_decode", (PyCFunction)(void(*)(void))_codecs_latin_1_decode, METH_FASTCALL, _codecs_latin_1_decode__doc__},
static PyObject *
_codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data,
@ -701,7 +701,7 @@ PyDoc_STRVAR(_codecs_ascii_decode__doc__,
"\n");
#define _CODECS_ASCII_DECODE_METHODDEF \
{"ascii_decode", (PyCFunction)_codecs_ascii_decode, METH_FASTCALL, _codecs_ascii_decode__doc__},
{"ascii_decode", (PyCFunction)(void(*)(void))_codecs_ascii_decode, METH_FASTCALL, _codecs_ascii_decode__doc__},
static PyObject *
_codecs_ascii_decode_impl(PyObject *module, Py_buffer *data,
@ -735,7 +735,7 @@ PyDoc_STRVAR(_codecs_charmap_decode__doc__,
"\n");
#define _CODECS_CHARMAP_DECODE_METHODDEF \
{"charmap_decode", (PyCFunction)_codecs_charmap_decode, METH_FASTCALL, _codecs_charmap_decode__doc__},
{"charmap_decode", (PyCFunction)(void(*)(void))_codecs_charmap_decode, METH_FASTCALL, _codecs_charmap_decode__doc__},
static PyObject *
_codecs_charmap_decode_impl(PyObject *module, Py_buffer *data,
@ -772,7 +772,7 @@ PyDoc_STRVAR(_codecs_mbcs_decode__doc__,
"\n");
#define _CODECS_MBCS_DECODE_METHODDEF \
{"mbcs_decode", (PyCFunction)_codecs_mbcs_decode, METH_FASTCALL, _codecs_mbcs_decode__doc__},
{"mbcs_decode", (PyCFunction)(void(*)(void))_codecs_mbcs_decode, METH_FASTCALL, _codecs_mbcs_decode__doc__},
static PyObject *
_codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data,
@ -811,7 +811,7 @@ PyDoc_STRVAR(_codecs_oem_decode__doc__,
"\n");
#define _CODECS_OEM_DECODE_METHODDEF \
{"oem_decode", (PyCFunction)_codecs_oem_decode, METH_FASTCALL, _codecs_oem_decode__doc__},
{"oem_decode", (PyCFunction)(void(*)(void))_codecs_oem_decode, METH_FASTCALL, _codecs_oem_decode__doc__},
static PyObject *
_codecs_oem_decode_impl(PyObject *module, Py_buffer *data,
@ -850,7 +850,7 @@ PyDoc_STRVAR(_codecs_code_page_decode__doc__,
"\n");
#define _CODECS_CODE_PAGE_DECODE_METHODDEF \
{"code_page_decode", (PyCFunction)_codecs_code_page_decode, METH_FASTCALL, _codecs_code_page_decode__doc__},
{"code_page_decode", (PyCFunction)(void(*)(void))_codecs_code_page_decode, METH_FASTCALL, _codecs_code_page_decode__doc__},
static PyObject *
_codecs_code_page_decode_impl(PyObject *module, int codepage,
@ -888,7 +888,7 @@ PyDoc_STRVAR(_codecs_readbuffer_encode__doc__,
"\n");
#define _CODECS_READBUFFER_ENCODE_METHODDEF \
{"readbuffer_encode", (PyCFunction)_codecs_readbuffer_encode, METH_FASTCALL, _codecs_readbuffer_encode__doc__},
{"readbuffer_encode", (PyCFunction)(void(*)(void))_codecs_readbuffer_encode, METH_FASTCALL, _codecs_readbuffer_encode__doc__},
static PyObject *
_codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data,
@ -922,7 +922,7 @@ PyDoc_STRVAR(_codecs_unicode_internal_encode__doc__,
"\n");
#define _CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF \
{"unicode_internal_encode", (PyCFunction)_codecs_unicode_internal_encode, METH_FASTCALL, _codecs_unicode_internal_encode__doc__},
{"unicode_internal_encode", (PyCFunction)(void(*)(void))_codecs_unicode_internal_encode, METH_FASTCALL, _codecs_unicode_internal_encode__doc__},
static PyObject *
_codecs_unicode_internal_encode_impl(PyObject *module, PyObject *obj,
@ -951,7 +951,7 @@ PyDoc_STRVAR(_codecs_utf_7_encode__doc__,
"\n");
#define _CODECS_UTF_7_ENCODE_METHODDEF \
{"utf_7_encode", (PyCFunction)_codecs_utf_7_encode, METH_FASTCALL, _codecs_utf_7_encode__doc__},
{"utf_7_encode", (PyCFunction)(void(*)(void))_codecs_utf_7_encode, METH_FASTCALL, _codecs_utf_7_encode__doc__},
static PyObject *
_codecs_utf_7_encode_impl(PyObject *module, PyObject *str,
@ -980,7 +980,7 @@ PyDoc_STRVAR(_codecs_utf_8_encode__doc__,
"\n");
#define _CODECS_UTF_8_ENCODE_METHODDEF \
{"utf_8_encode", (PyCFunction)_codecs_utf_8_encode, METH_FASTCALL, _codecs_utf_8_encode__doc__},
{"utf_8_encode", (PyCFunction)(void(*)(void))_codecs_utf_8_encode, METH_FASTCALL, _codecs_utf_8_encode__doc__},
static PyObject *
_codecs_utf_8_encode_impl(PyObject *module, PyObject *str,
@ -1009,7 +1009,7 @@ PyDoc_STRVAR(_codecs_utf_16_encode__doc__,
"\n");
#define _CODECS_UTF_16_ENCODE_METHODDEF \
{"utf_16_encode", (PyCFunction)_codecs_utf_16_encode, METH_FASTCALL, _codecs_utf_16_encode__doc__},
{"utf_16_encode", (PyCFunction)(void(*)(void))_codecs_utf_16_encode, METH_FASTCALL, _codecs_utf_16_encode__doc__},
static PyObject *
_codecs_utf_16_encode_impl(PyObject *module, PyObject *str,
@ -1039,7 +1039,7 @@ PyDoc_STRVAR(_codecs_utf_16_le_encode__doc__,
"\n");
#define _CODECS_UTF_16_LE_ENCODE_METHODDEF \
{"utf_16_le_encode", (PyCFunction)_codecs_utf_16_le_encode, METH_FASTCALL, _codecs_utf_16_le_encode__doc__},
{"utf_16_le_encode", (PyCFunction)(void(*)(void))_codecs_utf_16_le_encode, METH_FASTCALL, _codecs_utf_16_le_encode__doc__},
static PyObject *
_codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,
@ -1068,7 +1068,7 @@ PyDoc_STRVAR(_codecs_utf_16_be_encode__doc__,
"\n");
#define _CODECS_UTF_16_BE_ENCODE_METHODDEF \
{"utf_16_be_encode", (PyCFunction)_codecs_utf_16_be_encode, METH_FASTCALL, _codecs_utf_16_be_encode__doc__},
{"utf_16_be_encode", (PyCFunction)(void(*)(void))_codecs_utf_16_be_encode, METH_FASTCALL, _codecs_utf_16_be_encode__doc__},
static PyObject *
_codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,
@ -1097,7 +1097,7 @@ PyDoc_STRVAR(_codecs_utf_32_encode__doc__,
"\n");
#define _CODECS_UTF_32_ENCODE_METHODDEF \
{"utf_32_encode", (PyCFunction)_codecs_utf_32_encode, METH_FASTCALL, _codecs_utf_32_encode__doc__},
{"utf_32_encode", (PyCFunction)(void(*)(void))_codecs_utf_32_encode, METH_FASTCALL, _codecs_utf_32_encode__doc__},
static PyObject *
_codecs_utf_32_encode_impl(PyObject *module, PyObject *str,
@ -1127,7 +1127,7 @@ PyDoc_STRVAR(_codecs_utf_32_le_encode__doc__,
"\n");
#define _CODECS_UTF_32_LE_ENCODE_METHODDEF \
{"utf_32_le_encode", (PyCFunction)_codecs_utf_32_le_encode, METH_FASTCALL, _codecs_utf_32_le_encode__doc__},
{"utf_32_le_encode", (PyCFunction)(void(*)(void))_codecs_utf_32_le_encode, METH_FASTCALL, _codecs_utf_32_le_encode__doc__},
static PyObject *
_codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,
@ -1156,7 +1156,7 @@ PyDoc_STRVAR(_codecs_utf_32_be_encode__doc__,
"\n");
#define _CODECS_UTF_32_BE_ENCODE_METHODDEF \
{"utf_32_be_encode", (PyCFunction)_codecs_utf_32_be_encode, METH_FASTCALL, _codecs_utf_32_be_encode__doc__},
{"utf_32_be_encode", (PyCFunction)(void(*)(void))_codecs_utf_32_be_encode, METH_FASTCALL, _codecs_utf_32_be_encode__doc__},
static PyObject *
_codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,
@ -1185,7 +1185,7 @@ PyDoc_STRVAR(_codecs_unicode_escape_encode__doc__,
"\n");
#define _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF \
{"unicode_escape_encode", (PyCFunction)_codecs_unicode_escape_encode, METH_FASTCALL, _codecs_unicode_escape_encode__doc__},
{"unicode_escape_encode", (PyCFunction)(void(*)(void))_codecs_unicode_escape_encode, METH_FASTCALL, _codecs_unicode_escape_encode__doc__},
static PyObject *
_codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,
@ -1214,7 +1214,7 @@ PyDoc_STRVAR(_codecs_raw_unicode_escape_encode__doc__,
"\n");
#define _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF \
{"raw_unicode_escape_encode", (PyCFunction)_codecs_raw_unicode_escape_encode, METH_FASTCALL, _codecs_raw_unicode_escape_encode__doc__},
{"raw_unicode_escape_encode", (PyCFunction)(void(*)(void))_codecs_raw_unicode_escape_encode, METH_FASTCALL, _codecs_raw_unicode_escape_encode__doc__},
static PyObject *
_codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,
@ -1243,7 +1243,7 @@ PyDoc_STRVAR(_codecs_latin_1_encode__doc__,
"\n");
#define _CODECS_LATIN_1_ENCODE_METHODDEF \
{"latin_1_encode", (PyCFunction)_codecs_latin_1_encode, METH_FASTCALL, _codecs_latin_1_encode__doc__},
{"latin_1_encode", (PyCFunction)(void(*)(void))_codecs_latin_1_encode, METH_FASTCALL, _codecs_latin_1_encode__doc__},
static PyObject *
_codecs_latin_1_encode_impl(PyObject *module, PyObject *str,
@ -1272,7 +1272,7 @@ PyDoc_STRVAR(_codecs_ascii_encode__doc__,
"\n");
#define _CODECS_ASCII_ENCODE_METHODDEF \
{"ascii_encode", (PyCFunction)_codecs_ascii_encode, METH_FASTCALL, _codecs_ascii_encode__doc__},
{"ascii_encode", (PyCFunction)(void(*)(void))_codecs_ascii_encode, METH_FASTCALL, _codecs_ascii_encode__doc__},
static PyObject *
_codecs_ascii_encode_impl(PyObject *module, PyObject *str,
@ -1301,7 +1301,7 @@ PyDoc_STRVAR(_codecs_charmap_encode__doc__,
"\n");
#define _CODECS_CHARMAP_ENCODE_METHODDEF \
{"charmap_encode", (PyCFunction)_codecs_charmap_encode, METH_FASTCALL, _codecs_charmap_encode__doc__},
{"charmap_encode", (PyCFunction)(void(*)(void))_codecs_charmap_encode, METH_FASTCALL, _codecs_charmap_encode__doc__},
static PyObject *
_codecs_charmap_encode_impl(PyObject *module, PyObject *str,
@ -1359,7 +1359,7 @@ PyDoc_STRVAR(_codecs_mbcs_encode__doc__,
"\n");
#define _CODECS_MBCS_ENCODE_METHODDEF \
{"mbcs_encode", (PyCFunction)_codecs_mbcs_encode, METH_FASTCALL, _codecs_mbcs_encode__doc__},
{"mbcs_encode", (PyCFunction)(void(*)(void))_codecs_mbcs_encode, METH_FASTCALL, _codecs_mbcs_encode__doc__},
static PyObject *
_codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors);
@ -1391,7 +1391,7 @@ PyDoc_STRVAR(_codecs_oem_encode__doc__,
"\n");
#define _CODECS_OEM_ENCODE_METHODDEF \
{"oem_encode", (PyCFunction)_codecs_oem_encode, METH_FASTCALL, _codecs_oem_encode__doc__},
{"oem_encode", (PyCFunction)(void(*)(void))_codecs_oem_encode, METH_FASTCALL, _codecs_oem_encode__doc__},
static PyObject *
_codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors);
@ -1423,7 +1423,7 @@ PyDoc_STRVAR(_codecs_code_page_encode__doc__,
"\n");
#define _CODECS_CODE_PAGE_ENCODE_METHODDEF \
{"code_page_encode", (PyCFunction)_codecs_code_page_encode, METH_FASTCALL, _codecs_code_page_encode__doc__},
{"code_page_encode", (PyCFunction)(void(*)(void))_codecs_code_page_encode, METH_FASTCALL, _codecs_code_page_encode__doc__},
static PyObject *
_codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str,
@ -1460,7 +1460,7 @@ PyDoc_STRVAR(_codecs_register_error__doc__,
"error and must return a (replacement, new position) tuple.");
#define _CODECS_REGISTER_ERROR_METHODDEF \
{"register_error", (PyCFunction)_codecs_register_error, METH_FASTCALL, _codecs_register_error__doc__},
{"register_error", (PyCFunction)(void(*)(void))_codecs_register_error, METH_FASTCALL, _codecs_register_error__doc__},
static PyObject *
_codecs_register_error_impl(PyObject *module, const char *errors,
@ -1536,4 +1536,4 @@ exit:
#ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
#define _CODECS_CODE_PAGE_ENCODE_METHODDEF
#endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
/*[clinic end generated code: output=06fa0d6803103c62 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d29fe7c0cb206812 input=a9049054013a1b77]*/

4
Modules/clinic/_cryptmodule.c.h generated
View file

@ -14,7 +14,7 @@ PyDoc_STRVAR(crypt_crypt__doc__,
"results for a given *word*.");
#define CRYPT_CRYPT_METHODDEF \
{"crypt", (PyCFunction)crypt_crypt, METH_FASTCALL, crypt_crypt__doc__},
{"crypt", (PyCFunction)(void(*)(void))crypt_crypt, METH_FASTCALL, crypt_crypt__doc__},
static PyObject *
crypt_crypt_impl(PyObject *module, const char *word, const char *salt);
@ -35,4 +35,4 @@ crypt_crypt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
/*[clinic end generated code: output=8d803e53466b1cd3 input=a9049054013a1b77]*/
/*[clinic end generated code: output=79001dbfdd623ff9 input=a9049054013a1b77]*/

4
Modules/clinic/_curses_panel.c.h generated
View file

@ -137,7 +137,7 @@ PyDoc_STRVAR(_curses_panel_panel_move__doc__,
"Move the panel to the screen coordinates (y, x).");
#define _CURSES_PANEL_PANEL_MOVE_METHODDEF \
{"move", (PyCFunction)_curses_panel_panel_move, METH_FASTCALL, _curses_panel_panel_move__doc__},
{"move", (PyCFunction)(void(*)(void))_curses_panel_panel_move, METH_FASTCALL, _curses_panel_panel_move__doc__},
static PyObject *
_curses_panel_panel_move_impl(PyCursesPanelObject *self, int y, int x);
@ -314,4 +314,4 @@ _curses_panel_update_panels(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _curses_panel_update_panels_impl(module);
}
/*[clinic end generated code: output=96f627ca0b08b96d input=a9049054013a1b77]*/
/*[clinic end generated code: output=66e49cb9726a638f input=a9049054013a1b77]*/

46
Modules/clinic/_cursesmodule.c.h generated
View file

@ -233,7 +233,7 @@ PyDoc_STRVAR(_curses_window_bkgd__doc__,
" Background attributes.");
#define _CURSES_WINDOW_BKGD_METHODDEF \
{"bkgd", (PyCFunction)_curses_window_bkgd, METH_FASTCALL, _curses_window_bkgd__doc__},
{"bkgd", (PyCFunction)(void(*)(void))_curses_window_bkgd, METH_FASTCALL, _curses_window_bkgd__doc__},
static PyObject *
_curses_window_bkgd_impl(PyCursesWindowObject *self, PyObject *ch, long attr);
@ -348,7 +348,7 @@ PyDoc_STRVAR(_curses_window_bkgdset__doc__,
" Background attributes.");
#define _CURSES_WINDOW_BKGDSET_METHODDEF \
{"bkgdset", (PyCFunction)_curses_window_bkgdset, METH_FASTCALL, _curses_window_bkgdset__doc__},
{"bkgdset", (PyCFunction)(void(*)(void))_curses_window_bkgdset, METH_FASTCALL, _curses_window_bkgdset__doc__},
static PyObject *
_curses_window_bkgdset_impl(PyCursesWindowObject *self, PyObject *ch,
@ -403,7 +403,7 @@ PyDoc_STRVAR(_curses_window_border__doc__,
"used for that parameter.");
#define _CURSES_WINDOW_BORDER_METHODDEF \
{"border", (PyCFunction)_curses_window_border, METH_FASTCALL, _curses_window_border__doc__},
{"border", (PyCFunction)(void(*)(void))_curses_window_border, METH_FASTCALL, _curses_window_border__doc__},
static PyObject *
_curses_window_border_impl(PyCursesWindowObject *self, PyObject *ls,
@ -592,7 +592,7 @@ PyDoc_STRVAR(_curses_window_echochar__doc__,
" Attributes for the character.");
#define _CURSES_WINDOW_ECHOCHAR_METHODDEF \
{"echochar", (PyCFunction)_curses_window_echochar, METH_FASTCALL, _curses_window_echochar__doc__},
{"echochar", (PyCFunction)(void(*)(void))_curses_window_echochar, METH_FASTCALL, _curses_window_echochar__doc__},
static PyObject *
_curses_window_echochar_impl(PyCursesWindowObject *self, PyObject *ch,
@ -629,7 +629,7 @@ PyDoc_STRVAR(_curses_window_enclose__doc__,
" X-coordinate.");
#define _CURSES_WINDOW_ENCLOSE_METHODDEF \
{"enclose", (PyCFunction)_curses_window_enclose, METH_FASTCALL, _curses_window_enclose__doc__},
{"enclose", (PyCFunction)(void(*)(void))_curses_window_enclose, METH_FASTCALL, _curses_window_enclose__doc__},
static long
_curses_window_enclose_impl(PyCursesWindowObject *self, int y, int x);
@ -1426,7 +1426,7 @@ PyDoc_STRVAR(_curses_window_redrawln__doc__,
"They should be completely redrawn on the next refresh() call.");
#define _CURSES_WINDOW_REDRAWLN_METHODDEF \
{"redrawln", (PyCFunction)_curses_window_redrawln, METH_FASTCALL, _curses_window_redrawln__doc__},
{"redrawln", (PyCFunction)(void(*)(void))_curses_window_redrawln, METH_FASTCALL, _curses_window_redrawln__doc__},
static PyObject *
_curses_window_redrawln_impl(PyCursesWindowObject *self, int beg, int num);
@ -1517,7 +1517,7 @@ PyDoc_STRVAR(_curses_window_setscrreg__doc__,
"All scrolling actions will take place in this region.");
#define _CURSES_WINDOW_SETSCRREG_METHODDEF \
{"setscrreg", (PyCFunction)_curses_window_setscrreg, METH_FASTCALL, _curses_window_setscrreg__doc__},
{"setscrreg", (PyCFunction)(void(*)(void))_curses_window_setscrreg, METH_FASTCALL, _curses_window_setscrreg__doc__},
static PyObject *
_curses_window_setscrreg_impl(PyCursesWindowObject *self, int top,
@ -1843,7 +1843,7 @@ PyDoc_STRVAR(_curses_cbreak__doc__,
"Calling first raw() then cbreak() leaves the terminal in cbreak mode.");
#define _CURSES_CBREAK_METHODDEF \
{"cbreak", (PyCFunction)_curses_cbreak, METH_FASTCALL, _curses_cbreak__doc__},
{"cbreak", (PyCFunction)(void(*)(void))_curses_cbreak, METH_FASTCALL, _curses_cbreak__doc__},
static PyObject *
_curses_cbreak_impl(PyObject *module, int flag);
@ -2069,7 +2069,7 @@ PyDoc_STRVAR(_curses_echo__doc__,
"In echo mode, each character input is echoed to the screen as it is entered.");
#define _CURSES_ECHO_METHODDEF \
{"echo", (PyCFunction)_curses_echo, METH_FASTCALL, _curses_echo__doc__},
{"echo", (PyCFunction)(void(*)(void))_curses_echo, METH_FASTCALL, _curses_echo__doc__},
static PyObject *
_curses_echo_impl(PyObject *module, int flag);
@ -2227,7 +2227,7 @@ PyDoc_STRVAR(_curses_ungetmouse__doc__,
"The following getmouse() will return the given state data.");
#define _CURSES_UNGETMOUSE_METHODDEF \
{"ungetmouse", (PyCFunction)_curses_ungetmouse, METH_FASTCALL, _curses_ungetmouse__doc__},
{"ungetmouse", (PyCFunction)(void(*)(void))_curses_ungetmouse, METH_FASTCALL, _curses_ungetmouse__doc__},
static PyObject *
_curses_ungetmouse_impl(PyObject *module, short id, int x, int y, int z,
@ -2407,7 +2407,7 @@ PyDoc_STRVAR(_curses_init_color__doc__,
"most terminals; it is active only if can_change_color() returns 1.");
#define _CURSES_INIT_COLOR_METHODDEF \
{"init_color", (PyCFunction)_curses_init_color, METH_FASTCALL, _curses_init_color__doc__},
{"init_color", (PyCFunction)(void(*)(void))_curses_init_color, METH_FASTCALL, _curses_init_color__doc__},
static PyObject *
_curses_init_color_impl(PyObject *module, short color_number, short r,
@ -2449,7 +2449,7 @@ PyDoc_STRVAR(_curses_init_pair__doc__,
"all occurrences of that color-pair are changed to the new definition.");
#define _CURSES_INIT_PAIR_METHODDEF \
{"init_pair", (PyCFunction)_curses_init_pair, METH_FASTCALL, _curses_init_pair__doc__},
{"init_pair", (PyCFunction)(void(*)(void))_curses_init_pair, METH_FASTCALL, _curses_init_pair__doc__},
static PyObject *
_curses_init_pair_impl(PyObject *module, short pair_number, short fg,
@ -2507,7 +2507,7 @@ PyDoc_STRVAR(_curses_setupterm__doc__,
" If not supplied, the file descriptor for sys.stdout will be used.");
#define _CURSES_SETUPTERM_METHODDEF \
{"setupterm", (PyCFunction)_curses_setupterm, METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
{"setupterm", (PyCFunction)(void(*)(void))_curses_setupterm, METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
static PyObject *
_curses_setupterm_impl(PyObject *module, const char *term, int fd);
@ -2589,7 +2589,7 @@ PyDoc_STRVAR(_curses_is_term_resized__doc__,
" Width.");
#define _CURSES_IS_TERM_RESIZED_METHODDEF \
{"is_term_resized", (PyCFunction)_curses_is_term_resized, METH_FASTCALL, _curses_is_term_resized__doc__},
{"is_term_resized", (PyCFunction)(void(*)(void))_curses_is_term_resized, METH_FASTCALL, _curses_is_term_resized__doc__},
static PyObject *
_curses_is_term_resized_impl(PyObject *module, int nlines, int ncols);
@ -2828,7 +2828,7 @@ PyDoc_STRVAR(_curses_newpad__doc__,
" Width.");
#define _CURSES_NEWPAD_METHODDEF \
{"newpad", (PyCFunction)_curses_newpad, METH_FASTCALL, _curses_newpad__doc__},
{"newpad", (PyCFunction)(void(*)(void))_curses_newpad, METH_FASTCALL, _curses_newpad__doc__},
static PyObject *
_curses_newpad_impl(PyObject *module, int nlines, int ncols);
@ -2918,7 +2918,7 @@ PyDoc_STRVAR(_curses_nl__doc__,
"newline into return and line-feed on output. Newline mode is initially on.");
#define _CURSES_NL_METHODDEF \
{"nl", (PyCFunction)_curses_nl, METH_FASTCALL, _curses_nl__doc__},
{"nl", (PyCFunction)(void(*)(void))_curses_nl, METH_FASTCALL, _curses_nl__doc__},
static PyObject *
_curses_nl_impl(PyObject *module, int flag);
@ -3142,7 +3142,7 @@ PyDoc_STRVAR(_curses_qiflush__doc__,
"will be flushed when the INTR, QUIT and SUSP characters are read.");
#define _CURSES_QIFLUSH_METHODDEF \
{"qiflush", (PyCFunction)_curses_qiflush, METH_FASTCALL, _curses_qiflush__doc__},
{"qiflush", (PyCFunction)(void(*)(void))_curses_qiflush, METH_FASTCALL, _curses_qiflush__doc__},
static PyObject *
_curses_qiflush_impl(PyObject *module, int flag);
@ -3208,7 +3208,7 @@ PyDoc_STRVAR(_curses_raw__doc__,
"curses input functions one by one.");
#define _CURSES_RAW_METHODDEF \
{"raw", (PyCFunction)_curses_raw, METH_FASTCALL, _curses_raw__doc__},
{"raw", (PyCFunction)(void(*)(void))_curses_raw, METH_FASTCALL, _curses_raw__doc__},
static PyObject *
_curses_raw_impl(PyObject *module, int flag);
@ -3300,7 +3300,7 @@ PyDoc_STRVAR(_curses_resizeterm__doc__,
"window dimensions (in particular the SIGWINCH handler).");
#define _CURSES_RESIZETERM_METHODDEF \
{"resizeterm", (PyCFunction)_curses_resizeterm, METH_FASTCALL, _curses_resizeterm__doc__},
{"resizeterm", (PyCFunction)(void(*)(void))_curses_resizeterm, METH_FASTCALL, _curses_resizeterm__doc__},
static PyObject *
_curses_resizeterm_impl(PyObject *module, int nlines, int ncols);
@ -3344,7 +3344,7 @@ PyDoc_STRVAR(_curses_resize_term__doc__,
"without additional interaction with the application.");
#define _CURSES_RESIZE_TERM_METHODDEF \
{"resize_term", (PyCFunction)_curses_resize_term, METH_FASTCALL, _curses_resize_term__doc__},
{"resize_term", (PyCFunction)(void(*)(void))_curses_resize_term, METH_FASTCALL, _curses_resize_term__doc__},
static PyObject *
_curses_resize_term_impl(PyObject *module, int nlines, int ncols);
@ -3402,7 +3402,7 @@ PyDoc_STRVAR(_curses_setsyx__doc__,
"If y and x are both -1, then leaveok is set.");
#define _CURSES_SETSYX_METHODDEF \
{"setsyx", (PyCFunction)_curses_setsyx, METH_FASTCALL, _curses_setsyx__doc__},
{"setsyx", (PyCFunction)(void(*)(void))_curses_setsyx, METH_FASTCALL, _curses_setsyx__doc__},
static PyObject *
_curses_setsyx_impl(PyObject *module, int y, int x);
@ -3597,7 +3597,7 @@ PyDoc_STRVAR(_curses_tparm__doc__,
" Parameterized byte string obtained from the terminfo database.");
#define _CURSES_TPARM_METHODDEF \
{"tparm", (PyCFunction)_curses_tparm, METH_FASTCALL, _curses_tparm__doc__},
{"tparm", (PyCFunction)(void(*)(void))_curses_tparm, METH_FASTCALL, _curses_tparm__doc__},
static PyObject *
_curses_tparm_impl(PyObject *module, const char *str, int i1, int i2, int i3,
@ -3838,4 +3838,4 @@ _curses_use_default_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
#ifndef _CURSES_USE_DEFAULT_COLORS_METHODDEF
#define _CURSES_USE_DEFAULT_COLORS_METHODDEF
#endif /* !defined(_CURSES_USE_DEFAULT_COLORS_METHODDEF) */
/*[clinic end generated code: output=763ffe3abc3a97c7 input=a9049054013a1b77]*/
/*[clinic end generated code: output=177ad1d0b5586aaa input=a9049054013a1b77]*/

4
Modules/clinic/_datetimemodule.c.h generated
View file

@ -26,7 +26,7 @@ PyDoc_STRVAR(datetime_datetime_now__doc__,
"If no tz is specified, uses local timezone.");
#define DATETIME_DATETIME_NOW_METHODDEF \
{"now", (PyCFunction)datetime_datetime_now, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, datetime_datetime_now__doc__},
{"now", (PyCFunction)(void(*)(void))datetime_datetime_now, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, datetime_datetime_now__doc__},
static PyObject *
datetime_datetime_now_impl(PyTypeObject *type, PyObject *tz);
@ -48,4 +48,4 @@ datetime_datetime_now(PyTypeObject *type, PyObject *const *args, Py_ssize_t narg
exit:
return return_value;
}
/*[clinic end generated code: output=7fd14bd67749da23 input=a9049054013a1b77]*/
/*[clinic end generated code: output=b3d746843403a8ce input=a9049054013a1b77]*/

8
Modules/clinic/_dbmmodule.c.h generated
View file

@ -45,7 +45,7 @@ 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_FASTCALL, _dbm_dbm_get__doc__},
{"get", (PyCFunction)(void(*)(void))_dbm_dbm_get, METH_FASTCALL, _dbm_dbm_get__doc__},
static PyObject *
_dbm_dbm_get_impl(dbmobject *self, const char *key,
@ -78,7 +78,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_FASTCALL, _dbm_dbm_setdefault__doc__},
{"setdefault", (PyCFunction)(void(*)(void))_dbm_dbm_setdefault, METH_FASTCALL, _dbm_dbm_setdefault__doc__},
static PyObject *
_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
@ -118,7 +118,7 @@ PyDoc_STRVAR(dbmopen__doc__,
" (e.g. os.O_RDWR).");
#define DBMOPEN_METHODDEF \
{"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
{"open", (PyCFunction)(void(*)(void))dbmopen, METH_FASTCALL, dbmopen__doc__},
static PyObject *
dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
@ -141,4 +141,4 @@ dbmopen(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
/*[clinic end generated code: output=1cba297bc8d7c2c2 input=a9049054013a1b77]*/
/*[clinic end generated code: output=e4585e78f5821b5b input=a9049054013a1b77]*/

26
Modules/clinic/_elementtree.c.h generated
View file

@ -154,7 +154,7 @@ PyDoc_STRVAR(_elementtree_Element_find__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \
{"find", (PyCFunction)_elementtree_Element_find, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
{"find", (PyCFunction)(void(*)(void))_elementtree_Element_find, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
static PyObject *
_elementtree_Element_find_impl(ElementObject *self, PyObject *path,
@ -185,7 +185,7 @@ PyDoc_STRVAR(_elementtree_Element_findtext__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \
{"findtext", (PyCFunction)_elementtree_Element_findtext, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
{"findtext", (PyCFunction)(void(*)(void))_elementtree_Element_findtext, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
static PyObject *
_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
@ -218,7 +218,7 @@ PyDoc_STRVAR(_elementtree_Element_findall__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \
{"findall", (PyCFunction)_elementtree_Element_findall, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
{"findall", (PyCFunction)(void(*)(void))_elementtree_Element_findall, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
static PyObject *
_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
@ -249,7 +249,7 @@ PyDoc_STRVAR(_elementtree_Element_iterfind__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \
{"iterfind", (PyCFunction)_elementtree_Element_iterfind, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
{"iterfind", (PyCFunction)(void(*)(void))_elementtree_Element_iterfind, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
static PyObject *
_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
@ -280,7 +280,7 @@ PyDoc_STRVAR(_elementtree_Element_get__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_GET_METHODDEF \
{"get", (PyCFunction)_elementtree_Element_get, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_get__doc__},
{"get", (PyCFunction)(void(*)(void))_elementtree_Element_get, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_get__doc__},
static PyObject *
_elementtree_Element_get_impl(ElementObject *self, PyObject *key,
@ -328,7 +328,7 @@ PyDoc_STRVAR(_elementtree_Element_iter__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \
{"iter", (PyCFunction)_elementtree_Element_iter, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
{"iter", (PyCFunction)(void(*)(void))_elementtree_Element_iter, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
static PyObject *
_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag);
@ -357,7 +357,7 @@ PyDoc_STRVAR(_elementtree_Element_getiterator__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_GETITERATOR_METHODDEF \
{"getiterator", (PyCFunction)_elementtree_Element_getiterator, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_getiterator__doc__},
{"getiterator", (PyCFunction)(void(*)(void))_elementtree_Element_getiterator, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_getiterator__doc__},
static PyObject *
_elementtree_Element_getiterator_impl(ElementObject *self, PyObject *tag);
@ -403,7 +403,7 @@ PyDoc_STRVAR(_elementtree_Element_insert__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF \
{"insert", (PyCFunction)_elementtree_Element_insert, METH_FASTCALL, _elementtree_Element_insert__doc__},
{"insert", (PyCFunction)(void(*)(void))_elementtree_Element_insert, METH_FASTCALL, _elementtree_Element_insert__doc__},
static PyObject *
_elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,
@ -466,7 +466,7 @@ PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
{"makeelement", (PyCFunction)_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__},
{"makeelement", (PyCFunction)(void(*)(void))_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__},
static PyObject *
_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
@ -522,7 +522,7 @@ PyDoc_STRVAR(_elementtree_Element_set__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_SET_METHODDEF \
{"set", (PyCFunction)_elementtree_Element_set, METH_FASTCALL, _elementtree_Element_set__doc__},
{"set", (PyCFunction)(void(*)(void))_elementtree_Element_set, METH_FASTCALL, _elementtree_Element_set__doc__},
static PyObject *
_elementtree_Element_set_impl(ElementObject *self, PyObject *key,
@ -607,7 +607,7 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
"\n");
#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
{"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
{"start", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
static PyObject *
_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
@ -693,7 +693,7 @@ PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
"\n");
#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
{"_setevents", (PyCFunction)_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
{"_setevents", (PyCFunction)(void(*)(void))_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
static PyObject *
_elementtree_XMLParser__setevents_impl(XMLParserObject *self,
@ -717,4 +717,4 @@ _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *const *args,
exit:
return return_value;
}
/*[clinic end generated code: output=1bff22415aabb78b input=a9049054013a1b77]*/
/*[clinic end generated code: output=f1efdb511a5b027b input=a9049054013a1b77]*/

8
Modules/clinic/_gdbmmodule.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(_gdbm_gdbm_get__doc__,
"Get the value for key, or default if not present.");
#define _GDBM_GDBM_GET_METHODDEF \
{"get", (PyCFunction)_gdbm_gdbm_get, METH_FASTCALL, _gdbm_gdbm_get__doc__},
{"get", (PyCFunction)(void(*)(void))_gdbm_gdbm_get, METH_FASTCALL, _gdbm_gdbm_get__doc__},
static PyObject *
_gdbm_gdbm_get_impl(dbmobject *self, PyObject *key, PyObject *default_value);
@ -39,7 +39,7 @@ PyDoc_STRVAR(_gdbm_gdbm_setdefault__doc__,
"Get value for key, or set it to default and return default if not present.");
#define _GDBM_GDBM_SETDEFAULT_METHODDEF \
{"setdefault", (PyCFunction)_gdbm_gdbm_setdefault, METH_FASTCALL, _gdbm_gdbm_setdefault__doc__},
{"setdefault", (PyCFunction)(void(*)(void))_gdbm_gdbm_setdefault, METH_FASTCALL, _gdbm_gdbm_setdefault__doc__},
static PyObject *
_gdbm_gdbm_setdefault_impl(dbmobject *self, PyObject *key,
@ -231,7 +231,7 @@ PyDoc_STRVAR(dbmopen__doc__,
"when the database has to be created. It defaults to octal 0o666.");
#define DBMOPEN_METHODDEF \
{"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
{"open", (PyCFunction)(void(*)(void))dbmopen, METH_FASTCALL, dbmopen__doc__},
static PyObject *
dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
@ -254,4 +254,4 @@ dbmopen(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
/*[clinic end generated code: output=dec05ff9c5aeaeae input=a9049054013a1b77]*/
/*[clinic end generated code: output=5ca4361417bf96cb input=a9049054013a1b77]*/

6
Modules/clinic/_hashopenssl.c.h generated
View file

@ -12,7 +12,7 @@ PyDoc_STRVAR(_hashlib_scrypt__doc__,
"scrypt password-based key derivation function.");
#define _HASHLIB_SCRYPT_METHODDEF \
{"scrypt", (PyCFunction)_hashlib_scrypt, METH_FASTCALL|METH_KEYWORDS, _hashlib_scrypt__doc__},
{"scrypt", (PyCFunction)(void(*)(void))_hashlib_scrypt, METH_FASTCALL|METH_KEYWORDS, _hashlib_scrypt__doc__},
static PyObject *
_hashlib_scrypt_impl(PyObject *module, Py_buffer *password, Py_buffer *salt,
@ -61,7 +61,7 @@ PyDoc_STRVAR(_hashlib_hmac_digest__doc__,
"Single-shot HMAC.");
#define _HASHLIB_HMAC_DIGEST_METHODDEF \
{"hmac_digest", (PyCFunction)_hashlib_hmac_digest, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_digest__doc__},
{"hmac_digest", (PyCFunction)(void(*)(void))_hashlib_hmac_digest, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_digest__doc__},
static PyObject *
_hashlib_hmac_digest_impl(PyObject *module, Py_buffer *key, Py_buffer *msg,
@ -99,4 +99,4 @@ exit:
#ifndef _HASHLIB_SCRYPT_METHODDEF
#define _HASHLIB_SCRYPT_METHODDEF
#endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */
/*[clinic end generated code: output=b129f1a6ec7b8503 input=a9049054013a1b77]*/
/*[clinic end generated code: output=acf668396f59f2b6 input=a9049054013a1b77]*/

10
Modules/clinic/_heapqmodule.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(_heapq_heappush__doc__,
"Push item onto heap, maintaining the heap invariant.");
#define _HEAPQ_HEAPPUSH_METHODDEF \
{"heappush", (PyCFunction)_heapq_heappush, METH_FASTCALL, _heapq_heappush__doc__},
{"heappush", (PyCFunction)(void(*)(void))_heapq_heappush, METH_FASTCALL, _heapq_heappush__doc__},
static PyObject *
_heapq_heappush_impl(PyObject *module, PyObject *heap, PyObject *item);
@ -56,7 +56,7 @@ PyDoc_STRVAR(_heapq_heapreplace__doc__,
" item = heapreplace(heap, item)");
#define _HEAPQ_HEAPREPLACE_METHODDEF \
{"heapreplace", (PyCFunction)_heapq_heapreplace, METH_FASTCALL, _heapq_heapreplace__doc__},
{"heapreplace", (PyCFunction)(void(*)(void))_heapq_heapreplace, METH_FASTCALL, _heapq_heapreplace__doc__},
static PyObject *
_heapq_heapreplace_impl(PyObject *module, PyObject *heap, PyObject *item);
@ -89,7 +89,7 @@ PyDoc_STRVAR(_heapq_heappushpop__doc__,
"a separate call to heappop().");
#define _HEAPQ_HEAPPUSHPOP_METHODDEF \
{"heappushpop", (PyCFunction)_heapq_heappushpop, METH_FASTCALL, _heapq_heappushpop__doc__},
{"heappushpop", (PyCFunction)(void(*)(void))_heapq_heappushpop, METH_FASTCALL, _heapq_heappushpop__doc__},
static PyObject *
_heapq_heappushpop_impl(PyObject *module, PyObject *heap, PyObject *item);
@ -137,7 +137,7 @@ PyDoc_STRVAR(_heapq__heapreplace_max__doc__,
"Maxheap variant of heapreplace.");
#define _HEAPQ__HEAPREPLACE_MAX_METHODDEF \
{"_heapreplace_max", (PyCFunction)_heapq__heapreplace_max, METH_FASTCALL, _heapq__heapreplace_max__doc__},
{"_heapreplace_max", (PyCFunction)(void(*)(void))_heapq__heapreplace_max, METH_FASTCALL, _heapq__heapreplace_max__doc__},
static PyObject *
_heapq__heapreplace_max_impl(PyObject *module, PyObject *heap,
@ -169,4 +169,4 @@ PyDoc_STRVAR(_heapq__heapify_max__doc__,
#define _HEAPQ__HEAPIFY_MAX_METHODDEF \
{"_heapify_max", (PyCFunction)_heapq__heapify_max, METH_O, _heapq__heapify_max__doc__},
/*[clinic end generated code: output=0bb0dd0df473ab14 input=a9049054013a1b77]*/
/*[clinic end generated code: output=b73e874eeb9977b6 input=a9049054013a1b77]*/

6
Modules/clinic/_lzmamodule.c.h generated
View file

@ -81,7 +81,7 @@ PyDoc_STRVAR(_lzma_LZMADecompressor_decompress__doc__,
"the unused_data attribute.");
#define _LZMA_LZMADECOMPRESSOR_DECOMPRESS_METHODDEF \
{"decompress", (PyCFunction)_lzma_LZMADecompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _lzma_LZMADecompressor_decompress__doc__},
{"decompress", (PyCFunction)(void(*)(void))_lzma_LZMADecompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _lzma_LZMADecompressor_decompress__doc__},
static PyObject *
_lzma_LZMADecompressor_decompress_impl(Decompressor *self, Py_buffer *data,
@ -229,7 +229,7 @@ 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_FASTCALL, _lzma__decode_filter_properties__doc__},
{"_decode_filter_properties", (PyCFunction)(void(*)(void))_lzma__decode_filter_properties, METH_FASTCALL, _lzma__decode_filter_properties__doc__},
static PyObject *
_lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
@ -256,4 +256,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=38c2d52362bf3712 input=a9049054013a1b77]*/
/*[clinic end generated code: output=2acfd7c4b68530a6 input=a9049054013a1b77]*/

4
Modules/clinic/_opcode.c.h generated
View file

@ -9,7 +9,7 @@ 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_FASTCALL|METH_KEYWORDS, _opcode_stack_effect__doc__},
{"stack_effect", (PyCFunction)(void(*)(void))_opcode_stack_effect, METH_FASTCALL|METH_KEYWORDS, _opcode_stack_effect__doc__},
static int
_opcode_stack_effect_impl(PyObject *module, int opcode, PyObject *oparg,
@ -39,4 +39,4 @@ _opcode_stack_effect(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
/*[clinic end generated code: output=bbf6c4cfc91edc29 input=a9049054013a1b77]*/
/*[clinic end generated code: output=871941eea3d855c6 input=a9049054013a1b77]*/

90
Modules/clinic/_operator.c.h generated
View file

@ -37,7 +37,7 @@ PyDoc_STRVAR(_operator_add__doc__,
"Same as a + b.");
#define _OPERATOR_ADD_METHODDEF \
{"add", (PyCFunction)_operator_add, METH_FASTCALL, _operator_add__doc__},
{"add", (PyCFunction)(void(*)(void))_operator_add, METH_FASTCALL, _operator_add__doc__},
static PyObject *
_operator_add_impl(PyObject *module, PyObject *a, PyObject *b);
@ -67,7 +67,7 @@ PyDoc_STRVAR(_operator_sub__doc__,
"Same as a - b.");
#define _OPERATOR_SUB_METHODDEF \
{"sub", (PyCFunction)_operator_sub, METH_FASTCALL, _operator_sub__doc__},
{"sub", (PyCFunction)(void(*)(void))_operator_sub, METH_FASTCALL, _operator_sub__doc__},
static PyObject *
_operator_sub_impl(PyObject *module, PyObject *a, PyObject *b);
@ -97,7 +97,7 @@ PyDoc_STRVAR(_operator_mul__doc__,
"Same as a * b.");
#define _OPERATOR_MUL_METHODDEF \
{"mul", (PyCFunction)_operator_mul, METH_FASTCALL, _operator_mul__doc__},
{"mul", (PyCFunction)(void(*)(void))_operator_mul, METH_FASTCALL, _operator_mul__doc__},
static PyObject *
_operator_mul_impl(PyObject *module, PyObject *a, PyObject *b);
@ -127,7 +127,7 @@ PyDoc_STRVAR(_operator_matmul__doc__,
"Same as a @ b.");
#define _OPERATOR_MATMUL_METHODDEF \
{"matmul", (PyCFunction)_operator_matmul, METH_FASTCALL, _operator_matmul__doc__},
{"matmul", (PyCFunction)(void(*)(void))_operator_matmul, METH_FASTCALL, _operator_matmul__doc__},
static PyObject *
_operator_matmul_impl(PyObject *module, PyObject *a, PyObject *b);
@ -157,7 +157,7 @@ PyDoc_STRVAR(_operator_floordiv__doc__,
"Same as a // b.");
#define _OPERATOR_FLOORDIV_METHODDEF \
{"floordiv", (PyCFunction)_operator_floordiv, METH_FASTCALL, _operator_floordiv__doc__},
{"floordiv", (PyCFunction)(void(*)(void))_operator_floordiv, METH_FASTCALL, _operator_floordiv__doc__},
static PyObject *
_operator_floordiv_impl(PyObject *module, PyObject *a, PyObject *b);
@ -187,7 +187,7 @@ PyDoc_STRVAR(_operator_truediv__doc__,
"Same as a / b.");
#define _OPERATOR_TRUEDIV_METHODDEF \
{"truediv", (PyCFunction)_operator_truediv, METH_FASTCALL, _operator_truediv__doc__},
{"truediv", (PyCFunction)(void(*)(void))_operator_truediv, METH_FASTCALL, _operator_truediv__doc__},
static PyObject *
_operator_truediv_impl(PyObject *module, PyObject *a, PyObject *b);
@ -217,7 +217,7 @@ PyDoc_STRVAR(_operator_mod__doc__,
"Same as a % b.");
#define _OPERATOR_MOD_METHODDEF \
{"mod", (PyCFunction)_operator_mod, METH_FASTCALL, _operator_mod__doc__},
{"mod", (PyCFunction)(void(*)(void))_operator_mod, METH_FASTCALL, _operator_mod__doc__},
static PyObject *
_operator_mod_impl(PyObject *module, PyObject *a, PyObject *b);
@ -292,7 +292,7 @@ PyDoc_STRVAR(_operator_lshift__doc__,
"Same as a << b.");
#define _OPERATOR_LSHIFT_METHODDEF \
{"lshift", (PyCFunction)_operator_lshift, METH_FASTCALL, _operator_lshift__doc__},
{"lshift", (PyCFunction)(void(*)(void))_operator_lshift, METH_FASTCALL, _operator_lshift__doc__},
static PyObject *
_operator_lshift_impl(PyObject *module, PyObject *a, PyObject *b);
@ -322,7 +322,7 @@ PyDoc_STRVAR(_operator_rshift__doc__,
"Same as a >> b.");
#define _OPERATOR_RSHIFT_METHODDEF \
{"rshift", (PyCFunction)_operator_rshift, METH_FASTCALL, _operator_rshift__doc__},
{"rshift", (PyCFunction)(void(*)(void))_operator_rshift, METH_FASTCALL, _operator_rshift__doc__},
static PyObject *
_operator_rshift_impl(PyObject *module, PyObject *a, PyObject *b);
@ -380,7 +380,7 @@ PyDoc_STRVAR(_operator_and___doc__,
"Same as a & b.");
#define _OPERATOR_AND__METHODDEF \
{"and_", (PyCFunction)_operator_and_, METH_FASTCALL, _operator_and___doc__},
{"and_", (PyCFunction)(void(*)(void))_operator_and_, METH_FASTCALL, _operator_and___doc__},
static PyObject *
_operator_and__impl(PyObject *module, PyObject *a, PyObject *b);
@ -410,7 +410,7 @@ PyDoc_STRVAR(_operator_xor__doc__,
"Same as a ^ b.");
#define _OPERATOR_XOR_METHODDEF \
{"xor", (PyCFunction)_operator_xor, METH_FASTCALL, _operator_xor__doc__},
{"xor", (PyCFunction)(void(*)(void))_operator_xor, METH_FASTCALL, _operator_xor__doc__},
static PyObject *
_operator_xor_impl(PyObject *module, PyObject *a, PyObject *b);
@ -440,7 +440,7 @@ PyDoc_STRVAR(_operator_or___doc__,
"Same as a | b.");
#define _OPERATOR_OR__METHODDEF \
{"or_", (PyCFunction)_operator_or_, METH_FASTCALL, _operator_or___doc__},
{"or_", (PyCFunction)(void(*)(void))_operator_or_, METH_FASTCALL, _operator_or___doc__},
static PyObject *
_operator_or__impl(PyObject *module, PyObject *a, PyObject *b);
@ -470,7 +470,7 @@ PyDoc_STRVAR(_operator_iadd__doc__,
"Same as a += b.");
#define _OPERATOR_IADD_METHODDEF \
{"iadd", (PyCFunction)_operator_iadd, METH_FASTCALL, _operator_iadd__doc__},
{"iadd", (PyCFunction)(void(*)(void))_operator_iadd, METH_FASTCALL, _operator_iadd__doc__},
static PyObject *
_operator_iadd_impl(PyObject *module, PyObject *a, PyObject *b);
@ -500,7 +500,7 @@ PyDoc_STRVAR(_operator_isub__doc__,
"Same as a -= b.");
#define _OPERATOR_ISUB_METHODDEF \
{"isub", (PyCFunction)_operator_isub, METH_FASTCALL, _operator_isub__doc__},
{"isub", (PyCFunction)(void(*)(void))_operator_isub, METH_FASTCALL, _operator_isub__doc__},
static PyObject *
_operator_isub_impl(PyObject *module, PyObject *a, PyObject *b);
@ -530,7 +530,7 @@ PyDoc_STRVAR(_operator_imul__doc__,
"Same as a *= b.");
#define _OPERATOR_IMUL_METHODDEF \
{"imul", (PyCFunction)_operator_imul, METH_FASTCALL, _operator_imul__doc__},
{"imul", (PyCFunction)(void(*)(void))_operator_imul, METH_FASTCALL, _operator_imul__doc__},
static PyObject *
_operator_imul_impl(PyObject *module, PyObject *a, PyObject *b);
@ -560,7 +560,7 @@ PyDoc_STRVAR(_operator_imatmul__doc__,
"Same as a @= b.");
#define _OPERATOR_IMATMUL_METHODDEF \
{"imatmul", (PyCFunction)_operator_imatmul, METH_FASTCALL, _operator_imatmul__doc__},
{"imatmul", (PyCFunction)(void(*)(void))_operator_imatmul, METH_FASTCALL, _operator_imatmul__doc__},
static PyObject *
_operator_imatmul_impl(PyObject *module, PyObject *a, PyObject *b);
@ -590,7 +590,7 @@ PyDoc_STRVAR(_operator_ifloordiv__doc__,
"Same as a //= b.");
#define _OPERATOR_IFLOORDIV_METHODDEF \
{"ifloordiv", (PyCFunction)_operator_ifloordiv, METH_FASTCALL, _operator_ifloordiv__doc__},
{"ifloordiv", (PyCFunction)(void(*)(void))_operator_ifloordiv, METH_FASTCALL, _operator_ifloordiv__doc__},
static PyObject *
_operator_ifloordiv_impl(PyObject *module, PyObject *a, PyObject *b);
@ -620,7 +620,7 @@ PyDoc_STRVAR(_operator_itruediv__doc__,
"Same as a /= b.");
#define _OPERATOR_ITRUEDIV_METHODDEF \
{"itruediv", (PyCFunction)_operator_itruediv, METH_FASTCALL, _operator_itruediv__doc__},
{"itruediv", (PyCFunction)(void(*)(void))_operator_itruediv, METH_FASTCALL, _operator_itruediv__doc__},
static PyObject *
_operator_itruediv_impl(PyObject *module, PyObject *a, PyObject *b);
@ -650,7 +650,7 @@ PyDoc_STRVAR(_operator_imod__doc__,
"Same as a %= b.");
#define _OPERATOR_IMOD_METHODDEF \
{"imod", (PyCFunction)_operator_imod, METH_FASTCALL, _operator_imod__doc__},
{"imod", (PyCFunction)(void(*)(void))_operator_imod, METH_FASTCALL, _operator_imod__doc__},
static PyObject *
_operator_imod_impl(PyObject *module, PyObject *a, PyObject *b);
@ -680,7 +680,7 @@ PyDoc_STRVAR(_operator_ilshift__doc__,
"Same as a <<= b.");
#define _OPERATOR_ILSHIFT_METHODDEF \
{"ilshift", (PyCFunction)_operator_ilshift, METH_FASTCALL, _operator_ilshift__doc__},
{"ilshift", (PyCFunction)(void(*)(void))_operator_ilshift, METH_FASTCALL, _operator_ilshift__doc__},
static PyObject *
_operator_ilshift_impl(PyObject *module, PyObject *a, PyObject *b);
@ -710,7 +710,7 @@ PyDoc_STRVAR(_operator_irshift__doc__,
"Same as a >>= b.");
#define _OPERATOR_IRSHIFT_METHODDEF \
{"irshift", (PyCFunction)_operator_irshift, METH_FASTCALL, _operator_irshift__doc__},
{"irshift", (PyCFunction)(void(*)(void))_operator_irshift, METH_FASTCALL, _operator_irshift__doc__},
static PyObject *
_operator_irshift_impl(PyObject *module, PyObject *a, PyObject *b);
@ -740,7 +740,7 @@ PyDoc_STRVAR(_operator_iand__doc__,
"Same as a &= b.");
#define _OPERATOR_IAND_METHODDEF \
{"iand", (PyCFunction)_operator_iand, METH_FASTCALL, _operator_iand__doc__},
{"iand", (PyCFunction)(void(*)(void))_operator_iand, METH_FASTCALL, _operator_iand__doc__},
static PyObject *
_operator_iand_impl(PyObject *module, PyObject *a, PyObject *b);
@ -770,7 +770,7 @@ PyDoc_STRVAR(_operator_ixor__doc__,
"Same as a ^= b.");
#define _OPERATOR_IXOR_METHODDEF \
{"ixor", (PyCFunction)_operator_ixor, METH_FASTCALL, _operator_ixor__doc__},
{"ixor", (PyCFunction)(void(*)(void))_operator_ixor, METH_FASTCALL, _operator_ixor__doc__},
static PyObject *
_operator_ixor_impl(PyObject *module, PyObject *a, PyObject *b);
@ -800,7 +800,7 @@ PyDoc_STRVAR(_operator_ior__doc__,
"Same as a |= b.");
#define _OPERATOR_IOR_METHODDEF \
{"ior", (PyCFunction)_operator_ior, METH_FASTCALL, _operator_ior__doc__},
{"ior", (PyCFunction)(void(*)(void))_operator_ior, METH_FASTCALL, _operator_ior__doc__},
static PyObject *
_operator_ior_impl(PyObject *module, PyObject *a, PyObject *b);
@ -830,7 +830,7 @@ PyDoc_STRVAR(_operator_concat__doc__,
"Same as a + b, for a and b sequences.");
#define _OPERATOR_CONCAT_METHODDEF \
{"concat", (PyCFunction)_operator_concat, METH_FASTCALL, _operator_concat__doc__},
{"concat", (PyCFunction)(void(*)(void))_operator_concat, METH_FASTCALL, _operator_concat__doc__},
static PyObject *
_operator_concat_impl(PyObject *module, PyObject *a, PyObject *b);
@ -860,7 +860,7 @@ PyDoc_STRVAR(_operator_iconcat__doc__,
"Same as a += b, for a and b sequences.");
#define _OPERATOR_ICONCAT_METHODDEF \
{"iconcat", (PyCFunction)_operator_iconcat, METH_FASTCALL, _operator_iconcat__doc__},
{"iconcat", (PyCFunction)(void(*)(void))_operator_iconcat, METH_FASTCALL, _operator_iconcat__doc__},
static PyObject *
_operator_iconcat_impl(PyObject *module, PyObject *a, PyObject *b);
@ -890,7 +890,7 @@ PyDoc_STRVAR(_operator_contains__doc__,
"Same as b in a (note reversed operands).");
#define _OPERATOR_CONTAINS_METHODDEF \
{"contains", (PyCFunction)_operator_contains, METH_FASTCALL, _operator_contains__doc__},
{"contains", (PyCFunction)(void(*)(void))_operator_contains, METH_FASTCALL, _operator_contains__doc__},
static int
_operator_contains_impl(PyObject *module, PyObject *a, PyObject *b);
@ -925,7 +925,7 @@ PyDoc_STRVAR(_operator_indexOf__doc__,
"Return the first index of b in a.");
#define _OPERATOR_INDEXOF_METHODDEF \
{"indexOf", (PyCFunction)_operator_indexOf, METH_FASTCALL, _operator_indexOf__doc__},
{"indexOf", (PyCFunction)(void(*)(void))_operator_indexOf, METH_FASTCALL, _operator_indexOf__doc__},
static Py_ssize_t
_operator_indexOf_impl(PyObject *module, PyObject *a, PyObject *b);
@ -960,7 +960,7 @@ PyDoc_STRVAR(_operator_countOf__doc__,
"Return the number of times b occurs in a.");
#define _OPERATOR_COUNTOF_METHODDEF \
{"countOf", (PyCFunction)_operator_countOf, METH_FASTCALL, _operator_countOf__doc__},
{"countOf", (PyCFunction)(void(*)(void))_operator_countOf, METH_FASTCALL, _operator_countOf__doc__},
static Py_ssize_t
_operator_countOf_impl(PyObject *module, PyObject *a, PyObject *b);
@ -995,7 +995,7 @@ PyDoc_STRVAR(_operator_getitem__doc__,
"Same as a[b].");
#define _OPERATOR_GETITEM_METHODDEF \
{"getitem", (PyCFunction)_operator_getitem, METH_FASTCALL, _operator_getitem__doc__},
{"getitem", (PyCFunction)(void(*)(void))_operator_getitem, METH_FASTCALL, _operator_getitem__doc__},
static PyObject *
_operator_getitem_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1025,7 +1025,7 @@ PyDoc_STRVAR(_operator_setitem__doc__,
"Same as a[b] = c.");
#define _OPERATOR_SETITEM_METHODDEF \
{"setitem", (PyCFunction)_operator_setitem, METH_FASTCALL, _operator_setitem__doc__},
{"setitem", (PyCFunction)(void(*)(void))_operator_setitem, METH_FASTCALL, _operator_setitem__doc__},
static PyObject *
_operator_setitem_impl(PyObject *module, PyObject *a, PyObject *b,
@ -1057,7 +1057,7 @@ PyDoc_STRVAR(_operator_delitem__doc__,
"Same as del a[b].");
#define _OPERATOR_DELITEM_METHODDEF \
{"delitem", (PyCFunction)_operator_delitem, METH_FASTCALL, _operator_delitem__doc__},
{"delitem", (PyCFunction)(void(*)(void))_operator_delitem, METH_FASTCALL, _operator_delitem__doc__},
static PyObject *
_operator_delitem_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1087,7 +1087,7 @@ PyDoc_STRVAR(_operator_eq__doc__,
"Same as a == b.");
#define _OPERATOR_EQ_METHODDEF \
{"eq", (PyCFunction)_operator_eq, METH_FASTCALL, _operator_eq__doc__},
{"eq", (PyCFunction)(void(*)(void))_operator_eq, METH_FASTCALL, _operator_eq__doc__},
static PyObject *
_operator_eq_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1117,7 +1117,7 @@ PyDoc_STRVAR(_operator_ne__doc__,
"Same as a != b.");
#define _OPERATOR_NE_METHODDEF \
{"ne", (PyCFunction)_operator_ne, METH_FASTCALL, _operator_ne__doc__},
{"ne", (PyCFunction)(void(*)(void))_operator_ne, METH_FASTCALL, _operator_ne__doc__},
static PyObject *
_operator_ne_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1147,7 +1147,7 @@ PyDoc_STRVAR(_operator_lt__doc__,
"Same as a < b.");
#define _OPERATOR_LT_METHODDEF \
{"lt", (PyCFunction)_operator_lt, METH_FASTCALL, _operator_lt__doc__},
{"lt", (PyCFunction)(void(*)(void))_operator_lt, METH_FASTCALL, _operator_lt__doc__},
static PyObject *
_operator_lt_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1177,7 +1177,7 @@ PyDoc_STRVAR(_operator_le__doc__,
"Same as a <= b.");
#define _OPERATOR_LE_METHODDEF \
{"le", (PyCFunction)_operator_le, METH_FASTCALL, _operator_le__doc__},
{"le", (PyCFunction)(void(*)(void))_operator_le, METH_FASTCALL, _operator_le__doc__},
static PyObject *
_operator_le_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1207,7 +1207,7 @@ PyDoc_STRVAR(_operator_gt__doc__,
"Same as a > b.");
#define _OPERATOR_GT_METHODDEF \
{"gt", (PyCFunction)_operator_gt, METH_FASTCALL, _operator_gt__doc__},
{"gt", (PyCFunction)(void(*)(void))_operator_gt, METH_FASTCALL, _operator_gt__doc__},
static PyObject *
_operator_gt_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1237,7 +1237,7 @@ PyDoc_STRVAR(_operator_ge__doc__,
"Same as a >= b.");
#define _OPERATOR_GE_METHODDEF \
{"ge", (PyCFunction)_operator_ge, METH_FASTCALL, _operator_ge__doc__},
{"ge", (PyCFunction)(void(*)(void))_operator_ge, METH_FASTCALL, _operator_ge__doc__},
static PyObject *
_operator_ge_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1267,7 +1267,7 @@ PyDoc_STRVAR(_operator_pow__doc__,
"Same as a ** b.");
#define _OPERATOR_POW_METHODDEF \
{"pow", (PyCFunction)_operator_pow, METH_FASTCALL, _operator_pow__doc__},
{"pow", (PyCFunction)(void(*)(void))_operator_pow, METH_FASTCALL, _operator_pow__doc__},
static PyObject *
_operator_pow_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1297,7 +1297,7 @@ PyDoc_STRVAR(_operator_ipow__doc__,
"Same as a **= b.");
#define _OPERATOR_IPOW_METHODDEF \
{"ipow", (PyCFunction)_operator_ipow, METH_FASTCALL, _operator_ipow__doc__},
{"ipow", (PyCFunction)(void(*)(void))_operator_ipow, METH_FASTCALL, _operator_ipow__doc__},
static PyObject *
_operator_ipow_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1336,7 +1336,7 @@ PyDoc_STRVAR(_operator_is___doc__,
"Same as a is b.");
#define _OPERATOR_IS__METHODDEF \
{"is_", (PyCFunction)_operator_is_, METH_FASTCALL, _operator_is___doc__},
{"is_", (PyCFunction)(void(*)(void))_operator_is_, METH_FASTCALL, _operator_is___doc__},
static PyObject *
_operator_is__impl(PyObject *module, PyObject *a, PyObject *b);
@ -1366,7 +1366,7 @@ PyDoc_STRVAR(_operator_is_not__doc__,
"Same as a is not b.");
#define _OPERATOR_IS_NOT_METHODDEF \
{"is_not", (PyCFunction)_operator_is_not, METH_FASTCALL, _operator_is_not__doc__},
{"is_not", (PyCFunction)(void(*)(void))_operator_is_not, METH_FASTCALL, _operator_is_not__doc__},
static PyObject *
_operator_is_not_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1402,7 +1402,7 @@ PyDoc_STRVAR(_operator_length_hint__doc__,
"The result will be an integer >= 0.");
#define _OPERATOR_LENGTH_HINT_METHODDEF \
{"length_hint", (PyCFunction)_operator_length_hint, METH_FASTCALL, _operator_length_hint__doc__},
{"length_hint", (PyCFunction)(void(*)(void))_operator_length_hint, METH_FASTCALL, _operator_length_hint__doc__},
static Py_ssize_t
_operator_length_hint_impl(PyObject *module, PyObject *obj,
@ -1447,7 +1447,7 @@ PyDoc_STRVAR(_operator__compare_digest__doc__,
"types and lengths of a and b--but not their values.");
#define _OPERATOR__COMPARE_DIGEST_METHODDEF \
{"_compare_digest", (PyCFunction)_operator__compare_digest, METH_FASTCALL, _operator__compare_digest__doc__},
{"_compare_digest", (PyCFunction)(void(*)(void))_operator__compare_digest, METH_FASTCALL, _operator__compare_digest__doc__},
static PyObject *
_operator__compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
@ -1469,4 +1469,4 @@ _operator__compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t na
exit:
return return_value;
}
/*[clinic end generated code: output=d840f7ea76af2372 input=a9049054013a1b77]*/
/*[clinic end generated code: output=424b884884ab20b7 input=a9049054013a1b77]*/

12
Modules/clinic/_pickle.c.h generated
View file

@ -199,7 +199,7 @@ PyDoc_STRVAR(_pickle_Unpickler_find_class__doc__,
"needed. Both arguments passed are str objects.");
#define _PICKLE_UNPICKLER_FIND_CLASS_METHODDEF \
{"find_class", (PyCFunction)_pickle_Unpickler_find_class, METH_FASTCALL, _pickle_Unpickler_find_class__doc__},
{"find_class", (PyCFunction)(void(*)(void))_pickle_Unpickler_find_class, METH_FASTCALL, _pickle_Unpickler_find_class__doc__},
static PyObject *
_pickle_Unpickler_find_class_impl(UnpicklerObject *self,
@ -385,7 +385,7 @@ PyDoc_STRVAR(_pickle_dump__doc__,
"2, so that the pickle data stream is readable with Python 2.");
#define _PICKLE_DUMP_METHODDEF \
{"dump", (PyCFunction)_pickle_dump, METH_FASTCALL|METH_KEYWORDS, _pickle_dump__doc__},
{"dump", (PyCFunction)(void(*)(void))_pickle_dump, METH_FASTCALL|METH_KEYWORDS, _pickle_dump__doc__},
static PyObject *
_pickle_dump_impl(PyObject *module, PyObject *obj, PyObject *file,
@ -432,7 +432,7 @@ PyDoc_STRVAR(_pickle_dumps__doc__,
"Python 2, so that the pickle data stream is readable with Python 2.");
#define _PICKLE_DUMPS_METHODDEF \
{"dumps", (PyCFunction)_pickle_dumps, METH_FASTCALL|METH_KEYWORDS, _pickle_dumps__doc__},
{"dumps", (PyCFunction)(void(*)(void))_pickle_dumps, METH_FASTCALL|METH_KEYWORDS, _pickle_dumps__doc__},
static PyObject *
_pickle_dumps_impl(PyObject *module, PyObject *obj, PyObject *protocol,
@ -488,7 +488,7 @@ PyDoc_STRVAR(_pickle_load__doc__,
"string instances as bytes objects.");
#define _PICKLE_LOAD_METHODDEF \
{"load", (PyCFunction)_pickle_load, METH_FASTCALL|METH_KEYWORDS, _pickle_load__doc__},
{"load", (PyCFunction)(void(*)(void))_pickle_load, METH_FASTCALL|METH_KEYWORDS, _pickle_load__doc__},
static PyObject *
_pickle_load_impl(PyObject *module, PyObject *file, int fix_imports,
@ -536,7 +536,7 @@ PyDoc_STRVAR(_pickle_loads__doc__,
"string instances as bytes objects.");
#define _PICKLE_LOADS_METHODDEF \
{"loads", (PyCFunction)_pickle_loads, METH_FASTCALL|METH_KEYWORDS, _pickle_loads__doc__},
{"loads", (PyCFunction)(void(*)(void))_pickle_loads, METH_FASTCALL|METH_KEYWORDS, _pickle_loads__doc__},
static PyObject *
_pickle_loads_impl(PyObject *module, PyObject *data, int fix_imports,
@ -562,4 +562,4 @@ _pickle_loads(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec
exit:
return return_value;
}
/*[clinic end generated code: output=6fc104b8299c82dd input=a9049054013a1b77]*/
/*[clinic end generated code: output=4b32d63ff58b64d8 input=a9049054013a1b77]*/

8
Modules/clinic/_queuemodule.c.h generated
View file

@ -40,7 +40,7 @@ PyDoc_STRVAR(_queue_SimpleQueue_put__doc__,
"never blocks. They are provided for compatibility with the Queue class.");
#define _QUEUE_SIMPLEQUEUE_PUT_METHODDEF \
{"put", (PyCFunction)_queue_SimpleQueue_put, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put__doc__},
{"put", (PyCFunction)(void(*)(void))_queue_SimpleQueue_put, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put__doc__},
static PyObject *
_queue_SimpleQueue_put_impl(simplequeueobject *self, PyObject *item,
@ -76,7 +76,7 @@ PyDoc_STRVAR(_queue_SimpleQueue_put_nowait__doc__,
"for compatibility with the Queue class.");
#define _QUEUE_SIMPLEQUEUE_PUT_NOWAIT_METHODDEF \
{"put_nowait", (PyCFunction)_queue_SimpleQueue_put_nowait, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put_nowait__doc__},
{"put_nowait", (PyCFunction)(void(*)(void))_queue_SimpleQueue_put_nowait, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put_nowait__doc__},
static PyObject *
_queue_SimpleQueue_put_nowait_impl(simplequeueobject *self, PyObject *item);
@ -114,7 +114,7 @@ PyDoc_STRVAR(_queue_SimpleQueue_get__doc__,
"in that case).");
#define _QUEUE_SIMPLEQUEUE_GET_METHODDEF \
{"get", (PyCFunction)_queue_SimpleQueue_get, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_get__doc__},
{"get", (PyCFunction)(void(*)(void))_queue_SimpleQueue_get, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_get__doc__},
static PyObject *
_queue_SimpleQueue_get_impl(simplequeueobject *self, int block,
@ -215,4 +215,4 @@ _queue_SimpleQueue_qsize(simplequeueobject *self, PyObject *Py_UNUSED(ignored))
exit:
return return_value;
}
/*[clinic end generated code: output=8badc3bb85263689 input=a9049054013a1b77]*/
/*[clinic end generated code: output=c12ce9050f153304 input=a9049054013a1b77]*/

34
Modules/clinic/_sre.c.h generated
View file

@ -160,7 +160,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_match__doc__,
"Matches zero or more characters at the beginning of the string.");
#define _SRE_SRE_PATTERN_MATCH_METHODDEF \
{"match", (PyCFunction)_sre_SRE_Pattern_match, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_match__doc__},
{"match", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_match, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_match__doc__},
static PyObject *
_sre_SRE_Pattern_match_impl(PatternObject *self, PyObject *string,
@ -193,7 +193,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_fullmatch__doc__,
"Matches against all of the string.");
#define _SRE_SRE_PATTERN_FULLMATCH_METHODDEF \
{"fullmatch", (PyCFunction)_sre_SRE_Pattern_fullmatch, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_fullmatch__doc__},
{"fullmatch", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_fullmatch, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_fullmatch__doc__},
static PyObject *
_sre_SRE_Pattern_fullmatch_impl(PatternObject *self, PyObject *string,
@ -228,7 +228,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_search__doc__,
"Return None if no position in the string matches.");
#define _SRE_SRE_PATTERN_SEARCH_METHODDEF \
{"search", (PyCFunction)_sre_SRE_Pattern_search, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_search__doc__},
{"search", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_search, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_search__doc__},
static PyObject *
_sre_SRE_Pattern_search_impl(PatternObject *self, PyObject *string,
@ -261,7 +261,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_findall__doc__,
"Return a list of all non-overlapping matches of pattern in string.");
#define _SRE_SRE_PATTERN_FINDALL_METHODDEF \
{"findall", (PyCFunction)_sre_SRE_Pattern_findall, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_findall__doc__},
{"findall", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_findall, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_findall__doc__},
static PyObject *
_sre_SRE_Pattern_findall_impl(PatternObject *self, PyObject *string,
@ -296,7 +296,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_finditer__doc__,
"For each match, the iterator returns a match object.");
#define _SRE_SRE_PATTERN_FINDITER_METHODDEF \
{"finditer", (PyCFunction)_sre_SRE_Pattern_finditer, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_finditer__doc__},
{"finditer", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_finditer, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_finditer__doc__},
static PyObject *
_sre_SRE_Pattern_finditer_impl(PatternObject *self, PyObject *string,
@ -328,7 +328,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_scanner__doc__,
"\n");
#define _SRE_SRE_PATTERN_SCANNER_METHODDEF \
{"scanner", (PyCFunction)_sre_SRE_Pattern_scanner, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_scanner__doc__},
{"scanner", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_scanner, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_scanner__doc__},
static PyObject *
_sre_SRE_Pattern_scanner_impl(PatternObject *self, PyObject *string,
@ -361,7 +361,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_split__doc__,
"Split string by the occurrences of pattern.");
#define _SRE_SRE_PATTERN_SPLIT_METHODDEF \
{"split", (PyCFunction)_sre_SRE_Pattern_split, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_split__doc__},
{"split", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_split, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_split__doc__},
static PyObject *
_sre_SRE_Pattern_split_impl(PatternObject *self, PyObject *string,
@ -393,7 +393,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_sub__doc__,
"Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl.");
#define _SRE_SRE_PATTERN_SUB_METHODDEF \
{"sub", (PyCFunction)_sre_SRE_Pattern_sub, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_sub__doc__},
{"sub", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_sub, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_sub__doc__},
static PyObject *
_sre_SRE_Pattern_sub_impl(PatternObject *self, PyObject *repl,
@ -426,7 +426,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_subn__doc__,
"Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl.");
#define _SRE_SRE_PATTERN_SUBN_METHODDEF \
{"subn", (PyCFunction)_sre_SRE_Pattern_subn, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_subn__doc__},
{"subn", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_subn, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_subn__doc__},
static PyObject *
_sre_SRE_Pattern_subn_impl(PatternObject *self, PyObject *repl,
@ -484,7 +484,7 @@ PyDoc_STRVAR(_sre_compile__doc__,
"\n");
#define _SRE_COMPILE_METHODDEF \
{"compile", (PyCFunction)_sre_compile, METH_FASTCALL|METH_KEYWORDS, _sre_compile__doc__},
{"compile", (PyCFunction)(void(*)(void))_sre_compile, METH_FASTCALL|METH_KEYWORDS, _sre_compile__doc__},
static PyObject *
_sre_compile_impl(PyObject *module, PyObject *pattern, int flags,
@ -521,7 +521,7 @@ PyDoc_STRVAR(_sre_SRE_Match_expand__doc__,
"Return the string obtained by doing backslash substitution on the string template, as done by the sub() method.");
#define _SRE_SRE_MATCH_EXPAND_METHODDEF \
{"expand", (PyCFunction)_sre_SRE_Match_expand, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_expand__doc__},
{"expand", (PyCFunction)(void(*)(void))_sre_SRE_Match_expand, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_expand__doc__},
static PyObject *
_sre_SRE_Match_expand_impl(MatchObject *self, PyObject *template);
@ -554,7 +554,7 @@ PyDoc_STRVAR(_sre_SRE_Match_groups__doc__,
" Is used for groups that did not participate in the match.");
#define _SRE_SRE_MATCH_GROUPS_METHODDEF \
{"groups", (PyCFunction)_sre_SRE_Match_groups, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groups__doc__},
{"groups", (PyCFunction)(void(*)(void))_sre_SRE_Match_groups, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groups__doc__},
static PyObject *
_sre_SRE_Match_groups_impl(MatchObject *self, PyObject *default_value);
@ -587,7 +587,7 @@ PyDoc_STRVAR(_sre_SRE_Match_groupdict__doc__,
" Is used for groups that did not participate in the match.");
#define _SRE_SRE_MATCH_GROUPDICT_METHODDEF \
{"groupdict", (PyCFunction)_sre_SRE_Match_groupdict, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groupdict__doc__},
{"groupdict", (PyCFunction)(void(*)(void))_sre_SRE_Match_groupdict, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groupdict__doc__},
static PyObject *
_sre_SRE_Match_groupdict_impl(MatchObject *self, PyObject *default_value);
@ -617,7 +617,7 @@ PyDoc_STRVAR(_sre_SRE_Match_start__doc__,
"Return index of the start of the substring matched by group.");
#define _SRE_SRE_MATCH_START_METHODDEF \
{"start", (PyCFunction)_sre_SRE_Match_start, METH_FASTCALL, _sre_SRE_Match_start__doc__},
{"start", (PyCFunction)(void(*)(void))_sre_SRE_Match_start, METH_FASTCALL, _sre_SRE_Match_start__doc__},
static Py_ssize_t
_sre_SRE_Match_start_impl(MatchObject *self, PyObject *group);
@ -651,7 +651,7 @@ PyDoc_STRVAR(_sre_SRE_Match_end__doc__,
"Return index of the end of the substring matched by group.");
#define _SRE_SRE_MATCH_END_METHODDEF \
{"end", (PyCFunction)_sre_SRE_Match_end, METH_FASTCALL, _sre_SRE_Match_end__doc__},
{"end", (PyCFunction)(void(*)(void))_sre_SRE_Match_end, METH_FASTCALL, _sre_SRE_Match_end__doc__},
static Py_ssize_t
_sre_SRE_Match_end_impl(MatchObject *self, PyObject *group);
@ -685,7 +685,7 @@ PyDoc_STRVAR(_sre_SRE_Match_span__doc__,
"For match object m, return the 2-tuple (m.start(group), m.end(group)).");
#define _SRE_SRE_MATCH_SPAN_METHODDEF \
{"span", (PyCFunction)_sre_SRE_Match_span, METH_FASTCALL, _sre_SRE_Match_span__doc__},
{"span", (PyCFunction)(void(*)(void))_sre_SRE_Match_span, METH_FASTCALL, _sre_SRE_Match_span__doc__},
static PyObject *
_sre_SRE_Match_span_impl(MatchObject *self, PyObject *group);
@ -765,4 +765,4 @@ _sre_SRE_Scanner_search(ScannerObject *self, PyObject *Py_UNUSED(ignored))
{
return _sre_SRE_Scanner_search_impl(self);
}
/*[clinic end generated code: output=4b807104b65c1e0e input=a9049054013a1b77]*/
/*[clinic end generated code: output=5edeca5ec36b5f34 input=a9049054013a1b77]*/

26
Modules/clinic/_ssl.c.h generated
View file

@ -60,7 +60,7 @@ PyDoc_STRVAR(_ssl__SSLSocket_getpeercert__doc__,
"return the certificate even if it wasn\'t validated.");
#define _SSL__SSLSOCKET_GETPEERCERT_METHODDEF \
{"getpeercert", (PyCFunction)_ssl__SSLSocket_getpeercert, METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
{"getpeercert", (PyCFunction)(void(*)(void))_ssl__SSLSocket_getpeercert, METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
static PyObject *
_ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode);
@ -318,7 +318,7 @@ PyDoc_STRVAR(_ssl__SSLSocket_get_channel_binding__doc__,
"Only \'tls-unique\' channel binding data from RFC 5929 is supported.");
#define _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF \
{"get_channel_binding", (PyCFunction)_ssl__SSLSocket_get_channel_binding, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
{"get_channel_binding", (PyCFunction)(void(*)(void))_ssl__SSLSocket_get_channel_binding, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
static PyObject *
_ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
@ -500,7 +500,7 @@ PyDoc_STRVAR(_ssl__SSLContext_load_cert_chain__doc__,
"\n");
#define _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF \
{"load_cert_chain", (PyCFunction)_ssl__SSLContext_load_cert_chain, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
{"load_cert_chain", (PyCFunction)(void(*)(void))_ssl__SSLContext_load_cert_chain, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
static PyObject *
_ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
@ -532,7 +532,7 @@ PyDoc_STRVAR(_ssl__SSLContext_load_verify_locations__doc__,
"\n");
#define _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF \
{"load_verify_locations", (PyCFunction)_ssl__SSLContext_load_verify_locations, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
{"load_verify_locations", (PyCFunction)(void(*)(void))_ssl__SSLContext_load_verify_locations, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
static PyObject *
_ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
@ -575,7 +575,7 @@ PyDoc_STRVAR(_ssl__SSLContext__wrap_socket__doc__,
"\n");
#define _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF \
{"_wrap_socket", (PyCFunction)_ssl__SSLContext__wrap_socket, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
{"_wrap_socket", (PyCFunction)(void(*)(void))_ssl__SSLContext__wrap_socket, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
static PyObject *
_ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
@ -611,7 +611,7 @@ PyDoc_STRVAR(_ssl__SSLContext__wrap_bio__doc__,
"\n");
#define _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF \
{"_wrap_bio", (PyCFunction)_ssl__SSLContext__wrap_bio, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
{"_wrap_bio", (PyCFunction)(void(*)(void))_ssl__SSLContext__wrap_bio, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
static PyObject *
_ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
@ -725,7 +725,7 @@ PyDoc_STRVAR(_ssl__SSLContext_get_ca_certs__doc__,
"been used at least once.");
#define _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF \
{"get_ca_certs", (PyCFunction)_ssl__SSLContext_get_ca_certs, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
{"get_ca_certs", (PyCFunction)(void(*)(void))_ssl__SSLContext_get_ca_certs, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
static PyObject *
_ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form);
@ -782,7 +782,7 @@ PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__,
"distinguish between the two.");
#define _SSL_MEMORYBIO_READ_METHODDEF \
{"read", (PyCFunction)_ssl_MemoryBIO_read, METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
{"read", (PyCFunction)(void(*)(void))_ssl_MemoryBIO_read, METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
static PyObject *
_ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len);
@ -867,7 +867,7 @@ PyDoc_STRVAR(_ssl_RAND_add__doc__,
"string. See RFC 4086.");
#define _SSL_RAND_ADD_METHODDEF \
{"RAND_add", (PyCFunction)_ssl_RAND_add, METH_FASTCALL, _ssl_RAND_add__doc__},
{"RAND_add", (PyCFunction)(void(*)(void))_ssl_RAND_add, METH_FASTCALL, _ssl_RAND_add__doc__},
static PyObject *
_ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy);
@ -1036,7 +1036,7 @@ PyDoc_STRVAR(_ssl_txt2obj__doc__,
"long name are also matched.");
#define _SSL_TXT2OBJ_METHODDEF \
{"txt2obj", (PyCFunction)_ssl_txt2obj, METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
{"txt2obj", (PyCFunction)(void(*)(void))_ssl_txt2obj, METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
static PyObject *
_ssl_txt2obj_impl(PyObject *module, const char *txt, int name);
@ -1102,7 +1102,7 @@ PyDoc_STRVAR(_ssl_enum_certificates__doc__,
"a set of OIDs or the boolean True.");
#define _SSL_ENUM_CERTIFICATES_METHODDEF \
{"enum_certificates", (PyCFunction)_ssl_enum_certificates, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
{"enum_certificates", (PyCFunction)(void(*)(void))_ssl_enum_certificates, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
static PyObject *
_ssl_enum_certificates_impl(PyObject *module, const char *store_name);
@ -1141,7 +1141,7 @@ PyDoc_STRVAR(_ssl_enum_crls__doc__,
"X509_ASN_ENCODING or PKCS_7_ASN_ENCODING.");
#define _SSL_ENUM_CRLS_METHODDEF \
{"enum_crls", (PyCFunction)_ssl_enum_crls, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
{"enum_crls", (PyCFunction)(void(*)(void))_ssl_enum_crls, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
static PyObject *
_ssl_enum_crls_impl(PyObject *module, const char *store_name);
@ -1193,4 +1193,4 @@ exit:
#ifndef _SSL_ENUM_CRLS_METHODDEF
#define _SSL_ENUM_CRLS_METHODDEF
#endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */
/*[clinic end generated code: output=c4e73b70ac3618ba input=a9049054013a1b77]*/
/*[clinic end generated code: output=d87f783224be8fca input=a9049054013a1b77]*/

10
Modules/clinic/_struct.c.h generated
View file

@ -85,7 +85,7 @@ PyDoc_STRVAR(Struct_unpack_from__doc__,
"See help(struct) for more on format strings.");
#define STRUCT_UNPACK_FROM_METHODDEF \
{"unpack_from", (PyCFunction)Struct_unpack_from, METH_FASTCALL|METH_KEYWORDS, Struct_unpack_from__doc__},
{"unpack_from", (PyCFunction)(void(*)(void))Struct_unpack_from, METH_FASTCALL|METH_KEYWORDS, Struct_unpack_from__doc__},
static PyObject *
Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
@ -193,7 +193,7 @@ PyDoc_STRVAR(unpack__doc__,
"See help(struct) for more on format strings.");
#define UNPACK_METHODDEF \
{"unpack", (PyCFunction)unpack, METH_FASTCALL, unpack__doc__},
{"unpack", (PyCFunction)(void(*)(void))unpack, METH_FASTCALL, unpack__doc__},
static PyObject *
unpack_impl(PyObject *module, PyStructObject *s_object, Py_buffer *buffer);
@ -233,7 +233,7 @@ PyDoc_STRVAR(unpack_from__doc__,
"See help(struct) for more on format strings.");
#define UNPACK_FROM_METHODDEF \
{"unpack_from", (PyCFunction)unpack_from, METH_FASTCALL|METH_KEYWORDS, unpack_from__doc__},
{"unpack_from", (PyCFunction)(void(*)(void))unpack_from, METH_FASTCALL|METH_KEYWORDS, unpack_from__doc__},
static PyObject *
unpack_from_impl(PyObject *module, PyStructObject *s_object,
@ -278,7 +278,7 @@ PyDoc_STRVAR(iter_unpack__doc__,
"Requires that the bytes length be a multiple of the format struct size.");
#define ITER_UNPACK_METHODDEF \
{"iter_unpack", (PyCFunction)iter_unpack, METH_FASTCALL, iter_unpack__doc__},
{"iter_unpack", (PyCFunction)(void(*)(void))iter_unpack, METH_FASTCALL, iter_unpack__doc__},
static PyObject *
iter_unpack_impl(PyObject *module, PyStructObject *s_object,
@ -303,4 +303,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=d79b009652ae0b89 input=a9049054013a1b77]*/
/*[clinic end generated code: output=a73b0453174e4b51 input=a9049054013a1b77]*/

14
Modules/clinic/_tkinter.c.h generated
View file

@ -256,7 +256,7 @@ PyDoc_STRVAR(_tkinter_tkapp_createcommand__doc__,
"\n");
#define _TKINTER_TKAPP_CREATECOMMAND_METHODDEF \
{"createcommand", (PyCFunction)_tkinter_tkapp_createcommand, METH_FASTCALL, _tkinter_tkapp_createcommand__doc__},
{"createcommand", (PyCFunction)(void(*)(void))_tkinter_tkapp_createcommand, METH_FASTCALL, _tkinter_tkapp_createcommand__doc__},
static PyObject *
_tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
@ -313,7 +313,7 @@ PyDoc_STRVAR(_tkinter_tkapp_createfilehandler__doc__,
"\n");
#define _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF \
{"createfilehandler", (PyCFunction)_tkinter_tkapp_createfilehandler, METH_FASTCALL, _tkinter_tkapp_createfilehandler__doc__},
{"createfilehandler", (PyCFunction)(void(*)(void))_tkinter_tkapp_createfilehandler, METH_FASTCALL, _tkinter_tkapp_createfilehandler__doc__},
static PyObject *
_tkinter_tkapp_createfilehandler_impl(TkappObject *self, PyObject *file,
@ -374,7 +374,7 @@ PyDoc_STRVAR(_tkinter_tkapp_createtimerhandler__doc__,
"\n");
#define _TKINTER_TKAPP_CREATETIMERHANDLER_METHODDEF \
{"createtimerhandler", (PyCFunction)_tkinter_tkapp_createtimerhandler, METH_FASTCALL, _tkinter_tkapp_createtimerhandler__doc__},
{"createtimerhandler", (PyCFunction)(void(*)(void))_tkinter_tkapp_createtimerhandler, METH_FASTCALL, _tkinter_tkapp_createtimerhandler__doc__},
static PyObject *
_tkinter_tkapp_createtimerhandler_impl(TkappObject *self, int milliseconds,
@ -403,7 +403,7 @@ PyDoc_STRVAR(_tkinter_tkapp_mainloop__doc__,
"\n");
#define _TKINTER_TKAPP_MAINLOOP_METHODDEF \
{"mainloop", (PyCFunction)_tkinter_tkapp_mainloop, METH_FASTCALL, _tkinter_tkapp_mainloop__doc__},
{"mainloop", (PyCFunction)(void(*)(void))_tkinter_tkapp_mainloop, METH_FASTCALL, _tkinter_tkapp_mainloop__doc__},
static PyObject *
_tkinter_tkapp_mainloop_impl(TkappObject *self, int threshold);
@ -430,7 +430,7 @@ PyDoc_STRVAR(_tkinter_tkapp_dooneevent__doc__,
"\n");
#define _TKINTER_TKAPP_DOONEEVENT_METHODDEF \
{"dooneevent", (PyCFunction)_tkinter_tkapp_dooneevent, METH_FASTCALL, _tkinter_tkapp_dooneevent__doc__},
{"dooneevent", (PyCFunction)(void(*)(void))_tkinter_tkapp_dooneevent, METH_FASTCALL, _tkinter_tkapp_dooneevent__doc__},
static PyObject *
_tkinter_tkapp_dooneevent_impl(TkappObject *self, int flags);
@ -543,7 +543,7 @@ PyDoc_STRVAR(_tkinter_create__doc__,
" if not None, then pass -use to wish");
#define _TKINTER_CREATE_METHODDEF \
{"create", (PyCFunction)_tkinter_create, METH_FASTCALL, _tkinter_create__doc__},
{"create", (PyCFunction)(void(*)(void))_tkinter_create, METH_FASTCALL, _tkinter_create__doc__},
static PyObject *
_tkinter_create_impl(PyObject *module, const char *screenName,
@ -638,4 +638,4 @@ exit:
#ifndef _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
#define _TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF
#endif /* !defined(_TKINTER_TKAPP_DELETEFILEHANDLER_METHODDEF) */
/*[clinic end generated code: output=eb3202e07db3dbb1 input=a9049054013a1b77]*/
/*[clinic end generated code: output=a9d45a90cde94980 input=a9049054013a1b77]*/

4
Modules/clinic/_tracemalloc.c.h generated
View file

@ -84,7 +84,7 @@ PyDoc_STRVAR(_tracemalloc_start__doc__,
"trace to nframe.");
#define _TRACEMALLOC_START_METHODDEF \
{"start", (PyCFunction)_tracemalloc_start, METH_FASTCALL, _tracemalloc_start__doc__},
{"start", (PyCFunction)(void(*)(void))_tracemalloc_start, METH_FASTCALL, _tracemalloc_start__doc__},
static PyObject *
_tracemalloc_start_impl(PyObject *module, int nframe);
@ -185,4 +185,4 @@ _tracemalloc_get_traced_memory(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _tracemalloc_get_traced_memory_impl(module);
}
/*[clinic end generated code: output=d98afded69c89d52 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d4a2dd3eaba9f72d input=a9049054013a1b77]*/

4
Modules/clinic/_weakref.c.h generated
View file

@ -37,7 +37,7 @@ 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_FASTCALL, _weakref__remove_dead_weakref__doc__},
{"_remove_dead_weakref", (PyCFunction)(void(*)(void))_weakref__remove_dead_weakref, METH_FASTCALL, _weakref__remove_dead_weakref__doc__},
static PyObject *
_weakref__remove_dead_weakref_impl(PyObject *module, PyObject *dct,
@ -59,4 +59,4 @@ _weakref__remove_dead_weakref(PyObject *module, PyObject *const *args, Py_ssize_
exit:
return return_value;
}
/*[clinic end generated code: output=b6a61a4f365a3f0a input=a9049054013a1b77]*/
/*[clinic end generated code: output=927e889feb8a7dc4 input=a9049054013a1b77]*/

36
Modules/clinic/_winapi.c.h generated
View file

@ -95,7 +95,7 @@ PyDoc_STRVAR(_winapi_ConnectNamedPipe__doc__,
"\n");
#define _WINAPI_CONNECTNAMEDPIPE_METHODDEF \
{"ConnectNamedPipe", (PyCFunction)_winapi_ConnectNamedPipe, METH_FASTCALL|METH_KEYWORDS, _winapi_ConnectNamedPipe__doc__},
{"ConnectNamedPipe", (PyCFunction)(void(*)(void))_winapi_ConnectNamedPipe, METH_FASTCALL|METH_KEYWORDS, _winapi_ConnectNamedPipe__doc__},
static PyObject *
_winapi_ConnectNamedPipe_impl(PyObject *module, HANDLE handle,
@ -128,7 +128,7 @@ PyDoc_STRVAR(_winapi_CreateFile__doc__,
"\n");
#define _WINAPI_CREATEFILE_METHODDEF \
{"CreateFile", (PyCFunction)_winapi_CreateFile, METH_FASTCALL, _winapi_CreateFile__doc__},
{"CreateFile", (PyCFunction)(void(*)(void))_winapi_CreateFile, METH_FASTCALL, _winapi_CreateFile__doc__},
static HANDLE
_winapi_CreateFile_impl(PyObject *module, LPCTSTR file_name,
@ -173,7 +173,7 @@ PyDoc_STRVAR(_winapi_CreateJunction__doc__,
"\n");
#define _WINAPI_CREATEJUNCTION_METHODDEF \
{"CreateJunction", (PyCFunction)_winapi_CreateJunction, METH_FASTCALL, _winapi_CreateJunction__doc__},
{"CreateJunction", (PyCFunction)(void(*)(void))_winapi_CreateJunction, METH_FASTCALL, _winapi_CreateJunction__doc__},
static PyObject *
_winapi_CreateJunction_impl(PyObject *module, LPWSTR src_path,
@ -204,7 +204,7 @@ PyDoc_STRVAR(_winapi_CreateNamedPipe__doc__,
"\n");
#define _WINAPI_CREATENAMEDPIPE_METHODDEF \
{"CreateNamedPipe", (PyCFunction)_winapi_CreateNamedPipe, METH_FASTCALL, _winapi_CreateNamedPipe__doc__},
{"CreateNamedPipe", (PyCFunction)(void(*)(void))_winapi_CreateNamedPipe, METH_FASTCALL, _winapi_CreateNamedPipe__doc__},
static HANDLE
_winapi_CreateNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD open_mode,
@ -256,7 +256,7 @@ 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_FASTCALL, _winapi_CreatePipe__doc__},
{"CreatePipe", (PyCFunction)(void(*)(void))_winapi_CreatePipe, METH_FASTCALL, _winapi_CreatePipe__doc__},
static PyObject *
_winapi_CreatePipe_impl(PyObject *module, PyObject *pipe_attrs, DWORD size);
@ -295,7 +295,7 @@ PyDoc_STRVAR(_winapi_CreateProcess__doc__,
"process ID, and thread ID.");
#define _WINAPI_CREATEPROCESS_METHODDEF \
{"CreateProcess", (PyCFunction)_winapi_CreateProcess, METH_FASTCALL, _winapi_CreateProcess__doc__},
{"CreateProcess", (PyCFunction)(void(*)(void))_winapi_CreateProcess, METH_FASTCALL, _winapi_CreateProcess__doc__},
static PyObject *
_winapi_CreateProcess_impl(PyObject *module, Py_UNICODE *application_name,
@ -342,7 +342,7 @@ PyDoc_STRVAR(_winapi_DuplicateHandle__doc__,
"through both handles.");
#define _WINAPI_DUPLICATEHANDLE_METHODDEF \
{"DuplicateHandle", (PyCFunction)_winapi_DuplicateHandle, METH_FASTCALL, _winapi_DuplicateHandle__doc__},
{"DuplicateHandle", (PyCFunction)(void(*)(void))_winapi_DuplicateHandle, METH_FASTCALL, _winapi_DuplicateHandle__doc__},
static HANDLE
_winapi_DuplicateHandle_impl(PyObject *module, HANDLE source_process_handle,
@ -604,7 +604,7 @@ PyDoc_STRVAR(_winapi_OpenProcess__doc__,
"\n");
#define _WINAPI_OPENPROCESS_METHODDEF \
{"OpenProcess", (PyCFunction)_winapi_OpenProcess, METH_FASTCALL, _winapi_OpenProcess__doc__},
{"OpenProcess", (PyCFunction)(void(*)(void))_winapi_OpenProcess, METH_FASTCALL, _winapi_OpenProcess__doc__},
static HANDLE
_winapi_OpenProcess_impl(PyObject *module, DWORD desired_access,
@ -642,7 +642,7 @@ PyDoc_STRVAR(_winapi_PeekNamedPipe__doc__,
"\n");
#define _WINAPI_PEEKNAMEDPIPE_METHODDEF \
{"PeekNamedPipe", (PyCFunction)_winapi_PeekNamedPipe, METH_FASTCALL, _winapi_PeekNamedPipe__doc__},
{"PeekNamedPipe", (PyCFunction)(void(*)(void))_winapi_PeekNamedPipe, METH_FASTCALL, _winapi_PeekNamedPipe__doc__},
static PyObject *
_winapi_PeekNamedPipe_impl(PyObject *module, HANDLE handle, int size);
@ -670,7 +670,7 @@ PyDoc_STRVAR(_winapi_ReadFile__doc__,
"\n");
#define _WINAPI_READFILE_METHODDEF \
{"ReadFile", (PyCFunction)_winapi_ReadFile, METH_FASTCALL|METH_KEYWORDS, _winapi_ReadFile__doc__},
{"ReadFile", (PyCFunction)(void(*)(void))_winapi_ReadFile, METH_FASTCALL|METH_KEYWORDS, _winapi_ReadFile__doc__},
static PyObject *
_winapi_ReadFile_impl(PyObject *module, HANDLE handle, DWORD size,
@ -703,7 +703,7 @@ PyDoc_STRVAR(_winapi_SetNamedPipeHandleState__doc__,
"\n");
#define _WINAPI_SETNAMEDPIPEHANDLESTATE_METHODDEF \
{"SetNamedPipeHandleState", (PyCFunction)_winapi_SetNamedPipeHandleState, METH_FASTCALL, _winapi_SetNamedPipeHandleState__doc__},
{"SetNamedPipeHandleState", (PyCFunction)(void(*)(void))_winapi_SetNamedPipeHandleState, METH_FASTCALL, _winapi_SetNamedPipeHandleState__doc__},
static PyObject *
_winapi_SetNamedPipeHandleState_impl(PyObject *module, HANDLE named_pipe,
@ -737,7 +737,7 @@ PyDoc_STRVAR(_winapi_TerminateProcess__doc__,
"Terminate the specified process and all of its threads.");
#define _WINAPI_TERMINATEPROCESS_METHODDEF \
{"TerminateProcess", (PyCFunction)_winapi_TerminateProcess, METH_FASTCALL, _winapi_TerminateProcess__doc__},
{"TerminateProcess", (PyCFunction)(void(*)(void))_winapi_TerminateProcess, METH_FASTCALL, _winapi_TerminateProcess__doc__},
static PyObject *
_winapi_TerminateProcess_impl(PyObject *module, HANDLE handle,
@ -766,7 +766,7 @@ PyDoc_STRVAR(_winapi_WaitNamedPipe__doc__,
"\n");
#define _WINAPI_WAITNAMEDPIPE_METHODDEF \
{"WaitNamedPipe", (PyCFunction)_winapi_WaitNamedPipe, METH_FASTCALL, _winapi_WaitNamedPipe__doc__},
{"WaitNamedPipe", (PyCFunction)(void(*)(void))_winapi_WaitNamedPipe, METH_FASTCALL, _winapi_WaitNamedPipe__doc__},
static PyObject *
_winapi_WaitNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD timeout);
@ -795,7 +795,7 @@ PyDoc_STRVAR(_winapi_WaitForMultipleObjects__doc__,
"\n");
#define _WINAPI_WAITFORMULTIPLEOBJECTS_METHODDEF \
{"WaitForMultipleObjects", (PyCFunction)_winapi_WaitForMultipleObjects, METH_FASTCALL, _winapi_WaitForMultipleObjects__doc__},
{"WaitForMultipleObjects", (PyCFunction)(void(*)(void))_winapi_WaitForMultipleObjects, METH_FASTCALL, _winapi_WaitForMultipleObjects__doc__},
static PyObject *
_winapi_WaitForMultipleObjects_impl(PyObject *module, PyObject *handle_seq,
@ -830,7 +830,7 @@ PyDoc_STRVAR(_winapi_WaitForSingleObject__doc__,
"in milliseconds.");
#define _WINAPI_WAITFORSINGLEOBJECT_METHODDEF \
{"WaitForSingleObject", (PyCFunction)_winapi_WaitForSingleObject, METH_FASTCALL, _winapi_WaitForSingleObject__doc__},
{"WaitForSingleObject", (PyCFunction)(void(*)(void))_winapi_WaitForSingleObject, METH_FASTCALL, _winapi_WaitForSingleObject__doc__},
static long
_winapi_WaitForSingleObject_impl(PyObject *module, HANDLE handle,
@ -864,7 +864,7 @@ PyDoc_STRVAR(_winapi_WriteFile__doc__,
"\n");
#define _WINAPI_WRITEFILE_METHODDEF \
{"WriteFile", (PyCFunction)_winapi_WriteFile, METH_FASTCALL|METH_KEYWORDS, _winapi_WriteFile__doc__},
{"WriteFile", (PyCFunction)(void(*)(void))_winapi_WriteFile, METH_FASTCALL|METH_KEYWORDS, _winapi_WriteFile__doc__},
static PyObject *
_winapi_WriteFile_impl(PyObject *module, HANDLE handle, PyObject *buffer,
@ -914,7 +914,7 @@ PyDoc_STRVAR(_winapi_GetFileType__doc__,
"\n");
#define _WINAPI_GETFILETYPE_METHODDEF \
{"GetFileType", (PyCFunction)_winapi_GetFileType, METH_FASTCALL|METH_KEYWORDS, _winapi_GetFileType__doc__},
{"GetFileType", (PyCFunction)(void(*)(void))_winapi_GetFileType, METH_FASTCALL|METH_KEYWORDS, _winapi_GetFileType__doc__},
static DWORD
_winapi_GetFileType_impl(PyObject *module, HANDLE handle);
@ -941,4 +941,4 @@ _winapi_GetFileType(PyObject *module, PyObject *const *args, Py_ssize_t nargs, P
exit:
return return_value;
}
/*[clinic end generated code: output=baaf3d379b91be0a input=a9049054013a1b77]*/
/*[clinic end generated code: output=915dd640329de0c0 input=a9049054013a1b77]*/

10
Modules/clinic/arraymodule.c.h generated
View file

@ -65,7 +65,7 @@ PyDoc_STRVAR(array_array_pop__doc__,
"i defaults to -1.");
#define ARRAY_ARRAY_POP_METHODDEF \
{"pop", (PyCFunction)array_array_pop, METH_FASTCALL, array_array_pop__doc__},
{"pop", (PyCFunction)(void(*)(void))array_array_pop, METH_FASTCALL, array_array_pop__doc__},
static PyObject *
array_array_pop_impl(arrayobject *self, Py_ssize_t i);
@ -102,7 +102,7 @@ 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_FASTCALL, array_array_insert__doc__},
{"insert", (PyCFunction)(void(*)(void))array_array_insert, METH_FASTCALL, array_array_insert__doc__},
static PyObject *
array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v);
@ -200,7 +200,7 @@ 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_FASTCALL, array_array_fromfile__doc__},
{"fromfile", (PyCFunction)(void(*)(void))array_array_fromfile, METH_FASTCALL, array_array_fromfile__doc__},
static PyObject *
array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n);
@ -443,7 +443,7 @@ PyDoc_STRVAR(array__array_reconstructor__doc__,
"Internal. Used for pickling support.");
#define ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF \
{"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_FASTCALL, array__array_reconstructor__doc__},
{"_array_reconstructor", (PyCFunction)(void(*)(void))array__array_reconstructor, METH_FASTCALL, array__array_reconstructor__doc__},
static PyObject *
array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
@ -505,4 +505,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=1289bde2a095a712 input=a9049054013a1b77]*/
/*[clinic end generated code: output=3a4c6f3deb597bfd input=a9049054013a1b77]*/

54
Modules/clinic/audioop.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(audioop_getsample__doc__,
"Return the value of sample index from the fragment.");
#define AUDIOOP_GETSAMPLE_METHODDEF \
{"getsample", (PyCFunction)audioop_getsample, METH_FASTCALL, audioop_getsample__doc__},
{"getsample", (PyCFunction)(void(*)(void))audioop_getsample, METH_FASTCALL, audioop_getsample__doc__},
static PyObject *
audioop_getsample_impl(PyObject *module, Py_buffer *fragment, int width,
@ -45,7 +45,7 @@ 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_FASTCALL, audioop_max__doc__},
{"max", (PyCFunction)(void(*)(void))audioop_max, METH_FASTCALL, audioop_max__doc__},
static PyObject *
audioop_max_impl(PyObject *module, Py_buffer *fragment, int width);
@ -79,7 +79,7 @@ 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_FASTCALL, audioop_minmax__doc__},
{"minmax", (PyCFunction)(void(*)(void))audioop_minmax, METH_FASTCALL, audioop_minmax__doc__},
static PyObject *
audioop_minmax_impl(PyObject *module, Py_buffer *fragment, int width);
@ -113,7 +113,7 @@ PyDoc_STRVAR(audioop_avg__doc__,
"Return the average over all samples in the fragment.");
#define AUDIOOP_AVG_METHODDEF \
{"avg", (PyCFunction)audioop_avg, METH_FASTCALL, audioop_avg__doc__},
{"avg", (PyCFunction)(void(*)(void))audioop_avg, METH_FASTCALL, audioop_avg__doc__},
static PyObject *
audioop_avg_impl(PyObject *module, Py_buffer *fragment, int width);
@ -147,7 +147,7 @@ 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_FASTCALL, audioop_rms__doc__},
{"rms", (PyCFunction)(void(*)(void))audioop_rms, METH_FASTCALL, audioop_rms__doc__},
static PyObject *
audioop_rms_impl(PyObject *module, Py_buffer *fragment, int width);
@ -181,7 +181,7 @@ 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_FASTCALL, audioop_findfit__doc__},
{"findfit", (PyCFunction)(void(*)(void))audioop_findfit, METH_FASTCALL, audioop_findfit__doc__},
static PyObject *
audioop_findfit_impl(PyObject *module, Py_buffer *fragment,
@ -220,7 +220,7 @@ 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_FASTCALL, audioop_findfactor__doc__},
{"findfactor", (PyCFunction)(void(*)(void))audioop_findfactor, METH_FASTCALL, audioop_findfactor__doc__},
static PyObject *
audioop_findfactor_impl(PyObject *module, Py_buffer *fragment,
@ -259,7 +259,7 @@ 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_FASTCALL, audioop_findmax__doc__},
{"findmax", (PyCFunction)(void(*)(void))audioop_findmax, METH_FASTCALL, audioop_findmax__doc__},
static PyObject *
audioop_findmax_impl(PyObject *module, Py_buffer *fragment,
@ -294,7 +294,7 @@ 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_FASTCALL, audioop_avgpp__doc__},
{"avgpp", (PyCFunction)(void(*)(void))audioop_avgpp, METH_FASTCALL, audioop_avgpp__doc__},
static PyObject *
audioop_avgpp_impl(PyObject *module, Py_buffer *fragment, int width);
@ -328,7 +328,7 @@ PyDoc_STRVAR(audioop_maxpp__doc__,
"Return the maximum peak-peak value in the sound fragment.");
#define AUDIOOP_MAXPP_METHODDEF \
{"maxpp", (PyCFunction)audioop_maxpp, METH_FASTCALL, audioop_maxpp__doc__},
{"maxpp", (PyCFunction)(void(*)(void))audioop_maxpp, METH_FASTCALL, audioop_maxpp__doc__},
static PyObject *
audioop_maxpp_impl(PyObject *module, Py_buffer *fragment, int width);
@ -362,7 +362,7 @@ 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_FASTCALL, audioop_cross__doc__},
{"cross", (PyCFunction)(void(*)(void))audioop_cross, METH_FASTCALL, audioop_cross__doc__},
static PyObject *
audioop_cross_impl(PyObject *module, Py_buffer *fragment, int width);
@ -396,7 +396,7 @@ 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_FASTCALL, audioop_mul__doc__},
{"mul", (PyCFunction)(void(*)(void))audioop_mul, METH_FASTCALL, audioop_mul__doc__},
static PyObject *
audioop_mul_impl(PyObject *module, Py_buffer *fragment, int width,
@ -432,7 +432,7 @@ PyDoc_STRVAR(audioop_tomono__doc__,
"Convert a stereo fragment to a mono fragment.");
#define AUDIOOP_TOMONO_METHODDEF \
{"tomono", (PyCFunction)audioop_tomono, METH_FASTCALL, audioop_tomono__doc__},
{"tomono", (PyCFunction)(void(*)(void))audioop_tomono, METH_FASTCALL, audioop_tomono__doc__},
static PyObject *
audioop_tomono_impl(PyObject *module, Py_buffer *fragment, int width,
@ -469,7 +469,7 @@ PyDoc_STRVAR(audioop_tostereo__doc__,
"Generate a stereo fragment from a mono fragment.");
#define AUDIOOP_TOSTEREO_METHODDEF \
{"tostereo", (PyCFunction)audioop_tostereo, METH_FASTCALL, audioop_tostereo__doc__},
{"tostereo", (PyCFunction)(void(*)(void))audioop_tostereo, METH_FASTCALL, audioop_tostereo__doc__},
static PyObject *
audioop_tostereo_impl(PyObject *module, Py_buffer *fragment, int width,
@ -506,7 +506,7 @@ 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_FASTCALL, audioop_add__doc__},
{"add", (PyCFunction)(void(*)(void))audioop_add, METH_FASTCALL, audioop_add__doc__},
static PyObject *
audioop_add_impl(PyObject *module, Py_buffer *fragment1,
@ -546,7 +546,7 @@ 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_FASTCALL, audioop_bias__doc__},
{"bias", (PyCFunction)(void(*)(void))audioop_bias, METH_FASTCALL, audioop_bias__doc__},
static PyObject *
audioop_bias_impl(PyObject *module, Py_buffer *fragment, int width, int bias);
@ -581,7 +581,7 @@ 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_FASTCALL, audioop_reverse__doc__},
{"reverse", (PyCFunction)(void(*)(void))audioop_reverse, METH_FASTCALL, audioop_reverse__doc__},
static PyObject *
audioop_reverse_impl(PyObject *module, Py_buffer *fragment, int width);
@ -615,7 +615,7 @@ PyDoc_STRVAR(audioop_byteswap__doc__,
"Convert big-endian samples to little-endian and vice versa.");
#define AUDIOOP_BYTESWAP_METHODDEF \
{"byteswap", (PyCFunction)audioop_byteswap, METH_FASTCALL, audioop_byteswap__doc__},
{"byteswap", (PyCFunction)(void(*)(void))audioop_byteswap, METH_FASTCALL, audioop_byteswap__doc__},
static PyObject *
audioop_byteswap_impl(PyObject *module, Py_buffer *fragment, int width);
@ -649,7 +649,7 @@ PyDoc_STRVAR(audioop_lin2lin__doc__,
"Convert samples between 1-, 2-, 3- and 4-byte formats.");
#define AUDIOOP_LIN2LIN_METHODDEF \
{"lin2lin", (PyCFunction)audioop_lin2lin, METH_FASTCALL, audioop_lin2lin__doc__},
{"lin2lin", (PyCFunction)(void(*)(void))audioop_lin2lin, METH_FASTCALL, audioop_lin2lin__doc__},
static PyObject *
audioop_lin2lin_impl(PyObject *module, Py_buffer *fragment, int width,
@ -686,7 +686,7 @@ PyDoc_STRVAR(audioop_ratecv__doc__,
"Convert the frame rate of the input fragment.");
#define AUDIOOP_RATECV_METHODDEF \
{"ratecv", (PyCFunction)audioop_ratecv, METH_FASTCALL, audioop_ratecv__doc__},
{"ratecv", (PyCFunction)(void(*)(void))audioop_ratecv, METH_FASTCALL, audioop_ratecv__doc__},
static PyObject *
audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
@ -728,7 +728,7 @@ PyDoc_STRVAR(audioop_lin2ulaw__doc__,
"Convert samples in the audio fragment to u-LAW encoding.");
#define AUDIOOP_LIN2ULAW_METHODDEF \
{"lin2ulaw", (PyCFunction)audioop_lin2ulaw, METH_FASTCALL, audioop_lin2ulaw__doc__},
{"lin2ulaw", (PyCFunction)(void(*)(void))audioop_lin2ulaw, METH_FASTCALL, audioop_lin2ulaw__doc__},
static PyObject *
audioop_lin2ulaw_impl(PyObject *module, Py_buffer *fragment, int width);
@ -762,7 +762,7 @@ 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_FASTCALL, audioop_ulaw2lin__doc__},
{"ulaw2lin", (PyCFunction)(void(*)(void))audioop_ulaw2lin, METH_FASTCALL, audioop_ulaw2lin__doc__},
static PyObject *
audioop_ulaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
@ -796,7 +796,7 @@ PyDoc_STRVAR(audioop_lin2alaw__doc__,
"Convert samples in the audio fragment to a-LAW encoding.");
#define AUDIOOP_LIN2ALAW_METHODDEF \
{"lin2alaw", (PyCFunction)audioop_lin2alaw, METH_FASTCALL, audioop_lin2alaw__doc__},
{"lin2alaw", (PyCFunction)(void(*)(void))audioop_lin2alaw, METH_FASTCALL, audioop_lin2alaw__doc__},
static PyObject *
audioop_lin2alaw_impl(PyObject *module, Py_buffer *fragment, int width);
@ -830,7 +830,7 @@ 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_FASTCALL, audioop_alaw2lin__doc__},
{"alaw2lin", (PyCFunction)(void(*)(void))audioop_alaw2lin, METH_FASTCALL, audioop_alaw2lin__doc__},
static PyObject *
audioop_alaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
@ -864,7 +864,7 @@ PyDoc_STRVAR(audioop_lin2adpcm__doc__,
"Convert samples to 4 bit Intel/DVI ADPCM encoding.");
#define AUDIOOP_LIN2ADPCM_METHODDEF \
{"lin2adpcm", (PyCFunction)audioop_lin2adpcm, METH_FASTCALL, audioop_lin2adpcm__doc__},
{"lin2adpcm", (PyCFunction)(void(*)(void))audioop_lin2adpcm, METH_FASTCALL, audioop_lin2adpcm__doc__},
static PyObject *
audioop_lin2adpcm_impl(PyObject *module, Py_buffer *fragment, int width,
@ -900,7 +900,7 @@ 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_FASTCALL, audioop_adpcm2lin__doc__},
{"adpcm2lin", (PyCFunction)(void(*)(void))audioop_adpcm2lin, METH_FASTCALL, audioop_adpcm2lin__doc__},
static PyObject *
audioop_adpcm2lin_impl(PyObject *module, Py_buffer *fragment, int width,
@ -928,4 +928,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=2f88b8827ee0aa9b input=a9049054013a1b77]*/
/*[clinic end generated code: output=d197b1559196a48a input=a9049054013a1b77]*/

14
Modules/clinic/binascii.c.h generated
View file

@ -40,7 +40,7 @@ PyDoc_STRVAR(binascii_b2a_uu__doc__,
"Uuencode line of data.");
#define BINASCII_B2A_UU_METHODDEF \
{"b2a_uu", (PyCFunction)binascii_b2a_uu, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
{"b2a_uu", (PyCFunction)(void(*)(void))binascii_b2a_uu, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
static PyObject *
binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick);
@ -107,7 +107,7 @@ PyDoc_STRVAR(binascii_b2a_base64__doc__,
"Base64-code line of data.");
#define BINASCII_B2A_BASE64_METHODDEF \
{"b2a_base64", (PyCFunction)binascii_b2a_base64, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
{"b2a_base64", (PyCFunction)(void(*)(void))binascii_b2a_base64, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
static PyObject *
binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline);
@ -270,7 +270,7 @@ PyDoc_STRVAR(binascii_crc_hqx__doc__,
"Compute CRC-CCITT incrementally.");
#define BINASCII_CRC_HQX_METHODDEF \
{"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
{"crc_hqx", (PyCFunction)(void(*)(void))binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
static unsigned int
binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
@ -309,7 +309,7 @@ PyDoc_STRVAR(binascii_crc32__doc__,
"Compute CRC-32 incrementally.");
#define BINASCII_CRC32_METHODDEF \
{"crc32", (PyCFunction)binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
{"crc32", (PyCFunction)(void(*)(void))binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
static unsigned int
binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
@ -484,7 +484,7 @@ PyDoc_STRVAR(binascii_a2b_qp__doc__,
"Decode a string of qp-encoded data.");
#define BINASCII_A2B_QP_METHODDEF \
{"a2b_qp", (PyCFunction)binascii_a2b_qp, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
{"a2b_qp", (PyCFunction)(void(*)(void))binascii_a2b_qp, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
static PyObject *
binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header);
@ -523,7 +523,7 @@ PyDoc_STRVAR(binascii_b2a_qp__doc__,
"are both encoded. When quotetabs is set, space and tabs are encoded.");
#define BINASCII_B2A_QP_METHODDEF \
{"b2a_qp", (PyCFunction)binascii_b2a_qp, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
{"b2a_qp", (PyCFunction)(void(*)(void))binascii_b2a_qp, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
static PyObject *
binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs,
@ -554,4 +554,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=815f1c453fd6568f input=a9049054013a1b77]*/
/*[clinic end generated code: output=3f45e15ce8b563b7 input=a9049054013a1b77]*/

8
Modules/clinic/cmathmodule.c.h generated
View file

@ -641,7 +641,7 @@ 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_FASTCALL, cmath_log__doc__},
{"log", (PyCFunction)(void(*)(void))cmath_log, METH_FASTCALL, cmath_log__doc__},
static PyObject *
cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj);
@ -726,7 +726,7 @@ PyDoc_STRVAR(cmath_rect__doc__,
"Convert from polar coordinates to rectangular coordinates.");
#define CMATH_RECT_METHODDEF \
{"rect", (PyCFunction)cmath_rect, METH_FASTCALL, cmath_rect__doc__},
{"rect", (PyCFunction)(void(*)(void))cmath_rect, METH_FASTCALL, cmath_rect__doc__},
static PyObject *
cmath_rect_impl(PyObject *module, double r, double phi);
@ -851,7 +851,7 @@ PyDoc_STRVAR(cmath_isclose__doc__,
"not close to anything, even itself. inf and -inf are only close to themselves.");
#define CMATH_ISCLOSE_METHODDEF \
{"isclose", (PyCFunction)cmath_isclose, METH_FASTCALL|METH_KEYWORDS, cmath_isclose__doc__},
{"isclose", (PyCFunction)(void(*)(void))cmath_isclose, METH_FASTCALL|METH_KEYWORDS, cmath_isclose__doc__},
static int
cmath_isclose_impl(PyObject *module, Py_complex a, Py_complex b,
@ -882,4 +882,4 @@ cmath_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec
exit:
return return_value;
}
/*[clinic end generated code: output=dd93c3a6aeb42ebb input=a9049054013a1b77]*/
/*[clinic end generated code: output=17f6f65a229b1ef9 input=a9049054013a1b77]*/

10
Modules/clinic/fcntlmodule.c.h generated
View file

@ -19,7 +19,7 @@ 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_FASTCALL, fcntl_fcntl__doc__},
{"fcntl", (PyCFunction)(void(*)(void))fcntl_fcntl, METH_FASTCALL, fcntl_fcntl__doc__},
static PyObject *
fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg);
@ -76,7 +76,7 @@ PyDoc_STRVAR(fcntl_ioctl__doc__,
"code.");
#define FCNTL_IOCTL_METHODDEF \
{"ioctl", (PyCFunction)fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
{"ioctl", (PyCFunction)(void(*)(void))fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
static PyObject *
fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,
@ -111,7 +111,7 @@ PyDoc_STRVAR(fcntl_flock__doc__,
"function is emulated using fcntl()).");
#define FCNTL_FLOCK_METHODDEF \
{"flock", (PyCFunction)fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
{"flock", (PyCFunction)(void(*)(void))fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
static PyObject *
fcntl_flock_impl(PyObject *module, int fd, int code);
@ -161,7 +161,7 @@ PyDoc_STRVAR(fcntl_lockf__doc__,
" 2 - relative to the end of the file (SEEK_END)");
#define FCNTL_LOCKF_METHODDEF \
{"lockf", (PyCFunction)fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
{"lockf", (PyCFunction)(void(*)(void))fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
static PyObject *
fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
@ -186,4 +186,4 @@ fcntl_lockf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
/*[clinic end generated code: output=2f6e70ae67ec8ac9 input=a9049054013a1b77]*/
/*[clinic end generated code: output=fc1a781750750a14 input=a9049054013a1b77]*/

4
Modules/clinic/gcmodule.c.h generated
View file

@ -79,7 +79,7 @@ PyDoc_STRVAR(gc_collect__doc__,
"The number of unreachable objects is returned.");
#define GC_COLLECT_METHODDEF \
{"collect", (PyCFunction)gc_collect, METH_FASTCALL|METH_KEYWORDS, gc_collect__doc__},
{"collect", (PyCFunction)(void(*)(void))gc_collect, METH_FASTCALL|METH_KEYWORDS, gc_collect__doc__},
static Py_ssize_t
gc_collect_impl(PyObject *module, int generation);
@ -325,4 +325,4 @@ gc_get_freeze_count(PyObject *module, PyObject *Py_UNUSED(ignored))
exit:
return return_value;
}
/*[clinic end generated code: output=21dc9270b10b7891 input=a9049054013a1b77]*/
/*[clinic end generated code: output=ba67a1ab58780485 input=a9049054013a1b77]*/

6
Modules/clinic/grpmodule.c.h generated
View file

@ -11,7 +11,7 @@ PyDoc_STRVAR(grp_getgrgid__doc__,
"If id is not valid, raise KeyError.");
#define GRP_GETGRGID_METHODDEF \
{"getgrgid", (PyCFunction)grp_getgrgid, METH_FASTCALL|METH_KEYWORDS, grp_getgrgid__doc__},
{"getgrgid", (PyCFunction)(void(*)(void))grp_getgrgid, METH_FASTCALL|METH_KEYWORDS, grp_getgrgid__doc__},
static PyObject *
grp_getgrgid_impl(PyObject *module, PyObject *id);
@ -43,7 +43,7 @@ PyDoc_STRVAR(grp_getgrnam__doc__,
"If name is not valid, raise KeyError.");
#define GRP_GETGRNAM_METHODDEF \
{"getgrnam", (PyCFunction)grp_getgrnam, METH_FASTCALL|METH_KEYWORDS, grp_getgrnam__doc__},
{"getgrnam", (PyCFunction)(void(*)(void))grp_getgrnam, METH_FASTCALL|METH_KEYWORDS, grp_getgrnam__doc__},
static PyObject *
grp_getgrnam_impl(PyObject *module, PyObject *name);
@ -86,4 +86,4 @@ grp_getgrall(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return grp_getgrall_impl(module);
}
/*[clinic end generated code: output=0ccba09e8ec14c81 input=a9049054013a1b77]*/
/*[clinic end generated code: output=ab10233f6015bc0a input=a9049054013a1b77]*/

4
Modules/clinic/itertoolsmodule.c.h generated
View file

@ -131,7 +131,7 @@ PyDoc_STRVAR(itertools_tee__doc__,
"Returns a tuple of n independent iterators.");
#define ITERTOOLS_TEE_METHODDEF \
{"tee", (PyCFunction)itertools_tee, METH_FASTCALL, itertools_tee__doc__},
{"tee", (PyCFunction)(void(*)(void))itertools_tee, METH_FASTCALL, itertools_tee__doc__},
static PyObject *
itertools_tee_impl(PyObject *module, PyObject *iterable, Py_ssize_t n);
@ -510,4 +510,4 @@ itertools_count(PyTypeObject *type, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
/*[clinic end generated code: output=c8c47b766deeffc3 input=a9049054013a1b77]*/
/*[clinic end generated code: output=916251f891fa84b9 input=a9049054013a1b77]*/

14
Modules/clinic/mathmodule.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(math_gcd__doc__,
"greatest common divisor of x and y");
#define MATH_GCD_METHODDEF \
{"gcd", (PyCFunction)math_gcd, METH_FASTCALL, math_gcd__doc__},
{"gcd", (PyCFunction)(void(*)(void))math_gcd, METH_FASTCALL, math_gcd__doc__},
static PyObject *
math_gcd_impl(PyObject *module, PyObject *a, PyObject *b);
@ -126,7 +126,7 @@ PyDoc_STRVAR(math_ldexp__doc__,
"This is essentially the inverse of frexp().");
#define MATH_LDEXP_METHODDEF \
{"ldexp", (PyCFunction)math_ldexp, METH_FASTCALL, math_ldexp__doc__},
{"ldexp", (PyCFunction)(void(*)(void))math_ldexp, METH_FASTCALL, math_ldexp__doc__},
static PyObject *
math_ldexp_impl(PyObject *module, double x, PyObject *i);
@ -247,7 +247,7 @@ PyDoc_STRVAR(math_fmod__doc__,
"x % y may differ.");
#define MATH_FMOD_METHODDEF \
{"fmod", (PyCFunction)math_fmod, METH_FASTCALL, math_fmod__doc__},
{"fmod", (PyCFunction)(void(*)(void))math_fmod, METH_FASTCALL, math_fmod__doc__},
static PyObject *
math_fmod_impl(PyObject *module, double x, double y);
@ -282,7 +282,7 @@ PyDoc_STRVAR(math_dist__doc__,
" sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))");
#define MATH_DIST_METHODDEF \
{"dist", (PyCFunction)math_dist, METH_FASTCALL, math_dist__doc__},
{"dist", (PyCFunction)(void(*)(void))math_dist, METH_FASTCALL, math_dist__doc__},
static PyObject *
math_dist_impl(PyObject *module, PyObject *p, PyObject *q);
@ -312,7 +312,7 @@ PyDoc_STRVAR(math_pow__doc__,
"Return x**y (x to the power of y).");
#define MATH_POW_METHODDEF \
{"pow", (PyCFunction)math_pow, METH_FASTCALL, math_pow__doc__},
{"pow", (PyCFunction)(void(*)(void))math_pow, METH_FASTCALL, math_pow__doc__},
static PyObject *
math_pow_impl(PyObject *module, double x, double y);
@ -492,7 +492,7 @@ PyDoc_STRVAR(math_isclose__doc__,
"only close to themselves.");
#define MATH_ISCLOSE_METHODDEF \
{"isclose", (PyCFunction)math_isclose, METH_FASTCALL|METH_KEYWORDS, math_isclose__doc__},
{"isclose", (PyCFunction)(void(*)(void))math_isclose, METH_FASTCALL|METH_KEYWORDS, math_isclose__doc__},
static int
math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
@ -523,4 +523,4 @@ math_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject
exit:
return return_value;
}
/*[clinic end generated code: output=239c51a5acefbafb input=a9049054013a1b77]*/
/*[clinic end generated code: output=8b1709a71e5fb855 input=a9049054013a1b77]*/

4
Modules/clinic/md5module.c.h generated
View file

@ -72,7 +72,7 @@ PyDoc_STRVAR(_md5_md5__doc__,
"Return a new MD5 hash object; optionally initialized with a string.");
#define _MD5_MD5_METHODDEF \
{"md5", (PyCFunction)_md5_md5, METH_FASTCALL|METH_KEYWORDS, _md5_md5__doc__},
{"md5", (PyCFunction)(void(*)(void))_md5_md5, METH_FASTCALL|METH_KEYWORDS, _md5_md5__doc__},
static PyObject *
_md5_md5_impl(PyObject *module, PyObject *string);
@ -94,4 +94,4 @@ _md5_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kw
exit:
return return_value;
}
/*[clinic end generated code: output=72aa003c308e26cf input=a9049054013a1b77]*/
/*[clinic end generated code: output=83cb1aef575f13bc input=a9049054013a1b77]*/

220
Modules/clinic/posixmodule.c.h generated
View file

@ -28,7 +28,7 @@ PyDoc_STRVAR(os_stat__doc__,
" an open file descriptor.");
#define OS_STAT_METHODDEF \
{"stat", (PyCFunction)os_stat, METH_FASTCALL|METH_KEYWORDS, os_stat__doc__},
{"stat", (PyCFunction)(void(*)(void))os_stat, METH_FASTCALL|METH_KEYWORDS, os_stat__doc__},
static PyObject *
os_stat_impl(PyObject *module, path_t *path, int dir_fd, int follow_symlinks);
@ -66,7 +66,7 @@ PyDoc_STRVAR(os_lstat__doc__,
"Equivalent to stat(path, follow_symlinks=False).");
#define OS_LSTAT_METHODDEF \
{"lstat", (PyCFunction)os_lstat, METH_FASTCALL|METH_KEYWORDS, os_lstat__doc__},
{"lstat", (PyCFunction)(void(*)(void))os_lstat, METH_FASTCALL|METH_KEYWORDS, os_lstat__doc__},
static PyObject *
os_lstat_impl(PyObject *module, path_t *path, int dir_fd);
@ -126,7 +126,7 @@ PyDoc_STRVAR(os_access__doc__,
" has the specified access to the path.");
#define OS_ACCESS_METHODDEF \
{"access", (PyCFunction)os_access, METH_FASTCALL|METH_KEYWORDS, os_access__doc__},
{"access", (PyCFunction)(void(*)(void))os_access, METH_FASTCALL|METH_KEYWORDS, os_access__doc__},
static int
os_access_impl(PyObject *module, path_t *path, int mode, int dir_fd,
@ -234,7 +234,7 @@ PyDoc_STRVAR(os_chdir__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_CHDIR_METHODDEF \
{"chdir", (PyCFunction)os_chdir, METH_FASTCALL|METH_KEYWORDS, os_chdir__doc__},
{"chdir", (PyCFunction)(void(*)(void))os_chdir, METH_FASTCALL|METH_KEYWORDS, os_chdir__doc__},
static PyObject *
os_chdir_impl(PyObject *module, path_t *path);
@ -272,7 +272,7 @@ PyDoc_STRVAR(os_fchdir__doc__,
"Equivalent to os.chdir(fd).");
#define OS_FCHDIR_METHODDEF \
{"fchdir", (PyCFunction)os_fchdir, METH_FASTCALL|METH_KEYWORDS, os_fchdir__doc__},
{"fchdir", (PyCFunction)(void(*)(void))os_fchdir, METH_FASTCALL|METH_KEYWORDS, os_fchdir__doc__},
static PyObject *
os_fchdir_impl(PyObject *module, int fd);
@ -324,7 +324,7 @@ PyDoc_STRVAR(os_chmod__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_CHMOD_METHODDEF \
{"chmod", (PyCFunction)os_chmod, METH_FASTCALL|METH_KEYWORDS, os_chmod__doc__},
{"chmod", (PyCFunction)(void(*)(void))os_chmod, METH_FASTCALL|METH_KEYWORDS, os_chmod__doc__},
static PyObject *
os_chmod_impl(PyObject *module, path_t *path, int mode, int dir_fd,
@ -365,7 +365,7 @@ PyDoc_STRVAR(os_fchmod__doc__,
"Equivalent to os.chmod(fd, mode).");
#define OS_FCHMOD_METHODDEF \
{"fchmod", (PyCFunction)os_fchmod, METH_FASTCALL|METH_KEYWORDS, os_fchmod__doc__},
{"fchmod", (PyCFunction)(void(*)(void))os_fchmod, METH_FASTCALL|METH_KEYWORDS, os_fchmod__doc__},
static PyObject *
os_fchmod_impl(PyObject *module, int fd, int mode);
@ -403,7 +403,7 @@ PyDoc_STRVAR(os_lchmod__doc__,
"Equivalent to chmod(path, mode, follow_symlinks=False).\"");
#define OS_LCHMOD_METHODDEF \
{"lchmod", (PyCFunction)os_lchmod, METH_FASTCALL|METH_KEYWORDS, os_lchmod__doc__},
{"lchmod", (PyCFunction)(void(*)(void))os_lchmod, METH_FASTCALL|METH_KEYWORDS, os_lchmod__doc__},
static PyObject *
os_lchmod_impl(PyObject *module, path_t *path, int mode);
@ -447,7 +447,7 @@ PyDoc_STRVAR(os_chflags__doc__,
"unavailable, using it will raise a NotImplementedError.");
#define OS_CHFLAGS_METHODDEF \
{"chflags", (PyCFunction)os_chflags, METH_FASTCALL|METH_KEYWORDS, os_chflags__doc__},
{"chflags", (PyCFunction)(void(*)(void))os_chflags, METH_FASTCALL|METH_KEYWORDS, os_chflags__doc__},
static PyObject *
os_chflags_impl(PyObject *module, path_t *path, unsigned long flags,
@ -490,7 +490,7 @@ PyDoc_STRVAR(os_lchflags__doc__,
"Equivalent to chflags(path, flags, follow_symlinks=False).");
#define OS_LCHFLAGS_METHODDEF \
{"lchflags", (PyCFunction)os_lchflags, METH_FASTCALL|METH_KEYWORDS, os_lchflags__doc__},
{"lchflags", (PyCFunction)(void(*)(void))os_lchflags, METH_FASTCALL|METH_KEYWORDS, os_lchflags__doc__},
static PyObject *
os_lchflags_impl(PyObject *module, path_t *path, unsigned long flags);
@ -528,7 +528,7 @@ PyDoc_STRVAR(os_chroot__doc__,
"Change root directory to path.");
#define OS_CHROOT_METHODDEF \
{"chroot", (PyCFunction)os_chroot, METH_FASTCALL|METH_KEYWORDS, os_chroot__doc__},
{"chroot", (PyCFunction)(void(*)(void))os_chroot, METH_FASTCALL|METH_KEYWORDS, os_chroot__doc__},
static PyObject *
os_chroot_impl(PyObject *module, path_t *path);
@ -565,7 +565,7 @@ PyDoc_STRVAR(os_fsync__doc__,
"Force write of fd to disk.");
#define OS_FSYNC_METHODDEF \
{"fsync", (PyCFunction)os_fsync, METH_FASTCALL|METH_KEYWORDS, os_fsync__doc__},
{"fsync", (PyCFunction)(void(*)(void))os_fsync, METH_FASTCALL|METH_KEYWORDS, os_fsync__doc__},
static PyObject *
os_fsync_impl(PyObject *module, int fd);
@ -621,7 +621,7 @@ PyDoc_STRVAR(os_fdatasync__doc__,
"Force write of fd to disk without forcing update of metadata.");
#define OS_FDATASYNC_METHODDEF \
{"fdatasync", (PyCFunction)os_fdatasync, METH_FASTCALL|METH_KEYWORDS, os_fdatasync__doc__},
{"fdatasync", (PyCFunction)(void(*)(void))os_fdatasync, METH_FASTCALL|METH_KEYWORDS, os_fdatasync__doc__},
static PyObject *
os_fdatasync_impl(PyObject *module, int fd);
@ -679,7 +679,7 @@ PyDoc_STRVAR(os_chown__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_CHOWN_METHODDEF \
{"chown", (PyCFunction)os_chown, METH_FASTCALL|METH_KEYWORDS, os_chown__doc__},
{"chown", (PyCFunction)(void(*)(void))os_chown, METH_FASTCALL|METH_KEYWORDS, os_chown__doc__},
static PyObject *
os_chown_impl(PyObject *module, path_t *path, uid_t uid, gid_t gid,
@ -723,7 +723,7 @@ PyDoc_STRVAR(os_fchown__doc__,
"Equivalent to os.chown(fd, uid, gid).");
#define OS_FCHOWN_METHODDEF \
{"fchown", (PyCFunction)os_fchown, METH_FASTCALL|METH_KEYWORDS, os_fchown__doc__},
{"fchown", (PyCFunction)(void(*)(void))os_fchown, METH_FASTCALL|METH_KEYWORDS, os_fchown__doc__},
static PyObject *
os_fchown_impl(PyObject *module, int fd, uid_t uid, gid_t gid);
@ -762,7 +762,7 @@ PyDoc_STRVAR(os_lchown__doc__,
"Equivalent to os.chown(path, uid, gid, follow_symlinks=False).");
#define OS_LCHOWN_METHODDEF \
{"lchown", (PyCFunction)os_lchown, METH_FASTCALL|METH_KEYWORDS, os_lchown__doc__},
{"lchown", (PyCFunction)(void(*)(void))os_lchown, METH_FASTCALL|METH_KEYWORDS, os_lchown__doc__},
static PyObject *
os_lchown_impl(PyObject *module, path_t *path, uid_t uid, gid_t gid);
@ -848,7 +848,7 @@ PyDoc_STRVAR(os_link__doc__,
" NotImplementedError.");
#define OS_LINK_METHODDEF \
{"link", (PyCFunction)os_link, METH_FASTCALL|METH_KEYWORDS, os_link__doc__},
{"link", (PyCFunction)(void(*)(void))os_link, METH_FASTCALL|METH_KEYWORDS, os_link__doc__},
static PyObject *
os_link_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,
@ -901,7 +901,7 @@ PyDoc_STRVAR(os_listdir__doc__,
"entries \'.\' and \'..\' even if they are present in the directory.");
#define OS_LISTDIR_METHODDEF \
{"listdir", (PyCFunction)os_listdir, METH_FASTCALL|METH_KEYWORDS, os_listdir__doc__},
{"listdir", (PyCFunction)(void(*)(void))os_listdir, METH_FASTCALL|METH_KEYWORDS, os_listdir__doc__},
static PyObject *
os_listdir_impl(PyObject *module, path_t *path);
@ -1016,7 +1016,7 @@ PyDoc_STRVAR(os__getvolumepathname__doc__,
"A helper function for ismount on Win32.");
#define OS__GETVOLUMEPATHNAME_METHODDEF \
{"_getvolumepathname", (PyCFunction)os__getvolumepathname, METH_FASTCALL|METH_KEYWORDS, os__getvolumepathname__doc__},
{"_getvolumepathname", (PyCFunction)(void(*)(void))os__getvolumepathname, METH_FASTCALL|METH_KEYWORDS, os__getvolumepathname__doc__},
static PyObject *
os__getvolumepathname_impl(PyObject *module, path_t *path);
@ -1058,7 +1058,7 @@ PyDoc_STRVAR(os_mkdir__doc__,
"The mode argument is ignored on Windows.");
#define OS_MKDIR_METHODDEF \
{"mkdir", (PyCFunction)os_mkdir, METH_FASTCALL|METH_KEYWORDS, os_mkdir__doc__},
{"mkdir", (PyCFunction)(void(*)(void))os_mkdir, METH_FASTCALL|METH_KEYWORDS, os_mkdir__doc__},
static PyObject *
os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd);
@ -1126,7 +1126,7 @@ PyDoc_STRVAR(os_getpriority__doc__,
"Return program scheduling priority.");
#define OS_GETPRIORITY_METHODDEF \
{"getpriority", (PyCFunction)os_getpriority, METH_FASTCALL|METH_KEYWORDS, os_getpriority__doc__},
{"getpriority", (PyCFunction)(void(*)(void))os_getpriority, METH_FASTCALL|METH_KEYWORDS, os_getpriority__doc__},
static PyObject *
os_getpriority_impl(PyObject *module, int which, int who);
@ -1161,7 +1161,7 @@ PyDoc_STRVAR(os_setpriority__doc__,
"Set program scheduling priority.");
#define OS_SETPRIORITY_METHODDEF \
{"setpriority", (PyCFunction)os_setpriority, METH_FASTCALL|METH_KEYWORDS, os_setpriority__doc__},
{"setpriority", (PyCFunction)(void(*)(void))os_setpriority, METH_FASTCALL|METH_KEYWORDS, os_setpriority__doc__},
static PyObject *
os_setpriority_impl(PyObject *module, int which, int who, int priority);
@ -1201,7 +1201,7 @@ PyDoc_STRVAR(os_rename__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_RENAME_METHODDEF \
{"rename", (PyCFunction)os_rename, METH_FASTCALL|METH_KEYWORDS, os_rename__doc__},
{"rename", (PyCFunction)(void(*)(void))os_rename, METH_FASTCALL|METH_KEYWORDS, os_rename__doc__},
static PyObject *
os_rename_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,
@ -1246,7 +1246,7 @@ PyDoc_STRVAR(os_replace__doc__,
" If they are unavailable, using them will raise a NotImplementedError.\"");
#define OS_REPLACE_METHODDEF \
{"replace", (PyCFunction)os_replace, METH_FASTCALL|METH_KEYWORDS, os_replace__doc__},
{"replace", (PyCFunction)(void(*)(void))os_replace, METH_FASTCALL|METH_KEYWORDS, os_replace__doc__},
static PyObject *
os_replace_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,
@ -1290,7 +1290,7 @@ PyDoc_STRVAR(os_rmdir__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_RMDIR_METHODDEF \
{"rmdir", (PyCFunction)os_rmdir, METH_FASTCALL|METH_KEYWORDS, os_rmdir__doc__},
{"rmdir", (PyCFunction)(void(*)(void))os_rmdir, METH_FASTCALL|METH_KEYWORDS, os_rmdir__doc__},
static PyObject *
os_rmdir_impl(PyObject *module, path_t *path, int dir_fd);
@ -1326,7 +1326,7 @@ PyDoc_STRVAR(os_system__doc__,
"Execute the command in a subshell.");
#define OS_SYSTEM_METHODDEF \
{"system", (PyCFunction)os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
{"system", (PyCFunction)(void(*)(void))os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
static long
os_system_impl(PyObject *module, Py_UNICODE *command);
@ -1365,7 +1365,7 @@ PyDoc_STRVAR(os_system__doc__,
"Execute the command in a subshell.");
#define OS_SYSTEM_METHODDEF \
{"system", (PyCFunction)os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
{"system", (PyCFunction)(void(*)(void))os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
static long
os_system_impl(PyObject *module, PyObject *command);
@ -1437,7 +1437,7 @@ PyDoc_STRVAR(os_unlink__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_UNLINK_METHODDEF \
{"unlink", (PyCFunction)os_unlink, METH_FASTCALL|METH_KEYWORDS, os_unlink__doc__},
{"unlink", (PyCFunction)(void(*)(void))os_unlink, METH_FASTCALL|METH_KEYWORDS, os_unlink__doc__},
static PyObject *
os_unlink_impl(PyObject *module, path_t *path, int dir_fd);
@ -1476,7 +1476,7 @@ PyDoc_STRVAR(os_remove__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_REMOVE_METHODDEF \
{"remove", (PyCFunction)os_remove, METH_FASTCALL|METH_KEYWORDS, os_remove__doc__},
{"remove", (PyCFunction)(void(*)(void))os_remove, METH_FASTCALL|METH_KEYWORDS, os_remove__doc__},
static PyObject *
os_remove_impl(PyObject *module, path_t *path, int dir_fd);
@ -1558,7 +1558,7 @@ PyDoc_STRVAR(os_utime__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_UTIME_METHODDEF \
{"utime", (PyCFunction)os_utime, METH_FASTCALL|METH_KEYWORDS, os_utime__doc__},
{"utime", (PyCFunction)(void(*)(void))os_utime, METH_FASTCALL|METH_KEYWORDS, os_utime__doc__},
static PyObject *
os_utime_impl(PyObject *module, path_t *path, PyObject *times, PyObject *ns,
@ -1596,7 +1596,7 @@ PyDoc_STRVAR(os__exit__doc__,
"Exit to the system with specified status, without normal exit processing.");
#define OS__EXIT_METHODDEF \
{"_exit", (PyCFunction)os__exit, METH_FASTCALL|METH_KEYWORDS, os__exit__doc__},
{"_exit", (PyCFunction)(void(*)(void))os__exit, METH_FASTCALL|METH_KEYWORDS, os__exit__doc__},
static PyObject *
os__exit_impl(PyObject *module, int status);
@ -1633,7 +1633,7 @@ PyDoc_STRVAR(os_execv__doc__,
" Tuple or list of strings.");
#define OS_EXECV_METHODDEF \
{"execv", (PyCFunction)os_execv, METH_FASTCALL, os_execv__doc__},
{"execv", (PyCFunction)(void(*)(void))os_execv, METH_FASTCALL, os_execv__doc__},
static PyObject *
os_execv_impl(PyObject *module, path_t *path, PyObject *argv);
@ -1676,7 +1676,7 @@ PyDoc_STRVAR(os_execve__doc__,
" Dictionary of strings mapping to strings.");
#define OS_EXECVE_METHODDEF \
{"execve", (PyCFunction)os_execve, METH_FASTCALL|METH_KEYWORDS, os_execve__doc__},
{"execve", (PyCFunction)(void(*)(void))os_execve, METH_FASTCALL|METH_KEYWORDS, os_execve__doc__},
static PyObject *
os_execve_impl(PyObject *module, path_t *path, PyObject *argv, PyObject *env);
@ -1736,7 +1736,7 @@ PyDoc_STRVAR(os_posix_spawn__doc__,
" A tuple with the scheduler policy (optional) and parameters.");
#define OS_POSIX_SPAWN_METHODDEF \
{"posix_spawn", (PyCFunction)os_posix_spawn, METH_FASTCALL|METH_KEYWORDS, os_posix_spawn__doc__},
{"posix_spawn", (PyCFunction)(void(*)(void))os_posix_spawn, METH_FASTCALL|METH_KEYWORDS, os_posix_spawn__doc__},
static PyObject *
os_posix_spawn_impl(PyObject *module, path_t *path, PyObject *argv,
@ -1791,7 +1791,7 @@ PyDoc_STRVAR(os_spawnv__doc__,
" Tuple or list of strings.");
#define OS_SPAWNV_METHODDEF \
{"spawnv", (PyCFunction)os_spawnv, METH_FASTCALL, os_spawnv__doc__},
{"spawnv", (PyCFunction)(void(*)(void))os_spawnv, METH_FASTCALL, os_spawnv__doc__},
static PyObject *
os_spawnv_impl(PyObject *module, int mode, path_t *path, PyObject *argv);
@ -1837,7 +1837,7 @@ PyDoc_STRVAR(os_spawnve__doc__,
" Dictionary of strings mapping to strings.");
#define OS_SPAWNVE_METHODDEF \
{"spawnve", (PyCFunction)os_spawnve, METH_FASTCALL, os_spawnve__doc__},
{"spawnve", (PyCFunction)(void(*)(void))os_spawnve, METH_FASTCALL, os_spawnve__doc__},
static PyObject *
os_spawnve_impl(PyObject *module, int mode, path_t *path, PyObject *argv,
@ -1887,7 +1887,7 @@ PyDoc_STRVAR(os_register_at_fork__doc__,
"\'after_in_child\' and \'after_in_parent\' callbacks are called in order.");
#define OS_REGISTER_AT_FORK_METHODDEF \
{"register_at_fork", (PyCFunction)os_register_at_fork, METH_FASTCALL|METH_KEYWORDS, os_register_at_fork__doc__},
{"register_at_fork", (PyCFunction)(void(*)(void))os_register_at_fork, METH_FASTCALL|METH_KEYWORDS, os_register_at_fork__doc__},
static PyObject *
os_register_at_fork_impl(PyObject *module, PyObject *before,
@ -1972,7 +1972,7 @@ PyDoc_STRVAR(os_sched_get_priority_max__doc__,
"Get the maximum scheduling priority for policy.");
#define OS_SCHED_GET_PRIORITY_MAX_METHODDEF \
{"sched_get_priority_max", (PyCFunction)os_sched_get_priority_max, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_max__doc__},
{"sched_get_priority_max", (PyCFunction)(void(*)(void))os_sched_get_priority_max, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_max__doc__},
static PyObject *
os_sched_get_priority_max_impl(PyObject *module, int policy);
@ -2006,7 +2006,7 @@ PyDoc_STRVAR(os_sched_get_priority_min__doc__,
"Get the minimum scheduling priority for policy.");
#define OS_SCHED_GET_PRIORITY_MIN_METHODDEF \
{"sched_get_priority_min", (PyCFunction)os_sched_get_priority_min, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_min__doc__},
{"sched_get_priority_min", (PyCFunction)(void(*)(void))os_sched_get_priority_min, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_min__doc__},
static PyObject *
os_sched_get_priority_min_impl(PyObject *module, int policy);
@ -2110,7 +2110,7 @@ PyDoc_STRVAR(os_sched_setscheduler__doc__,
"param is an instance of sched_param.");
#define OS_SCHED_SETSCHEDULER_METHODDEF \
{"sched_setscheduler", (PyCFunction)os_sched_setscheduler, METH_FASTCALL, os_sched_setscheduler__doc__},
{"sched_setscheduler", (PyCFunction)(void(*)(void))os_sched_setscheduler, METH_FASTCALL, os_sched_setscheduler__doc__},
static PyObject *
os_sched_setscheduler_impl(PyObject *module, pid_t pid, int policy,
@ -2182,7 +2182,7 @@ PyDoc_STRVAR(os_sched_setparam__doc__,
"param should be an instance of sched_param.");
#define OS_SCHED_SETPARAM_METHODDEF \
{"sched_setparam", (PyCFunction)os_sched_setparam, METH_FASTCALL, os_sched_setparam__doc__},
{"sched_setparam", (PyCFunction)(void(*)(void))os_sched_setparam, METH_FASTCALL, os_sched_setparam__doc__},
static PyObject *
os_sched_setparam_impl(PyObject *module, pid_t pid,
@ -2278,7 +2278,7 @@ PyDoc_STRVAR(os_sched_setaffinity__doc__,
"mask should be an iterable of integers identifying CPUs.");
#define OS_SCHED_SETAFFINITY_METHODDEF \
{"sched_setaffinity", (PyCFunction)os_sched_setaffinity, METH_FASTCALL, os_sched_setaffinity__doc__},
{"sched_setaffinity", (PyCFunction)(void(*)(void))os_sched_setaffinity, METH_FASTCALL, os_sched_setaffinity__doc__},
static PyObject *
os_sched_setaffinity_impl(PyObject *module, pid_t pid, PyObject *mask);
@ -2506,7 +2506,7 @@ PyDoc_STRVAR(os_getpgid__doc__,
"Call the system call getpgid(), and return the result.");
#define OS_GETPGID_METHODDEF \
{"getpgid", (PyCFunction)os_getpgid, METH_FASTCALL|METH_KEYWORDS, os_getpgid__doc__},
{"getpgid", (PyCFunction)(void(*)(void))os_getpgid, METH_FASTCALL|METH_KEYWORDS, os_getpgid__doc__},
static PyObject *
os_getpgid_impl(PyObject *module, pid_t pid);
@ -2653,7 +2653,7 @@ PyDoc_STRVAR(os_kill__doc__,
"Kill a process with a signal.");
#define OS_KILL_METHODDEF \
{"kill", (PyCFunction)os_kill, METH_FASTCALL, os_kill__doc__},
{"kill", (PyCFunction)(void(*)(void))os_kill, METH_FASTCALL, os_kill__doc__},
static PyObject *
os_kill_impl(PyObject *module, pid_t pid, Py_ssize_t signal);
@ -2686,7 +2686,7 @@ PyDoc_STRVAR(os_killpg__doc__,
"Kill a process group with a signal.");
#define OS_KILLPG_METHODDEF \
{"killpg", (PyCFunction)os_killpg, METH_FASTCALL, os_killpg__doc__},
{"killpg", (PyCFunction)(void(*)(void))os_killpg, METH_FASTCALL, os_killpg__doc__},
static PyObject *
os_killpg_impl(PyObject *module, pid_t pgid, int signal);
@ -2843,7 +2843,7 @@ PyDoc_STRVAR(os_setreuid__doc__,
"Set the current process\'s real and effective user ids.");
#define OS_SETREUID_METHODDEF \
{"setreuid", (PyCFunction)os_setreuid, METH_FASTCALL, os_setreuid__doc__},
{"setreuid", (PyCFunction)(void(*)(void))os_setreuid, METH_FASTCALL, os_setreuid__doc__},
static PyObject *
os_setreuid_impl(PyObject *module, uid_t ruid, uid_t euid);
@ -2876,7 +2876,7 @@ PyDoc_STRVAR(os_setregid__doc__,
"Set the current process\'s real and effective group ids.");
#define OS_SETREGID_METHODDEF \
{"setregid", (PyCFunction)os_setregid, METH_FASTCALL, os_setregid__doc__},
{"setregid", (PyCFunction)(void(*)(void))os_setregid, METH_FASTCALL, os_setregid__doc__},
static PyObject *
os_setregid_impl(PyObject *module, gid_t rgid, gid_t egid);
@ -2956,7 +2956,7 @@ PyDoc_STRVAR(os_wait3__doc__,
" (pid, status, rusage)");
#define OS_WAIT3_METHODDEF \
{"wait3", (PyCFunction)os_wait3, METH_FASTCALL|METH_KEYWORDS, os_wait3__doc__},
{"wait3", (PyCFunction)(void(*)(void))os_wait3, METH_FASTCALL|METH_KEYWORDS, os_wait3__doc__},
static PyObject *
os_wait3_impl(PyObject *module, int options);
@ -2993,7 +2993,7 @@ PyDoc_STRVAR(os_wait4__doc__,
" (pid, status, rusage)");
#define OS_WAIT4_METHODDEF \
{"wait4", (PyCFunction)os_wait4, METH_FASTCALL|METH_KEYWORDS, os_wait4__doc__},
{"wait4", (PyCFunction)(void(*)(void))os_wait4, METH_FASTCALL|METH_KEYWORDS, os_wait4__doc__},
static PyObject *
os_wait4_impl(PyObject *module, pid_t pid, int options);
@ -3039,7 +3039,7 @@ PyDoc_STRVAR(os_waitid__doc__,
"no children in a waitable state.");
#define OS_WAITID_METHODDEF \
{"waitid", (PyCFunction)os_waitid, METH_FASTCALL, os_waitid__doc__},
{"waitid", (PyCFunction)(void(*)(void))os_waitid, METH_FASTCALL, os_waitid__doc__},
static PyObject *
os_waitid_impl(PyObject *module, idtype_t idtype, id_t id, int options);
@ -3078,7 +3078,7 @@ PyDoc_STRVAR(os_waitpid__doc__,
"The options argument is ignored on Windows.");
#define OS_WAITPID_METHODDEF \
{"waitpid", (PyCFunction)os_waitpid, METH_FASTCALL, os_waitpid__doc__},
{"waitpid", (PyCFunction)(void(*)(void))os_waitpid, METH_FASTCALL, os_waitpid__doc__},
static PyObject *
os_waitpid_impl(PyObject *module, pid_t pid, int options);
@ -3116,7 +3116,7 @@ PyDoc_STRVAR(os_waitpid__doc__,
"The options argument is ignored on Windows.");
#define OS_WAITPID_METHODDEF \
{"waitpid", (PyCFunction)os_waitpid, METH_FASTCALL, os_waitpid__doc__},
{"waitpid", (PyCFunction)(void(*)(void))os_waitpid, METH_FASTCALL, os_waitpid__doc__},
static PyObject *
os_waitpid_impl(PyObject *module, intptr_t pid, int options);
@ -3180,7 +3180,7 @@ PyDoc_STRVAR(os_readlink__doc__,
"using it will raise a NotImplementedError.");
#define OS_READLINK_METHODDEF \
{"readlink", (PyCFunction)os_readlink, METH_FASTCALL|METH_KEYWORDS, os_readlink__doc__},
{"readlink", (PyCFunction)(void(*)(void))os_readlink, METH_FASTCALL|METH_KEYWORDS, os_readlink__doc__},
static PyObject *
os_readlink_impl(PyObject *module, path_t *path, int dir_fd);
@ -3228,7 +3228,7 @@ PyDoc_STRVAR(os_symlink__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_SYMLINK_METHODDEF \
{"symlink", (PyCFunction)os_symlink, METH_FASTCALL|METH_KEYWORDS, os_symlink__doc__},
{"symlink", (PyCFunction)(void(*)(void))os_symlink, METH_FASTCALL|METH_KEYWORDS, os_symlink__doc__},
static PyObject *
os_symlink_impl(PyObject *module, path_t *src, path_t *dst,
@ -3350,7 +3350,7 @@ PyDoc_STRVAR(os_setpgid__doc__,
"Call the system call setpgid(pid, pgrp).");
#define OS_SETPGID_METHODDEF \
{"setpgid", (PyCFunction)os_setpgid, METH_FASTCALL, os_setpgid__doc__},
{"setpgid", (PyCFunction)(void(*)(void))os_setpgid, METH_FASTCALL, os_setpgid__doc__},
static PyObject *
os_setpgid_impl(PyObject *module, pid_t pid, pid_t pgrp);
@ -3414,7 +3414,7 @@ PyDoc_STRVAR(os_tcsetpgrp__doc__,
"Set the process group associated with the terminal specified by fd.");
#define OS_TCSETPGRP_METHODDEF \
{"tcsetpgrp", (PyCFunction)os_tcsetpgrp, METH_FASTCALL, os_tcsetpgrp__doc__},
{"tcsetpgrp", (PyCFunction)(void(*)(void))os_tcsetpgrp, METH_FASTCALL, os_tcsetpgrp__doc__},
static PyObject *
os_tcsetpgrp_impl(PyObject *module, int fd, pid_t pgid);
@ -3450,7 +3450,7 @@ PyDoc_STRVAR(os_open__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_OPEN_METHODDEF \
{"open", (PyCFunction)os_open, METH_FASTCALL|METH_KEYWORDS, os_open__doc__},
{"open", (PyCFunction)(void(*)(void))os_open, METH_FASTCALL|METH_KEYWORDS, os_open__doc__},
static int
os_open_impl(PyObject *module, path_t *path, int flags, int mode, int dir_fd);
@ -3491,7 +3491,7 @@ PyDoc_STRVAR(os_close__doc__,
"Close a file descriptor.");
#define OS_CLOSE_METHODDEF \
{"close", (PyCFunction)os_close, METH_FASTCALL|METH_KEYWORDS, os_close__doc__},
{"close", (PyCFunction)(void(*)(void))os_close, METH_FASTCALL|METH_KEYWORDS, os_close__doc__},
static PyObject *
os_close_impl(PyObject *module, int fd);
@ -3521,7 +3521,7 @@ PyDoc_STRVAR(os_closerange__doc__,
"Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
#define OS_CLOSERANGE_METHODDEF \
{"closerange", (PyCFunction)os_closerange, METH_FASTCALL, os_closerange__doc__},
{"closerange", (PyCFunction)(void(*)(void))os_closerange, METH_FASTCALL, os_closerange__doc__},
static PyObject *
os_closerange_impl(PyObject *module, int fd_low, int fd_high);
@ -3582,7 +3582,7 @@ PyDoc_STRVAR(os_dup2__doc__,
"Duplicate file descriptor.");
#define OS_DUP2_METHODDEF \
{"dup2", (PyCFunction)os_dup2, METH_FASTCALL|METH_KEYWORDS, os_dup2__doc__},
{"dup2", (PyCFunction)(void(*)(void))os_dup2, METH_FASTCALL|METH_KEYWORDS, os_dup2__doc__},
static int
os_dup2_impl(PyObject *module, int fd, int fd2, int inheritable);
@ -3628,7 +3628,7 @@ PyDoc_STRVAR(os_lockf__doc__,
" The number of bytes to lock, starting at the current position.");
#define OS_LOCKF_METHODDEF \
{"lockf", (PyCFunction)os_lockf, METH_FASTCALL, os_lockf__doc__},
{"lockf", (PyCFunction)(void(*)(void))os_lockf, METH_FASTCALL, os_lockf__doc__},
static PyObject *
os_lockf_impl(PyObject *module, int fd, int command, Py_off_t length);
@ -3663,7 +3663,7 @@ PyDoc_STRVAR(os_lseek__doc__,
"relative to the beginning of the file.");
#define OS_LSEEK_METHODDEF \
{"lseek", (PyCFunction)os_lseek, METH_FASTCALL, os_lseek__doc__},
{"lseek", (PyCFunction)(void(*)(void))os_lseek, METH_FASTCALL, os_lseek__doc__},
static Py_off_t
os_lseek_impl(PyObject *module, int fd, Py_off_t position, int how);
@ -3698,7 +3698,7 @@ PyDoc_STRVAR(os_read__doc__,
"Read from a file descriptor. Returns a bytes object.");
#define OS_READ_METHODDEF \
{"read", (PyCFunction)os_read, METH_FASTCALL, os_read__doc__},
{"read", (PyCFunction)(void(*)(void))os_read, METH_FASTCALL, os_read__doc__},
static PyObject *
os_read_impl(PyObject *module, int fd, Py_ssize_t length);
@ -3737,7 +3737,7 @@ PyDoc_STRVAR(os_readv__doc__,
"which may be less than the total capacity of all the buffers.");
#define OS_READV_METHODDEF \
{"readv", (PyCFunction)os_readv, METH_FASTCALL, os_readv__doc__},
{"readv", (PyCFunction)(void(*)(void))os_readv, METH_FASTCALL, os_readv__doc__},
static Py_ssize_t
os_readv_impl(PyObject *module, int fd, PyObject *buffers);
@ -3778,7 +3778,7 @@ PyDoc_STRVAR(os_pread__doc__,
"the beginning of the file. The file offset remains unchanged.");
#define OS_PREAD_METHODDEF \
{"pread", (PyCFunction)os_pread, METH_FASTCALL, os_pread__doc__},
{"pread", (PyCFunction)(void(*)(void))os_pread, METH_FASTCALL, os_pread__doc__},
static PyObject *
os_pread_impl(PyObject *module, int fd, int length, Py_off_t offset);
@ -3826,7 +3826,7 @@ PyDoc_STRVAR(os_preadv__doc__,
"Using non-zero flags requires Linux 4.6 or newer.");
#define OS_PREADV_METHODDEF \
{"preadv", (PyCFunction)os_preadv, METH_FASTCALL, os_preadv__doc__},
{"preadv", (PyCFunction)(void(*)(void))os_preadv, METH_FASTCALL, os_preadv__doc__},
static Py_ssize_t
os_preadv_impl(PyObject *module, int fd, PyObject *buffers, Py_off_t offset,
@ -3865,7 +3865,7 @@ PyDoc_STRVAR(os_write__doc__,
"Write a bytes object to a file descriptor.");
#define OS_WRITE_METHODDEF \
{"write", (PyCFunction)os_write, METH_FASTCALL, os_write__doc__},
{"write", (PyCFunction)(void(*)(void))os_write, METH_FASTCALL, os_write__doc__},
static Py_ssize_t
os_write_impl(PyObject *module, int fd, Py_buffer *data);
@ -3906,7 +3906,7 @@ PyDoc_STRVAR(os__fcopyfile__doc__,
"Efficiently copy content or metadata of 2 regular file descriptors (macOS).");
#define OS__FCOPYFILE_METHODDEF \
{"_fcopyfile", (PyCFunction)os__fcopyfile, METH_FASTCALL, os__fcopyfile__doc__},
{"_fcopyfile", (PyCFunction)(void(*)(void))os__fcopyfile, METH_FASTCALL, os__fcopyfile__doc__},
static PyObject *
os__fcopyfile_impl(PyObject *module, int infd, int outfd, int flags);
@ -3941,7 +3941,7 @@ PyDoc_STRVAR(os_fstat__doc__,
"Equivalent to os.stat(fd).");
#define OS_FSTAT_METHODDEF \
{"fstat", (PyCFunction)os_fstat, METH_FASTCALL|METH_KEYWORDS, os_fstat__doc__},
{"fstat", (PyCFunction)(void(*)(void))os_fstat, METH_FASTCALL|METH_KEYWORDS, os_fstat__doc__},
static PyObject *
os_fstat_impl(PyObject *module, int fd);
@ -4073,7 +4073,7 @@ PyDoc_STRVAR(os_writev__doc__,
"buffers must be a sequence of bytes-like objects.");
#define OS_WRITEV_METHODDEF \
{"writev", (PyCFunction)os_writev, METH_FASTCALL, os_writev__doc__},
{"writev", (PyCFunction)(void(*)(void))os_writev, METH_FASTCALL, os_writev__doc__},
static Py_ssize_t
os_writev_impl(PyObject *module, int fd, PyObject *buffers);
@ -4115,7 +4115,7 @@ PyDoc_STRVAR(os_pwrite__doc__,
"current file offset.");
#define OS_PWRITE_METHODDEF \
{"pwrite", (PyCFunction)os_pwrite, METH_FASTCALL, os_pwrite__doc__},
{"pwrite", (PyCFunction)(void(*)(void))os_pwrite, METH_FASTCALL, os_pwrite__doc__},
static Py_ssize_t
os_pwrite_impl(PyObject *module, int fd, Py_buffer *buffer, Py_off_t offset);
@ -4173,7 +4173,7 @@ PyDoc_STRVAR(os_pwritev__doc__,
"Using non-zero flags requires Linux 4.7 or newer.");
#define OS_PWRITEV_METHODDEF \
{"pwritev", (PyCFunction)os_pwritev, METH_FASTCALL, os_pwritev__doc__},
{"pwritev", (PyCFunction)(void(*)(void))os_pwritev, METH_FASTCALL, os_pwritev__doc__},
static Py_ssize_t
os_pwritev_impl(PyObject *module, int fd, PyObject *buffers, Py_off_t offset,
@ -4219,7 +4219,7 @@ PyDoc_STRVAR(os_mkfifo__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_MKFIFO_METHODDEF \
{"mkfifo", (PyCFunction)os_mkfifo, METH_FASTCALL|METH_KEYWORDS, os_mkfifo__doc__},
{"mkfifo", (PyCFunction)(void(*)(void))os_mkfifo, METH_FASTCALL|METH_KEYWORDS, os_mkfifo__doc__},
static PyObject *
os_mkfifo_impl(PyObject *module, path_t *path, int mode, int dir_fd);
@ -4270,7 +4270,7 @@ PyDoc_STRVAR(os_mknod__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_MKNOD_METHODDEF \
{"mknod", (PyCFunction)os_mknod, METH_FASTCALL|METH_KEYWORDS, os_mknod__doc__},
{"mknod", (PyCFunction)(void(*)(void))os_mknod, METH_FASTCALL|METH_KEYWORDS, os_mknod__doc__},
static PyObject *
os_mknod_impl(PyObject *module, path_t *path, int mode, dev_t device,
@ -4383,7 +4383,7 @@ PyDoc_STRVAR(os_makedev__doc__,
"Composes a raw device number from the major and minor device numbers.");
#define OS_MAKEDEV_METHODDEF \
{"makedev", (PyCFunction)os_makedev, METH_FASTCALL, os_makedev__doc__},
{"makedev", (PyCFunction)(void(*)(void))os_makedev, METH_FASTCALL, os_makedev__doc__},
static dev_t
os_makedev_impl(PyObject *module, int major, int minor);
@ -4421,7 +4421,7 @@ PyDoc_STRVAR(os_ftruncate__doc__,
"Truncate a file, specified by file descriptor, to a specific length.");
#define OS_FTRUNCATE_METHODDEF \
{"ftruncate", (PyCFunction)os_ftruncate, METH_FASTCALL, os_ftruncate__doc__},
{"ftruncate", (PyCFunction)(void(*)(void))os_ftruncate, METH_FASTCALL, os_ftruncate__doc__},
static PyObject *
os_ftruncate_impl(PyObject *module, int fd, Py_off_t length);
@ -4457,7 +4457,7 @@ PyDoc_STRVAR(os_truncate__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_TRUNCATE_METHODDEF \
{"truncate", (PyCFunction)os_truncate, METH_FASTCALL|METH_KEYWORDS, os_truncate__doc__},
{"truncate", (PyCFunction)(void(*)(void))os_truncate, METH_FASTCALL|METH_KEYWORDS, os_truncate__doc__},
static PyObject *
os_truncate_impl(PyObject *module, path_t *path, Py_off_t length);
@ -4498,7 +4498,7 @@ PyDoc_STRVAR(os_posix_fallocate__doc__,
"starting at offset bytes from the beginning and continuing for length bytes.");
#define OS_POSIX_FALLOCATE_METHODDEF \
{"posix_fallocate", (PyCFunction)os_posix_fallocate, METH_FASTCALL, os_posix_fallocate__doc__},
{"posix_fallocate", (PyCFunction)(void(*)(void))os_posix_fallocate, METH_FASTCALL, os_posix_fallocate__doc__},
static PyObject *
os_posix_fallocate_impl(PyObject *module, int fd, Py_off_t offset,
@ -4541,7 +4541,7 @@ PyDoc_STRVAR(os_posix_fadvise__doc__,
"POSIX_FADV_DONTNEED.");
#define OS_POSIX_FADVISE_METHODDEF \
{"posix_fadvise", (PyCFunction)os_posix_fadvise, METH_FASTCALL, os_posix_fadvise__doc__},
{"posix_fadvise", (PyCFunction)(void(*)(void))os_posix_fadvise, METH_FASTCALL, os_posix_fadvise__doc__},
static PyObject *
os_posix_fadvise_impl(PyObject *module, int fd, Py_off_t offset,
@ -4577,7 +4577,7 @@ PyDoc_STRVAR(os_putenv__doc__,
"Change or add an environment variable.");
#define OS_PUTENV_METHODDEF \
{"putenv", (PyCFunction)os_putenv, METH_FASTCALL, os_putenv__doc__},
{"putenv", (PyCFunction)(void(*)(void))os_putenv, METH_FASTCALL, os_putenv__doc__},
static PyObject *
os_putenv_impl(PyObject *module, PyObject *name, PyObject *value);
@ -4610,7 +4610,7 @@ PyDoc_STRVAR(os_putenv__doc__,
"Change or add an environment variable.");
#define OS_PUTENV_METHODDEF \
{"putenv", (PyCFunction)os_putenv, METH_FASTCALL, os_putenv__doc__},
{"putenv", (PyCFunction)(void(*)(void))os_putenv, METH_FASTCALL, os_putenv__doc__},
static PyObject *
os_putenv_impl(PyObject *module, PyObject *name, PyObject *value);
@ -4748,7 +4748,7 @@ PyDoc_STRVAR(os_WIFCONTINUED__doc__,
"job control stop.");
#define OS_WIFCONTINUED_METHODDEF \
{"WIFCONTINUED", (PyCFunction)os_WIFCONTINUED, METH_FASTCALL|METH_KEYWORDS, os_WIFCONTINUED__doc__},
{"WIFCONTINUED", (PyCFunction)(void(*)(void))os_WIFCONTINUED, METH_FASTCALL|METH_KEYWORDS, os_WIFCONTINUED__doc__},
static int
os_WIFCONTINUED_impl(PyObject *module, int status);
@ -4787,7 +4787,7 @@ PyDoc_STRVAR(os_WIFSTOPPED__doc__,
"Return True if the process returning status was stopped.");
#define OS_WIFSTOPPED_METHODDEF \
{"WIFSTOPPED", (PyCFunction)os_WIFSTOPPED, METH_FASTCALL|METH_KEYWORDS, os_WIFSTOPPED__doc__},
{"WIFSTOPPED", (PyCFunction)(void(*)(void))os_WIFSTOPPED, METH_FASTCALL|METH_KEYWORDS, os_WIFSTOPPED__doc__},
static int
os_WIFSTOPPED_impl(PyObject *module, int status);
@ -4826,7 +4826,7 @@ PyDoc_STRVAR(os_WIFSIGNALED__doc__,
"Return True if the process returning status was terminated by a signal.");
#define OS_WIFSIGNALED_METHODDEF \
{"WIFSIGNALED", (PyCFunction)os_WIFSIGNALED, METH_FASTCALL|METH_KEYWORDS, os_WIFSIGNALED__doc__},
{"WIFSIGNALED", (PyCFunction)(void(*)(void))os_WIFSIGNALED, METH_FASTCALL|METH_KEYWORDS, os_WIFSIGNALED__doc__},
static int
os_WIFSIGNALED_impl(PyObject *module, int status);
@ -4865,7 +4865,7 @@ PyDoc_STRVAR(os_WIFEXITED__doc__,
"Return True if the process returning status exited via the exit() system call.");
#define OS_WIFEXITED_METHODDEF \
{"WIFEXITED", (PyCFunction)os_WIFEXITED, METH_FASTCALL|METH_KEYWORDS, os_WIFEXITED__doc__},
{"WIFEXITED", (PyCFunction)(void(*)(void))os_WIFEXITED, METH_FASTCALL|METH_KEYWORDS, os_WIFEXITED__doc__},
static int
os_WIFEXITED_impl(PyObject *module, int status);
@ -4904,7 +4904,7 @@ PyDoc_STRVAR(os_WEXITSTATUS__doc__,
"Return the process return code from status.");
#define OS_WEXITSTATUS_METHODDEF \
{"WEXITSTATUS", (PyCFunction)os_WEXITSTATUS, METH_FASTCALL|METH_KEYWORDS, os_WEXITSTATUS__doc__},
{"WEXITSTATUS", (PyCFunction)(void(*)(void))os_WEXITSTATUS, METH_FASTCALL|METH_KEYWORDS, os_WEXITSTATUS__doc__},
static int
os_WEXITSTATUS_impl(PyObject *module, int status);
@ -4943,7 +4943,7 @@ PyDoc_STRVAR(os_WTERMSIG__doc__,
"Return the signal that terminated the process that provided the status value.");
#define OS_WTERMSIG_METHODDEF \
{"WTERMSIG", (PyCFunction)os_WTERMSIG, METH_FASTCALL|METH_KEYWORDS, os_WTERMSIG__doc__},
{"WTERMSIG", (PyCFunction)(void(*)(void))os_WTERMSIG, METH_FASTCALL|METH_KEYWORDS, os_WTERMSIG__doc__},
static int
os_WTERMSIG_impl(PyObject *module, int status);
@ -4982,7 +4982,7 @@ PyDoc_STRVAR(os_WSTOPSIG__doc__,
"Return the signal that stopped the process that provided the status value.");
#define OS_WSTOPSIG_METHODDEF \
{"WSTOPSIG", (PyCFunction)os_WSTOPSIG, METH_FASTCALL|METH_KEYWORDS, os_WSTOPSIG__doc__},
{"WSTOPSIG", (PyCFunction)(void(*)(void))os_WSTOPSIG, METH_FASTCALL|METH_KEYWORDS, os_WSTOPSIG__doc__},
static int
os_WSTOPSIG_impl(PyObject *module, int status);
@ -5058,7 +5058,7 @@ PyDoc_STRVAR(os_statvfs__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_STATVFS_METHODDEF \
{"statvfs", (PyCFunction)os_statvfs, METH_FASTCALL|METH_KEYWORDS, os_statvfs__doc__},
{"statvfs", (PyCFunction)(void(*)(void))os_statvfs, METH_FASTCALL|METH_KEYWORDS, os_statvfs__doc__},
static PyObject *
os_statvfs_impl(PyObject *module, path_t *path);
@ -5095,7 +5095,7 @@ PyDoc_STRVAR(os__getdiskusage__doc__,
"Return disk usage statistics about the given path as a (total, free) tuple.");
#define OS__GETDISKUSAGE_METHODDEF \
{"_getdiskusage", (PyCFunction)os__getdiskusage, METH_FASTCALL|METH_KEYWORDS, os__getdiskusage__doc__},
{"_getdiskusage", (PyCFunction)(void(*)(void))os__getdiskusage, METH_FASTCALL|METH_KEYWORDS, os__getdiskusage__doc__},
static PyObject *
os__getdiskusage_impl(PyObject *module, path_t *path);
@ -5134,7 +5134,7 @@ PyDoc_STRVAR(os_fpathconf__doc__,
"If there is no limit, return -1.");
#define OS_FPATHCONF_METHODDEF \
{"fpathconf", (PyCFunction)os_fpathconf, METH_FASTCALL, os_fpathconf__doc__},
{"fpathconf", (PyCFunction)(void(*)(void))os_fpathconf, METH_FASTCALL, os_fpathconf__doc__},
static long
os_fpathconf_impl(PyObject *module, int fd, int name);
@ -5176,7 +5176,7 @@ PyDoc_STRVAR(os_pathconf__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_PATHCONF_METHODDEF \
{"pathconf", (PyCFunction)os_pathconf, METH_FASTCALL|METH_KEYWORDS, os_pathconf__doc__},
{"pathconf", (PyCFunction)(void(*)(void))os_pathconf, METH_FASTCALL|METH_KEYWORDS, os_pathconf__doc__},
static long
os_pathconf_impl(PyObject *module, path_t *path, int name);
@ -5324,7 +5324,7 @@ PyDoc_STRVAR(os_startfile__doc__,
"the underlying Win32 ShellExecute function doesn\'t work if it is.");
#define OS_STARTFILE_METHODDEF \
{"startfile", (PyCFunction)os_startfile, METH_FASTCALL|METH_KEYWORDS, os_startfile__doc__},
{"startfile", (PyCFunction)(void(*)(void))os_startfile, METH_FASTCALL|METH_KEYWORDS, os_startfile__doc__},
static PyObject *
os_startfile_impl(PyObject *module, path_t *filepath, Py_UNICODE *operation);
@ -5389,7 +5389,7 @@ PyDoc_STRVAR(os_device_encoding__doc__,
"If the device is not a terminal, return None.");
#define OS_DEVICE_ENCODING_METHODDEF \
{"device_encoding", (PyCFunction)os_device_encoding, METH_FASTCALL|METH_KEYWORDS, os_device_encoding__doc__},
{"device_encoding", (PyCFunction)(void(*)(void))os_device_encoding, METH_FASTCALL|METH_KEYWORDS, os_device_encoding__doc__},
static PyObject *
os_device_encoding_impl(PyObject *module, int fd);
@ -5421,7 +5421,7 @@ PyDoc_STRVAR(os_setresuid__doc__,
"Set the current process\'s real, effective, and saved user ids.");
#define OS_SETRESUID_METHODDEF \
{"setresuid", (PyCFunction)os_setresuid, METH_FASTCALL, os_setresuid__doc__},
{"setresuid", (PyCFunction)(void(*)(void))os_setresuid, METH_FASTCALL, os_setresuid__doc__},
static PyObject *
os_setresuid_impl(PyObject *module, uid_t ruid, uid_t euid, uid_t suid);
@ -5455,7 +5455,7 @@ PyDoc_STRVAR(os_setresgid__doc__,
"Set the current process\'s real, effective, and saved group ids.");
#define OS_SETRESGID_METHODDEF \
{"setresgid", (PyCFunction)os_setresgid, METH_FASTCALL, os_setresgid__doc__},
{"setresgid", (PyCFunction)(void(*)(void))os_setresgid, METH_FASTCALL, os_setresgid__doc__},
static PyObject *
os_setresgid_impl(PyObject *module, gid_t rgid, gid_t egid, gid_t sgid);
@ -5538,7 +5538,7 @@ PyDoc_STRVAR(os_getxattr__doc__,
" the link points to.");
#define OS_GETXATTR_METHODDEF \
{"getxattr", (PyCFunction)os_getxattr, METH_FASTCALL|METH_KEYWORDS, os_getxattr__doc__},
{"getxattr", (PyCFunction)(void(*)(void))os_getxattr, METH_FASTCALL|METH_KEYWORDS, os_getxattr__doc__},
static PyObject *
os_getxattr_impl(PyObject *module, path_t *path, path_t *attribute,
@ -5586,7 +5586,7 @@ PyDoc_STRVAR(os_setxattr__doc__,
" the link points to.");
#define OS_SETXATTR_METHODDEF \
{"setxattr", (PyCFunction)os_setxattr, METH_FASTCALL|METH_KEYWORDS, os_setxattr__doc__},
{"setxattr", (PyCFunction)(void(*)(void))os_setxattr, METH_FASTCALL|METH_KEYWORDS, os_setxattr__doc__},
static PyObject *
os_setxattr_impl(PyObject *module, path_t *path, path_t *attribute,
@ -5639,7 +5639,7 @@ PyDoc_STRVAR(os_removexattr__doc__,
" the link points to.");
#define OS_REMOVEXATTR_METHODDEF \
{"removexattr", (PyCFunction)os_removexattr, METH_FASTCALL|METH_KEYWORDS, os_removexattr__doc__},
{"removexattr", (PyCFunction)(void(*)(void))os_removexattr, METH_FASTCALL|METH_KEYWORDS, os_removexattr__doc__},
static PyObject *
os_removexattr_impl(PyObject *module, path_t *path, path_t *attribute,
@ -5687,7 +5687,7 @@ PyDoc_STRVAR(os_listxattr__doc__,
" the link points to.");
#define OS_LISTXATTR_METHODDEF \
{"listxattr", (PyCFunction)os_listxattr, METH_FASTCALL|METH_KEYWORDS, os_listxattr__doc__},
{"listxattr", (PyCFunction)(void(*)(void))os_listxattr, METH_FASTCALL|METH_KEYWORDS, os_listxattr__doc__},
static PyObject *
os_listxattr_impl(PyObject *module, path_t *path, int follow_symlinks);
@ -5804,7 +5804,7 @@ PyDoc_STRVAR(os_set_inheritable__doc__,
"Set the inheritable flag of the specified file descriptor.");
#define OS_SET_INHERITABLE_METHODDEF \
{"set_inheritable", (PyCFunction)os_set_inheritable, METH_FASTCALL, os_set_inheritable__doc__},
{"set_inheritable", (PyCFunction)(void(*)(void))os_set_inheritable, METH_FASTCALL, os_set_inheritable__doc__},
static PyObject *
os_set_inheritable_impl(PyObject *module, int fd, int inheritable);
@ -5871,7 +5871,7 @@ PyDoc_STRVAR(os_set_handle_inheritable__doc__,
"Set the inheritable flag of the specified handle.");
#define OS_SET_HANDLE_INHERITABLE_METHODDEF \
{"set_handle_inheritable", (PyCFunction)os_set_handle_inheritable, METH_FASTCALL, os_set_handle_inheritable__doc__},
{"set_handle_inheritable", (PyCFunction)(void(*)(void))os_set_handle_inheritable, METH_FASTCALL, os_set_handle_inheritable__doc__},
static PyObject *
os_set_handle_inheritable_impl(PyObject *module, intptr_t handle,
@ -5946,7 +5946,7 @@ PyDoc_STRVAR(os_set_blocking__doc__,
"clear the O_NONBLOCK flag otherwise.");
#define OS_SET_BLOCKING_METHODDEF \
{"set_blocking", (PyCFunction)os_set_blocking, METH_FASTCALL, os_set_blocking__doc__},
{"set_blocking", (PyCFunction)(void(*)(void))os_set_blocking, METH_FASTCALL, os_set_blocking__doc__},
static PyObject *
os_set_blocking_impl(PyObject *module, int fd, int blocking);
@ -6005,7 +6005,7 @@ PyDoc_STRVAR(os_DirEntry_stat__doc__,
"Return stat_result object for the entry; cached per entry.");
#define OS_DIRENTRY_STAT_METHODDEF \
{"stat", (PyCFunction)os_DirEntry_stat, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_stat__doc__},
{"stat", (PyCFunction)(void(*)(void))os_DirEntry_stat, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_stat__doc__},
static PyObject *
os_DirEntry_stat_impl(DirEntry *self, int follow_symlinks);
@ -6035,7 +6035,7 @@ PyDoc_STRVAR(os_DirEntry_is_dir__doc__,
"Return True if the entry is a directory; cached per entry.");
#define OS_DIRENTRY_IS_DIR_METHODDEF \
{"is_dir", (PyCFunction)os_DirEntry_is_dir, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_dir__doc__},
{"is_dir", (PyCFunction)(void(*)(void))os_DirEntry_is_dir, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_dir__doc__},
static int
os_DirEntry_is_dir_impl(DirEntry *self, int follow_symlinks);
@ -6070,7 +6070,7 @@ PyDoc_STRVAR(os_DirEntry_is_file__doc__,
"Return True if the entry is a file; cached per entry.");
#define OS_DIRENTRY_IS_FILE_METHODDEF \
{"is_file", (PyCFunction)os_DirEntry_is_file, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_file__doc__},
{"is_file", (PyCFunction)(void(*)(void))os_DirEntry_is_file, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_file__doc__},
static int
os_DirEntry_is_file_impl(DirEntry *self, int follow_symlinks);
@ -6147,7 +6147,7 @@ PyDoc_STRVAR(os_scandir__doc__,
"If path is None, uses the path=\'.\'.");
#define OS_SCANDIR_METHODDEF \
{"scandir", (PyCFunction)os_scandir, METH_FASTCALL|METH_KEYWORDS, os_scandir__doc__},
{"scandir", (PyCFunction)(void(*)(void))os_scandir, METH_FASTCALL|METH_KEYWORDS, os_scandir__doc__},
static PyObject *
os_scandir_impl(PyObject *module, path_t *path);
@ -6184,7 +6184,7 @@ PyDoc_STRVAR(os_fspath__doc__,
"types raise a TypeError.");
#define OS_FSPATH_METHODDEF \
{"fspath", (PyCFunction)os_fspath, METH_FASTCALL|METH_KEYWORDS, os_fspath__doc__},
{"fspath", (PyCFunction)(void(*)(void))os_fspath, METH_FASTCALL|METH_KEYWORDS, os_fspath__doc__},
static PyObject *
os_fspath_impl(PyObject *module, PyObject *path);
@ -6216,7 +6216,7 @@ PyDoc_STRVAR(os_getrandom__doc__,
"Obtain a series of random bytes.");
#define OS_GETRANDOM_METHODDEF \
{"getrandom", (PyCFunction)os_getrandom, METH_FASTCALL|METH_KEYWORDS, os_getrandom__doc__},
{"getrandom", (PyCFunction)(void(*)(void))os_getrandom, METH_FASTCALL|METH_KEYWORDS, os_getrandom__doc__},
static PyObject *
os_getrandom_impl(PyObject *module, Py_ssize_t size, int flags);
@ -6757,4 +6757,4 @@ exit:
#ifndef OS_GETRANDOM_METHODDEF
#define OS_GETRANDOM_METHODDEF
#endif /* !defined(OS_GETRANDOM_METHODDEF) */
/*[clinic end generated code: output=f2951c34e0907fb6 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d62c0bb988141e70 input=a9049054013a1b77]*/

10
Modules/clinic/pyexpat.c.h generated
View file

@ -11,7 +11,7 @@ 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_FASTCALL, pyexpat_xmlparser_Parse__doc__},
{"Parse", (PyCFunction)(void(*)(void))pyexpat_xmlparser_Parse, METH_FASTCALL, pyexpat_xmlparser_Parse__doc__},
static PyObject *
pyexpat_xmlparser_Parse_impl(xmlparseobject *self, PyObject *data,
@ -116,7 +116,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_FASTCALL, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
{"ExternalEntityParserCreate", (PyCFunction)(void(*)(void))pyexpat_xmlparser_ExternalEntityParserCreate, METH_FASTCALL, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
static PyObject *
pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
@ -185,7 +185,7 @@ 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_FASTCALL, pyexpat_xmlparser_UseForeignDTD__doc__},
{"UseForeignDTD", (PyCFunction)(void(*)(void))pyexpat_xmlparser_UseForeignDTD, METH_FASTCALL, pyexpat_xmlparser_UseForeignDTD__doc__},
static PyObject *
pyexpat_xmlparser_UseForeignDTD_impl(xmlparseobject *self, int flag);
@ -216,7 +216,7 @@ PyDoc_STRVAR(pyexpat_ParserCreate__doc__,
"Return a new XML parser object.");
#define PYEXPAT_PARSERCREATE_METHODDEF \
{"ParserCreate", (PyCFunction)pyexpat_ParserCreate, METH_FASTCALL|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
{"ParserCreate", (PyCFunction)(void(*)(void))pyexpat_ParserCreate, METH_FASTCALL|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
static PyObject *
pyexpat_ParserCreate_impl(PyObject *module, const char *encoding,
@ -272,4 +272,4 @@ exit:
#ifndef PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
#define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
#endif /* !defined(PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF) */
/*[clinic end generated code: output=6bdf1faf8ba1af32 input=a9049054013a1b77]*/
/*[clinic end generated code: output=c390207761c679d3 input=a9049054013a1b77]*/

4
Modules/clinic/resource.c.h generated
View file

@ -60,7 +60,7 @@ PyDoc_STRVAR(resource_setrlimit__doc__,
"\n");
#define RESOURCE_SETRLIMIT_METHODDEF \
{"setrlimit", (PyCFunction)resource_setrlimit, METH_FASTCALL, resource_setrlimit__doc__},
{"setrlimit", (PyCFunction)(void(*)(void))resource_setrlimit, METH_FASTCALL, resource_setrlimit__doc__},
static PyObject *
resource_setrlimit_impl(PyObject *module, int resource, PyObject *limits);
@ -157,4 +157,4 @@ exit:
#ifndef RESOURCE_PRLIMIT_METHODDEF
#define RESOURCE_PRLIMIT_METHODDEF
#endif /* !defined(RESOURCE_PRLIMIT_METHODDEF) */
/*[clinic end generated code: output=2a69aca90631a582 input=a9049054013a1b77]*/
/*[clinic end generated code: output=637ed2c42bde5ca6 input=a9049054013a1b77]*/

28
Modules/clinic/selectmodule.c.h generated
View file

@ -30,7 +30,7 @@ PyDoc_STRVAR(select_select__doc__,
"descriptors can be used.");
#define SELECT_SELECT_METHODDEF \
{"select", (PyCFunction)select_select, METH_FASTCALL, select_select__doc__},
{"select", (PyCFunction)(void(*)(void))select_select, METH_FASTCALL, select_select__doc__},
static PyObject *
select_select_impl(PyObject *module, PyObject *rlist, PyObject *wlist,
@ -70,7 +70,7 @@ PyDoc_STRVAR(select_poll_register__doc__,
" an optional bitmask describing the type of events to check for");
#define SELECT_POLL_REGISTER_METHODDEF \
{"register", (PyCFunction)select_poll_register, METH_FASTCALL, select_poll_register__doc__},
{"register", (PyCFunction)(void(*)(void))select_poll_register, METH_FASTCALL, select_poll_register__doc__},
static PyObject *
select_poll_register_impl(pollObject *self, int fd, unsigned short eventmask);
@ -109,7 +109,7 @@ PyDoc_STRVAR(select_poll_modify__doc__,
" a bitmask describing the type of events to check for");
#define SELECT_POLL_MODIFY_METHODDEF \
{"modify", (PyCFunction)select_poll_modify, METH_FASTCALL, select_poll_modify__doc__},
{"modify", (PyCFunction)(void(*)(void))select_poll_modify, METH_FASTCALL, select_poll_modify__doc__},
static PyObject *
select_poll_modify_impl(pollObject *self, int fd, unsigned short eventmask);
@ -176,7 +176,7 @@ PyDoc_STRVAR(select_poll_poll__doc__,
"report, as a list of (fd, event) 2-tuples.");
#define SELECT_POLL_POLL_METHODDEF \
{"poll", (PyCFunction)select_poll_poll, METH_FASTCALL, select_poll_poll__doc__},
{"poll", (PyCFunction)(void(*)(void))select_poll_poll, METH_FASTCALL, select_poll_poll__doc__},
static PyObject *
select_poll_poll_impl(pollObject *self, PyObject *timeout_obj);
@ -215,7 +215,7 @@ PyDoc_STRVAR(select_devpoll_register__doc__,
" an optional bitmask describing the type of events to check for");
#define SELECT_DEVPOLL_REGISTER_METHODDEF \
{"register", (PyCFunction)select_devpoll_register, METH_FASTCALL, select_devpoll_register__doc__},
{"register", (PyCFunction)(void(*)(void))select_devpoll_register, METH_FASTCALL, select_devpoll_register__doc__},
static PyObject *
select_devpoll_register_impl(devpollObject *self, int fd,
@ -255,7 +255,7 @@ PyDoc_STRVAR(select_devpoll_modify__doc__,
" an optional bitmask describing the type of events to check for");
#define SELECT_DEVPOLL_MODIFY_METHODDEF \
{"modify", (PyCFunction)select_devpoll_modify, METH_FASTCALL, select_devpoll_modify__doc__},
{"modify", (PyCFunction)(void(*)(void))select_devpoll_modify, METH_FASTCALL, select_devpoll_modify__doc__},
static PyObject *
select_devpoll_modify_impl(devpollObject *self, int fd,
@ -323,7 +323,7 @@ PyDoc_STRVAR(select_devpoll_poll__doc__,
"report, as a list of (fd, event) 2-tuples.");
#define SELECT_DEVPOLL_POLL_METHODDEF \
{"poll", (PyCFunction)select_devpoll_poll, METH_FASTCALL, select_devpoll_poll__doc__},
{"poll", (PyCFunction)(void(*)(void))select_devpoll_poll, METH_FASTCALL, select_devpoll_poll__doc__},
static PyObject *
select_devpoll_poll_impl(devpollObject *self, PyObject *timeout_obj);
@ -577,7 +577,7 @@ PyDoc_STRVAR(select_epoll_register__doc__,
"The epoll interface supports all file descriptors that support poll.");
#define SELECT_EPOLL_REGISTER_METHODDEF \
{"register", (PyCFunction)select_epoll_register, METH_FASTCALL|METH_KEYWORDS, select_epoll_register__doc__},
{"register", (PyCFunction)(void(*)(void))select_epoll_register, METH_FASTCALL|METH_KEYWORDS, select_epoll_register__doc__},
static PyObject *
select_epoll_register_impl(pyEpoll_Object *self, int fd,
@ -618,7 +618,7 @@ PyDoc_STRVAR(select_epoll_modify__doc__,
" a bit set composed of the various EPOLL constants");
#define SELECT_EPOLL_MODIFY_METHODDEF \
{"modify", (PyCFunction)select_epoll_modify, METH_FASTCALL|METH_KEYWORDS, select_epoll_modify__doc__},
{"modify", (PyCFunction)(void(*)(void))select_epoll_modify, METH_FASTCALL|METH_KEYWORDS, select_epoll_modify__doc__},
static PyObject *
select_epoll_modify_impl(pyEpoll_Object *self, int fd,
@ -657,7 +657,7 @@ PyDoc_STRVAR(select_epoll_unregister__doc__,
" the target file descriptor of the operation");
#define SELECT_EPOLL_UNREGISTER_METHODDEF \
{"unregister", (PyCFunction)select_epoll_unregister, METH_FASTCALL|METH_KEYWORDS, select_epoll_unregister__doc__},
{"unregister", (PyCFunction)(void(*)(void))select_epoll_unregister, METH_FASTCALL|METH_KEYWORDS, select_epoll_unregister__doc__},
static PyObject *
select_epoll_unregister_impl(pyEpoll_Object *self, int fd);
@ -700,7 +700,7 @@ PyDoc_STRVAR(select_epoll_poll__doc__,
"as a list of (fd, events) 2-tuples.");
#define SELECT_EPOLL_POLL_METHODDEF \
{"poll", (PyCFunction)select_epoll_poll, METH_FASTCALL|METH_KEYWORDS, select_epoll_poll__doc__},
{"poll", (PyCFunction)(void(*)(void))select_epoll_poll, METH_FASTCALL|METH_KEYWORDS, select_epoll_poll__doc__},
static PyObject *
select_epoll_poll_impl(pyEpoll_Object *self, PyObject *timeout_obj,
@ -756,7 +756,7 @@ PyDoc_STRVAR(select_epoll___exit____doc__,
"\n");
#define SELECT_EPOLL___EXIT___METHODDEF \
{"__exit__", (PyCFunction)select_epoll___exit__, METH_FASTCALL, select_epoll___exit____doc__},
{"__exit__", (PyCFunction)(void(*)(void))select_epoll___exit__, METH_FASTCALL, select_epoll___exit____doc__},
static PyObject *
select_epoll___exit___impl(pyEpoll_Object *self, PyObject *exc_type,
@ -922,7 +922,7 @@ PyDoc_STRVAR(select_kqueue_control__doc__,
" This accepts floats for smaller timeouts, too.");
#define SELECT_KQUEUE_CONTROL_METHODDEF \
{"control", (PyCFunction)select_kqueue_control, METH_FASTCALL, select_kqueue_control__doc__},
{"control", (PyCFunction)(void(*)(void))select_kqueue_control, METH_FASTCALL, select_kqueue_control__doc__},
static PyObject *
select_kqueue_control_impl(kqueue_queue_Object *self, PyObject *changelist,
@ -1047,4 +1047,4 @@ exit:
#ifndef SELECT_KQUEUE_CONTROL_METHODDEF
#define SELECT_KQUEUE_CONTROL_METHODDEF
#endif /* !defined(SELECT_KQUEUE_CONTROL_METHODDEF) */
/*[clinic end generated code: output=561bec8bcb0e00c5 input=a9049054013a1b77]*/
/*[clinic end generated code: output=04c4019eb5a4d464 input=a9049054013a1b77]*/

4
Modules/clinic/sha1module.c.h generated
View file

@ -72,7 +72,7 @@ PyDoc_STRVAR(_sha1_sha1__doc__,
"Return a new SHA1 hash object; optionally initialized with a string.");
#define _SHA1_SHA1_METHODDEF \
{"sha1", (PyCFunction)_sha1_sha1, METH_FASTCALL|METH_KEYWORDS, _sha1_sha1__doc__},
{"sha1", (PyCFunction)(void(*)(void))_sha1_sha1, METH_FASTCALL|METH_KEYWORDS, _sha1_sha1__doc__},
static PyObject *
_sha1_sha1_impl(PyObject *module, PyObject *string);
@ -94,4 +94,4 @@ _sha1_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *
exit:
return return_value;
}
/*[clinic end generated code: output=81d2424c0585bfd4 input=a9049054013a1b77]*/
/*[clinic end generated code: output=3bae85313ee5a3b5 input=a9049054013a1b77]*/

6
Modules/clinic/sha256module.c.h generated
View file

@ -72,7 +72,7 @@ PyDoc_STRVAR(_sha256_sha256__doc__,
"Return a new SHA-256 hash object; optionally initialized with a string.");
#define _SHA256_SHA256_METHODDEF \
{"sha256", (PyCFunction)_sha256_sha256, METH_FASTCALL|METH_KEYWORDS, _sha256_sha256__doc__},
{"sha256", (PyCFunction)(void(*)(void))_sha256_sha256, METH_FASTCALL|METH_KEYWORDS, _sha256_sha256__doc__},
static PyObject *
_sha256_sha256_impl(PyObject *module, PyObject *string);
@ -102,7 +102,7 @@ PyDoc_STRVAR(_sha256_sha224__doc__,
"Return a new SHA-224 hash object; optionally initialized with a string.");
#define _SHA256_SHA224_METHODDEF \
{"sha224", (PyCFunction)_sha256_sha224, METH_FASTCALL|METH_KEYWORDS, _sha256_sha224__doc__},
{"sha224", (PyCFunction)(void(*)(void))_sha256_sha224, METH_FASTCALL|METH_KEYWORDS, _sha256_sha224__doc__},
static PyObject *
_sha256_sha224_impl(PyObject *module, PyObject *string);
@ -124,4 +124,4 @@ _sha256_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje
exit:
return return_value;
}
/*[clinic end generated code: output=0086286cffcbc31c input=a9049054013a1b77]*/
/*[clinic end generated code: output=fb208641d4bc3b5f input=a9049054013a1b77]*/

6
Modules/clinic/sha512module.c.h generated
View file

@ -72,7 +72,7 @@ PyDoc_STRVAR(_sha512_sha512__doc__,
"Return a new SHA-512 hash object; optionally initialized with a string.");
#define _SHA512_SHA512_METHODDEF \
{"sha512", (PyCFunction)_sha512_sha512, METH_FASTCALL|METH_KEYWORDS, _sha512_sha512__doc__},
{"sha512", (PyCFunction)(void(*)(void))_sha512_sha512, METH_FASTCALL|METH_KEYWORDS, _sha512_sha512__doc__},
static PyObject *
_sha512_sha512_impl(PyObject *module, PyObject *string);
@ -102,7 +102,7 @@ PyDoc_STRVAR(_sha512_sha384__doc__,
"Return a new SHA-384 hash object; optionally initialized with a string.");
#define _SHA512_SHA384_METHODDEF \
{"sha384", (PyCFunction)_sha512_sha384, METH_FASTCALL|METH_KEYWORDS, _sha512_sha384__doc__},
{"sha384", (PyCFunction)(void(*)(void))_sha512_sha384, METH_FASTCALL|METH_KEYWORDS, _sha512_sha384__doc__},
static PyObject *
_sha512_sha384_impl(PyObject *module, PyObject *string);
@ -124,4 +124,4 @@ _sha512_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje
exit:
return return_value;
}
/*[clinic end generated code: output=fcc3306fb6672222 input=a9049054013a1b77]*/
/*[clinic end generated code: output=3706fa47bea06c0b input=a9049054013a1b77]*/

14
Modules/clinic/signalmodule.c.h generated
View file

@ -74,7 +74,7 @@ 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_FASTCALL, signal_signal__doc__},
{"signal", (PyCFunction)(void(*)(void))signal_signal, METH_FASTCALL, signal_signal__doc__},
static PyObject *
signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
@ -171,7 +171,7 @@ PyDoc_STRVAR(signal_siginterrupt__doc__,
"signal sig, else system calls will be interrupted.");
#define SIGNAL_SIGINTERRUPT_METHODDEF \
{"siginterrupt", (PyCFunction)signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
{"siginterrupt", (PyCFunction)(void(*)(void))signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
static PyObject *
signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
@ -209,7 +209,7 @@ PyDoc_STRVAR(signal_setitimer__doc__,
"Returns old values as a tuple: (delay, interval).");
#define SIGNAL_SETITIMER_METHODDEF \
{"setitimer", (PyCFunction)signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
{"setitimer", (PyCFunction)(void(*)(void))signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
static PyObject *
signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
@ -275,7 +275,7 @@ 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_FASTCALL, signal_pthread_sigmask__doc__},
{"pthread_sigmask", (PyCFunction)(void(*)(void))signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
static PyObject *
signal_pthread_sigmask_impl(PyObject *module, int how, sigset_t mask);
@ -428,7 +428,7 @@ PyDoc_STRVAR(signal_sigtimedwait__doc__,
"The timeout is specified in seconds, with floating point numbers allowed.");
#define SIGNAL_SIGTIMEDWAIT_METHODDEF \
{"sigtimedwait", (PyCFunction)signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
{"sigtimedwait", (PyCFunction)(void(*)(void))signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
static PyObject *
signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
@ -462,7 +462,7 @@ PyDoc_STRVAR(signal_pthread_kill__doc__,
"Send a signal to a thread.");
#define SIGNAL_PTHREAD_KILL_METHODDEF \
{"pthread_kill", (PyCFunction)signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
{"pthread_kill", (PyCFunction)(void(*)(void))signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
static PyObject *
signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
@ -534,4 +534,4 @@ exit:
#ifndef SIGNAL_PTHREAD_KILL_METHODDEF
#define SIGNAL_PTHREAD_KILL_METHODDEF
#endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
/*[clinic end generated code: output=549f0efdc7405834 input=a9049054013a1b77]*/
/*[clinic end generated code: output=fa0040750f4c1fcb input=a9049054013a1b77]*/

4
Modules/clinic/symtablemodule.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(_symtable_symtable__doc__,
"Return symbol and scope dictionaries used internally by compiler.");
#define _SYMTABLE_SYMTABLE_METHODDEF \
{"symtable", (PyCFunction)_symtable_symtable, METH_FASTCALL, _symtable_symtable__doc__},
{"symtable", (PyCFunction)(void(*)(void))_symtable_symtable, METH_FASTCALL, _symtable_symtable__doc__},
static PyObject *
_symtable_symtable_impl(PyObject *module, const char *str,
@ -32,4 +32,4 @@ _symtable_symtable(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
/*[clinic end generated code: output=c18565060a6cae04 input=a9049054013a1b77]*/
/*[clinic end generated code: output=52ece07dd0e7a113 input=a9049054013a1b77]*/

14
Modules/clinic/unicodedata.c.h generated
View file

@ -13,7 +13,7 @@ PyDoc_STRVAR(unicodedata_UCD_decimal__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_DECIMAL_METHODDEF \
{"decimal", (PyCFunction)unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__},
{"decimal", (PyCFunction)(void(*)(void))unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__},
static PyObject *
unicodedata_UCD_decimal_impl(PyObject *self, int chr,
@ -47,7 +47,7 @@ PyDoc_STRVAR(unicodedata_UCD_digit__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_DIGIT_METHODDEF \
{"digit", (PyCFunction)unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__},
{"digit", (PyCFunction)(void(*)(void))unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__},
static PyObject *
unicodedata_UCD_digit_impl(PyObject *self, int chr, PyObject *default_value);
@ -80,7 +80,7 @@ PyDoc_STRVAR(unicodedata_UCD_numeric__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_NUMERIC_METHODDEF \
{"numeric", (PyCFunction)unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__},
{"numeric", (PyCFunction)(void(*)(void))unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__},
static PyObject *
unicodedata_UCD_numeric_impl(PyObject *self, int chr,
@ -293,7 +293,7 @@ PyDoc_STRVAR(unicodedata_UCD_is_normalized__doc__,
"Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'.");
#define UNICODEDATA_UCD_IS_NORMALIZED_METHODDEF \
{"is_normalized", (PyCFunction)unicodedata_UCD_is_normalized, METH_FASTCALL, unicodedata_UCD_is_normalized__doc__},
{"is_normalized", (PyCFunction)(void(*)(void))unicodedata_UCD_is_normalized, METH_FASTCALL, unicodedata_UCD_is_normalized__doc__},
static PyObject *
unicodedata_UCD_is_normalized_impl(PyObject *self, PyObject *form,
@ -325,7 +325,7 @@ 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_FASTCALL, unicodedata_UCD_normalize__doc__},
{"normalize", (PyCFunction)(void(*)(void))unicodedata_UCD_normalize, METH_FASTCALL, unicodedata_UCD_normalize__doc__},
static PyObject *
unicodedata_UCD_normalize_impl(PyObject *self, PyObject *form,
@ -358,7 +358,7 @@ PyDoc_STRVAR(unicodedata_UCD_name__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_NAME_METHODDEF \
{"name", (PyCFunction)unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__},
{"name", (PyCFunction)(void(*)(void))unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__},
static PyObject *
unicodedata_UCD_name_impl(PyObject *self, int chr, PyObject *default_value);
@ -411,4 +411,4 @@ unicodedata_UCD_lookup(PyObject *self, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=2c5fbf597c18f6b8 input=a9049054013a1b77]*/
/*[clinic end generated code: output=67f474927be668bf input=a9049054013a1b77]*/

325
Modules/clinic/zipimport.c.h generated Normal file
View file

@ -0,0 +1,325 @@
/*[clinic input]
preserve
[clinic start generated code]*/
PyDoc_STRVAR(zipimport_zipimporter___init____doc__,
"zipimporter(archivepath, /)\n"
"--\n"
"\n"
"Create a new zipimporter instance.\n"
"\n"
" archivepath\n"
" A path-like object to a zipfile, or to a specific path inside\n"
" a zipfile.\n"
"\n"
"\'archivepath\' must be a path-like object to a zipfile, or to a specific path\n"
"inside a zipfile. For example, it can be \'/tmp/myimport.zip\', or\n"
"\'/tmp/myimport.zip/mydirectory\', if mydirectory is a valid directory inside\n"
"the archive.\n"
"\n"
"\'ZipImportError\' is raised if \'archivepath\' doesn\'t point to a valid Zip\n"
"archive.\n"
"\n"
"The \'archive\' attribute of the zipimporter object contains the name of the\n"
"zipfile targeted.");
static int
zipimport_zipimporter___init___impl(ZipImporter *self, PyObject *path);
static int
zipimport_zipimporter___init__(PyObject *self, PyObject *args, PyObject *kwargs)
{
int return_value = -1;
PyObject *path;
if ((Py_TYPE(self) == &ZipImporter_Type) &&
!_PyArg_NoKeywords("zipimporter", kwargs)) {
goto exit;
}
if (!PyArg_ParseTuple(args, "O&:zipimporter",
PyUnicode_FSDecoder, &path)) {
goto exit;
}
return_value = zipimport_zipimporter___init___impl((ZipImporter *)self, path);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_find_module__doc__,
"find_module($self, fullname, path=None, /)\n"
"--\n"
"\n"
"Search for a module specified by \'fullname\'.\n"
"\n"
"\'fullname\' must be the fully qualified (dotted) module name. It returns the\n"
"zipimporter instance itself if the module was found, or None if it wasn\'t.\n"
"The optional \'path\' argument is ignored -- it\'s there for compatibility\n"
"with the importer protocol.");
#define ZIPIMPORT_ZIPIMPORTER_FIND_MODULE_METHODDEF \
{"find_module", (PyCFunction)(void *)zipimport_zipimporter_find_module, METH_FASTCALL, zipimport_zipimporter_find_module__doc__},
static PyObject *
zipimport_zipimporter_find_module_impl(ZipImporter *self, PyObject *fullname,
PyObject *path);
static PyObject *
zipimport_zipimporter_find_module(ZipImporter *self, PyObject *const *args, Py_ssize_t nargs)
{
PyObject *return_value = NULL;
PyObject *fullname;
PyObject *path = Py_None;
if (!_PyArg_ParseStack(args, nargs, "U|O:find_module",
&fullname, &path)) {
goto exit;
}
return_value = zipimport_zipimporter_find_module_impl(self, fullname, path);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_find_loader__doc__,
"find_loader($self, fullname, path=None, /)\n"
"--\n"
"\n"
"Search for a module specified by \'fullname\'.\n"
"\n"
"\'fullname\' must be the fully qualified (dotted) module name. It returns the\n"
"zipimporter instance itself if the module was found, a string containing the\n"
"full path name if it\'s possibly a portion of a namespace package,\n"
"or None otherwise. The optional \'path\' argument is ignored -- it\'s\n"
"there for compatibility with the importer protocol.");
#define ZIPIMPORT_ZIPIMPORTER_FIND_LOADER_METHODDEF \
{"find_loader", (PyCFunction)(void *)zipimport_zipimporter_find_loader, METH_FASTCALL, zipimport_zipimporter_find_loader__doc__},
static PyObject *
zipimport_zipimporter_find_loader_impl(ZipImporter *self, PyObject *fullname,
PyObject *path);
static PyObject *
zipimport_zipimporter_find_loader(ZipImporter *self, PyObject *const *args, Py_ssize_t nargs)
{
PyObject *return_value = NULL;
PyObject *fullname;
PyObject *path = Py_None;
if (!_PyArg_ParseStack(args, nargs, "U|O:find_loader",
&fullname, &path)) {
goto exit;
}
return_value = zipimport_zipimporter_find_loader_impl(self, fullname, path);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_load_module__doc__,
"load_module($self, fullname, /)\n"
"--\n"
"\n"
"Load the module specified by \'fullname\'.\n"
"\n"
"\'fullname\' must be the fully qualified (dotted) module name. It returns the\n"
"imported module, or raises ZipImportError if it wasn\'t found.");
#define ZIPIMPORT_ZIPIMPORTER_LOAD_MODULE_METHODDEF \
{"load_module", (PyCFunction)zipimport_zipimporter_load_module, METH_O, zipimport_zipimporter_load_module__doc__},
static PyObject *
zipimport_zipimporter_load_module_impl(ZipImporter *self, PyObject *fullname);
static PyObject *
zipimport_zipimporter_load_module(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *fullname;
if (!PyArg_Parse(arg, "U:load_module", &fullname)) {
goto exit;
}
return_value = zipimport_zipimporter_load_module_impl(self, fullname);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_get_filename__doc__,
"get_filename($self, fullname, /)\n"
"--\n"
"\n"
"Return the filename for the specified module.");
#define ZIPIMPORT_ZIPIMPORTER_GET_FILENAME_METHODDEF \
{"get_filename", (PyCFunction)zipimport_zipimporter_get_filename, METH_O, zipimport_zipimporter_get_filename__doc__},
static PyObject *
zipimport_zipimporter_get_filename_impl(ZipImporter *self,
PyObject *fullname);
static PyObject *
zipimport_zipimporter_get_filename(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *fullname;
if (!PyArg_Parse(arg, "U:get_filename", &fullname)) {
goto exit;
}
return_value = zipimport_zipimporter_get_filename_impl(self, fullname);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_is_package__doc__,
"is_package($self, fullname, /)\n"
"--\n"
"\n"
"Return True if the module specified by fullname is a package.\n"
"\n"
"Raise ZipImportError if the module couldn\'t be found.");
#define ZIPIMPORT_ZIPIMPORTER_IS_PACKAGE_METHODDEF \
{"is_package", (PyCFunction)zipimport_zipimporter_is_package, METH_O, zipimport_zipimporter_is_package__doc__},
static PyObject *
zipimport_zipimporter_is_package_impl(ZipImporter *self, PyObject *fullname);
static PyObject *
zipimport_zipimporter_is_package(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *fullname;
if (!PyArg_Parse(arg, "U:is_package", &fullname)) {
goto exit;
}
return_value = zipimport_zipimporter_is_package_impl(self, fullname);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_get_data__doc__,
"get_data($self, pathname, /)\n"
"--\n"
"\n"
"Return the data associated with \'pathname\'.\n"
"\n"
"Raise OSError if the file was not found.");
#define ZIPIMPORT_ZIPIMPORTER_GET_DATA_METHODDEF \
{"get_data", (PyCFunction)zipimport_zipimporter_get_data, METH_O, zipimport_zipimporter_get_data__doc__},
static PyObject *
zipimport_zipimporter_get_data_impl(ZipImporter *self, PyObject *path);
static PyObject *
zipimport_zipimporter_get_data(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *path;
if (!PyArg_Parse(arg, "U:get_data", &path)) {
goto exit;
}
return_value = zipimport_zipimporter_get_data_impl(self, path);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_get_code__doc__,
"get_code($self, fullname, /)\n"
"--\n"
"\n"
"Return the code object for the specified module.\n"
"\n"
"Raise ZipImportError if the module couldn\'t be found.");
#define ZIPIMPORT_ZIPIMPORTER_GET_CODE_METHODDEF \
{"get_code", (PyCFunction)zipimport_zipimporter_get_code, METH_O, zipimport_zipimporter_get_code__doc__},
static PyObject *
zipimport_zipimporter_get_code_impl(ZipImporter *self, PyObject *fullname);
static PyObject *
zipimport_zipimporter_get_code(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *fullname;
if (!PyArg_Parse(arg, "U:get_code", &fullname)) {
goto exit;
}
return_value = zipimport_zipimporter_get_code_impl(self, fullname);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_get_source__doc__,
"get_source($self, fullname, /)\n"
"--\n"
"\n"
"Return the source code for the specified module.\n"
"\n"
"Raise ZipImportError if the module couldn\'t be found, return None if the\n"
"archive does contain the module, but has no source for it.");
#define ZIPIMPORT_ZIPIMPORTER_GET_SOURCE_METHODDEF \
{"get_source", (PyCFunction)zipimport_zipimporter_get_source, METH_O, zipimport_zipimporter_get_source__doc__},
static PyObject *
zipimport_zipimporter_get_source_impl(ZipImporter *self, PyObject *fullname);
static PyObject *
zipimport_zipimporter_get_source(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *fullname;
if (!PyArg_Parse(arg, "U:get_source", &fullname)) {
goto exit;
}
return_value = zipimport_zipimporter_get_source_impl(self, fullname);
exit:
return return_value;
}
PyDoc_STRVAR(zipimport_zipimporter_get_resource_reader__doc__,
"get_resource_reader($self, fullname, /)\n"
"--\n"
"\n"
"Return the ResourceReader for a package in a zip file.\n"
"\n"
"If \'fullname\' is a package within the zip file, return the \'ResourceReader\'\n"
"object for the package. Otherwise return None.");
#define ZIPIMPORT_ZIPIMPORTER_GET_RESOURCE_READER_METHODDEF \
{"get_resource_reader", (PyCFunction)zipimport_zipimporter_get_resource_reader, METH_O, zipimport_zipimporter_get_resource_reader__doc__},
static PyObject *
zipimport_zipimporter_get_resource_reader_impl(ZipImporter *self,
PyObject *fullname);
static PyObject *
zipimport_zipimporter_get_resource_reader(ZipImporter *self, PyObject *arg)
{
PyObject *return_value = NULL;
PyObject *fullname;
if (!PyArg_Parse(arg, "U:get_resource_reader", &fullname)) {
goto exit;
}
return_value = zipimport_zipimporter_get_resource_reader_impl(self, fullname);
exit:
return return_value;
}
/*[clinic end generated code: output=854ce3502180dc1f input=a9049054013a1b77]*/

20
Modules/clinic/zlibmodule.c.h generated
View file

@ -14,7 +14,7 @@ PyDoc_STRVAR(zlib_compress__doc__,
" Compression level, in 0-9 or -1.");
#define ZLIB_COMPRESS_METHODDEF \
{"compress", (PyCFunction)zlib_compress, METH_FASTCALL|METH_KEYWORDS, zlib_compress__doc__},
{"compress", (PyCFunction)(void(*)(void))zlib_compress, METH_FASTCALL|METH_KEYWORDS, zlib_compress__doc__},
static PyObject *
zlib_compress_impl(PyObject *module, Py_buffer *data, int level);
@ -57,7 +57,7 @@ PyDoc_STRVAR(zlib_decompress__doc__,
" The initial output buffer size.");
#define ZLIB_DECOMPRESS_METHODDEF \
{"decompress", (PyCFunction)zlib_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_decompress__doc__},
{"decompress", (PyCFunction)(void(*)(void))zlib_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_decompress__doc__},
static PyObject *
zlib_decompress_impl(PyObject *module, Py_buffer *data, int wbits,
@ -119,7 +119,7 @@ PyDoc_STRVAR(zlib_compressobj__doc__,
" containing subsequences that are likely to occur in the input data.");
#define ZLIB_COMPRESSOBJ_METHODDEF \
{"compressobj", (PyCFunction)zlib_compressobj, METH_FASTCALL|METH_KEYWORDS, zlib_compressobj__doc__},
{"compressobj", (PyCFunction)(void(*)(void))zlib_compressobj, METH_FASTCALL|METH_KEYWORDS, zlib_compressobj__doc__},
static PyObject *
zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,
@ -166,7 +166,7 @@ PyDoc_STRVAR(zlib_decompressobj__doc__,
" dictionary as used by the compressor that produced the input data.");
#define ZLIB_DECOMPRESSOBJ_METHODDEF \
{"decompressobj", (PyCFunction)zlib_decompressobj, METH_FASTCALL|METH_KEYWORDS, zlib_decompressobj__doc__},
{"decompressobj", (PyCFunction)(void(*)(void))zlib_decompressobj, METH_FASTCALL|METH_KEYWORDS, zlib_decompressobj__doc__},
static PyObject *
zlib_decompressobj_impl(PyObject *module, int wbits, PyObject *zdict);
@ -247,7 +247,7 @@ PyDoc_STRVAR(zlib_Decompress_decompress__doc__,
"Call the flush() method to clear these buffers.");
#define ZLIB_DECOMPRESS_DECOMPRESS_METHODDEF \
{"decompress", (PyCFunction)zlib_Decompress_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_decompress__doc__},
{"decompress", (PyCFunction)(void(*)(void))zlib_Decompress_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_decompress__doc__},
static PyObject *
zlib_Decompress_decompress_impl(compobject *self, Py_buffer *data,
@ -290,7 +290,7 @@ PyDoc_STRVAR(zlib_Compress_flush__doc__,
" can still be compressed.");
#define ZLIB_COMPRESS_FLUSH_METHODDEF \
{"flush", (PyCFunction)zlib_Compress_flush, METH_FASTCALL, zlib_Compress_flush__doc__},
{"flush", (PyCFunction)(void(*)(void))zlib_Compress_flush, METH_FASTCALL, zlib_Compress_flush__doc__},
static PyObject *
zlib_Compress_flush_impl(compobject *self, int mode);
@ -431,7 +431,7 @@ PyDoc_STRVAR(zlib_Decompress_flush__doc__,
" the initial size of the output buffer.");
#define ZLIB_DECOMPRESS_FLUSH_METHODDEF \
{"flush", (PyCFunction)zlib_Decompress_flush, METH_FASTCALL, zlib_Decompress_flush__doc__},
{"flush", (PyCFunction)(void(*)(void))zlib_Decompress_flush, METH_FASTCALL, zlib_Decompress_flush__doc__},
static PyObject *
zlib_Decompress_flush_impl(compobject *self, Py_ssize_t length);
@ -464,7 +464,7 @@ PyDoc_STRVAR(zlib_adler32__doc__,
"The returned checksum is an integer.");
#define ZLIB_ADLER32_METHODDEF \
{"adler32", (PyCFunction)zlib_adler32, METH_FASTCALL, zlib_adler32__doc__},
{"adler32", (PyCFunction)(void(*)(void))zlib_adler32, METH_FASTCALL, zlib_adler32__doc__},
static PyObject *
zlib_adler32_impl(PyObject *module, Py_buffer *data, unsigned int value);
@ -503,7 +503,7 @@ PyDoc_STRVAR(zlib_crc32__doc__,
"The returned checksum is an integer.");
#define ZLIB_CRC32_METHODDEF \
{"crc32", (PyCFunction)zlib_crc32, METH_FASTCALL, zlib_crc32__doc__},
{"crc32", (PyCFunction)(void(*)(void))zlib_crc32, METH_FASTCALL, zlib_crc32__doc__},
static PyObject *
zlib_crc32_impl(PyObject *module, Py_buffer *data, unsigned int value);
@ -553,4 +553,4 @@ exit:
#ifndef ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF
#define ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF
#endif /* !defined(ZLIB_DECOMPRESS___DEEPCOPY___METHODDEF) */
/*[clinic end generated code: output=d46c646770146ade input=a9049054013a1b77]*/
/*[clinic end generated code: output=e721c15e7af2d2fd input=a9049054013a1b77]*/

28
Objects/clinic/bytearrayobject.c.h generated
View file

@ -51,7 +51,7 @@ PyDoc_STRVAR(bytearray_translate__doc__,
"The remaining characters are mapped through the given translation table.");
#define BYTEARRAY_TRANSLATE_METHODDEF \
{"translate", (PyCFunction)bytearray_translate, METH_FASTCALL|METH_KEYWORDS, bytearray_translate__doc__},
{"translate", (PyCFunction)(void(*)(void))bytearray_translate, METH_FASTCALL|METH_KEYWORDS, bytearray_translate__doc__},
static PyObject *
bytearray_translate_impl(PyByteArrayObject *self, PyObject *table,
@ -88,7 +88,7 @@ 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_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
{"maketrans", (PyCFunction)(void(*)(void))bytearray_maketrans, METH_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
static PyObject *
bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to);
@ -133,7 +133,7 @@ PyDoc_STRVAR(bytearray_replace__doc__,
"replaced.");
#define BYTEARRAY_REPLACE_METHODDEF \
{"replace", (PyCFunction)bytearray_replace, METH_FASTCALL, bytearray_replace__doc__},
{"replace", (PyCFunction)(void(*)(void))bytearray_replace, METH_FASTCALL, bytearray_replace__doc__},
static PyObject *
bytearray_replace_impl(PyByteArrayObject *self, Py_buffer *old,
@ -181,7 +181,7 @@ PyDoc_STRVAR(bytearray_split__doc__,
" -1 (the default value) means no limit.");
#define BYTEARRAY_SPLIT_METHODDEF \
{"split", (PyCFunction)bytearray_split, METH_FASTCALL|METH_KEYWORDS, bytearray_split__doc__},
{"split", (PyCFunction)(void(*)(void))bytearray_split, METH_FASTCALL|METH_KEYWORDS, bytearray_split__doc__},
static PyObject *
bytearray_split_impl(PyByteArrayObject *self, PyObject *sep,
@ -256,7 +256,7 @@ PyDoc_STRVAR(bytearray_rsplit__doc__,
"Splitting is done starting at the end of the bytearray and working to the front.");
#define BYTEARRAY_RSPLIT_METHODDEF \
{"rsplit", (PyCFunction)bytearray_rsplit, METH_FASTCALL|METH_KEYWORDS, bytearray_rsplit__doc__},
{"rsplit", (PyCFunction)(void(*)(void))bytearray_rsplit, METH_FASTCALL|METH_KEYWORDS, bytearray_rsplit__doc__},
static PyObject *
bytearray_rsplit_impl(PyByteArrayObject *self, PyObject *sep,
@ -311,7 +311,7 @@ PyDoc_STRVAR(bytearray_insert__doc__,
" The item to be inserted.");
#define BYTEARRAY_INSERT_METHODDEF \
{"insert", (PyCFunction)bytearray_insert, METH_FASTCALL, bytearray_insert__doc__},
{"insert", (PyCFunction)(void(*)(void))bytearray_insert, METH_FASTCALL, bytearray_insert__doc__},
static PyObject *
bytearray_insert_impl(PyByteArrayObject *self, Py_ssize_t index, int item);
@ -388,7 +388,7 @@ 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_FASTCALL, bytearray_pop__doc__},
{"pop", (PyCFunction)(void(*)(void))bytearray_pop, METH_FASTCALL, bytearray_pop__doc__},
static PyObject *
bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index);
@ -448,7 +448,7 @@ PyDoc_STRVAR(bytearray_strip__doc__,
"If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
#define BYTEARRAY_STRIP_METHODDEF \
{"strip", (PyCFunction)bytearray_strip, METH_FASTCALL, bytearray_strip__doc__},
{"strip", (PyCFunction)(void(*)(void))bytearray_strip, METH_FASTCALL, bytearray_strip__doc__},
static PyObject *
bytearray_strip_impl(PyByteArrayObject *self, PyObject *bytes);
@ -479,7 +479,7 @@ PyDoc_STRVAR(bytearray_lstrip__doc__,
"If the argument is omitted or None, strip leading ASCII whitespace.");
#define BYTEARRAY_LSTRIP_METHODDEF \
{"lstrip", (PyCFunction)bytearray_lstrip, METH_FASTCALL, bytearray_lstrip__doc__},
{"lstrip", (PyCFunction)(void(*)(void))bytearray_lstrip, METH_FASTCALL, bytearray_lstrip__doc__},
static PyObject *
bytearray_lstrip_impl(PyByteArrayObject *self, PyObject *bytes);
@ -510,7 +510,7 @@ PyDoc_STRVAR(bytearray_rstrip__doc__,
"If the argument is omitted or None, strip trailing ASCII whitespace.");
#define BYTEARRAY_RSTRIP_METHODDEF \
{"rstrip", (PyCFunction)bytearray_rstrip, METH_FASTCALL, bytearray_rstrip__doc__},
{"rstrip", (PyCFunction)(void(*)(void))bytearray_rstrip, METH_FASTCALL, bytearray_rstrip__doc__},
static PyObject *
bytearray_rstrip_impl(PyByteArrayObject *self, PyObject *bytes);
@ -548,7 +548,7 @@ PyDoc_STRVAR(bytearray_decode__doc__,
" can handle UnicodeDecodeErrors.");
#define BYTEARRAY_DECODE_METHODDEF \
{"decode", (PyCFunction)bytearray_decode, METH_FASTCALL|METH_KEYWORDS, bytearray_decode__doc__},
{"decode", (PyCFunction)(void(*)(void))bytearray_decode, METH_FASTCALL|METH_KEYWORDS, bytearray_decode__doc__},
static PyObject *
bytearray_decode_impl(PyByteArrayObject *self, const char *encoding,
@ -596,7 +596,7 @@ PyDoc_STRVAR(bytearray_splitlines__doc__,
"true.");
#define BYTEARRAY_SPLITLINES_METHODDEF \
{"splitlines", (PyCFunction)bytearray_splitlines, METH_FASTCALL|METH_KEYWORDS, bytearray_splitlines__doc__},
{"splitlines", (PyCFunction)(void(*)(void))bytearray_splitlines, METH_FASTCALL|METH_KEYWORDS, bytearray_splitlines__doc__},
static PyObject *
bytearray_splitlines_impl(PyByteArrayObject *self, int keepends);
@ -674,7 +674,7 @@ PyDoc_STRVAR(bytearray_reduce_ex__doc__,
"Return state information for pickling.");
#define BYTEARRAY_REDUCE_EX_METHODDEF \
{"__reduce_ex__", (PyCFunction)bytearray_reduce_ex, METH_FASTCALL, bytearray_reduce_ex__doc__},
{"__reduce_ex__", (PyCFunction)(void(*)(void))bytearray_reduce_ex, METH_FASTCALL, bytearray_reduce_ex__doc__},
static PyObject *
bytearray_reduce_ex_impl(PyByteArrayObject *self, int proto);
@ -712,4 +712,4 @@ bytearray_sizeof(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
{
return bytearray_sizeof_impl(self);
}
/*[clinic end generated code: output=bb9051a369adb328 input=a9049054013a1b77]*/
/*[clinic end generated code: output=b88bb192dddca6e1 input=a9049054013a1b77]*/

22
Objects/clinic/bytesobject.c.h generated
View file

@ -17,7 +17,7 @@ PyDoc_STRVAR(bytes_split__doc__,
" -1 (the default value) means no limit.");
#define BYTES_SPLIT_METHODDEF \
{"split", (PyCFunction)bytes_split, METH_FASTCALL|METH_KEYWORDS, bytes_split__doc__},
{"split", (PyCFunction)(void(*)(void))bytes_split, METH_FASTCALL|METH_KEYWORDS, bytes_split__doc__},
static PyObject *
bytes_split_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit);
@ -136,7 +136,7 @@ PyDoc_STRVAR(bytes_rsplit__doc__,
"Splitting is done starting at the end of the bytes and working to the front.");
#define BYTES_RSPLIT_METHODDEF \
{"rsplit", (PyCFunction)bytes_rsplit, METH_FASTCALL|METH_KEYWORDS, bytes_rsplit__doc__},
{"rsplit", (PyCFunction)(void(*)(void))bytes_rsplit, METH_FASTCALL|METH_KEYWORDS, bytes_rsplit__doc__},
static PyObject *
bytes_rsplit_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit);
@ -184,7 +184,7 @@ PyDoc_STRVAR(bytes_strip__doc__,
"If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
#define BYTES_STRIP_METHODDEF \
{"strip", (PyCFunction)bytes_strip, METH_FASTCALL, bytes_strip__doc__},
{"strip", (PyCFunction)(void(*)(void))bytes_strip, METH_FASTCALL, bytes_strip__doc__},
static PyObject *
bytes_strip_impl(PyBytesObject *self, PyObject *bytes);
@ -215,7 +215,7 @@ PyDoc_STRVAR(bytes_lstrip__doc__,
"If the argument is omitted or None, strip leading ASCII whitespace.");
#define BYTES_LSTRIP_METHODDEF \
{"lstrip", (PyCFunction)bytes_lstrip, METH_FASTCALL, bytes_lstrip__doc__},
{"lstrip", (PyCFunction)(void(*)(void))bytes_lstrip, METH_FASTCALL, bytes_lstrip__doc__},
static PyObject *
bytes_lstrip_impl(PyBytesObject *self, PyObject *bytes);
@ -246,7 +246,7 @@ PyDoc_STRVAR(bytes_rstrip__doc__,
"If the argument is omitted or None, strip trailing ASCII whitespace.");
#define BYTES_RSTRIP_METHODDEF \
{"rstrip", (PyCFunction)bytes_rstrip, METH_FASTCALL, bytes_rstrip__doc__},
{"rstrip", (PyCFunction)(void(*)(void))bytes_rstrip, METH_FASTCALL, bytes_rstrip__doc__},
static PyObject *
bytes_rstrip_impl(PyBytesObject *self, PyObject *bytes);
@ -281,7 +281,7 @@ PyDoc_STRVAR(bytes_translate__doc__,
"The remaining characters are mapped through the given translation table.");
#define BYTES_TRANSLATE_METHODDEF \
{"translate", (PyCFunction)bytes_translate, METH_FASTCALL|METH_KEYWORDS, bytes_translate__doc__},
{"translate", (PyCFunction)(void(*)(void))bytes_translate, METH_FASTCALL|METH_KEYWORDS, bytes_translate__doc__},
static PyObject *
bytes_translate_impl(PyBytesObject *self, PyObject *table,
@ -318,7 +318,7 @@ 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_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
{"maketrans", (PyCFunction)(void(*)(void))bytes_maketrans, METH_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
static PyObject *
bytes_maketrans_impl(Py_buffer *frm, Py_buffer *to);
@ -363,7 +363,7 @@ PyDoc_STRVAR(bytes_replace__doc__,
"replaced.");
#define BYTES_REPLACE_METHODDEF \
{"replace", (PyCFunction)bytes_replace, METH_FASTCALL, bytes_replace__doc__},
{"replace", (PyCFunction)(void(*)(void))bytes_replace, METH_FASTCALL, bytes_replace__doc__},
static PyObject *
bytes_replace_impl(PyBytesObject *self, Py_buffer *old, Py_buffer *new,
@ -412,7 +412,7 @@ PyDoc_STRVAR(bytes_decode__doc__,
" can handle UnicodeDecodeErrors.");
#define BYTES_DECODE_METHODDEF \
{"decode", (PyCFunction)bytes_decode, METH_FASTCALL|METH_KEYWORDS, bytes_decode__doc__},
{"decode", (PyCFunction)(void(*)(void))bytes_decode, METH_FASTCALL|METH_KEYWORDS, bytes_decode__doc__},
static PyObject *
bytes_decode_impl(PyBytesObject *self, const char *encoding,
@ -447,7 +447,7 @@ PyDoc_STRVAR(bytes_splitlines__doc__,
"true.");
#define BYTES_SPLITLINES_METHODDEF \
{"splitlines", (PyCFunction)bytes_splitlines, METH_FASTCALL|METH_KEYWORDS, bytes_splitlines__doc__},
{"splitlines", (PyCFunction)(void(*)(void))bytes_splitlines, METH_FASTCALL|METH_KEYWORDS, bytes_splitlines__doc__},
static PyObject *
bytes_splitlines_impl(PyBytesObject *self, int keepends);
@ -499,4 +499,4 @@ bytes_fromhex(PyTypeObject *type, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=470acd12b2534765 input=a9049054013a1b77]*/
/*[clinic end generated code: output=07b33ac65362301b input=a9049054013a1b77]*/

8
Objects/clinic/dictobject.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(dict_fromkeys__doc__,
"Create a new dictionary with keys from iterable and values set to value.");
#define DICT_FROMKEYS_METHODDEF \
{"fromkeys", (PyCFunction)dict_fromkeys, METH_FASTCALL|METH_CLASS, dict_fromkeys__doc__},
{"fromkeys", (PyCFunction)(void(*)(void))dict_fromkeys, METH_FASTCALL|METH_CLASS, dict_fromkeys__doc__},
static PyObject *
dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value);
@ -48,7 +48,7 @@ PyDoc_STRVAR(dict_get__doc__,
"Return the value for key if key is in the dictionary, else default.");
#define DICT_GET_METHODDEF \
{"get", (PyCFunction)dict_get, METH_FASTCALL, dict_get__doc__},
{"get", (PyCFunction)(void(*)(void))dict_get, METH_FASTCALL, dict_get__doc__},
static PyObject *
dict_get_impl(PyDictObject *self, PyObject *key, PyObject *default_value);
@ -80,7 +80,7 @@ PyDoc_STRVAR(dict_setdefault__doc__,
"Return the value for key if key is in the dictionary, else default.");
#define DICT_SETDEFAULT_METHODDEF \
{"setdefault", (PyCFunction)dict_setdefault, METH_FASTCALL, dict_setdefault__doc__},
{"setdefault", (PyCFunction)(void(*)(void))dict_setdefault, METH_FASTCALL, dict_setdefault__doc__},
static PyObject *
dict_setdefault_impl(PyDictObject *self, PyObject *key,
@ -121,4 +121,4 @@ dict___reversed__(PyDictObject *self, PyObject *Py_UNUSED(ignored))
{
return dict___reversed___impl(self);
}
/*[clinic end generated code: output=b9923851cbd9213a input=a9049054013a1b77]*/
/*[clinic end generated code: output=193e08cb8099fe22 input=a9049054013a1b77]*/

6
Objects/clinic/floatobject.c.h generated
View file

@ -47,7 +47,7 @@ PyDoc_STRVAR(float___round____doc__,
"When an argument is passed, work like built-in round(x, ndigits).");
#define FLOAT___ROUND___METHODDEF \
{"__round__", (PyCFunction)float___round__, METH_FASTCALL, float___round____doc__},
{"__round__", (PyCFunction)(void(*)(void))float___round__, METH_FASTCALL, float___round____doc__},
static PyObject *
float___round___impl(PyObject *self, PyObject *o_ndigits);
@ -256,7 +256,7 @@ PyDoc_STRVAR(float___set_format____doc__,
"This affects how floats are converted to and from binary strings.");
#define FLOAT___SET_FORMAT___METHODDEF \
{"__set_format__", (PyCFunction)float___set_format__, METH_FASTCALL|METH_CLASS, float___set_format____doc__},
{"__set_format__", (PyCFunction)(void(*)(void))float___set_format__, METH_FASTCALL|METH_CLASS, float___set_format____doc__},
static PyObject *
float___set_format___impl(PyTypeObject *type, const char *typestr,
@ -305,4 +305,4 @@ float___format__(PyObject *self, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=a3c366a156be61f9 input=a9049054013a1b77]*/
/*[clinic end generated code: output=091dd499f5386a6c input=a9049054013a1b77]*/

10
Objects/clinic/listobject.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(list_insert__doc__,
"Insert object before index.");
#define LIST_INSERT_METHODDEF \
{"insert", (PyCFunction)list_insert, METH_FASTCALL, list_insert__doc__},
{"insert", (PyCFunction)(void(*)(void))list_insert, METH_FASTCALL, list_insert__doc__},
static PyObject *
list_insert_impl(PyListObject *self, Py_ssize_t index, PyObject *object);
@ -94,7 +94,7 @@ PyDoc_STRVAR(list_pop__doc__,
"Raises IndexError if list is empty or index is out of range.");
#define LIST_POP_METHODDEF \
{"pop", (PyCFunction)list_pop, METH_FASTCALL, list_pop__doc__},
{"pop", (PyCFunction)(void(*)(void))list_pop, METH_FASTCALL, list_pop__doc__},
static PyObject *
list_pop_impl(PyListObject *self, Py_ssize_t index);
@ -122,7 +122,7 @@ PyDoc_STRVAR(list_sort__doc__,
"Stable sort *IN PLACE*.");
#define LIST_SORT_METHODDEF \
{"sort", (PyCFunction)list_sort, METH_FASTCALL|METH_KEYWORDS, list_sort__doc__},
{"sort", (PyCFunction)(void(*)(void))list_sort, METH_FASTCALL|METH_KEYWORDS, list_sort__doc__},
static PyObject *
list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse);
@ -173,7 +173,7 @@ PyDoc_STRVAR(list_index__doc__,
"Raises ValueError if the value is not present.");
#define LIST_INDEX_METHODDEF \
{"index", (PyCFunction)list_index, METH_FASTCALL, list_index__doc__},
{"index", (PyCFunction)(void(*)(void))list_index, METH_FASTCALL, list_index__doc__},
static PyObject *
list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
@ -285,4 +285,4 @@ list___reversed__(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
return list___reversed___impl(self);
}
/*[clinic end generated code: output=d8cb29e6e6d79844 input=a9049054013a1b77]*/
/*[clinic end generated code: output=652ae4ee63a9de71 input=a9049054013a1b77]*/

6
Objects/clinic/longobject.c.h generated
View file

@ -167,7 +167,7 @@ PyDoc_STRVAR(int_to_bytes__doc__,
" is raised.");
#define INT_TO_BYTES_METHODDEF \
{"to_bytes", (PyCFunction)int_to_bytes, METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
{"to_bytes", (PyCFunction)(void(*)(void))int_to_bytes, METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
static PyObject *
int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,
@ -214,7 +214,7 @@ PyDoc_STRVAR(int_from_bytes__doc__,
" Indicates whether two\'s complement is used to represent the integer.");
#define INT_FROM_BYTES_METHODDEF \
{"from_bytes", (PyCFunction)int_from_bytes, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
{"from_bytes", (PyCFunction)(void(*)(void))int_from_bytes, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
static PyObject *
int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,
@ -239,4 +239,4 @@ int_from_bytes(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyOb
exit:
return return_value;
}
/*[clinic end generated code: output=6d5e92d7dc803751 input=a9049054013a1b77]*/
/*[clinic end generated code: output=403ccd096555fd1e input=a9049054013a1b77]*/

10
Objects/clinic/odictobject.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(OrderedDict_fromkeys__doc__,
"Create a new ordered dictionary with keys from iterable and values set to value.");
#define ORDEREDDICT_FROMKEYS_METHODDEF \
{"fromkeys", (PyCFunction)OrderedDict_fromkeys, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, OrderedDict_fromkeys__doc__},
{"fromkeys", (PyCFunction)(void(*)(void))OrderedDict_fromkeys, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, OrderedDict_fromkeys__doc__},
static PyObject *
OrderedDict_fromkeys_impl(PyTypeObject *type, PyObject *seq, PyObject *value);
@ -42,7 +42,7 @@ PyDoc_STRVAR(OrderedDict_setdefault__doc__,
"Return the value for key if key is in the dictionary, else default.");
#define ORDEREDDICT_SETDEFAULT_METHODDEF \
{"setdefault", (PyCFunction)OrderedDict_setdefault, METH_FASTCALL|METH_KEYWORDS, OrderedDict_setdefault__doc__},
{"setdefault", (PyCFunction)(void(*)(void))OrderedDict_setdefault, METH_FASTCALL|METH_KEYWORDS, OrderedDict_setdefault__doc__},
static PyObject *
OrderedDict_setdefault_impl(PyODictObject *self, PyObject *key,
@ -76,7 +76,7 @@ PyDoc_STRVAR(OrderedDict_popitem__doc__,
"Pairs are returned in LIFO order if last is true or FIFO order if false.");
#define ORDEREDDICT_POPITEM_METHODDEF \
{"popitem", (PyCFunction)OrderedDict_popitem, METH_FASTCALL|METH_KEYWORDS, OrderedDict_popitem__doc__},
{"popitem", (PyCFunction)(void(*)(void))OrderedDict_popitem, METH_FASTCALL|METH_KEYWORDS, OrderedDict_popitem__doc__},
static PyObject *
OrderedDict_popitem_impl(PyODictObject *self, int last);
@ -108,7 +108,7 @@ PyDoc_STRVAR(OrderedDict_move_to_end__doc__,
"Raise KeyError if the element does not exist.");
#define ORDEREDDICT_MOVE_TO_END_METHODDEF \
{"move_to_end", (PyCFunction)OrderedDict_move_to_end, METH_FASTCALL|METH_KEYWORDS, OrderedDict_move_to_end__doc__},
{"move_to_end", (PyCFunction)(void(*)(void))OrderedDict_move_to_end, METH_FASTCALL|METH_KEYWORDS, OrderedDict_move_to_end__doc__},
static PyObject *
OrderedDict_move_to_end_impl(PyODictObject *self, PyObject *key, int last);
@ -131,4 +131,4 @@ OrderedDict_move_to_end(PyODictObject *self, PyObject *const *args, Py_ssize_t n
exit:
return return_value;
}
/*[clinic end generated code: output=7f23d569eda2a558 input=a9049054013a1b77]*/
/*[clinic end generated code: output=f6f189e1fe032e0b input=a9049054013a1b77]*/

4
Objects/clinic/tupleobject.c.h generated
View file

@ -11,7 +11,7 @@ PyDoc_STRVAR(tuple_index__doc__,
"Raises ValueError if the value is not present.");
#define TUPLE_INDEX_METHODDEF \
{"index", (PyCFunction)tuple_index, METH_FASTCALL, tuple_index__doc__},
{"index", (PyCFunction)(void(*)(void))tuple_index, METH_FASTCALL, tuple_index__doc__},
static PyObject *
tuple_index_impl(PyTupleObject *self, PyObject *value, Py_ssize_t start,
@ -95,4 +95,4 @@ tuple___getnewargs__(PyTupleObject *self, PyObject *Py_UNUSED(ignored))
{
return tuple___getnewargs___impl(self);
}
/*[clinic end generated code: output=0fbf4321fb4365ac input=a9049054013a1b77]*/
/*[clinic end generated code: output=0a6ebd2d16b09c5d input=a9049054013a1b77]*/

28
Objects/clinic/unicodeobject.c.h generated
View file

@ -71,7 +71,7 @@ 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_FASTCALL, unicode_center__doc__},
{"center", (PyCFunction)(void(*)(void))unicode_center, METH_FASTCALL, unicode_center__doc__},
static PyObject *
unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
@ -109,7 +109,7 @@ PyDoc_STRVAR(unicode_encode__doc__,
" codecs.register_error that can handle UnicodeEncodeErrors.");
#define UNICODE_ENCODE_METHODDEF \
{"encode", (PyCFunction)unicode_encode, METH_FASTCALL|METH_KEYWORDS, unicode_encode__doc__},
{"encode", (PyCFunction)(void(*)(void))unicode_encode, METH_FASTCALL|METH_KEYWORDS, unicode_encode__doc__},
static PyObject *
unicode_encode_impl(PyObject *self, const char *encoding, const char *errors);
@ -142,7 +142,7 @@ PyDoc_STRVAR(unicode_expandtabs__doc__,
"If tabsize is not given, a tab size of 8 characters is assumed.");
#define UNICODE_EXPANDTABS_METHODDEF \
{"expandtabs", (PyCFunction)unicode_expandtabs, METH_FASTCALL|METH_KEYWORDS, unicode_expandtabs__doc__},
{"expandtabs", (PyCFunction)(void(*)(void))unicode_expandtabs, METH_FASTCALL|METH_KEYWORDS, unicode_expandtabs__doc__},
static PyObject *
unicode_expandtabs_impl(PyObject *self, int tabsize);
@ -440,7 +440,7 @@ 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_FASTCALL, unicode_ljust__doc__},
{"ljust", (PyCFunction)(void(*)(void))unicode_ljust, METH_FASTCALL, unicode_ljust__doc__},
static PyObject *
unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
@ -489,7 +489,7 @@ PyDoc_STRVAR(unicode_strip__doc__,
"If chars is given and not None, remove characters in chars instead.");
#define UNICODE_STRIP_METHODDEF \
{"strip", (PyCFunction)unicode_strip, METH_FASTCALL, unicode_strip__doc__},
{"strip", (PyCFunction)(void(*)(void))unicode_strip, METH_FASTCALL, unicode_strip__doc__},
static PyObject *
unicode_strip_impl(PyObject *self, PyObject *chars);
@ -520,7 +520,7 @@ PyDoc_STRVAR(unicode_lstrip__doc__,
"If chars is given and not None, remove characters in chars instead.");
#define UNICODE_LSTRIP_METHODDEF \
{"lstrip", (PyCFunction)unicode_lstrip, METH_FASTCALL, unicode_lstrip__doc__},
{"lstrip", (PyCFunction)(void(*)(void))unicode_lstrip, METH_FASTCALL, unicode_lstrip__doc__},
static PyObject *
unicode_lstrip_impl(PyObject *self, PyObject *chars);
@ -551,7 +551,7 @@ PyDoc_STRVAR(unicode_rstrip__doc__,
"If chars is given and not None, remove characters in chars instead.");
#define UNICODE_RSTRIP_METHODDEF \
{"rstrip", (PyCFunction)unicode_rstrip, METH_FASTCALL, unicode_rstrip__doc__},
{"rstrip", (PyCFunction)(void(*)(void))unicode_rstrip, METH_FASTCALL, unicode_rstrip__doc__},
static PyObject *
unicode_rstrip_impl(PyObject *self, PyObject *chars);
@ -587,7 +587,7 @@ PyDoc_STRVAR(unicode_replace__doc__,
"replaced.");
#define UNICODE_REPLACE_METHODDEF \
{"replace", (PyCFunction)unicode_replace, METH_FASTCALL, unicode_replace__doc__},
{"replace", (PyCFunction)(void(*)(void))unicode_replace, METH_FASTCALL, unicode_replace__doc__},
static PyObject *
unicode_replace_impl(PyObject *self, PyObject *old, PyObject *new,
@ -620,7 +620,7 @@ 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_FASTCALL, unicode_rjust__doc__},
{"rjust", (PyCFunction)(void(*)(void))unicode_rjust, METH_FASTCALL, unicode_rjust__doc__},
static PyObject *
unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
@ -657,7 +657,7 @@ PyDoc_STRVAR(unicode_split__doc__,
" -1 (the default value) means no limit.");
#define UNICODE_SPLIT_METHODDEF \
{"split", (PyCFunction)unicode_split, METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
{"split", (PyCFunction)(void(*)(void))unicode_split, METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
static PyObject *
unicode_split_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
@ -730,7 +730,7 @@ PyDoc_STRVAR(unicode_rsplit__doc__,
"Splits are done starting at the end of the string and working to the front.");
#define UNICODE_RSPLIT_METHODDEF \
{"rsplit", (PyCFunction)unicode_rsplit, METH_FASTCALL|METH_KEYWORDS, unicode_rsplit__doc__},
{"rsplit", (PyCFunction)(void(*)(void))unicode_rsplit, METH_FASTCALL|METH_KEYWORDS, unicode_rsplit__doc__},
static PyObject *
unicode_rsplit_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
@ -764,7 +764,7 @@ PyDoc_STRVAR(unicode_splitlines__doc__,
"true.");
#define UNICODE_SPLITLINES_METHODDEF \
{"splitlines", (PyCFunction)unicode_splitlines, METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
{"splitlines", (PyCFunction)(void(*)(void))unicode_splitlines, METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
static PyObject *
unicode_splitlines_impl(PyObject *self, int keepends);
@ -820,7 +820,7 @@ 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_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
{"maketrans", (PyCFunction)(void(*)(void))unicode_maketrans, METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
static PyObject *
unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z);
@ -951,4 +951,4 @@ unicode_sizeof(PyObject *self, PyObject *Py_UNUSED(ignored))
{
return unicode_sizeof_impl(self);
}
/*[clinic end generated code: output=8bcd992b25733bcc input=a9049054013a1b77]*/
/*[clinic end generated code: output=d323802b67bfc6d8 input=a9049054013a1b77]*/

10
Objects/stringlib/clinic/transmogrify.h.h
View file

@ -11,7 +11,7 @@ PyDoc_STRVAR(stringlib_expandtabs__doc__,
"If tabsize is not given, a tab size of 8 characters is assumed.");
#define STRINGLIB_EXPANDTABS_METHODDEF \
{"expandtabs", (PyCFunction)stringlib_expandtabs, METH_FASTCALL|METH_KEYWORDS, stringlib_expandtabs__doc__},
{"expandtabs", (PyCFunction)(void(*)(void))stringlib_expandtabs, METH_FASTCALL|METH_KEYWORDS, stringlib_expandtabs__doc__},
static PyObject *
stringlib_expandtabs_impl(PyObject *self, int tabsize);
@ -43,7 +43,7 @@ PyDoc_STRVAR(stringlib_ljust__doc__,
"Padding is done using the specified fill character.");
#define STRINGLIB_LJUST_METHODDEF \
{"ljust", (PyCFunction)stringlib_ljust, METH_FASTCALL, stringlib_ljust__doc__},
{"ljust", (PyCFunction)(void(*)(void))stringlib_ljust, METH_FASTCALL, stringlib_ljust__doc__},
static PyObject *
stringlib_ljust_impl(PyObject *self, Py_ssize_t width, char fillchar);
@ -74,7 +74,7 @@ PyDoc_STRVAR(stringlib_rjust__doc__,
"Padding is done using the specified fill character.");
#define STRINGLIB_RJUST_METHODDEF \
{"rjust", (PyCFunction)stringlib_rjust, METH_FASTCALL, stringlib_rjust__doc__},
{"rjust", (PyCFunction)(void(*)(void))stringlib_rjust, METH_FASTCALL, stringlib_rjust__doc__},
static PyObject *
stringlib_rjust_impl(PyObject *self, Py_ssize_t width, char fillchar);
@ -105,7 +105,7 @@ PyDoc_STRVAR(stringlib_center__doc__,
"Padding is done using the specified fill character.");
#define STRINGLIB_CENTER_METHODDEF \
{"center", (PyCFunction)stringlib_center, METH_FASTCALL, stringlib_center__doc__},
{"center", (PyCFunction)(void(*)(void))stringlib_center, METH_FASTCALL, stringlib_center__doc__},
static PyObject *
stringlib_center_impl(PyObject *self, Py_ssize_t width, char fillchar);
@ -155,4 +155,4 @@ stringlib_zfill(PyObject *self, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=336620159a1fc70d input=a9049054013a1b77]*/
/*[clinic end generated code: output=d09ba158d470566e input=a9049054013a1b77]*/

6
PC/clinic/_testconsole.c.h generated
View file

@ -11,7 +11,7 @@ PyDoc_STRVAR(_testconsole_write_input__doc__,
"Writes UTF-16-LE encoded bytes to the console as if typed by a user.");
#define _TESTCONSOLE_WRITE_INPUT_METHODDEF \
{"write_input", (PyCFunction)_testconsole_write_input, METH_FASTCALL|METH_KEYWORDS, _testconsole_write_input__doc__},
{"write_input", (PyCFunction)(void(*)(void))_testconsole_write_input, METH_FASTCALL|METH_KEYWORDS, _testconsole_write_input__doc__},
static PyObject *
_testconsole_write_input_impl(PyObject *module, PyObject *file,
@ -47,7 +47,7 @@ PyDoc_STRVAR(_testconsole_read_output__doc__,
"Reads a str from the console as written to stdout.");
#define _TESTCONSOLE_READ_OUTPUT_METHODDEF \
{"read_output", (PyCFunction)_testconsole_read_output, METH_FASTCALL|METH_KEYWORDS, _testconsole_read_output__doc__},
{"read_output", (PyCFunction)(void(*)(void))_testconsole_read_output, METH_FASTCALL|METH_KEYWORDS, _testconsole_read_output__doc__},
static PyObject *
_testconsole_read_output_impl(PyObject *module, PyObject *file);
@ -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=e7dd05a60463c5f0 input=a9049054013a1b77]*/
/*[clinic end generated code: output=ab9ea8e78d26288e input=a9049054013a1b77]*/

12
PC/clinic/msvcrtmodule.c.h generated
View file

@ -37,7 +37,7 @@ PyDoc_STRVAR(msvcrt_locking__doc__,
"individually.");
#define MSVCRT_LOCKING_METHODDEF \
{"locking", (PyCFunction)msvcrt_locking, METH_FASTCALL, msvcrt_locking__doc__},
{"locking", (PyCFunction)(void(*)(void))msvcrt_locking, METH_FASTCALL, msvcrt_locking__doc__},
static PyObject *
msvcrt_locking_impl(PyObject *module, int fd, int mode, long nbytes);
@ -72,7 +72,7 @@ PyDoc_STRVAR(msvcrt_setmode__doc__,
"Return value is the previous mode.");
#define MSVCRT_SETMODE_METHODDEF \
{"setmode", (PyCFunction)msvcrt_setmode, METH_FASTCALL, msvcrt_setmode__doc__},
{"setmode", (PyCFunction)(void(*)(void))msvcrt_setmode, METH_FASTCALL, msvcrt_setmode__doc__},
static long
msvcrt_setmode_impl(PyObject *module, int fd, int flags);
@ -110,7 +110,7 @@ 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_FASTCALL, msvcrt_open_osfhandle__doc__},
{"open_osfhandle", (PyCFunction)(void(*)(void))msvcrt_open_osfhandle, METH_FASTCALL, msvcrt_open_osfhandle__doc__},
static long
msvcrt_open_osfhandle_impl(PyObject *module, void *handle, int flags);
@ -424,7 +424,7 @@ PyDoc_STRVAR(msvcrt_CrtSetReportFile__doc__,
"Only available on Debug builds.");
#define MSVCRT_CRTSETREPORTFILE_METHODDEF \
{"CrtSetReportFile", (PyCFunction)msvcrt_CrtSetReportFile, METH_FASTCALL, msvcrt_CrtSetReportFile__doc__},
{"CrtSetReportFile", (PyCFunction)(void(*)(void))msvcrt_CrtSetReportFile, METH_FASTCALL, msvcrt_CrtSetReportFile__doc__},
static void *
msvcrt_CrtSetReportFile_impl(PyObject *module, int type, void *file);
@ -464,7 +464,7 @@ PyDoc_STRVAR(msvcrt_CrtSetReportMode__doc__,
"Only available on Debug builds.");
#define MSVCRT_CRTSETREPORTMODE_METHODDEF \
{"CrtSetReportMode", (PyCFunction)msvcrt_CrtSetReportMode, METH_FASTCALL, msvcrt_CrtSetReportMode__doc__},
{"CrtSetReportMode", (PyCFunction)(void(*)(void))msvcrt_CrtSetReportMode, METH_FASTCALL, msvcrt_CrtSetReportMode__doc__},
static long
msvcrt_CrtSetReportMode_impl(PyObject *module, int type, int mode);
@ -569,4 +569,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=3dd4cf62afb9771a input=a9049054013a1b77]*/
/*[clinic end generated code: output=632089ff9236ac77 input=a9049054013a1b77]*/

36
PC/clinic/winreg.c.h generated
View file

@ -77,7 +77,7 @@ PyDoc_STRVAR(winreg_HKEYType___exit____doc__,
"\n");
#define WINREG_HKEYTYPE___EXIT___METHODDEF \
{"__exit__", (PyCFunction)winreg_HKEYType___exit__, METH_FASTCALL|METH_KEYWORDS, winreg_HKEYType___exit____doc__},
{"__exit__", (PyCFunction)(void(*)(void))winreg_HKEYType___exit__, METH_FASTCALL|METH_KEYWORDS, winreg_HKEYType___exit____doc__},
static PyObject *
winreg_HKEYType___exit___impl(PyHKEYObject *self, PyObject *exc_type,
@ -134,7 +134,7 @@ PyDoc_STRVAR(winreg_ConnectRegistry__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_CONNECTREGISTRY_METHODDEF \
{"ConnectRegistry", (PyCFunction)winreg_ConnectRegistry, METH_FASTCALL, winreg_ConnectRegistry__doc__},
{"ConnectRegistry", (PyCFunction)(void(*)(void))winreg_ConnectRegistry, METH_FASTCALL, winreg_ConnectRegistry__doc__},
static HKEY
winreg_ConnectRegistry_impl(PyObject *module, Py_UNICODE *computer_name,
@ -182,7 +182,7 @@ PyDoc_STRVAR(winreg_CreateKey__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_CREATEKEY_METHODDEF \
{"CreateKey", (PyCFunction)winreg_CreateKey, METH_FASTCALL, winreg_CreateKey__doc__},
{"CreateKey", (PyCFunction)(void(*)(void))winreg_CreateKey, METH_FASTCALL, winreg_CreateKey__doc__},
static HKEY
winreg_CreateKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
@ -235,7 +235,7 @@ PyDoc_STRVAR(winreg_CreateKeyEx__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_CREATEKEYEX_METHODDEF \
{"CreateKeyEx", (PyCFunction)winreg_CreateKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_CreateKeyEx__doc__},
{"CreateKeyEx", (PyCFunction)(void(*)(void))winreg_CreateKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_CreateKeyEx__doc__},
static HKEY
winreg_CreateKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@ -286,7 +286,7 @@ 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_FASTCALL, winreg_DeleteKey__doc__},
{"DeleteKey", (PyCFunction)(void(*)(void))winreg_DeleteKey, METH_FASTCALL, winreg_DeleteKey__doc__},
static PyObject *
winreg_DeleteKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
@ -334,7 +334,7 @@ PyDoc_STRVAR(winreg_DeleteKeyEx__doc__,
"On unsupported Windows versions, NotImplementedError is raised.");
#define WINREG_DELETEKEYEX_METHODDEF \
{"DeleteKeyEx", (PyCFunction)winreg_DeleteKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},
{"DeleteKeyEx", (PyCFunction)(void(*)(void))winreg_DeleteKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},
static PyObject *
winreg_DeleteKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@ -373,7 +373,7 @@ PyDoc_STRVAR(winreg_DeleteValue__doc__,
" A string that identifies the value to remove.");
#define WINREG_DELETEVALUE_METHODDEF \
{"DeleteValue", (PyCFunction)winreg_DeleteValue, METH_FASTCALL, winreg_DeleteValue__doc__},
{"DeleteValue", (PyCFunction)(void(*)(void))winreg_DeleteValue, METH_FASTCALL, winreg_DeleteValue__doc__},
static PyObject *
winreg_DeleteValue_impl(PyObject *module, HKEY key, Py_UNICODE *value);
@ -411,7 +411,7 @@ PyDoc_STRVAR(winreg_EnumKey__doc__,
"raised, indicating no more values are available.");
#define WINREG_ENUMKEY_METHODDEF \
{"EnumKey", (PyCFunction)winreg_EnumKey, METH_FASTCALL, winreg_EnumKey__doc__},
{"EnumKey", (PyCFunction)(void(*)(void))winreg_EnumKey, METH_FASTCALL, winreg_EnumKey__doc__},
static PyObject *
winreg_EnumKey_impl(PyObject *module, HKEY key, int index);
@ -458,7 +458,7 @@ PyDoc_STRVAR(winreg_EnumValue__doc__,
" An integer that identifies the type of the value data.");
#define WINREG_ENUMVALUE_METHODDEF \
{"EnumValue", (PyCFunction)winreg_EnumValue, METH_FASTCALL, winreg_EnumValue__doc__},
{"EnumValue", (PyCFunction)(void(*)(void))winreg_EnumValue, METH_FASTCALL, winreg_EnumValue__doc__},
static PyObject *
winreg_EnumValue_impl(PyObject *module, HKEY key, int index);
@ -576,7 +576,7 @@ PyDoc_STRVAR(winreg_LoadKey__doc__,
"tree.");
#define WINREG_LOADKEY_METHODDEF \
{"LoadKey", (PyCFunction)winreg_LoadKey, METH_FASTCALL, winreg_LoadKey__doc__},
{"LoadKey", (PyCFunction)(void(*)(void))winreg_LoadKey, METH_FASTCALL, winreg_LoadKey__doc__},
static PyObject *
winreg_LoadKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@ -620,7 +620,7 @@ PyDoc_STRVAR(winreg_OpenKey__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_OPENKEY_METHODDEF \
{"OpenKey", (PyCFunction)winreg_OpenKey, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKey__doc__},
{"OpenKey", (PyCFunction)(void(*)(void))winreg_OpenKey, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKey__doc__},
static HKEY
winreg_OpenKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@ -672,7 +672,7 @@ PyDoc_STRVAR(winreg_OpenKeyEx__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_OPENKEYEX_METHODDEF \
{"OpenKeyEx", (PyCFunction)winreg_OpenKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKeyEx__doc__},
{"OpenKeyEx", (PyCFunction)(void(*)(void))winreg_OpenKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKeyEx__doc__},
static HKEY
winreg_OpenKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@ -761,7 +761,7 @@ PyDoc_STRVAR(winreg_QueryValue__doc__,
"completeness.");
#define WINREG_QUERYVALUE_METHODDEF \
{"QueryValue", (PyCFunction)winreg_QueryValue, METH_FASTCALL, winreg_QueryValue__doc__},
{"QueryValue", (PyCFunction)(void(*)(void))winreg_QueryValue, METH_FASTCALL, winreg_QueryValue__doc__},
static PyObject *
winreg_QueryValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
@ -800,7 +800,7 @@ 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_FASTCALL, winreg_QueryValueEx__doc__},
{"QueryValueEx", (PyCFunction)(void(*)(void))winreg_QueryValueEx, METH_FASTCALL, winreg_QueryValueEx__doc__},
static PyObject *
winreg_QueryValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *name);
@ -844,7 +844,7 @@ PyDoc_STRVAR(winreg_SaveKey__doc__,
"to the API.");
#define WINREG_SAVEKEY_METHODDEF \
{"SaveKey", (PyCFunction)winreg_SaveKey, METH_FASTCALL, winreg_SaveKey__doc__},
{"SaveKey", (PyCFunction)(void(*)(void))winreg_SaveKey, METH_FASTCALL, winreg_SaveKey__doc__},
static PyObject *
winreg_SaveKey_impl(PyObject *module, HKEY key, Py_UNICODE *file_name);
@ -893,7 +893,7 @@ PyDoc_STRVAR(winreg_SetValue__doc__,
"KEY_SET_VALUE access.");
#define WINREG_SETVALUE_METHODDEF \
{"SetValue", (PyCFunction)winreg_SetValue, METH_FASTCALL, winreg_SetValue__doc__},
{"SetValue", (PyCFunction)(void(*)(void))winreg_SetValue, METH_FASTCALL, winreg_SetValue__doc__},
static PyObject *
winreg_SetValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@ -964,7 +964,7 @@ PyDoc_STRVAR(winreg_SetValueEx__doc__,
"the configuration registry to help the registry perform efficiently.");
#define WINREG_SETVALUEEX_METHODDEF \
{"SetValueEx", (PyCFunction)winreg_SetValueEx, METH_FASTCALL, winreg_SetValueEx__doc__},
{"SetValueEx", (PyCFunction)(void(*)(void))winreg_SetValueEx, METH_FASTCALL, winreg_SetValueEx__doc__},
static PyObject *
winreg_SetValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *value_name,
@ -1091,4 +1091,4 @@ winreg_QueryReflectionKey(PyObject *module, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=d1c8e2678015dd7d input=a9049054013a1b77]*/
/*[clinic end generated code: output=45a9aec9f9258c0a input=a9049054013a1b77]*/

8
PC/clinic/winsound.c.h generated
View file

@ -14,7 +14,7 @@ PyDoc_STRVAR(winsound_PlaySound__doc__,
" Flag values, ored together. See module documentation.");
#define WINSOUND_PLAYSOUND_METHODDEF \
{"PlaySound", (PyCFunction)winsound_PlaySound, METH_FASTCALL|METH_KEYWORDS, winsound_PlaySound__doc__},
{"PlaySound", (PyCFunction)(void(*)(void))winsound_PlaySound, METH_FASTCALL|METH_KEYWORDS, winsound_PlaySound__doc__},
static PyObject *
winsound_PlaySound_impl(PyObject *module, PyObject *sound, int flags);
@ -51,7 +51,7 @@ PyDoc_STRVAR(winsound_Beep__doc__,
" How long the sound should play, in milliseconds.");
#define WINSOUND_BEEP_METHODDEF \
{"Beep", (PyCFunction)winsound_Beep, METH_FASTCALL|METH_KEYWORDS, winsound_Beep__doc__},
{"Beep", (PyCFunction)(void(*)(void))winsound_Beep, METH_FASTCALL|METH_KEYWORDS, winsound_Beep__doc__},
static PyObject *
winsound_Beep_impl(PyObject *module, int frequency, int duration);
@ -84,7 +84,7 @@ PyDoc_STRVAR(winsound_MessageBeep__doc__,
"x defaults to MB_OK.");
#define WINSOUND_MESSAGEBEEP_METHODDEF \
{"MessageBeep", (PyCFunction)winsound_MessageBeep, METH_FASTCALL|METH_KEYWORDS, winsound_MessageBeep__doc__},
{"MessageBeep", (PyCFunction)(void(*)(void))winsound_MessageBeep, METH_FASTCALL|METH_KEYWORDS, winsound_MessageBeep__doc__},
static PyObject *
winsound_MessageBeep_impl(PyObject *module, int type);
@ -106,4 +106,4 @@ winsound_MessageBeep(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
/*[clinic end generated code: output=beeee8be95667b7d input=a9049054013a1b77]*/
/*[clinic end generated code: output=19e5f0fb15bcd5bc input=a9049054013a1b77]*/

4
Python/clinic/_warnings.c.h generated
View file

@ -9,7 +9,7 @@ PyDoc_STRVAR(warnings_warn__doc__,
"Issue a warning, or maybe ignore it or raise an exception.");
#define WARNINGS_WARN_METHODDEF \
{"warn", (PyCFunction)warnings_warn, METH_FASTCALL|METH_KEYWORDS, warnings_warn__doc__},
{"warn", (PyCFunction)(void(*)(void))warnings_warn, METH_FASTCALL|METH_KEYWORDS, warnings_warn__doc__},
static PyObject *
warnings_warn_impl(PyObject *module, PyObject *message, PyObject *category,
@ -35,4 +35,4 @@ warnings_warn(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec
exit:
return return_value;
}
/*[clinic end generated code: output=86369ece63001d78 input=a9049054013a1b77]*/
/*[clinic end generated code: output=a4fbe6e2d1cc2091 input=a9049054013a1b77]*/

30
Python/clinic/bltinmodule.c.h generated
View file

@ -82,7 +82,7 @@ PyDoc_STRVAR(builtin_format__doc__,
"details.");
#define BUILTIN_FORMAT_METHODDEF \
{"format", (PyCFunction)builtin_format, METH_FASTCALL, builtin_format__doc__},
{"format", (PyCFunction)(void(*)(void))builtin_format, METH_FASTCALL, builtin_format__doc__},
static PyObject *
builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec);
@ -150,7 +150,7 @@ PyDoc_STRVAR(builtin_compile__doc__,
"in addition to any features explicitly specified.");
#define BUILTIN_COMPILE_METHODDEF \
{"compile", (PyCFunction)builtin_compile, METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
{"compile", (PyCFunction)(void(*)(void))builtin_compile, METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
static PyObject *
builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
@ -187,7 +187,7 @@ PyDoc_STRVAR(builtin_divmod__doc__,
"Return the tuple (x//y, x%y). Invariant: div*y + mod == x.");
#define BUILTIN_DIVMOD_METHODDEF \
{"divmod", (PyCFunction)builtin_divmod, METH_FASTCALL, builtin_divmod__doc__},
{"divmod", (PyCFunction)(void(*)(void))builtin_divmod, METH_FASTCALL, builtin_divmod__doc__},
static PyObject *
builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y);
@ -223,7 +223,7 @@ PyDoc_STRVAR(builtin_eval__doc__,
"If only globals is given, locals defaults to it.");
#define BUILTIN_EVAL_METHODDEF \
{"eval", (PyCFunction)builtin_eval, METH_FASTCALL, builtin_eval__doc__},
{"eval", (PyCFunction)(void(*)(void))builtin_eval, METH_FASTCALL, builtin_eval__doc__},
static PyObject *
builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
@ -261,7 +261,7 @@ PyDoc_STRVAR(builtin_exec__doc__,
"If only globals is given, locals defaults to it.");
#define BUILTIN_EXEC_METHODDEF \
{"exec", (PyCFunction)builtin_exec, METH_FASTCALL, builtin_exec__doc__},
{"exec", (PyCFunction)(void(*)(void))builtin_exec, METH_FASTCALL, builtin_exec__doc__},
static PyObject *
builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
@ -316,7 +316,7 @@ PyDoc_STRVAR(builtin_hasattr__doc__,
"This is done by calling getattr(obj, name) and catching AttributeError.");
#define BUILTIN_HASATTR_METHODDEF \
{"hasattr", (PyCFunction)builtin_hasattr, METH_FASTCALL, builtin_hasattr__doc__},
{"hasattr", (PyCFunction)(void(*)(void))builtin_hasattr, METH_FASTCALL, builtin_hasattr__doc__},
static PyObject *
builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name);
@ -360,7 +360,7 @@ PyDoc_STRVAR(builtin_setattr__doc__,
"setattr(x, \'y\', v) is equivalent to ``x.y = v\'\'");
#define BUILTIN_SETATTR_METHODDEF \
{"setattr", (PyCFunction)builtin_setattr, METH_FASTCALL, builtin_setattr__doc__},
{"setattr", (PyCFunction)(void(*)(void))builtin_setattr, METH_FASTCALL, builtin_setattr__doc__},
static PyObject *
builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name,
@ -394,7 +394,7 @@ PyDoc_STRVAR(builtin_delattr__doc__,
"delattr(x, \'y\') is equivalent to ``del x.y\'\'");
#define BUILTIN_DELATTR_METHODDEF \
{"delattr", (PyCFunction)builtin_delattr, METH_FASTCALL, builtin_delattr__doc__},
{"delattr", (PyCFunction)(void(*)(void))builtin_delattr, METH_FASTCALL, builtin_delattr__doc__},
static PyObject *
builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name);
@ -503,7 +503,7 @@ PyDoc_STRVAR(builtin_pow__doc__,
"invoked using the three argument form.");
#define BUILTIN_POW_METHODDEF \
{"pow", (PyCFunction)builtin_pow, METH_FASTCALL, builtin_pow__doc__},
{"pow", (PyCFunction)(void(*)(void))builtin_pow, METH_FASTCALL, builtin_pow__doc__},
static PyObject *
builtin_pow_impl(PyObject *module, PyObject *x, PyObject *y, PyObject *z);
@ -540,7 +540,7 @@ PyDoc_STRVAR(builtin_input__doc__,
"On *nix systems, readline is used if available.");
#define BUILTIN_INPUT_METHODDEF \
{"input", (PyCFunction)builtin_input, METH_FASTCALL, builtin_input__doc__},
{"input", (PyCFunction)(void(*)(void))builtin_input, METH_FASTCALL, builtin_input__doc__},
static PyObject *
builtin_input_impl(PyObject *module, PyObject *prompt);
@ -583,7 +583,7 @@ PyDoc_STRVAR(builtin_round__doc__,
"the return value has the same type as the number. ndigits may be negative.");
#define BUILTIN_ROUND_METHODDEF \
{"round", (PyCFunction)builtin_round, METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
{"round", (PyCFunction)(void(*)(void))builtin_round, METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
static PyObject *
builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits);
@ -618,7 +618,7 @@ PyDoc_STRVAR(builtin_sum__doc__,
"reject non-numeric types.");
#define BUILTIN_SUM_METHODDEF \
{"sum", (PyCFunction)builtin_sum, METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
{"sum", (PyCFunction)(void(*)(void))builtin_sum, METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
static PyObject *
builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start);
@ -653,7 +653,7 @@ PyDoc_STRVAR(builtin_isinstance__doc__,
"or ...`` etc.");
#define BUILTIN_ISINSTANCE_METHODDEF \
{"isinstance", (PyCFunction)builtin_isinstance, METH_FASTCALL, builtin_isinstance__doc__},
{"isinstance", (PyCFunction)(void(*)(void))builtin_isinstance, METH_FASTCALL, builtin_isinstance__doc__},
static PyObject *
builtin_isinstance_impl(PyObject *module, PyObject *obj,
@ -688,7 +688,7 @@ PyDoc_STRVAR(builtin_issubclass__doc__,
"or ...`` etc.");
#define BUILTIN_ISSUBCLASS_METHODDEF \
{"issubclass", (PyCFunction)builtin_issubclass, METH_FASTCALL, builtin_issubclass__doc__},
{"issubclass", (PyCFunction)(void(*)(void))builtin_issubclass, METH_FASTCALL, builtin_issubclass__doc__},
static PyObject *
builtin_issubclass_impl(PyObject *module, PyObject *cls,
@ -711,4 +711,4 @@ builtin_issubclass(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
/*[clinic end generated code: output=eb6d08a32e7c83b6 input=a9049054013a1b77]*/
/*[clinic end generated code: output=fa8d97ac8695363b input=a9049054013a1b77]*/

6
Python/clinic/context.c.h generated
View file

@ -12,7 +12,7 @@ PyDoc_STRVAR(_contextvars_Context_get__doc__,
"return None.");
#define _CONTEXTVARS_CONTEXT_GET_METHODDEF \
{"get", (PyCFunction)_contextvars_Context_get, METH_FASTCALL, _contextvars_Context_get__doc__},
{"get", (PyCFunction)(void(*)(void))_contextvars_Context_get, METH_FASTCALL, _contextvars_Context_get__doc__},
static PyObject *
_contextvars_Context_get_impl(PyContext *self, PyObject *key,
@ -123,7 +123,7 @@ PyDoc_STRVAR(_contextvars_ContextVar_get__doc__,
" * raise a LookupError.");
#define _CONTEXTVARS_CONTEXTVAR_GET_METHODDEF \
{"get", (PyCFunction)_contextvars_ContextVar_get, METH_FASTCALL, _contextvars_ContextVar_get__doc__},
{"get", (PyCFunction)(void(*)(void))_contextvars_ContextVar_get, METH_FASTCALL, _contextvars_ContextVar_get__doc__},
static PyObject *
_contextvars_ContextVar_get_impl(PyContextVar *self, PyObject *default_value);
@ -170,4 +170,4 @@ PyDoc_STRVAR(_contextvars_ContextVar_reset__doc__,
#define _CONTEXTVARS_CONTEXTVAR_RESET_METHODDEF \
{"reset", (PyCFunction)_contextvars_ContextVar_reset, METH_O, _contextvars_ContextVar_reset__doc__},
/*[clinic end generated code: output=33414d13716d0648 input=a9049054013a1b77]*/
/*[clinic end generated code: output=9c93e22bcadbaa2b input=a9049054013a1b77]*/

8
Python/clinic/import.c.h generated
View file

@ -75,7 +75,7 @@ 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_FASTCALL, _imp__fix_co_filename__doc__},
{"_fix_co_filename", (PyCFunction)(void(*)(void))_imp__fix_co_filename, METH_FASTCALL, _imp__fix_co_filename__doc__},
static PyObject *
_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
@ -269,7 +269,7 @@ PyDoc_STRVAR(_imp_create_dynamic__doc__,
"Create an extension module.");
#define _IMP_CREATE_DYNAMIC_METHODDEF \
{"create_dynamic", (PyCFunction)_imp_create_dynamic, METH_FASTCALL, _imp_create_dynamic__doc__},
{"create_dynamic", (PyCFunction)(void(*)(void))_imp_create_dynamic, METH_FASTCALL, _imp_create_dynamic__doc__},
static PyObject *
_imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file);
@ -360,7 +360,7 @@ PyDoc_STRVAR(_imp_source_hash__doc__,
"\n");
#define _IMP_SOURCE_HASH_METHODDEF \
{"source_hash", (PyCFunction)_imp_source_hash, METH_FASTCALL|METH_KEYWORDS, _imp_source_hash__doc__},
{"source_hash", (PyCFunction)(void(*)(void))_imp_source_hash, METH_FASTCALL|METH_KEYWORDS, _imp_source_hash__doc__},
static PyObject *
_imp_source_hash_impl(PyObject *module, long key, Py_buffer *source);
@ -396,4 +396,4 @@ exit:
#ifndef _IMP_EXEC_DYNAMIC_METHODDEF
#define _IMP_EXEC_DYNAMIC_METHODDEF
#endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
/*[clinic end generated code: output=f0660cd1de6b3a73 input=a9049054013a1b77]*/
/*[clinic end generated code: output=ad747b76e105fff2 input=a9049054013a1b77]*/

6
Python/clinic/marshal.c.h generated
View file

@ -20,7 +20,7 @@ PyDoc_STRVAR(marshal_dump__doc__,
"to the file. The object will not be properly read back by load().");
#define MARSHAL_DUMP_METHODDEF \
{"dump", (PyCFunction)marshal_dump, METH_FASTCALL, marshal_dump__doc__},
{"dump", (PyCFunction)(void(*)(void))marshal_dump, METH_FASTCALL, marshal_dump__doc__},
static PyObject *
marshal_dump_impl(PyObject *module, PyObject *value, PyObject *file,
@ -78,7 +78,7 @@ PyDoc_STRVAR(marshal_dumps__doc__,
"unsupported type.");
#define MARSHAL_DUMPS_METHODDEF \
{"dumps", (PyCFunction)marshal_dumps, METH_FASTCALL, marshal_dumps__doc__},
{"dumps", (PyCFunction)(void(*)(void))marshal_dumps, METH_FASTCALL, marshal_dumps__doc__},
static PyObject *
marshal_dumps_impl(PyObject *module, PyObject *value, int version);
@ -134,4 +134,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=584eb2222d86fdc3 input=a9049054013a1b77]*/
/*[clinic end generated code: output=cbb6128201bee7e0 input=a9049054013a1b77]*/

4
Python/clinic/sysmodule.c.h generated
View file

@ -13,7 +13,7 @@ PyDoc_STRVAR(sys_set_coroutine_origin_tracking_depth__doc__,
"to disable.");
#define SYS_SET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF \
{"set_coroutine_origin_tracking_depth", (PyCFunction)sys_set_coroutine_origin_tracking_depth, METH_FASTCALL|METH_KEYWORDS, sys_set_coroutine_origin_tracking_depth__doc__},
{"set_coroutine_origin_tracking_depth", (PyCFunction)(void(*)(void))sys_set_coroutine_origin_tracking_depth, METH_FASTCALL|METH_KEYWORDS, sys_set_coroutine_origin_tracking_depth__doc__},
static PyObject *
sys_set_coroutine_origin_tracking_depth_impl(PyObject *module, int depth);
@ -63,4 +63,4 @@ sys_get_coroutine_origin_tracking_depth(PyObject *module, PyObject *Py_UNUSED(ig
exit:
return return_value;
}
/*[clinic end generated code: output=4a3ac42b97d710ff input=a9049054013a1b77]*/
/*[clinic end generated code: output=dfd3eb5b137a9861 input=a9049054013a1b77]*/

8
Tools/clinic/clinic.py
View file

@ -680,7 +680,7 @@ def output_templates(self, f):
methoddef_define = normalize_snippet("""
#define {methoddef_name} \\
{{"{name}", (PyCFunction){c_basename}, {methoddef_flags}, {c_basename}__doc__}},
{{"{name}", {methoddef_cast}{c_basename}, {methoddef_flags}, {c_basename}__doc__}},
""")
if new_or_init and not f.docstring:
docstring_prototype = docstring_definition = ''
@ -944,10 +944,16 @@ def insert_keywords(s):
parser_definition = insert_keywords(parser_definition)
if flags in ('METH_NOARGS', 'METH_O', 'METH_VARARGS'):
methoddef_cast = "(PyCFunction)"
else:
methoddef_cast = "(PyCFunction)(void(*)(void))"
if f.methoddef_flags:
flags += '|' + f.methoddef_flags
methoddef_define = methoddef_define.replace('{methoddef_flags}', flags)
methoddef_define = methoddef_define.replace('{methoddef_cast}', methoddef_cast)
methoddef_ifndef = ''
conditional = self.cpp.condition()