"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=a9de1ae79c960e81 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a2c1af38d943ccec input=a9049054013a1b77]*/
"\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);
"\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);
"\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);
"\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);
"\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);
"\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);
exit:
return return_value;
}
-/*[clinic end generated code: output=9a20dd4eaabb5d58 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=cb4bf8d50533953b input=a9049054013a1b77]*/
"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);
"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);
"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);
"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);
"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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=9ba9a68c8c5669e7 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=89538a941ae1267a input=a9049054013a1b77]*/
"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);
"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);
"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);
#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]*/
"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);
"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);
"\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);
{
return _io__RawIOBase_readall_impl(self);
}
-/*[clinic end generated code: output=64989ec3dbf44a7c input=a9049054013a1b77]*/
+/*[clinic end generated code: output=cde4b0e96a4e69e3 input=a9049054013a1b77]*/
"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);
"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);
"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);
"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);
{
return _io_StringIO_seekable_impl(self);
}
-/*[clinic end generated code: output=73c4d6e5cc3b1a58 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=00c3c7a1c6ea6773 input=a9049054013a1b77]*/
"\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,
"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,
"\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);
"\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);
"\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);
"\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);
{
return _io_TextIOWrapper_close_impl(self);
}
-/*[clinic end generated code: output=b5be870b0039d577 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a811badd76bfe92e input=a9049054013a1b77]*/
"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);
#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]*/
"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,
"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,
"\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,
"\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,
"\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,
"\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,
"\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,
#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]*/
"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);
"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,
"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,
{
return _abc_get_cache_token_impl(module);
}
-/*[clinic end generated code: output=9d6f861a8f45bc6f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=606db3cb658d9240 input=a9049054013a1b77]*/
"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,
"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);
"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);
"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);
"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,
"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);
"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);
"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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=67da879c9f841505 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fd474bdc8f03d5ae input=a9049054013a1b77]*/
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=564a0313177fff63 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=e47f4255d265b07d input=a9049054013a1b77]*/
"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,
"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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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,
"\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);
"\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);
"\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,
"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,
#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]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=8d803e53466b1cd3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=79001dbfdd623ff9 input=a9049054013a1b77]*/
"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);
{
return _curses_panel_update_panels_impl(module);
}
-/*[clinic end generated code: output=96f627ca0b08b96d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=66e49cb9726a638f input=a9049054013a1b77]*/
" 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);
" 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,
"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,
" 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,
" 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);
"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);
"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,
"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);
"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);
"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,
"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,
"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,
" 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);
" 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);
" 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);
"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);
"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);
"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);
"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);
"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);
"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);
" 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,
#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]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=7fd14bd67749da23 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b3d746843403a8ce input=a9049054013a1b77]*/
"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,
"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,
" (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,
exit:
return return_value;
}
-/*[clinic end generated code: output=1cba297bc8d7c2c2 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=e4585e78f5821b5b input=a9049054013a1b77]*/
"\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,
"\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,
"\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,
"\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,
"\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,
"\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);
"\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);
"\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,
"\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,
"\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,
"\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,
"\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,
exit:
return return_value;
}
-/*[clinic end generated code: output=1bff22415aabb78b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=f1efdb511a5b027b input=a9049054013a1b77]*/
"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);
"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,
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=dec05ff9c5aeaeae input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5ca4361417bf96cb input=a9049054013a1b77]*/
"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,
"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,
#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]*/
"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);
" 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);
"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);
"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,
#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]*/
"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,
"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,
return return_value;
}
-/*[clinic end generated code: output=38c2d52362bf3712 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=2acfd7c4b68530a6 input=a9049054013a1b77]*/
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=bbf6c4cfc91edc29 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=871941eea3d855c6 input=a9049054013a1b77]*/
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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,
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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,
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=d840f7ea76af2372 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=424b884884ab20b7 input=a9049054013a1b77]*/
"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,
"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,
"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,
"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,
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=6fc104b8299c82dd input=a9049054013a1b77]*/
+/*[clinic end generated code: output=4b32d63ff58b64d8 input=a9049054013a1b77]*/
"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,
"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);
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=8badc3bb85263689 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=c12ce9050f153304 input=a9049054013a1b77]*/
"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,
"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,
"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,
"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,
"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,
"\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,
"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,
"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,
"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,
"\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,
"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);
" 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);
" 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);
"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);
"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);
"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);
{
return _sre_SRE_Scanner_search_impl(self);
}
-/*[clinic end generated code: output=4b807104b65c1e0e input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5edeca5ec36b5f34 input=a9049054013a1b77]*/
"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);
"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,
"\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,
"\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,
"\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,
"\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,
"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);
"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);
"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);
"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);
"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);
"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);
#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]*/
"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,
"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);
"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,
"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,
return return_value;
}
-/*[clinic end generated code: output=d79b009652ae0b89 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a73b0453174e4b51 input=a9049054013a1b77]*/
"\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,
"\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,
"\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,
"\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);
"\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);
" 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,
#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]*/
"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);
{
return _tracemalloc_get_traced_memory_impl(module);
}
-/*[clinic end generated code: output=d98afded69c89d52 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d4a2dd3eaba9f72d input=a9049054013a1b77]*/
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=b6a61a4f365a3f0a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=927e889feb8a7dc4 input=a9049054013a1b77]*/
"\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,
"\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,
"\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,
"\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,
"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);
"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,
"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,
"\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,
"\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);
"\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,
"\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,
"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,
"\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);
"\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,
"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,
"\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,
"\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);
exit:
return return_value;
}
-/*[clinic end generated code: output=baaf3d379b91be0a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=915dd640329de0c0 input=a9049054013a1b77]*/
"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);
"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);
"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);
"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,
#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]*/
"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,
"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);
"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);
"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);
"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);
"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,
"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,
"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,
"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);
"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);
"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);
"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,
"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,
"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,
"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,
"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);
"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);
"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);
"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,
"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,
"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);
"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);
"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);
"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);
"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,
"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,
return return_value;
}
-/*[clinic end generated code: output=2f88b8827ee0aa9b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d197b1559196a48a input=a9049054013a1b77]*/
"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);
"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);
"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);
"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);
"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);
"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,
return return_value;
}
-/*[clinic end generated code: output=815f1c453fd6568f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3f45e15ce8b563b7 input=a9049054013a1b77]*/
"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);
"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);
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=dd93c3a6aeb42ebb input=a9049054013a1b77]*/
+/*[clinic end generated code: output=17f6f65a229b1ef9 input=a9049054013a1b77]*/
"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);
"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,
"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);
" 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,
exit:
return return_value;
}
-/*[clinic end generated code: output=2f6e70ae67ec8ac9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fc1a781750750a14 input=a9049054013a1b77]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=21dc9270b10b7891 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ba67a1ab58780485 input=a9049054013a1b77]*/
"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);
"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);
{
return grp_getgrall_impl(module);
}
-/*[clinic end generated code: output=0ccba09e8ec14c81 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ab10233f6015bc0a input=a9049054013a1b77]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=c8c47b766deeffc3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=916251f891fa84b9 input=a9049054013a1b77]*/
"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);
"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);
"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);
" 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);
"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);
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=239c51a5acefbafb input=a9049054013a1b77]*/
+/*[clinic end generated code: output=8b1709a71e5fb855 input=a9049054013a1b77]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=72aa003c308e26cf input=a9049054013a1b77]*/
+/*[clinic end generated code: output=83cb1aef575f13bc input=a9049054013a1b77]*/
" 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);
"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);
" 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,
" 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);
"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);
" 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,
"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);
"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);
"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,
"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);
"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);
"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);
"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);
" 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,
"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);
"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);
" 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,
"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);
"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);
"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);
"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);
"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);
" 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,
" 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,
" 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);
"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);
"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);
" 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);
" 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);
" 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,
"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);
" 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);
" 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);
" 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,
" 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);
" 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,
"\'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,
"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);
"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);
"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,
"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,
"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);
"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);
"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);
"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);
"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);
"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);
" (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);
" (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);
"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);
"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);
"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);
"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);
" 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,
"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);
"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);
" 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);
"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);
"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);
"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);
" 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);
"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);
"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);
"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);
"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);
"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,
"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);
"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);
"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);
"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);
"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);
"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,
" 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);
" 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,
"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);
"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);
" 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);
"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,
"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,
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
"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);
" 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);
"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);
"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);
" 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);
"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);
"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);
"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);
"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);
" 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,
" 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,
" 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,
" 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);
"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);
"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,
"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);
"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);
"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);
"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);
"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);
"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);
"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);
#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]*/
"`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,
"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,
"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);
"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,
#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]*/
"\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);
#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]*/
"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,
" 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);
" 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);
"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);
" 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,
" 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,
"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);
"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,
" 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,
" 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);
"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,
"\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,
" 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,
#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]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=81d2424c0585bfd4 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3bae85313ee5a3b5 input=a9049054013a1b77]*/
"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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=0086286cffcbc31c input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fb208641d4bc3b5f input=a9049054013a1b77]*/
"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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=fcc3306fb6672222 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3706fa47bea06c0b input=a9049054013a1b77]*/
"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);
"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);
"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,
"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);
"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,
"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,
#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]*/
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=c18565060a6cae04 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=52ece07dd0e7a113 input=a9049054013a1b77]*/
"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,
"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);
"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,
"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,
"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,
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=2c5fbf597c18f6b8 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=67f474927be668bf input=a9049054013a1b77]*/
--- /dev/null
+/*[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]*/
" 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);
" 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,
" 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,
" 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);
"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,
" 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);
" 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);
"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);
"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);
#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]*/
"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,
"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);
"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,
" -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,
"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,
" 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);
"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);
"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);
"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);
"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);
" 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,
"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);
"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);
{
return bytearray_sizeof_impl(self);
}
-/*[clinic end generated code: output=bb9051a369adb328 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b88bb192dddca6e1 input=a9049054013a1b77]*/
" -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);
"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);
"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);
"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);
"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);
"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,
"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);
"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,
" 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,
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=470acd12b2534765 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=07b33ac65362301b input=a9049054013a1b77]*/
"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);
"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);
"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,
{
return dict___reversed___impl(self);
}
-/*[clinic end generated code: output=b9923851cbd9213a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=193e08cb8099fe22 input=a9049054013a1b77]*/
"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);
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=a3c366a156be61f9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=091dd499f5386a6c input=a9049054013a1b77]*/
"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);
"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);
"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);
"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,
{
return list___reversed___impl(self);
}
-/*[clinic end generated code: output=d8cb29e6e6d79844 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=652ae4ee63a9de71 input=a9049054013a1b77]*/
" 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,
" 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,
exit:
return return_value;
}
-/*[clinic end generated code: output=6d5e92d7dc803751 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=403ccd096555fd1e input=a9049054013a1b77]*/
"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);
"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,
"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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=7f23d569eda2a558 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=f6f189e1fe032e0b input=a9049054013a1b77]*/
"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,
{
return tuple___getnewargs___impl(self);
}
-/*[clinic end generated code: output=0fbf4321fb4365ac input=a9049054013a1b77]*/
+/*[clinic end generated code: output=0a6ebd2d16b09c5d input=a9049054013a1b77]*/
"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);
" 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);
"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);
"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);
"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);
"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);
"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);
"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,
"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);
" -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);
"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);
"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);
"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);
{
return unicode_sizeof_impl(self);
}
-/*[clinic end generated code: output=8bcd992b25733bcc input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d323802b67bfc6d8 input=a9049054013a1b77]*/
"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);
"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);
"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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=336620159a1fc70d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d09ba158d470566e input=a9049054013a1b77]*/
"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,
"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);
#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]*/
"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);
"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);
"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);
"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);
"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);
#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]*/
"\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,
"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,
"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);
"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,
"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);
"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,
" 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);
"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);
" 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);
"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,
"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,
"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,
"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);
"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);
"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);
"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,
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=d1c8e2678015dd7d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=45a9aec9f9258c0a input=a9049054013a1b77]*/
" 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);
" 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);
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=beeee8be95667b7d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=19e5f0fb15bcd5bc input=a9049054013a1b77]*/
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=86369ece63001d78 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a4fbe6e2d1cc2091 input=a9049054013a1b77]*/
"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);
"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,
"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);
"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,
"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,
"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);
"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,
"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);
"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);
"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);
"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);
"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);
"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,
"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,
exit:
return return_value;
}
-/*[clinic end generated code: output=eb6d08a32e7c83b6 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fa8d97ac8695363b input=a9049054013a1b77]*/
"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,
" * 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);
#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]*/
" 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,
"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);
"\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);
#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]*/
"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,
"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);
return return_value;
}
-/*[clinic end generated code: output=584eb2222d86fdc3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=cbb6128201bee7e0 input=a9049054013a1b77]*/
"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);
exit:
return return_value;
}
-/*[clinic end generated code: output=4a3ac42b97d710ff input=a9049054013a1b77]*/
+/*[clinic end generated code: output=dfd3eb5b137a9861 input=a9049054013a1b77]*/
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 = ''
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()
projects / python / commitdiff