Python-checkins
Threads by month
- ----- 2024 -----
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2020 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2019 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2018 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2017 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2016 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2015 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2014 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2013 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2012 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2011 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2010 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2009 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2008 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2007 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2006 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2005 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2004 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2003 -----
- December
- November
- October
- September
- August
November 2018
- 2 participants
- 507 discussions
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
27 Nov '18
https://github.com/python/cpython/commit/d669154ee52048f98ac63ba177f3fd1cf6…
commit: d669154ee52048f98ac63ba177f3fd1cf62f0174
branch: 3.7
author: Miss Islington (bot) <31488909+miss-islington(a)users.noreply.github.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T03:57:56-08:00
summary:
bpo-35317: Fix mktime() error in test_email (GH-10721)
Fix mktime() overflow error in test_email: run
test_localtime_daylight_true_dst_true() and
test_localtime_daylight_false_dst_true() with a specific timezone.
(cherry picked from commit cfaafda8e3e19764682abb4bd4c574accb784c42)
Co-authored-by: Victor Stinner <vstinner(a)redhat.com>
files:
A Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst
M Lib/test/test_email/test_utils.py
diff --git a/Lib/test/test_email/test_utils.py b/Lib/test/test_email/test_utils.py
index 6dcb3bbe7aab..4e3c3f3a195f 100644
--- a/Lib/test/test_email/test_utils.py
+++ b/Lib/test/test_email/test_utils.py
@@ -75,6 +75,7 @@ def test_localtime_daylight_false_dst_false(self):
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
+ @test.support.run_with_tz('Europe/Minsk')
def test_localtime_daylight_true_dst_true(self):
test.support.patch(self, time, 'daylight', True)
t0 = datetime.datetime(2012, 3, 12, 1, 1)
@@ -82,6 +83,7 @@ def test_localtime_daylight_true_dst_true(self):
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
+ @test.support.run_with_tz('Europe/Minsk')
def test_localtime_daylight_false_dst_true(self):
test.support.patch(self, time, 'daylight', False)
t0 = datetime.datetime(2012, 3, 12, 1, 1)
diff --git a/Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst b/Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst
new file mode 100644
index 000000000000..73a30f71927f
--- /dev/null
+++ b/Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst
@@ -0,0 +1,3 @@
+Fix ``mktime()`` overflow error in ``test_email``: run
+``test_localtime_daylight_true_dst_true()`` and
+``test_localtime_daylight_false_dst_true()`` with a specific timezone.
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
27 Nov '18
https://github.com/python/cpython/commit/480833808e918a1dcebbbcfd07d5a8de3c…
commit: 480833808e918a1dcebbbcfd07d5a8de3c5c2a66
branch: master
author: Victor Stinner <vstinner(a)redhat.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T12:42:25+01:00
summary:
bpo-35134: Update "make tags": add Include/cpython/ (GH-10739)
"make tags" and "make TAGS" now also parse Include/cpython/ header
files.
files:
M Makefile.pre.in
diff --git a/Makefile.pre.in b/Makefile.pre.in
index 17007aef5623..eee64a75f785 100644
--- a/Makefile.pre.in
+++ b/Makefile.pre.in
@@ -1667,7 +1667,7 @@ autoconf:
# Create a tags file for vi
tags::
- ctags -w $(srcdir)/Include/*.h $(srcdir)/Include/internal/*.h
+ ctags -w $(srcdir)/Include/*.h $(srcdir)/Include/cpython/*.h $(srcdir)/Include/internal/*.h
for i in $(SRCDIRS); do ctags -f tags -w -a $(srcdir)/$$i/*.[ch]; done
ctags -f tags -w -a $(srcdir)/Modules/_ctypes/*.[ch]
LC_ALL=C sort -o tags tags
@@ -1675,7 +1675,7 @@ tags::
# Create a tags file for GNU Emacs
TAGS::
cd $(srcdir); \
- etags Include/*.h Include/internal/*.h; \
+ etags Include/*.h Include/cpython/*.h Include/internal/*.h; \
for i in $(SRCDIRS); do etags -a $$i/*.[ch]; done
# Sanitation targets -- clean leaves libraries, executables and tags
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
27 Nov '18
https://github.com/python/cpython/commit/7f9fb0f34555641722be5468b7fbd53dd3…
commit: 7f9fb0f34555641722be5468b7fbd53dd3c0f1e2
branch: 3.7
author: Victor Stinner <vstinner(a)redhat.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T12:42:04+01:00
summary:
bpo-33954: Rewrite FILL() macro of unicodeobject.c (GH-10738)
Copy code from master: add assertions on start and value, replace 'i'
iterator with 'end' pointer for the loop stop condition.
_PyUnicode_FastFill(): fix type of 'data', it must not be constant,
since data is modified by FILL().
files:
M Objects/unicodeobject.c
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 8dd7c3b8258c..e6371d2337c3 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -220,22 +220,30 @@ static PyObject *unicode_empty = NULL;
#define FILL(kind, data, value, start, length) \
do { \
- Py_ssize_t i_ = 0; \
+ assert(0 <= start); \
assert(kind != PyUnicode_WCHAR_KIND); \
- switch ((kind)) { \
+ switch (kind) { \
case PyUnicode_1BYTE_KIND: { \
- unsigned char * to_ = (unsigned char *)((data)) + (start); \
- memset(to_, (unsigned char)value, (length)); \
+ assert(value <= 0xff); \
+ Py_UCS1 ch = (unsigned char)value; \
+ Py_UCS1 *to = (Py_UCS1 *)data + start; \
+ memset(to, ch, length); \
break; \
} \
case PyUnicode_2BYTE_KIND: { \
- Py_UCS2 * to_ = (Py_UCS2 *)((data)) + (start); \
- for (; i_ < (length); ++i_, ++to_) *to_ = (value); \
+ assert(value <= 0xffff); \
+ Py_UCS2 ch = (Py_UCS2)value; \
+ Py_UCS2 *to = (Py_UCS2 *)data + start; \
+ const Py_UCS2 *end = to + length; \
+ for (; to < end; ++to) *to = ch; \
break; \
} \
case PyUnicode_4BYTE_KIND: { \
- Py_UCS4 * to_ = (Py_UCS4 *)((data)) + (start); \
- for (; i_ < (length); ++i_, ++to_) *to_ = (value); \
+ assert(value <= MAX_UNICODE); \
+ Py_UCS4 ch = value; \
+ Py_UCS4 * to = (Py_UCS4 *)data + start; \
+ const Py_UCS4 *end = to + length; \
+ for (; to < end; ++to) *to = ch; \
break; \
} \
default: Py_UNREACHABLE(); \
@@ -10079,7 +10087,7 @@ _PyUnicode_FastFill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length,
Py_UCS4 fill_char)
{
const enum PyUnicode_Kind kind = PyUnicode_KIND(unicode);
- const void *data = PyUnicode_DATA(unicode);
+ void *data = PyUnicode_DATA(unicode);
assert(PyUnicode_IS_READY(unicode));
assert(unicode_modifiable(unicode));
assert(fill_char <= PyUnicode_MAX_CHAR_VALUE(unicode));
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
27 Nov '18
https://github.com/python/cpython/commit/163403a63e9272fcd14707e344122c2e3c…
commit: 163403a63e9272fcd14707e344122c2e3c5e0244
branch: master
author: Victor Stinner <vstinner(a)redhat.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T12:41:17+01:00
summary:
bpo-33954: Fix compiler warning in _PyUnicode_FastFill() (GH-10737)
'data' argument of unicode_fill() is modified, so it must not be
constant.
Add more assertions to unicode_fill(): check the maximum character
value.
files:
M Objects/unicodeobject.c
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index cdfc2f6f2199..2b1db918a154 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -228,12 +228,14 @@ unicode_fill(enum PyUnicode_Kind kind, void *data, Py_UCS4 value,
assert(kind != PyUnicode_WCHAR_KIND);
switch (kind) {
case PyUnicode_1BYTE_KIND: {
+ assert(value <= 0xff);
Py_UCS1 ch = (unsigned char)value;
Py_UCS1 *to = (Py_UCS1 *)data + start;
memset(to, ch, length);
break;
}
case PyUnicode_2BYTE_KIND: {
+ assert(value <= 0xffff);
Py_UCS2 ch = (Py_UCS2)value;
Py_UCS2 *to = (Py_UCS2 *)data + start;
const Py_UCS2 *end = to + length;
@@ -241,6 +243,7 @@ unicode_fill(enum PyUnicode_Kind kind, void *data, Py_UCS4 value,
break;
}
case PyUnicode_4BYTE_KIND: {
+ assert(value <= MAX_UNICODE);
Py_UCS4 ch = value;
Py_UCS4 * to = (Py_UCS4 *)data + start;
const Py_UCS4 *end = to + length;
@@ -10117,7 +10120,7 @@ _PyUnicode_FastFill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length,
Py_UCS4 fill_char)
{
const enum PyUnicode_Kind kind = PyUnicode_KIND(unicode);
- const void *data = PyUnicode_DATA(unicode);
+ void *data = PyUnicode_DATA(unicode);
assert(PyUnicode_IS_READY(unicode));
assert(unicode_modifiable(unicode));
assert(fill_char <= PyUnicode_MAX_CHAR_VALUE(unicode));
1
0
https://github.com/python/cpython/commit/cfaafda8e3e19764682abb4bd4c574accb…
commit: cfaafda8e3e19764682abb4bd4c574accb784c42
branch: master
author: Victor Stinner <vstinner(a)redhat.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T12:40:50+01:00
summary:
bpo-35317: Fix mktime() error in test_email (GH-10721)
Fix mktime() overflow error in test_email: run
test_localtime_daylight_true_dst_true() and
test_localtime_daylight_false_dst_true() with a specific timezone.
files:
A Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst
M Lib/test/test_email/test_utils.py
diff --git a/Lib/test/test_email/test_utils.py b/Lib/test/test_email/test_utils.py
index 6dcb3bbe7aab..4e3c3f3a195f 100644
--- a/Lib/test/test_email/test_utils.py
+++ b/Lib/test/test_email/test_utils.py
@@ -75,6 +75,7 @@ def test_localtime_daylight_false_dst_false(self):
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
+ @test.support.run_with_tz('Europe/Minsk')
def test_localtime_daylight_true_dst_true(self):
test.support.patch(self, time, 'daylight', True)
t0 = datetime.datetime(2012, 3, 12, 1, 1)
@@ -82,6 +83,7 @@ def test_localtime_daylight_true_dst_true(self):
t2 = utils.localtime(t1)
self.assertEqual(t1, t2)
+ @test.support.run_with_tz('Europe/Minsk')
def test_localtime_daylight_false_dst_true(self):
test.support.patch(self, time, 'daylight', False)
t0 = datetime.datetime(2012, 3, 12, 1, 1)
diff --git a/Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst b/Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst
new file mode 100644
index 000000000000..73a30f71927f
--- /dev/null
+++ b/Misc/NEWS.d/next/Tests/2018-11-26-16-54-21.bpo-35317.jByGP2.rst
@@ -0,0 +1,3 @@
+Fix ``mktime()`` overflow error in ``test_email``: run
+``test_localtime_daylight_true_dst_true()`` and
+``test_localtime_daylight_false_dst_true()`` with a specific timezone.
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
27 Nov '18
https://github.com/python/cpython/commit/62be74290aca26d16f3f55ece7ff6dad14…
commit: 62be74290aca26d16f3f55ece7ff6dad14e60e8d
branch: master
author: Serhiy Storchaka <storchaka(a)gmail.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T13:27:31+02:00
summary:
bpo-33012: Fix invalid function cast warnings with gcc 8. (GH-6749)
Fix invalid function cast warnings with gcc 8
for method conventions different from METH_NOARGS, METH_O and
METH_VARARGS excluding Argument Clinic generated code.
files:
M Doc/extending/extending.rst
M Modules/_bisectmodule.c
M Modules/_collectionsmodule.c
M Modules/_csv.c
M Modules/_datetimemodule.c
M Modules/_decimal/_decimal.c
M Modules/_elementtree.c
M Modules/_functoolsmodule.c
M Modules/_hashopenssl.c
M Modules/_lsprof.c
M Modules/_multiprocessing/semaphore.c
M Modules/_sqlite/connection.c
M Modules/_sqlite/cursor.c
M Modules/_sqlite/module.c
M Modules/_struct.c
M Modules/_testbuffer.c
M Modules/_testcapimodule.c
M Modules/_threadmodule.c
M Modules/_xxsubinterpretersmodule.c
M Modules/atexitmodule.c
M Modules/faulthandler.c
M Modules/nismodule.c
M Modules/parsermodule.c
M Modules/posixmodule.c
M Modules/signalmodule.c
M Modules/socketmodule.c
M Modules/syslogmodule.c
M Modules/xxsubtype.c
M Objects/call.c
M Objects/dictobject.c
M Objects/memoryobject.c
M Objects/odictobject.c
M Objects/typeobject.c
M Objects/unicodeobject.c
M Python/_warnings.c
M Python/bltinmodule.c
M Python/context.c
M Python/sysmodule.c
diff --git a/Doc/extending/extending.rst b/Doc/extending/extending.rst
index b788a5575b3f..9fbd91f6a034 100644
--- a/Doc/extending/extending.rst
+++ b/Doc/extending/extending.rst
@@ -757,7 +757,7 @@ Philbrick (philbrick(a)hks.com)::
* only take two PyObject* parameters, and keywdarg_parrot() takes
* three.
*/
- {"parrot", (PyCFunction)keywdarg_parrot, METH_VARARGS | METH_KEYWORDS,
+ {"parrot", (PyCFunction)(void(*)(void))keywdarg_parrot, METH_VARARGS | METH_KEYWORDS,
"Print a lovely skit to standard output."},
{NULL, NULL, 0, NULL} /* sentinel */
};
diff --git a/Modules/_bisectmodule.c b/Modules/_bisectmodule.c
index 7dd73f94750b..461a11f5099d 100644
--- a/Modules/_bisectmodule.c
+++ b/Modules/_bisectmodule.c
@@ -241,13 +241,13 @@ Optional args lo (default 0) and hi (default len(a)) bound the\n\
slice of a to be searched.\n");
static PyMethodDef bisect_methods[] = {
- {"bisect_right", (PyCFunction)bisect_right,
+ {"bisect_right", (PyCFunction)(void(*)(void))bisect_right,
METH_VARARGS|METH_KEYWORDS, bisect_right_doc},
- {"insort_right", (PyCFunction)insort_right,
+ {"insort_right", (PyCFunction)(void(*)(void))insort_right,
METH_VARARGS|METH_KEYWORDS, insort_right_doc},
- {"bisect_left", (PyCFunction)bisect_left,
+ {"bisect_left", (PyCFunction)(void(*)(void))bisect_left,
METH_VARARGS|METH_KEYWORDS, bisect_left_doc},
- {"insort_left", (PyCFunction)insort_left,
+ {"insort_left", (PyCFunction)(void(*)(void))insort_left,
METH_VARARGS|METH_KEYWORDS, insort_left_doc},
{NULL, NULL} /* sentinel */
};
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index a495e5f718f8..1ad4a03467c2 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -1573,9 +1573,9 @@ static PyMethodDef deque_methods[] = {
METH_O, extend_doc},
{"extendleft", (PyCFunction)deque_extendleft,
METH_O, extendleft_doc},
- {"index", (PyCFunction)deque_index,
+ {"index", (PyCFunction)(void(*)(void))deque_index,
METH_FASTCALL, index_doc},
- {"insert", (PyCFunction)deque_insert,
+ {"insert", (PyCFunction)(void(*)(void))deque_insert,
METH_FASTCALL, insert_doc},
{"pop", (PyCFunction)deque_pop,
METH_NOARGS, pop_doc},
@@ -1589,7 +1589,7 @@ static PyMethodDef deque_methods[] = {
METH_NOARGS, reversed_doc},
{"reverse", (PyCFunction)deque_reverse,
METH_NOARGS, reverse_doc},
- {"rotate", (PyCFunction)deque_rotate,
+ {"rotate", (PyCFunction)(void(*)(void))deque_rotate,
METH_FASTCALL, rotate_doc},
{"__sizeof__", (PyCFunction)deque_sizeof,
METH_NOARGS, sizeof_doc},
diff --git a/Modules/_csv.c b/Modules/_csv.c
index 4cc1f7c88d87..b4e92de27a97 100644
--- a/Modules/_csv.c
+++ b/Modules/_csv.c
@@ -1583,13 +1583,13 @@ PyDoc_STRVAR(csv_field_size_limit_doc,
"the old limit is returned");
static struct PyMethodDef csv_methods[] = {
- { "reader", (PyCFunction)csv_reader,
+ { "reader", (PyCFunction)(void(*)(void))csv_reader,
METH_VARARGS | METH_KEYWORDS, csv_reader_doc},
- { "writer", (PyCFunction)csv_writer,
+ { "writer", (PyCFunction)(void(*)(void))csv_writer,
METH_VARARGS | METH_KEYWORDS, csv_writer_doc},
{ "list_dialects", (PyCFunction)csv_list_dialects,
METH_NOARGS, csv_list_dialects_doc},
- { "register_dialect", (PyCFunction)csv_register_dialect,
+ { "register_dialect", (PyCFunction)(void(*)(void))csv_register_dialect,
METH_VARARGS | METH_KEYWORDS, csv_register_dialect_doc},
{ "unregister_dialect", (PyCFunction)csv_unregister_dialect,
METH_O, csv_unregister_dialect_doc},
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
index 0054ea83c462..eb9c35d02d4e 100644
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -3255,7 +3255,7 @@ static PyMethodDef date_methods[] = {
{"ctime", (PyCFunction)date_ctime, METH_NOARGS,
PyDoc_STR("Return ctime() style string.")},
- {"strftime", (PyCFunction)date_strftime, METH_VARARGS | METH_KEYWORDS,
+ {"strftime", (PyCFunction)(void(*)(void))date_strftime, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("format -> strftime() style string.")},
{"__format__", (PyCFunction)date_format, METH_VARARGS,
@@ -3283,7 +3283,7 @@ static PyMethodDef date_methods[] = {
PyDoc_STR("Return the day of the week represented by the date.\n"
"Monday == 0 ... Sunday == 6")},
- {"replace", (PyCFunction)date_replace, METH_VARARGS | METH_KEYWORDS,
+ {"replace", (PyCFunction)(void(*)(void))date_replace, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Return date with new specified fields.")},
{"__reduce__", (PyCFunction)date_reduce, METH_NOARGS,
@@ -4392,12 +4392,12 @@ time_reduce(PyDateTime_Time *self, PyObject *arg)
static PyMethodDef time_methods[] = {
- {"isoformat", (PyCFunction)time_isoformat, METH_VARARGS | METH_KEYWORDS,
+ {"isoformat", (PyCFunction)(void(*)(void))time_isoformat, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Return string in ISO 8601 format, [HH[:MM[:SS[.mmm[uuu]]]]]"
"[+HH:MM].\n\n"
"timespec specifies what components of the time to include.\n")},
- {"strftime", (PyCFunction)time_strftime, METH_VARARGS | METH_KEYWORDS,
+ {"strftime", (PyCFunction)(void(*)(void))time_strftime, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("format -> strftime() style string.")},
{"__format__", (PyCFunction)date_format, METH_VARARGS,
@@ -4412,7 +4412,7 @@ static PyMethodDef time_methods[] = {
{"dst", (PyCFunction)time_dst, METH_NOARGS,
PyDoc_STR("Return self.tzinfo.dst(self).")},
- {"replace", (PyCFunction)time_replace, METH_VARARGS | METH_KEYWORDS,
+ {"replace", (PyCFunction)(void(*)(void))time_replace, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Return time with new specified fields.")},
{"fromisoformat", (PyCFunction)time_fromisoformat, METH_O | METH_CLASS,
@@ -6025,7 +6025,7 @@ static PyMethodDef datetime_methods[] = {
METH_NOARGS | METH_CLASS,
PyDoc_STR("Return a new datetime representing UTC day and time.")},
- {"fromtimestamp", (PyCFunction)datetime_fromtimestamp,
+ {"fromtimestamp", (PyCFunction)(void(*)(void))datetime_fromtimestamp,
METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("timestamp[, tz] -> tz's local time from POSIX timestamp.")},
@@ -6038,7 +6038,7 @@ static PyMethodDef datetime_methods[] = {
PyDoc_STR("string, format -> new datetime parsed from a string "
"(like time.strptime()).")},
- {"combine", (PyCFunction)datetime_combine,
+ {"combine", (PyCFunction)(void(*)(void))datetime_combine,
METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("date, time -> datetime with same date and time fields")},
@@ -6069,7 +6069,7 @@ static PyMethodDef datetime_methods[] = {
{"utctimetuple", (PyCFunction)datetime_utctimetuple, METH_NOARGS,
PyDoc_STR("Return UTC time tuple, compatible with time.localtime().")},
- {"isoformat", (PyCFunction)datetime_isoformat, METH_VARARGS | METH_KEYWORDS,
+ {"isoformat", (PyCFunction)(void(*)(void))datetime_isoformat, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("[sep] -> string in ISO 8601 format, "
"YYYY-MM-DDT[HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM].\n"
"sep is used to separate the year from the time, and "
@@ -6087,10 +6087,10 @@ static PyMethodDef datetime_methods[] = {
{"dst", (PyCFunction)datetime_dst, METH_NOARGS,
PyDoc_STR("Return self.tzinfo.dst(self).")},
- {"replace", (PyCFunction)datetime_replace, METH_VARARGS | METH_KEYWORDS,
+ {"replace", (PyCFunction)(void(*)(void))datetime_replace, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Return datetime with new specified fields.")},
- {"astimezone", (PyCFunction)datetime_astimezone, METH_VARARGS | METH_KEYWORDS,
+ {"astimezone", (PyCFunction)(void(*)(void))datetime_astimezone, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("tz -> convert to local time in new timezone tz\n")},
{"__reduce_ex__", (PyCFunction)datetime_reduce_ex, METH_VARARGS,
diff --git a/Modules/_decimal/_decimal.c b/Modules/_decimal/_decimal.c
index 1e58d3d5b779..51aed2c67dc6 100644
--- a/Modules/_decimal/_decimal.c
+++ b/Modules/_decimal/_decimal.c
@@ -4598,30 +4598,30 @@ static PyNumberMethods dec_number_methods =
static PyMethodDef dec_methods [] =
{
/* Unary arithmetic functions, optional context arg */
- { "exp", (PyCFunction)dec_mpd_qexp, METH_VARARGS|METH_KEYWORDS, doc_exp },
- { "ln", (PyCFunction)dec_mpd_qln, METH_VARARGS|METH_KEYWORDS, doc_ln },
- { "log10", (PyCFunction)dec_mpd_qlog10, METH_VARARGS|METH_KEYWORDS, doc_log10 },
- { "next_minus", (PyCFunction)dec_mpd_qnext_minus, METH_VARARGS|METH_KEYWORDS, doc_next_minus },
- { "next_plus", (PyCFunction)dec_mpd_qnext_plus, METH_VARARGS|METH_KEYWORDS, doc_next_plus },
- { "normalize", (PyCFunction)dec_mpd_qreduce, METH_VARARGS|METH_KEYWORDS, doc_normalize },
- { "to_integral", (PyCFunction)PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral },
- { "to_integral_exact", (PyCFunction)PyDec_ToIntegralExact, METH_VARARGS|METH_KEYWORDS, doc_to_integral_exact },
- { "to_integral_value", (PyCFunction)PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral_value },
- { "sqrt", (PyCFunction)dec_mpd_qsqrt, METH_VARARGS|METH_KEYWORDS, doc_sqrt },
+ { "exp", (PyCFunction)(void(*)(void))dec_mpd_qexp, METH_VARARGS|METH_KEYWORDS, doc_exp },
+ { "ln", (PyCFunction)(void(*)(void))dec_mpd_qln, METH_VARARGS|METH_KEYWORDS, doc_ln },
+ { "log10", (PyCFunction)(void(*)(void))dec_mpd_qlog10, METH_VARARGS|METH_KEYWORDS, doc_log10 },
+ { "next_minus", (PyCFunction)(void(*)(void))dec_mpd_qnext_minus, METH_VARARGS|METH_KEYWORDS, doc_next_minus },
+ { "next_plus", (PyCFunction)(void(*)(void))dec_mpd_qnext_plus, METH_VARARGS|METH_KEYWORDS, doc_next_plus },
+ { "normalize", (PyCFunction)(void(*)(void))dec_mpd_qreduce, METH_VARARGS|METH_KEYWORDS, doc_normalize },
+ { "to_integral", (PyCFunction)(void(*)(void))PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral },
+ { "to_integral_exact", (PyCFunction)(void(*)(void))PyDec_ToIntegralExact, METH_VARARGS|METH_KEYWORDS, doc_to_integral_exact },
+ { "to_integral_value", (PyCFunction)(void(*)(void))PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral_value },
+ { "sqrt", (PyCFunction)(void(*)(void))dec_mpd_qsqrt, METH_VARARGS|METH_KEYWORDS, doc_sqrt },
/* Binary arithmetic functions, optional context arg */
- { "compare", (PyCFunction)dec_mpd_qcompare, METH_VARARGS|METH_KEYWORDS, doc_compare },
- { "compare_signal", (PyCFunction)dec_mpd_qcompare_signal, METH_VARARGS|METH_KEYWORDS, doc_compare_signal },
- { "max", (PyCFunction)dec_mpd_qmax, METH_VARARGS|METH_KEYWORDS, doc_max },
- { "max_mag", (PyCFunction)dec_mpd_qmax_mag, METH_VARARGS|METH_KEYWORDS, doc_max_mag },
- { "min", (PyCFunction)dec_mpd_qmin, METH_VARARGS|METH_KEYWORDS, doc_min },
- { "min_mag", (PyCFunction)dec_mpd_qmin_mag, METH_VARARGS|METH_KEYWORDS, doc_min_mag },
- { "next_toward", (PyCFunction)dec_mpd_qnext_toward, METH_VARARGS|METH_KEYWORDS, doc_next_toward },
- { "quantize", (PyCFunction)dec_mpd_qquantize, METH_VARARGS|METH_KEYWORDS, doc_quantize },
- { "remainder_near", (PyCFunction)dec_mpd_qrem_near, METH_VARARGS|METH_KEYWORDS, doc_remainder_near },
+ { "compare", (PyCFunction)(void(*)(void))dec_mpd_qcompare, METH_VARARGS|METH_KEYWORDS, doc_compare },
+ { "compare_signal", (PyCFunction)(void(*)(void))dec_mpd_qcompare_signal, METH_VARARGS|METH_KEYWORDS, doc_compare_signal },
+ { "max", (PyCFunction)(void(*)(void))dec_mpd_qmax, METH_VARARGS|METH_KEYWORDS, doc_max },
+ { "max_mag", (PyCFunction)(void(*)(void))dec_mpd_qmax_mag, METH_VARARGS|METH_KEYWORDS, doc_max_mag },
+ { "min", (PyCFunction)(void(*)(void))dec_mpd_qmin, METH_VARARGS|METH_KEYWORDS, doc_min },
+ { "min_mag", (PyCFunction)(void(*)(void))dec_mpd_qmin_mag, METH_VARARGS|METH_KEYWORDS, doc_min_mag },
+ { "next_toward", (PyCFunction)(void(*)(void))dec_mpd_qnext_toward, METH_VARARGS|METH_KEYWORDS, doc_next_toward },
+ { "quantize", (PyCFunction)(void(*)(void))dec_mpd_qquantize, METH_VARARGS|METH_KEYWORDS, doc_quantize },
+ { "remainder_near", (PyCFunction)(void(*)(void))dec_mpd_qrem_near, METH_VARARGS|METH_KEYWORDS, doc_remainder_near },
/* Ternary arithmetic functions, optional context arg */
- { "fma", (PyCFunction)dec_mpd_qfma, METH_VARARGS|METH_KEYWORDS, doc_fma },
+ { "fma", (PyCFunction)(void(*)(void))dec_mpd_qfma, METH_VARARGS|METH_KEYWORDS, doc_fma },
/* Boolean functions, no context arg */
{ "is_canonical", dec_mpd_iscanonical, METH_NOARGS, doc_is_canonical },
@@ -4634,8 +4634,8 @@ static PyMethodDef dec_methods [] =
{ "is_zero", dec_mpd_iszero, METH_NOARGS, doc_is_zero },
/* Boolean functions, optional context arg */
- { "is_normal", (PyCFunction)dec_mpd_isnormal, METH_VARARGS|METH_KEYWORDS, doc_is_normal },
- { "is_subnormal", (PyCFunction)dec_mpd_issubnormal, METH_VARARGS|METH_KEYWORDS, doc_is_subnormal },
+ { "is_normal", (PyCFunction)(void(*)(void))dec_mpd_isnormal, METH_VARARGS|METH_KEYWORDS, doc_is_normal },
+ { "is_subnormal", (PyCFunction)(void(*)(void))dec_mpd_issubnormal, METH_VARARGS|METH_KEYWORDS, doc_is_subnormal },
/* Unary functions, no context arg */
{ "adjusted", dec_mpd_adjexp, METH_NOARGS, doc_adjusted },
@@ -4648,24 +4648,24 @@ static PyMethodDef dec_methods [] =
{ "copy_negate", dec_mpd_qcopy_negate, METH_NOARGS, doc_copy_negate },
/* Unary functions, optional context arg */
- { "logb", (PyCFunction)dec_mpd_qlogb, METH_VARARGS|METH_KEYWORDS, doc_logb },
- { "logical_invert", (PyCFunction)dec_mpd_qinvert, METH_VARARGS|METH_KEYWORDS, doc_logical_invert },
- { "number_class", (PyCFunction)dec_mpd_class, METH_VARARGS|METH_KEYWORDS, doc_number_class },
- { "to_eng_string", (PyCFunction)dec_mpd_to_eng, METH_VARARGS|METH_KEYWORDS, doc_to_eng_string },
+ { "logb", (PyCFunction)(void(*)(void))dec_mpd_qlogb, METH_VARARGS|METH_KEYWORDS, doc_logb },
+ { "logical_invert", (PyCFunction)(void(*)(void))dec_mpd_qinvert, METH_VARARGS|METH_KEYWORDS, doc_logical_invert },
+ { "number_class", (PyCFunction)(void(*)(void))dec_mpd_class, METH_VARARGS|METH_KEYWORDS, doc_number_class },
+ { "to_eng_string", (PyCFunction)(void(*)(void))dec_mpd_to_eng, METH_VARARGS|METH_KEYWORDS, doc_to_eng_string },
/* Binary functions, optional context arg for conversion errors */
- { "compare_total", (PyCFunction)dec_mpd_compare_total, METH_VARARGS|METH_KEYWORDS, doc_compare_total },
- { "compare_total_mag", (PyCFunction)dec_mpd_compare_total_mag, METH_VARARGS|METH_KEYWORDS, doc_compare_total_mag },
- { "copy_sign", (PyCFunction)dec_mpd_qcopy_sign, METH_VARARGS|METH_KEYWORDS, doc_copy_sign },
- { "same_quantum", (PyCFunction)dec_mpd_same_quantum, METH_VARARGS|METH_KEYWORDS, doc_same_quantum },
+ { "compare_total", (PyCFunction)(void(*)(void))dec_mpd_compare_total, METH_VARARGS|METH_KEYWORDS, doc_compare_total },
+ { "compare_total_mag", (PyCFunction)(void(*)(void))dec_mpd_compare_total_mag, METH_VARARGS|METH_KEYWORDS, doc_compare_total_mag },
+ { "copy_sign", (PyCFunction)(void(*)(void))dec_mpd_qcopy_sign, METH_VARARGS|METH_KEYWORDS, doc_copy_sign },
+ { "same_quantum", (PyCFunction)(void(*)(void))dec_mpd_same_quantum, METH_VARARGS|METH_KEYWORDS, doc_same_quantum },
/* Binary functions, optional context arg */
- { "logical_and", (PyCFunction)dec_mpd_qand, METH_VARARGS|METH_KEYWORDS, doc_logical_and },
- { "logical_or", (PyCFunction)dec_mpd_qor, METH_VARARGS|METH_KEYWORDS, doc_logical_or },
- { "logical_xor", (PyCFunction)dec_mpd_qxor, METH_VARARGS|METH_KEYWORDS, doc_logical_xor },
- { "rotate", (PyCFunction)dec_mpd_qrotate, METH_VARARGS|METH_KEYWORDS, doc_rotate },
- { "scaleb", (PyCFunction)dec_mpd_qscaleb, METH_VARARGS|METH_KEYWORDS, doc_scaleb },
- { "shift", (PyCFunction)dec_mpd_qshift, METH_VARARGS|METH_KEYWORDS, doc_shift },
+ { "logical_and", (PyCFunction)(void(*)(void))dec_mpd_qand, METH_VARARGS|METH_KEYWORDS, doc_logical_and },
+ { "logical_or", (PyCFunction)(void(*)(void))dec_mpd_qor, METH_VARARGS|METH_KEYWORDS, doc_logical_or },
+ { "logical_xor", (PyCFunction)(void(*)(void))dec_mpd_qxor, METH_VARARGS|METH_KEYWORDS, doc_logical_xor },
+ { "rotate", (PyCFunction)(void(*)(void))dec_mpd_qrotate, METH_VARARGS|METH_KEYWORDS, doc_rotate },
+ { "scaleb", (PyCFunction)(void(*)(void))dec_mpd_qscaleb, METH_VARARGS|METH_KEYWORDS, doc_scaleb },
+ { "shift", (PyCFunction)(void(*)(void))dec_mpd_qshift, METH_VARARGS|METH_KEYWORDS, doc_shift },
/* Miscellaneous */
{ "from_float", dec_from_float, METH_O|METH_CLASS, doc_from_float },
@@ -5303,7 +5303,7 @@ static PyMethodDef context_methods [] =
{ "subtract", ctx_mpd_qsub, METH_VARARGS, doc_ctx_subtract },
/* Binary or ternary arithmetic functions */
- { "power", (PyCFunction)ctx_mpd_qpow, METH_VARARGS|METH_KEYWORDS, doc_ctx_power },
+ { "power", (PyCFunction)(void(*)(void))ctx_mpd_qpow, METH_VARARGS|METH_KEYWORDS, doc_ctx_power },
/* Ternary arithmetic functions */
{ "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma },
@@ -5421,7 +5421,7 @@ static PyMethodDef _decimal_methods [] =
{
{ "getcontext", (PyCFunction)PyDec_GetCurrentContext, METH_NOARGS, doc_getcontext},
{ "setcontext", (PyCFunction)PyDec_SetCurrentContext, METH_O, doc_setcontext},
- { "localcontext", (PyCFunction)ctxmanager_new, METH_VARARGS|METH_KEYWORDS, doc_localcontext},
+ { "localcontext", (PyCFunction)(void(*)(void))ctxmanager_new, METH_VARARGS|METH_KEYWORDS, doc_localcontext},
#ifdef EXTRA_FUNCTIONALITY
{ "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context},
#endif
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index 2f1c4c02e82a..62374d887c76 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -3968,7 +3968,7 @@ static PyTypeObject XMLParser_Type = {
/* python module interface */
static PyMethodDef _functions[] = {
- {"SubElement", (PyCFunction) subelement, METH_VARARGS | METH_KEYWORDS},
+ {"SubElement", (PyCFunction)(void(*)(void)) subelement, METH_VARARGS | METH_KEYWORDS},
{NULL, NULL}
};
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 8701f6c89d71..0fb4847af9c3 100644
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -1236,7 +1236,7 @@ PyDoc_STRVAR(module_doc,
static PyMethodDef module_methods[] = {
{"reduce", functools_reduce, METH_VARARGS, functools_reduce_doc},
- {"cmp_to_key", (PyCFunction)functools_cmp_to_key,
+ {"cmp_to_key", (PyCFunction)(void(*)(void))functools_cmp_to_key,
METH_VARARGS | METH_KEYWORDS, functools_cmp_to_key_doc},
{NULL, NULL} /* sentinel */
};
diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c
index 42ea9974b952..d7e613c886c3 100644
--- a/Modules/_hashopenssl.c
+++ b/Modules/_hashopenssl.c
@@ -1011,7 +1011,7 @@ generate_hash_name_list(void)
/* a PyMethodDef structure for the constructor */
#define CONSTRUCTOR_METH_DEF(NAME) \
- {"openssl_" #NAME, (PyCFunction)EVP_new_ ## NAME, METH_FASTCALL, \
+ {"openssl_" #NAME, (PyCFunction)(void(*)(void))EVP_new_ ## NAME, METH_FASTCALL, \
PyDoc_STR("Returns a " #NAME \
" hash object; optionally initialized with a string") \
}
@@ -1034,9 +1034,9 @@ GEN_CONSTRUCTOR(sha512)
/* List of functions exported by this module */
static struct PyMethodDef EVP_functions[] = {
- {"new", (PyCFunction)EVP_new, METH_VARARGS|METH_KEYWORDS, EVP_new__doc__},
+ {"new", (PyCFunction)(void(*)(void))EVP_new, METH_VARARGS|METH_KEYWORDS, EVP_new__doc__},
#ifdef PY_PBKDF2_HMAC
- {"pbkdf2_hmac", (PyCFunction)pbkdf2_hmac, METH_VARARGS|METH_KEYWORDS,
+ {"pbkdf2_hmac", (PyCFunction)(void(*)(void))pbkdf2_hmac, METH_VARARGS|METH_KEYWORDS,
pbkdf2_hmac__doc__},
#endif
_HASHLIB_SCRYPT_METHODDEF
diff --git a/Modules/_lsprof.c b/Modules/_lsprof.c
index 233f62fe2f14..4508f5e65695 100644
--- a/Modules/_lsprof.c
+++ b/Modules/_lsprof.c
@@ -778,7 +778,7 @@ profiler_init(ProfilerObject *pObj, PyObject *args, PyObject *kw)
static PyMethodDef profiler_methods[] = {
{"getstats", (PyCFunction)profiler_getstats,
METH_NOARGS, getstats_doc},
- {"enable", (PyCFunction)profiler_enable,
+ {"enable", (PyCFunction)(void(*)(void))profiler_enable,
METH_VARARGS | METH_KEYWORDS, enable_doc},
{"disable", (PyCFunction)profiler_disable,
METH_NOARGS, disable_doc},
diff --git a/Modules/_multiprocessing/semaphore.c b/Modules/_multiprocessing/semaphore.c
index b1d3a216cbe8..e15adfbd6b19 100644
--- a/Modules/_multiprocessing/semaphore.c
+++ b/Modules/_multiprocessing/semaphore.c
@@ -581,11 +581,11 @@ semlock_afterfork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
*/
static PyMethodDef semlock_methods[] = {
- {"acquire", (PyCFunction)semlock_acquire, METH_VARARGS | METH_KEYWORDS,
+ {"acquire", (PyCFunction)(void(*)(void))semlock_acquire, METH_VARARGS | METH_KEYWORDS,
"acquire the semaphore/lock"},
{"release", (PyCFunction)semlock_release, METH_NOARGS,
"release the semaphore/lock"},
- {"__enter__", (PyCFunction)semlock_acquire, METH_VARARGS | METH_KEYWORDS,
+ {"__enter__", (PyCFunction)(void(*)(void))semlock_acquire, METH_VARARGS | METH_KEYWORDS,
"enter the semaphore/lock"},
{"__exit__", (PyCFunction)semlock_release, METH_VARARGS,
"exit the semaphore/lock"},
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index 89a875189780..65e8df4f7c61 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -1764,7 +1764,7 @@ static PyGetSetDef connection_getset[] = {
};
static PyMethodDef connection_methods[] = {
- {"cursor", (PyCFunction)pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
+ {"cursor", (PyCFunction)(void(*)(void))pysqlite_connection_cursor, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Return a cursor for the connection.")},
{"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
PyDoc_STR("Closes the connection.")},
@@ -1772,11 +1772,11 @@ static PyMethodDef connection_methods[] = {
PyDoc_STR("Commit the current transaction.")},
{"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS,
PyDoc_STR("Roll back the current transaction.")},
- {"create_function", (PyCFunction)pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS,
+ {"create_function", (PyCFunction)(void(*)(void))pysqlite_connection_create_function, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Creates a new function. Non-standard.")},
- {"create_aggregate", (PyCFunction)pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS,
+ {"create_aggregate", (PyCFunction)(void(*)(void))pysqlite_connection_create_aggregate, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Creates a new aggregate. Non-standard.")},
- {"set_authorizer", (PyCFunction)pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS,
+ {"set_authorizer", (PyCFunction)(void(*)(void))pysqlite_connection_set_authorizer, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Sets authorizer callback. Non-standard.")},
#ifdef HAVE_LOAD_EXTENSION
{"enable_load_extension", (PyCFunction)pysqlite_enable_load_extension, METH_VARARGS,
@@ -1784,9 +1784,9 @@ static PyMethodDef connection_methods[] = {
{"load_extension", (PyCFunction)pysqlite_load_extension, METH_VARARGS,
PyDoc_STR("Load SQLite extension module. Non-standard.")},
#endif
- {"set_progress_handler", (PyCFunction)pysqlite_connection_set_progress_handler, METH_VARARGS|METH_KEYWORDS,
+ {"set_progress_handler", (PyCFunction)(void(*)(void))pysqlite_connection_set_progress_handler, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Sets progress handler callback. Non-standard.")},
- {"set_trace_callback", (PyCFunction)pysqlite_connection_set_trace_callback, METH_VARARGS|METH_KEYWORDS,
+ {"set_trace_callback", (PyCFunction)(void(*)(void))pysqlite_connection_set_trace_callback, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Sets a trace callback called for each SQL statement (passed as unicode). Non-standard.")},
{"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS,
PyDoc_STR("Executes a SQL statement. Non-standard.")},
@@ -1801,7 +1801,7 @@ static PyMethodDef connection_methods[] = {
{"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS,
PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")},
#ifdef HAVE_BACKUP_API
- {"backup", (PyCFunction)pysqlite_connection_backup, METH_VARARGS | METH_KEYWORDS,
+ {"backup", (PyCFunction)(void(*)(void))pysqlite_connection_backup, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Makes a backup of the database. Non-standard.")},
#endif
{"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS,
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
index c62ad5d64eec..8a46e5cf2eb0 100644
--- a/Modules/_sqlite/cursor.c
+++ b/Modules/_sqlite/cursor.c
@@ -908,7 +908,7 @@ static PyMethodDef cursor_methods[] = {
PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
{"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS,
PyDoc_STR("Fetches one row from the resultset.")},
- {"fetchmany", (PyCFunction)pysqlite_cursor_fetchmany, METH_VARARGS|METH_KEYWORDS,
+ {"fetchmany", (PyCFunction)(void(*)(void))pysqlite_cursor_fetchmany, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("Fetches several rows from the resultset.")},
{"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS,
PyDoc_STR("Fetches all rows from the resultset.")},
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
index db2b4958b146..274ee13c375e 100644
--- a/Modules/_sqlite/module.c
+++ b/Modules/_sqlite/module.c
@@ -245,12 +245,12 @@ static void converters_init(PyObject* dict)
}
static PyMethodDef module_methods[] = {
- {"connect", (PyCFunction)module_connect,
+ {"connect", (PyCFunction)(void(*)(void))module_connect,
METH_VARARGS | METH_KEYWORDS, module_connect_doc},
- {"complete_statement", (PyCFunction)module_complete,
+ {"complete_statement", (PyCFunction)(void(*)(void))module_complete,
METH_VARARGS | METH_KEYWORDS, module_complete_doc},
#ifdef HAVE_SHARED_CACHE
- {"enable_shared_cache", (PyCFunction)module_enable_shared_cache,
+ {"enable_shared_cache", (PyCFunction)(void(*)(void))module_enable_shared_cache,
METH_VARARGS | METH_KEYWORDS, module_enable_shared_cache_doc},
#endif
{"register_adapter", (PyCFunction)module_register_adapter,
diff --git a/Modules/_struct.c b/Modules/_struct.c
index 0be52d9ab94b..67673300e0e3 100644
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -2006,8 +2006,8 @@ s_sizeof(PyStructObject *self, void *unused)
static struct PyMethodDef s_methods[] = {
STRUCT_ITER_UNPACK_METHODDEF
- {"pack", (PyCFunction)s_pack, METH_FASTCALL, s_pack__doc__},
- {"pack_into", (PyCFunction)s_pack_into, METH_FASTCALL, s_pack_into__doc__},
+ {"pack", (PyCFunction)(void(*)(void))s_pack, METH_FASTCALL, s_pack__doc__},
+ {"pack_into", (PyCFunction)(void(*)(void))s_pack_into, METH_FASTCALL, s_pack_into__doc__},
STRUCT_UNPACK_METHODDEF
STRUCT_UNPACK_FROM_METHODDEF
{"__sizeof__", (PyCFunction)s_sizeof, METH_NOARGS, s_sizeof__doc__},
@@ -2264,8 +2264,8 @@ static struct PyMethodDef module_functions[] = {
_CLEARCACHE_METHODDEF
CALCSIZE_METHODDEF
ITER_UNPACK_METHODDEF
- {"pack", (PyCFunction)pack, METH_FASTCALL, pack_doc},
- {"pack_into", (PyCFunction)pack_into, METH_FASTCALL, pack_into_doc},
+ {"pack", (PyCFunction)(void(*)(void))pack, METH_FASTCALL, pack_doc},
+ {"pack_into", (PyCFunction)(void(*)(void))pack_into, METH_FASTCALL, pack_into_doc},
UNPACK_METHODDEF
UNPACK_FROM_METHODDEF
{NULL, NULL} /* sentinel */
diff --git a/Modules/_testbuffer.c b/Modules/_testbuffer.c
index b1b8ff370151..4ff44f91a6ab 100644
--- a/Modules/_testbuffer.c
+++ b/Modules/_testbuffer.c
@@ -2635,7 +2635,7 @@ static PyMethodDef ndarray_methods [] =
{
{ "tolist", ndarray_tolist, METH_NOARGS, NULL },
{ "tobytes", ndarray_tobytes, METH_NOARGS, NULL },
- { "push", (PyCFunction)ndarray_push, METH_VARARGS|METH_KEYWORDS, NULL },
+ { "push", (PyCFunction)(void(*)(void))ndarray_push, METH_VARARGS|METH_KEYWORDS, NULL },
{ "pop", ndarray_pop, METH_NOARGS, NULL },
{ "add_suboffsets", ndarray_add_suboffsets, METH_NOARGS, NULL },
{ "memoryview_from_buffer", ndarray_memoryview_from_buffer, METH_NOARGS, NULL },
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index 4715f39e6db9..4933ef3b61c4 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -4787,14 +4787,14 @@ static PyMethodDef TestMethods[] = {
{"getbuffer_with_null_view", getbuffer_with_null_view, METH_O},
{"test_buildvalue_N", test_buildvalue_N, METH_NOARGS},
{"get_args", get_args, METH_VARARGS},
- {"get_kwargs", (PyCFunction)get_kwargs, METH_VARARGS|METH_KEYWORDS},
+ {"get_kwargs", (PyCFunction)(void(*)(void))get_kwargs, METH_VARARGS|METH_KEYWORDS},
{"getargs_tuple", getargs_tuple, METH_VARARGS},
- {"getargs_keywords", (PyCFunction)getargs_keywords,
+ {"getargs_keywords", (PyCFunction)(void(*)(void))getargs_keywords,
METH_VARARGS|METH_KEYWORDS},
- {"getargs_keyword_only", (PyCFunction)getargs_keyword_only,
+ {"getargs_keyword_only", (PyCFunction)(void(*)(void))getargs_keyword_only,
METH_VARARGS|METH_KEYWORDS},
{"getargs_positional_only_and_keywords",
- (PyCFunction)getargs_positional_only_and_keywords,
+ (PyCFunction)(void(*)(void))getargs_positional_only_and_keywords,
METH_VARARGS|METH_KEYWORDS},
{"getargs_b", getargs_b, METH_VARARGS},
{"getargs_B", getargs_B, METH_VARARGS},
@@ -4863,7 +4863,7 @@ static PyMethodDef TestMethods[] = {
{"set_exc_info", test_set_exc_info, METH_VARARGS},
{"argparsing", argparsing, METH_VARARGS},
{"code_newempty", code_newempty, METH_VARARGS},
- {"make_exception_with_doc", (PyCFunction)make_exception_with_doc,
+ {"make_exception_with_doc", (PyCFunction)(void(*)(void))make_exception_with_doc,
METH_VARARGS | METH_KEYWORDS},
{"make_memoryview_from_NULL_pointer", make_memoryview_from_NULL_pointer,
METH_NOARGS},
@@ -4960,7 +4960,7 @@ static PyMethodDef TestMethods[] = {
{"get_mapping_items", get_mapping_items, METH_O},
{"test_pythread_tss_key_state", test_pythread_tss_key_state, METH_VARARGS},
{"hamt", new_hamt, METH_NOARGS},
- {"bad_get", (PyCFunction)bad_get, METH_FASTCALL},
+ {"bad_get", (PyCFunction)(void(*)(void))bad_get, METH_FASTCALL},
{"EncodeLocaleEx", encode_locale_ex, METH_VARARGS},
{"DecodeLocaleEx", decode_locale_ex, METH_VARARGS},
{"get_global_config", get_global_config, METH_NOARGS},
@@ -5388,7 +5388,7 @@ generic_alias_mro_entries(PyGenericAliasObject *self, PyObject *bases)
}
static PyMethodDef generic_alias_methods[] = {
- {"__mro_entries__", (PyCFunction) generic_alias_mro_entries, METH_O, NULL},
+ {"__mro_entries__", (PyCFunction)(void(*)(void))generic_alias_mro_entries, METH_O, NULL},
{NULL} /* sentinel */
};
diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
index a4ddb87e2b7f..d075ef7455db 100644
--- a/Modules/_threadmodule.c
+++ b/Modules/_threadmodule.c
@@ -204,9 +204,9 @@ lock_repr(lockobject *self)
}
static PyMethodDef lock_methods[] = {
- {"acquire_lock", (PyCFunction)lock_PyThread_acquire_lock,
+ {"acquire_lock", (PyCFunction)(void(*)(void))lock_PyThread_acquire_lock,
METH_VARARGS | METH_KEYWORDS, acquire_doc},
- {"acquire", (PyCFunction)lock_PyThread_acquire_lock,
+ {"acquire", (PyCFunction)(void(*)(void))lock_PyThread_acquire_lock,
METH_VARARGS | METH_KEYWORDS, acquire_doc},
{"release_lock", (PyCFunction)lock_PyThread_release_lock,
METH_NOARGS, release_doc},
@@ -216,7 +216,7 @@ static PyMethodDef lock_methods[] = {
METH_NOARGS, locked_doc},
{"locked", (PyCFunction)lock_locked_lock,
METH_NOARGS, locked_doc},
- {"__enter__", (PyCFunction)lock_PyThread_acquire_lock,
+ {"__enter__", (PyCFunction)(void(*)(void))lock_PyThread_acquire_lock,
METH_VARARGS | METH_KEYWORDS, acquire_doc},
{"__exit__", (PyCFunction)lock_PyThread_release_lock,
METH_VARARGS, release_doc},
@@ -466,7 +466,7 @@ rlock_repr(rlockobject *self)
static PyMethodDef rlock_methods[] = {
- {"acquire", (PyCFunction)rlock_acquire,
+ {"acquire", (PyCFunction)(void(*)(void))rlock_acquire,
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"release", (PyCFunction)rlock_release,
METH_NOARGS, rlock_release_doc},
@@ -476,7 +476,7 @@ static PyMethodDef rlock_methods[] = {
METH_VARARGS, rlock_acquire_restore_doc},
{"_release_save", (PyCFunction)rlock_release_save,
METH_NOARGS, rlock_release_save_doc},
- {"__enter__", (PyCFunction)rlock_acquire,
+ {"__enter__", (PyCFunction)(void(*)(void))rlock_acquire,
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"__exit__", (PyCFunction)rlock_release,
METH_VARARGS, rlock_release_doc},
diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
index 33509ef4ded5..235df7076f99 100644
--- a/Modules/_xxsubinterpretersmodule.c
+++ b/Modules/_xxsubinterpretersmodule.c
@@ -2768,7 +2768,7 @@ channel__channel_id(PyObject *self, PyObject *args, PyObject *kwds)
static PyMethodDef module_functions[] = {
{"create", (PyCFunction)interp_create,
METH_VARARGS, create_doc},
- {"destroy", (PyCFunction)interp_destroy,
+ {"destroy", (PyCFunction)(void(*)(void))interp_destroy,
METH_VARARGS | METH_KEYWORDS, destroy_doc},
{"list_all", interp_list_all,
METH_NOARGS, list_all_doc},
@@ -2776,29 +2776,29 @@ static PyMethodDef module_functions[] = {
METH_NOARGS, get_current_doc},
{"get_main", interp_get_main,
METH_NOARGS, get_main_doc},
- {"is_running", (PyCFunction)interp_is_running,
+ {"is_running", (PyCFunction)(void(*)(void))interp_is_running,
METH_VARARGS | METH_KEYWORDS, is_running_doc},
- {"run_string", (PyCFunction)interp_run_string,
+ {"run_string", (PyCFunction)(void(*)(void))interp_run_string,
METH_VARARGS | METH_KEYWORDS, run_string_doc},
- {"is_shareable", (PyCFunction)object_is_shareable,
+ {"is_shareable", (PyCFunction)(void(*)(void))object_is_shareable,
METH_VARARGS | METH_KEYWORDS, is_shareable_doc},
{"channel_create", channel_create,
METH_NOARGS, channel_create_doc},
- {"channel_destroy", (PyCFunction)channel_destroy,
+ {"channel_destroy", (PyCFunction)(void(*)(void))channel_destroy,
METH_VARARGS | METH_KEYWORDS, channel_destroy_doc},
{"channel_list_all", channel_list_all,
METH_NOARGS, channel_list_all_doc},
- {"channel_send", (PyCFunction)channel_send,
+ {"channel_send", (PyCFunction)(void(*)(void))channel_send,
METH_VARARGS | METH_KEYWORDS, channel_send_doc},
- {"channel_recv", (PyCFunction)channel_recv,
+ {"channel_recv", (PyCFunction)(void(*)(void))channel_recv,
METH_VARARGS | METH_KEYWORDS, channel_recv_doc},
- {"channel_close", (PyCFunction)channel_close,
+ {"channel_close", (PyCFunction)(void(*)(void))channel_close,
METH_VARARGS | METH_KEYWORDS, channel_close_doc},
- {"channel_release", (PyCFunction)channel_release,
+ {"channel_release", (PyCFunction)(void(*)(void))channel_release,
METH_VARARGS | METH_KEYWORDS, channel_release_doc},
- {"_channel_id", (PyCFunction)channel__channel_id,
+ {"_channel_id", (PyCFunction)(void(*)(void))channel__channel_id,
METH_VARARGS | METH_KEYWORDS, NULL},
{NULL, NULL} /* sentinel */
diff --git a/Modules/atexitmodule.c b/Modules/atexitmodule.c
index afa1cfad6c41..1d6d6e53cfbf 100644
--- a/Modules/atexitmodule.c
+++ b/Modules/atexitmodule.c
@@ -291,7 +291,7 @@ atexit_unregister(PyObject *self, PyObject *func)
}
static PyMethodDef atexit_methods[] = {
- {"register", (PyCFunction) atexit_register, METH_VARARGS|METH_KEYWORDS,
+ {"register", (PyCFunction)(void(*)(void)) atexit_register, METH_VARARGS|METH_KEYWORDS,
atexit_register__doc__},
{"_clear", (PyCFunction) atexit_clear, METH_NOARGS,
atexit_clear__doc__},
diff --git a/Modules/faulthandler.c b/Modules/faulthandler.c
index 17bf3faeefe4..30fe18695fec 100644
--- a/Modules/faulthandler.c
+++ b/Modules/faulthandler.c
@@ -1175,7 +1175,7 @@ PyDoc_STRVAR(module_doc,
static PyMethodDef module_methods[] = {
{"enable",
- (PyCFunction)faulthandler_py_enable, METH_VARARGS|METH_KEYWORDS,
+ (PyCFunction)(void(*)(void))faulthandler_py_enable, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("enable(file=sys.stderr, all_threads=True): "
"enable the fault handler")},
{"disable", faulthandler_disable_py, METH_NOARGS,
@@ -1183,13 +1183,13 @@ static PyMethodDef module_methods[] = {
{"is_enabled", faulthandler_is_enabled, METH_NOARGS,
PyDoc_STR("is_enabled()->bool: check if the handler is enabled")},
{"dump_traceback",
- (PyCFunction)faulthandler_dump_traceback_py, METH_VARARGS|METH_KEYWORDS,
+ (PyCFunction)(void(*)(void))faulthandler_dump_traceback_py, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("dump_traceback(file=sys.stderr, all_threads=True): "
"dump the traceback of the current thread, or of all threads "
"if all_threads is True, into file")},
#ifdef FAULTHANDLER_LATER
{"dump_traceback_later",
- (PyCFunction)faulthandler_dump_traceback_later, METH_VARARGS|METH_KEYWORDS,
+ (PyCFunction)(void(*)(void))faulthandler_dump_traceback_later, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("dump_traceback_later(timeout, repeat=False, file=sys.stderrn, exit=False):\n"
"dump the traceback of all threads in timeout seconds,\n"
"or each timeout seconds if repeat is True. If exit is True, "
@@ -1202,13 +1202,13 @@ static PyMethodDef module_methods[] = {
#ifdef FAULTHANDLER_USER
{"register",
- (PyCFunction)faulthandler_register_py, METH_VARARGS|METH_KEYWORDS,
+ (PyCFunction)(void(*)(void))faulthandler_register_py, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("register(signum, file=sys.stderr, all_threads=True, chain=False): "
"register a handler for the signal 'signum': dump the "
"traceback of the current thread, or of all threads if "
"all_threads is True, into file")},
{"unregister",
- faulthandler_unregister_py, METH_VARARGS|METH_KEYWORDS,
+ (PyCFunction)(void(*)(void))faulthandler_unregister_py, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("unregister(signum): unregister the handler of the signal "
"'signum' registered by register()")},
#endif
diff --git a/Modules/nismodule.c b/Modules/nismodule.c
index 1a538dc3b233..bc6796c278ca 100644
--- a/Modules/nismodule.c
+++ b/Modules/nismodule.c
@@ -423,13 +423,13 @@ nis_maps (PyObject *self, PyObject *args, PyObject *kwdict)
}
static PyMethodDef nis_methods[] = {
- {"match", (PyCFunction)nis_match,
+ {"match", (PyCFunction)(void(*)(void))nis_match,
METH_VARARGS | METH_KEYWORDS,
match__doc__},
- {"cat", (PyCFunction)nis_cat,
+ {"cat", (PyCFunction)(void(*)(void))nis_cat,
METH_VARARGS | METH_KEYWORDS,
cat__doc__},
- {"maps", (PyCFunction)nis_maps,
+ {"maps", (PyCFunction)(void(*)(void))nis_maps,
METH_VARARGS | METH_KEYWORDS,
maps__doc__},
{"get_default_domain", nis_get_default_domain,
diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index c8fb3d21771b..8f88657c00b6 100644
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -206,15 +206,15 @@ static PyObject* parser_st2tuple(PyST_Object *, PyObject *, PyObject *);
#define PUBLIC_METHOD_TYPE (METH_VARARGS|METH_KEYWORDS)
static PyMethodDef parser_methods[] = {
- {"compile", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE,
+ {"compile", (PyCFunction)(void(*)(void))parser_compilest, PUBLIC_METHOD_TYPE,
PyDoc_STR("Compile this ST object into a code object.")},
- {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE,
+ {"isexpr", (PyCFunction)(void(*)(void))parser_isexpr, PUBLIC_METHOD_TYPE,
PyDoc_STR("Determines if this ST object was created from an expression.")},
- {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE,
+ {"issuite", (PyCFunction)(void(*)(void))parser_issuite, PUBLIC_METHOD_TYPE,
PyDoc_STR("Determines if this ST object was created from a suite.")},
- {"tolist", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE,
+ {"tolist", (PyCFunction)(void(*)(void))parser_st2list, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates a list-tree representation of this ST.")},
- {"totuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE,
+ {"totuple", (PyCFunction)(void(*)(void))parser_st2tuple, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates a tuple-tree representation of this ST.")},
{"__sizeof__", (PyCFunction)parser_sizeof, METH_NOARGS,
PyDoc_STR("Returns size in memory, in bytes.")},
@@ -1087,23 +1087,23 @@ parser__pickler(PyObject *self, PyObject *args)
* inheritance.
*/
static PyMethodDef parser_functions[] = {
- {"compilest", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE,
+ {"compilest", (PyCFunction)(void(*)(void))parser_compilest, PUBLIC_METHOD_TYPE,
PyDoc_STR("Compiles an ST object into a code object.")},
- {"expr", (PyCFunction)parser_expr, PUBLIC_METHOD_TYPE,
+ {"expr", (PyCFunction)(void(*)(void))parser_expr, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates an ST object from an expression.")},
- {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE,
+ {"isexpr", (PyCFunction)(void(*)(void))parser_isexpr, PUBLIC_METHOD_TYPE,
PyDoc_STR("Determines if an ST object was created from an expression.")},
- {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE,
+ {"issuite", (PyCFunction)(void(*)(void))parser_issuite, PUBLIC_METHOD_TYPE,
PyDoc_STR("Determines if an ST object was created from a suite.")},
- {"suite", (PyCFunction)parser_suite, PUBLIC_METHOD_TYPE,
+ {"suite", (PyCFunction)(void(*)(void))parser_suite, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates an ST object from a suite.")},
- {"sequence2st", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE,
+ {"sequence2st", (PyCFunction)(void(*)(void))parser_tuple2st, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates an ST object from a tree representation.")},
- {"st2tuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE,
+ {"st2tuple", (PyCFunction)(void(*)(void))parser_st2tuple, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates a tuple-tree representation of an ST.")},
- {"st2list", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE,
+ {"st2list", (PyCFunction)(void(*)(void))parser_st2list, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates a list-tree representation of an ST.")},
- {"tuple2st", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE,
+ {"tuple2st", (PyCFunction)(void(*)(void))parser_tuple2st, PUBLIC_METHOD_TYPE,
PyDoc_STR("Creates an ST object from a tree representation.")},
/* private stuff: support pickle module */
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 44d6009bda71..d42e40f243e2 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -13175,7 +13175,7 @@ static PyMethodDef posix_methods[] = {
OS_PWRITE_METHODDEF
OS_PWRITEV_METHODDEF
#ifdef HAVE_SENDFILE
- {"sendfile", (PyCFunction)posix_sendfile, METH_VARARGS | METH_KEYWORDS,
+ {"sendfile", (PyCFunction)(void(*)(void))posix_sendfile, METH_VARARGS | METH_KEYWORDS,
posix_sendfile__doc__},
#endif
OS_FSTAT_METHODDEF
diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c
index 1915fd9be456..52ab4e998a97 100644
--- a/Modules/signalmodule.c
+++ b/Modules/signalmodule.c
@@ -1210,7 +1210,7 @@ static PyMethodDef signal_methods[] = {
SIGNAL_SIGNAL_METHODDEF
SIGNAL_STRSIGNAL_METHODDEF
SIGNAL_GETSIGNAL_METHODDEF
- {"set_wakeup_fd", (PyCFunction)signal_set_wakeup_fd, METH_VARARGS | METH_KEYWORDS, set_wakeup_fd_doc},
+ {"set_wakeup_fd", (PyCFunction)(void(*)(void))signal_set_wakeup_fd, METH_VARARGS | METH_KEYWORDS, set_wakeup_fd_doc},
SIGNAL_SIGINTERRUPT_METHODDEF
SIGNAL_PAUSE_METHODDEF
SIGNAL_PTHREAD_KILL_METHODDEF
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index a47f0314605c..04bfdafeb323 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -4810,11 +4810,11 @@ static PyMethodDef sock_methods[] = {
listen_doc},
{"recv", (PyCFunction)sock_recv, METH_VARARGS,
recv_doc},
- {"recv_into", (PyCFunction)sock_recv_into, METH_VARARGS | METH_KEYWORDS,
+ {"recv_into", (PyCFunction)(void(*)(void))sock_recv_into, METH_VARARGS | METH_KEYWORDS,
recv_into_doc},
{"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
recvfrom_doc},
- {"recvfrom_into", (PyCFunction)sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
+ {"recvfrom_into", (PyCFunction)(void(*)(void))sock_recvfrom_into, METH_VARARGS | METH_KEYWORDS,
recvfrom_into_doc},
{"send", (PyCFunction)sock_send, METH_VARARGS,
send_doc},
@@ -4843,7 +4843,7 @@ static PyMethodDef sock_methods[] = {
sendmsg_doc},
#endif
#ifdef HAVE_SOCKADDR_ALG
- {"sendmsg_afalg", (PyCFunction)sock_sendmsg_afalg, METH_VARARGS | METH_KEYWORDS,
+ {"sendmsg_afalg", (PyCFunction)(void(*)(void))sock_sendmsg_afalg, METH_VARARGS | METH_KEYWORDS,
sendmsg_afalg_doc},
#endif
{NULL, NULL} /* sentinel */
@@ -6741,7 +6741,7 @@ static PyMethodDef socket_methods[] = {
{"inet_ntop", socket_inet_ntop,
METH_VARARGS, inet_ntop_doc},
#endif
- {"getaddrinfo", (PyCFunction)socket_getaddrinfo,
+ {"getaddrinfo", (PyCFunction)(void(*)(void))socket_getaddrinfo,
METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
{"getnameinfo", socket_getnameinfo,
METH_VARARGS, getnameinfo_doc},
diff --git a/Modules/syslogmodule.c b/Modules/syslogmodule.c
index a5807dcce9ce..b2ea73baa1be 100644
--- a/Modules/syslogmodule.c
+++ b/Modules/syslogmodule.c
@@ -238,7 +238,7 @@ syslog_log_upto(PyObject *self, PyObject *args)
/* List of functions defined in the module */
static PyMethodDef syslog_methods[] = {
- {"openlog", (PyCFunction) syslog_openlog, METH_VARARGS | METH_KEYWORDS},
+ {"openlog", (PyCFunction)(void(*)(void)) syslog_openlog, METH_VARARGS | METH_KEYWORDS},
{"closelog", syslog_closelog, METH_NOARGS},
{"syslog", syslog_syslog, METH_VARARGS},
{"setlogmask", syslog_setlogmask, METH_VARARGS},
diff --git a/Modules/xxsubtype.c b/Modules/xxsubtype.c
index 11242d739138..d9cb4cdb902f 100644
--- a/Modules/xxsubtype.c
+++ b/Modules/xxsubtype.c
@@ -70,10 +70,10 @@ static PyMethodDef spamlist_methods[] = {
PyDoc_STR("setstate(state)")},
/* These entries differ only in the flags; they are used by the tests
in test.test_descr. */
- {"classmeth", (PyCFunction)spamlist_specialmeth,
+ {"classmeth", (PyCFunction)(void(*)(void))spamlist_specialmeth,
METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("classmeth(*args, **kw)")},
- {"staticmeth", (PyCFunction)spamlist_specialmeth,
+ {"staticmeth", (PyCFunction)(void(*)(void))spamlist_specialmeth,
METH_VARARGS | METH_KEYWORDS | METH_STATIC,
PyDoc_STR("staticmeth(*args, **kw)")},
{NULL, NULL},
diff --git a/Objects/call.c b/Objects/call.c
index ba2ddcb35b9b..be8e90d03d66 100644
--- a/Objects/call.c
+++ b/Objects/call.c
@@ -514,7 +514,7 @@ _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self,
}
if (flags & METH_KEYWORDS) {
- result = (*(PyCFunctionWithKeywords)meth) (self, argstuple, kwargs);
+ result = (*(PyCFunctionWithKeywords)(void(*)(void))meth) (self, argstuple, kwargs);
}
else {
result = (*meth) (self, argstuple);
@@ -529,7 +529,7 @@ _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self,
goto no_keyword_error;
}
- result = (*(_PyCFunctionFast)meth) (self, args, nargs);
+ result = (*(_PyCFunctionFast)(void(*)(void))meth) (self, args, nargs);
break;
}
@@ -537,7 +537,7 @@ _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self,
{
PyObject *const *stack;
PyObject *kwnames;
- _PyCFunctionFastWithKeywords fastmeth = (_PyCFunctionFastWithKeywords)meth;
+ _PyCFunctionFastWithKeywords fastmeth = (_PyCFunctionFastWithKeywords)(void(*)(void))meth;
if (_PyStack_UnpackDict(args, nargs, kwargs, &stack, &kwnames) < 0) {
goto exit;
@@ -650,12 +650,12 @@ _PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self,
if (nkwargs) {
goto no_keyword_error;
}
- result = ((_PyCFunctionFast)meth) (self, args, nargs);
+ result = ((_PyCFunctionFast)(void(*)(void))meth) (self, args, nargs);
break;
case METH_FASTCALL | METH_KEYWORDS:
/* Fast-path: avoid temporary dict to pass keyword arguments */
- result = ((_PyCFunctionFastWithKeywords)meth) (self, args, nargs, kwnames);
+ result = ((_PyCFunctionFastWithKeywords)(void(*)(void))meth) (self, args, nargs, kwnames);
break;
case METH_VARARGS:
@@ -689,7 +689,7 @@ _PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self,
kwdict = NULL;
}
- result = (*(PyCFunctionWithKeywords)meth) (self, argtuple, kwdict);
+ result = (*(PyCFunctionWithKeywords)(void(*)(void))meth) (self, argtuple, kwdict);
Py_XDECREF(kwdict);
}
else {
@@ -752,7 +752,7 @@ cfunction_call_varargs(PyObject *func, PyObject *args, PyObject *kwargs)
return NULL;
}
- result = (*(PyCFunctionWithKeywords)meth)(self, args, kwargs);
+ result = (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, args, kwargs);
Py_LeaveRecursiveCall();
}
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 2f108bd48d00..72cb4c5d666f 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -3095,15 +3095,15 @@ PyDoc_STRVAR(values__doc__,
static PyMethodDef mapp_methods[] = {
DICT___CONTAINS___METHODDEF
- {"__getitem__", (PyCFunction)dict_subscript, METH_O | METH_COEXIST,
+ {"__getitem__", (PyCFunction)(void(*)(void))dict_subscript, METH_O | METH_COEXIST,
getitem__doc__},
- {"__sizeof__", (PyCFunction)dict_sizeof, METH_NOARGS,
+ {"__sizeof__", (PyCFunction)(void(*)(void))dict_sizeof, METH_NOARGS,
sizeof__doc__},
DICT_GET_METHODDEF
DICT_SETDEFAULT_METHODDEF
{"pop", (PyCFunction)dict_pop, METH_VARARGS,
pop__doc__},
- {"popitem", (PyCFunction)dict_popitem, METH_NOARGS,
+ {"popitem", (PyCFunction)(void(*)(void))dict_popitem, METH_NOARGS,
popitem__doc__},
{"keys", dictkeys_new, METH_NOARGS,
keys__doc__},
@@ -3111,7 +3111,7 @@ static PyMethodDef mapp_methods[] = {
items__doc__},
{"values", dictvalues_new, METH_NOARGS,
values__doc__},
- {"update", (PyCFunction)dict_update, METH_VARARGS | METH_KEYWORDS,
+ {"update", (PyCFunction)(void(*)(void))dict_update, METH_VARARGS | METH_KEYWORDS,
update__doc__},
DICT_FROMKEYS_METHODDEF
{"clear", (PyCFunction)dict_clear, METH_NOARGS,
@@ -3420,9 +3420,9 @@ dictiter_reduce(dictiterobject *di, PyObject *Py_UNUSED(ignored));
PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
static PyMethodDef dictiter_methods[] = {
- {"__length_hint__", (PyCFunction)dictiter_len, METH_NOARGS,
+ {"__length_hint__", (PyCFunction)(void(*)(void))dictiter_len, METH_NOARGS,
length_hint_doc},
- {"__reduce__", (PyCFunction)dictiter_reduce, METH_NOARGS,
+ {"__reduce__", (PyCFunction)(void(*)(void))dictiter_reduce, METH_NOARGS,
reduce_doc},
{NULL, NULL} /* sentinel */
};
@@ -4209,7 +4209,7 @@ PyDoc_STRVAR(reversed_keys_doc,
static PyMethodDef dictkeys_methods[] = {
{"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O,
isdisjoint_doc},
- {"__reversed__", (PyCFunction)dictkeys_reversed, METH_NOARGS,
+ {"__reversed__", (PyCFunction)(void(*)(void))dictkeys_reversed, METH_NOARGS,
reversed_keys_doc},
{NULL, NULL} /* sentinel */
};
@@ -4315,7 +4315,7 @@ PyDoc_STRVAR(reversed_items_doc,
static PyMethodDef dictitems_methods[] = {
{"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O,
isdisjoint_doc},
- {"__reversed__", (PyCFunction)dictitems_reversed, METH_NOARGS,
+ {"__reversed__", (PyCFunction)(void(*)(void))dictitems_reversed, METH_NOARGS,
reversed_items_doc},
{NULL, NULL} /* sentinel */
};
@@ -4396,7 +4396,7 @@ PyDoc_STRVAR(reversed_values_doc,
"Return a reverse iterator over the dict values.");
static PyMethodDef dictvalues_methods[] = {
- {"__reversed__", (PyCFunction)dictvalues_reversed, METH_NOARGS,
+ {"__reversed__", (PyCFunction)(void(*)(void))dictvalues_reversed, METH_NOARGS,
reversed_values_doc},
{NULL, NULL} /* sentinel */
};
diff --git a/Objects/memoryobject.c b/Objects/memoryobject.c
index 0f528eec68bc..c1350b7dc37d 100644
--- a/Objects/memoryobject.c
+++ b/Objects/memoryobject.c
@@ -3086,7 +3086,7 @@ static PyMethodDef memory_methods[] = {
{"tobytes", (PyCFunction)memory_tobytes, METH_NOARGS, memory_tobytes_doc},
{"hex", (PyCFunction)memory_hex, METH_NOARGS, memory_hex_doc},
{"tolist", (PyCFunction)memory_tolist, METH_NOARGS, memory_tolist_doc},
- {"cast", (PyCFunction)memory_cast, METH_VARARGS|METH_KEYWORDS, memory_cast_doc},
+ {"cast", (PyCFunction)(void(*)(void))memory_cast, METH_VARARGS|METH_KEYWORDS, memory_cast_doc},
{"toreadonly", (PyCFunction)memory_toreadonly, METH_NOARGS, memory_toreadonly_doc},
{"__enter__", memory_enter, METH_NOARGS, NULL},
{"__exit__", memory_exit, METH_VARARGS, NULL},
diff --git a/Objects/odictobject.c b/Objects/odictobject.c
index 0f542006c694..689062c95ddc 100644
--- a/Objects/odictobject.c
+++ b/Objects/odictobject.c
@@ -1311,7 +1311,7 @@ static PyMethodDef odict_methods[] = {
{"__reduce__", (PyCFunction)odict_reduce, METH_NOARGS,
odict_reduce__doc__},
ORDEREDDICT_SETDEFAULT_METHODDEF
- {"pop", (PyCFunction)odict_pop,
+ {"pop", (PyCFunction)(void(*)(void))odict_pop,
METH_VARARGS | METH_KEYWORDS, odict_pop__doc__},
ORDEREDDICT_POPITEM_METHODDEF
{"keys", odictkeys_new, METH_NOARGS,
@@ -1320,7 +1320,7 @@ static PyMethodDef odict_methods[] = {
odict_values__doc__},
{"items", odictitems_new, METH_NOARGS,
odict_items__doc__},
- {"update", (PyCFunction)odict_update, METH_VARARGS | METH_KEYWORDS,
+ {"update", (PyCFunction)(void(*)(void))odict_update, METH_VARARGS | METH_KEYWORDS,
odict_update__doc__},
{"clear", (PyCFunction)odict_clear, METH_NOARGS,
odict_clear__doc__},
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 2345b7c07dc5..73d385b0f8a0 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -3481,7 +3481,7 @@ type___sizeof___impl(PyTypeObject *self)
static PyMethodDef type_methods[] = {
TYPE_MRO_METHODDEF
TYPE___SUBCLASSES___METHODDEF
- {"__prepare__", (PyCFunction)type_prepare,
+ {"__prepare__", (PyCFunction)(void(*)(void))type_prepare,
METH_FASTCALL | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("__prepare__() -> dict\n"
"used to create the namespace for the class statement")},
@@ -5944,7 +5944,7 @@ tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds)
}
static struct PyMethodDef tp_new_methoddef[] = {
- {"__new__", (PyCFunction)tp_new_wrapper, METH_VARARGS|METH_KEYWORDS,
+ {"__new__", (PyCFunction)(void(*)(void))tp_new_wrapper, METH_VARARGS|METH_KEYWORDS,
PyDoc_STR("__new__($type, *args, **kwargs)\n--\n\n"
"Create and return a new object. "
"See help(type) for accurate signature.")},
@@ -7140,7 +7140,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
}
else if (Py_TYPE(descr) == &PyCFunction_Type &&
PyCFunction_GET_FUNCTION(descr) ==
- (PyCFunction)tp_new_wrapper &&
+ (PyCFunction)(void(*)(void))tp_new_wrapper &&
ptr == (void**)&type->tp_new)
{
/* The __new__ wrapper is not a wrapper descriptor,
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 3da40ddc5898..cdfc2f6f2199 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -13948,7 +13948,7 @@ static PyMethodDef unicode_methods[] = {
UNICODE_ISIDENTIFIER_METHODDEF
UNICODE_ISPRINTABLE_METHODDEF
UNICODE_ZFILL_METHODDEF
- {"format", (PyCFunction) do_string_format, METH_VARARGS | METH_KEYWORDS, format__doc__},
+ {"format", (PyCFunction)(void(*)(void)) do_string_format, METH_VARARGS | METH_KEYWORDS, format__doc__},
{"format_map", (PyCFunction) do_string_format_map, METH_O, format_map__doc__},
UNICODE___FORMAT___METHODDEF
UNICODE_MAKETRANS_METHODDEF
diff --git a/Python/_warnings.c b/Python/_warnings.c
index 4065005354b8..ccbc73f54e4f 100644
--- a/Python/_warnings.c
+++ b/Python/_warnings.c
@@ -1150,7 +1150,7 @@ PyDoc_STRVAR(warn_explicit_doc,
static PyMethodDef warnings_functions[] = {
WARNINGS_WARN_METHODDEF
- {"warn_explicit", (PyCFunction)warnings_warn_explicit,
+ {"warn_explicit", (PyCFunction)(void(*)(void))warnings_warn_explicit,
METH_VARARGS | METH_KEYWORDS, warn_explicit_doc},
{"_filters_mutated", (PyCFunction)warnings_filters_mutated, METH_NOARGS,
NULL},
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index f0d342ae92d2..e19bc5604ba1 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -2195,7 +2195,7 @@ PyDoc_STRVAR(builtin_sorted__doc__,
"reverse flag can be set to request the result in descending order.");
#define BUILTIN_SORTED_METHODDEF \
- {"sorted", (PyCFunction)builtin_sorted, METH_FASTCALL | METH_KEYWORDS, builtin_sorted__doc__},
+ {"sorted", (PyCFunction)(void(*)(void))builtin_sorted, METH_FASTCALL | METH_KEYWORDS, builtin_sorted__doc__},
static PyObject *
builtin_sorted(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
@@ -2691,15 +2691,15 @@ PyTypeObject PyZip_Type = {
static PyMethodDef builtin_methods[] = {
- {"__build_class__", (PyCFunction)builtin___build_class__,
+ {"__build_class__", (PyCFunction)(void(*)(void))builtin___build_class__,
METH_FASTCALL | METH_KEYWORDS, build_class_doc},
- {"__import__", (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
+ {"__import__", (PyCFunction)(void(*)(void))builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
BUILTIN_ABS_METHODDEF
BUILTIN_ALL_METHODDEF
BUILTIN_ANY_METHODDEF
BUILTIN_ASCII_METHODDEF
BUILTIN_BIN_METHODDEF
- {"breakpoint", (PyCFunction)builtin_breakpoint, METH_FASTCALL | METH_KEYWORDS, breakpoint_doc},
+ {"breakpoint", (PyCFunction)(void(*)(void))builtin_breakpoint, METH_FASTCALL | METH_KEYWORDS, breakpoint_doc},
BUILTIN_CALLABLE_METHODDEF
BUILTIN_CHR_METHODDEF
BUILTIN_COMPILE_METHODDEF
@@ -2709,7 +2709,7 @@ static PyMethodDef builtin_methods[] = {
BUILTIN_EVAL_METHODDEF
BUILTIN_EXEC_METHODDEF
BUILTIN_FORMAT_METHODDEF
- {"getattr", (PyCFunction)builtin_getattr, METH_FASTCALL, getattr_doc},
+ {"getattr", (PyCFunction)(void(*)(void))builtin_getattr, METH_FASTCALL, getattr_doc},
BUILTIN_GLOBALS_METHODDEF
BUILTIN_HASATTR_METHODDEF
BUILTIN_HASH_METHODDEF
@@ -2721,13 +2721,13 @@ static PyMethodDef builtin_methods[] = {
{"iter", builtin_iter, METH_VARARGS, iter_doc},
BUILTIN_LEN_METHODDEF
BUILTIN_LOCALS_METHODDEF
- {"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc},
- {"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc},
- {"next", (PyCFunction)builtin_next, METH_FASTCALL, next_doc},
+ {"max", (PyCFunction)(void(*)(void))builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc},
+ {"min", (PyCFunction)(void(*)(void))builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc},
+ {"next", (PyCFunction)(void(*)(void))builtin_next, METH_FASTCALL, next_doc},
BUILTIN_OCT_METHODDEF
BUILTIN_ORD_METHODDEF
BUILTIN_POW_METHODDEF
- {"print", (PyCFunction)builtin_print, METH_FASTCALL | METH_KEYWORDS, print_doc},
+ {"print", (PyCFunction)(void(*)(void))builtin_print, METH_FASTCALL | METH_KEYWORDS, print_doc},
BUILTIN_REPR_METHODDEF
BUILTIN_ROUND_METHODDEF
BUILTIN_SETATTR_METHODDEF
diff --git a/Python/context.c b/Python/context.c
index 302f7696bb6b..d6ef5b337ca3 100644
--- a/Python/context.c
+++ b/Python/context.c
@@ -648,7 +648,7 @@ static PyMethodDef PyContext_methods[] = {
_CONTEXTVARS_CONTEXT_KEYS_METHODDEF
_CONTEXTVARS_CONTEXT_VALUES_METHODDEF
_CONTEXTVARS_CONTEXT_COPY_METHODDEF
- {"run", (PyCFunction)context_run, METH_FASTCALL | METH_KEYWORDS, NULL},
+ {"run", (PyCFunction)(void(*)(void))context_run, METH_FASTCALL | METH_KEYWORDS, NULL},
{NULL, NULL}
};
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 2284e88d4c11..0ca3de39f8bd 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -1521,7 +1521,7 @@ sys_getandroidapilevel(PyObject *self)
static PyMethodDef sys_methods[] = {
/* Might as well keep this in alphabetic order */
- {"breakpointhook", (PyCFunction)sys_breakpointhook,
+ {"breakpointhook", (PyCFunction)(void(*)(void))sys_breakpointhook,
METH_FASTCALL | METH_KEYWORDS, breakpointhook_doc},
{"callstats", sys_callstats, METH_NOARGS,
callstats_doc},
@@ -1560,7 +1560,7 @@ static PyMethodDef sys_methods[] = {
{"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
{"getrecursionlimit", sys_getrecursionlimit, METH_NOARGS,
getrecursionlimit_doc},
- {"getsizeof", (PyCFunction)sys_getsizeof,
+ {"getsizeof", (PyCFunction)(void(*)(void))sys_getsizeof,
METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
{"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
#ifdef MS_WINDOWS
@@ -1601,7 +1601,7 @@ static PyMethodDef sys_methods[] = {
set_coroutine_wrapper_doc},
{"get_coroutine_wrapper", sys_get_coroutine_wrapper, METH_NOARGS,
get_coroutine_wrapper_doc},
- {"set_asyncgen_hooks", (PyCFunction)sys_set_asyncgen_hooks,
+ {"set_asyncgen_hooks", (PyCFunction)(void(*)(void))sys_set_asyncgen_hooks,
METH_VARARGS | METH_KEYWORDS, set_asyncgen_hooks_doc},
{"get_asyncgen_hooks", sys_get_asyncgen_hooks, METH_NOARGS,
get_asyncgen_hooks_doc},
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
27 Nov '18
https://github.com/python/cpython/commit/81524022d0c0df7a41f9b2b2df41e2ebe1…
commit: 81524022d0c0df7a41f9b2b2df41e2ebe140e610
branch: master
author: Serhiy Storchaka <storchaka(a)gmail.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T13:05:02+02:00
summary:
bpo-33012: Fix signatures of METH_NOARGS funstions. (GH-10736)
files:
M Modules/_collectionsmodule.c
M Modules/_cursesmodule.c
M Modules/_testcapimodule.c
M Objects/dictobject.c
M Objects/odictobject.c
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index 267cf07f1f72..a495e5f718f8 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -1310,7 +1310,7 @@ deque_traverse(dequeobject *deque, visitproc visit, void *arg)
}
static PyObject *
-deque_reduce(dequeobject *deque)
+deque_reduce(dequeobject *deque, PyObject *Py_UNUSED(ignored))
{
PyObject *dict, *it;
_Py_IDENTIFIER(__dict__);
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index c8f564a31dbd..cd3241208a27 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -412,26 +412,26 @@ PyTypeObject PyCursesWindow_Type;
PARSESTR - format string for argument parsing
*/
-#define Window_NoArgNoReturnFunction(X) \
- static PyObject *PyCursesWindow_ ## X \
- (PyCursesWindowObject *self, PyObject *args) \
+#define Window_NoArgNoReturnFunction(X) \
+ static PyObject *PyCursesWindow_ ## X \
+ (PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored)) \
{ return PyCursesCheckERR(X(self->win), # X); }
#define Window_NoArgTrueFalseFunction(X) \
static PyObject * PyCursesWindow_ ## X \
- (PyCursesWindowObject *self) \
+ (PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored)) \
{ \
return PyBool_FromLong(X(self->win)); }
#define Window_NoArgNoReturnVoidFunction(X) \
static PyObject * PyCursesWindow_ ## X \
- (PyCursesWindowObject *self) \
+ (PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored)) \
{ \
X(self->win); Py_RETURN_NONE; }
#define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR) \
static PyObject * PyCursesWindow_ ## X \
- (PyCursesWindowObject *self) \
+ (PyCursesWindowObject *self, PyObject *Py_UNUSED(ignored)) \
{ \
TYPE arg1, arg2; \
X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); }
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
index 0dc4d7a36b76..4715f39e6db9 100644
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -947,7 +947,7 @@ test_buildvalue_N_error(const char *fmt)
}
static PyObject *
-test_buildvalue_N(PyObject *self, PyObject *noargs)
+test_buildvalue_N(PyObject *self, PyObject *Py_UNUSED(ignored))
{
PyObject *arg, *res;
@@ -2457,7 +2457,7 @@ pending_threadfunc(PyObject *self, PyObject *arg)
/* Some tests of PyUnicode_FromFormat(). This needs more tests. */
static PyObject *
-test_string_from_format(PyObject *self, PyObject *args)
+test_string_from_format(PyObject *self, PyObject *Py_UNUSED(ignored))
{
PyObject *result;
char *msg;
@@ -2597,7 +2597,7 @@ typedef struct {
} known_capsule;
static PyObject *
-test_capsule(PyObject *self, PyObject *args)
+test_capsule(PyObject *self, PyObject *Py_UNUSED(ignored))
{
PyObject *object;
const char *error = NULL;
@@ -2968,7 +2968,7 @@ make_memoryview_from_NULL_pointer(PyObject *self, PyObject *Py_UNUSED(ignored))
}
static PyObject *
-test_from_contiguous(PyObject* self, PyObject *noargs)
+test_from_contiguous(PyObject* self, PyObject *Py_UNUSED(ignored))
{
int data[9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1};
int init[5] = {0, 1, 2, 3, 4};
@@ -3021,7 +3021,7 @@ test_from_contiguous(PyObject* self, PyObject *noargs)
extern PyTypeObject _PyBytesIOBuffer_Type;
static PyObject *
-test_pep3118_obsolete_write_locks(PyObject* self, PyObject *noargs)
+test_pep3118_obsolete_write_locks(PyObject* self, PyObject *Py_UNUSED(ignored))
{
PyTypeObject *type = &_PyBytesIOBuffer_Type;
PyObject *b;
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 24561dd42c2e..2f108bd48d00 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -4201,7 +4201,7 @@ dictviews_isdisjoint(PyObject *self, PyObject *other)
PyDoc_STRVAR(isdisjoint_doc,
"Return True if the view and the given iterable have a null intersection.");
-static PyObject* dictkeys_reversed(_PyDictViewObject *dv);
+static PyObject* dictkeys_reversed(_PyDictViewObject *dv, PyObject *Py_UNUSED(ignored));
PyDoc_STRVAR(reversed_keys_doc,
"Return a reverse iterator over the dict keys.");
@@ -4254,7 +4254,7 @@ dictkeys_new(PyObject *dict, PyObject *Py_UNUSED(ignored))
}
static PyObject *
-dictkeys_reversed(_PyDictViewObject *dv)
+dictkeys_reversed(_PyDictViewObject *dv, PyObject *Py_UNUSED(ignored))
{
if (dv->dv_dict == NULL) {
Py_RETURN_NONE;
diff --git a/Objects/odictobject.c b/Objects/odictobject.c
index bdd61080d18b..0f542006c694 100644
--- a/Objects/odictobject.c
+++ b/Objects/odictobject.c
@@ -1804,7 +1804,7 @@ odictiter_iternext(odictiterobject *di)
PyDoc_STRVAR(reduce_doc, "Return state information for pickling");
static PyObject *
-odictiter_reduce(odictiterobject *di)
+odictiter_reduce(odictiterobject *di, PyObject *Py_UNUSED(ignored))
{
/* copy the iterator state */
odictiterobject tmp = *di;
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
bpo-33012: Fix invalid function cast warnings with gcc 8 in Argument Clinic. (GH-6748)
by Serhiy Storchaka 27 Nov '18
by Serhiy Storchaka 27 Nov '18
27 Nov '18
https://github.com/python/cpython/commit/4a934d490fac779d8954a8292369c4506b…
commit: 4a934d490fac779d8954a8292369c4506bab23fa
branch: master
author: Serhiy Storchaka <storchaka(a)gmail.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T11:27:36+02:00
summary:
bpo-33012: Fix invalid function cast warnings with gcc 8 in Argument Clinic. (GH-6748)
Fix invalid function cast warnings with gcc 8
for method conventions different from METH_NOARGS, METH_O and
METH_VARARGS in Argument Clinic generated code.
files:
A Modules/clinic/zipimport.c.h
M Modules/_io/clinic/_iomodule.c.h
M Modules/_io/clinic/bufferedio.c.h
M Modules/_io/clinic/bytesio.c.h
M Modules/_io/clinic/fileio.c.h
M Modules/_io/clinic/iobase.c.h
M Modules/_io/clinic/stringio.c.h
M Modules/_io/clinic/textio.c.h
M Modules/_io/clinic/winconsoleio.c.h
M Modules/cjkcodecs/clinic/multibytecodec.c.h
M Modules/clinic/_abc.c.h
M Modules/clinic/_asynciomodule.c.h
M Modules/clinic/_bz2module.c.h
M Modules/clinic/_codecsmodule.c.h
M Modules/clinic/_cryptmodule.c.h
M Modules/clinic/_curses_panel.c.h
M Modules/clinic/_cursesmodule.c.h
M Modules/clinic/_datetimemodule.c.h
M Modules/clinic/_dbmmodule.c.h
M Modules/clinic/_elementtree.c.h
M Modules/clinic/_gdbmmodule.c.h
M Modules/clinic/_hashopenssl.c.h
M Modules/clinic/_heapqmodule.c.h
M Modules/clinic/_lzmamodule.c.h
M Modules/clinic/_opcode.c.h
M Modules/clinic/_operator.c.h
M Modules/clinic/_pickle.c.h
M Modules/clinic/_queuemodule.c.h
M Modules/clinic/_sre.c.h
M Modules/clinic/_ssl.c.h
M Modules/clinic/_struct.c.h
M Modules/clinic/_tkinter.c.h
M Modules/clinic/_tracemalloc.c.h
M Modules/clinic/_weakref.c.h
M Modules/clinic/_winapi.c.h
M Modules/clinic/arraymodule.c.h
M Modules/clinic/audioop.c.h
M Modules/clinic/binascii.c.h
M Modules/clinic/cmathmodule.c.h
M Modules/clinic/fcntlmodule.c.h
M Modules/clinic/gcmodule.c.h
M Modules/clinic/grpmodule.c.h
M Modules/clinic/itertoolsmodule.c.h
M Modules/clinic/mathmodule.c.h
M Modules/clinic/md5module.c.h
M Modules/clinic/posixmodule.c.h
M Modules/clinic/pyexpat.c.h
M Modules/clinic/resource.c.h
M Modules/clinic/selectmodule.c.h
M Modules/clinic/sha1module.c.h
M Modules/clinic/sha256module.c.h
M Modules/clinic/sha512module.c.h
M Modules/clinic/signalmodule.c.h
M Modules/clinic/symtablemodule.c.h
M Modules/clinic/unicodedata.c.h
M Modules/clinic/zlibmodule.c.h
M Objects/clinic/bytearrayobject.c.h
M Objects/clinic/bytesobject.c.h
M Objects/clinic/dictobject.c.h
M Objects/clinic/floatobject.c.h
M Objects/clinic/listobject.c.h
M Objects/clinic/longobject.c.h
M Objects/clinic/odictobject.c.h
M Objects/clinic/tupleobject.c.h
M Objects/clinic/unicodeobject.c.h
M Objects/stringlib/clinic/transmogrify.h.h
M PC/clinic/_testconsole.c.h
M PC/clinic/msvcrtmodule.c.h
M PC/clinic/winreg.c.h
M PC/clinic/winsound.c.h
M Python/clinic/_warnings.c.h
M Python/clinic/bltinmodule.c.h
M Python/clinic/context.c.h
M Python/clinic/import.c.h
M Python/clinic/marshal.c.h
M Python/clinic/sysmodule.c.h
M Tools/clinic/clinic.py
diff --git a/Modules/_io/clinic/_iomodule.c.h b/Modules/_io/clinic/_iomodule.c.h
index b8ae2ce34eb9..f03e84e4318a 100644
--- a/Modules/_io/clinic/_iomodule.c.h
+++ b/Modules/_io/clinic/_iomodule.c.h
@@ -127,7 +127,7 @@ PyDoc_STRVAR(_io_open__doc__,
"opened in a binary mode.");
#define _IO_OPEN_METHODDEF \
- {"open", (PyCFunction)_io_open, METH_FASTCALL|METH_KEYWORDS, _io_open__doc__},
+ {"open", (PyCFunction)(void(*)(void))_io_open, METH_FASTCALL|METH_KEYWORDS, _io_open__doc__},
static PyObject *
_io_open_impl(PyObject *module, PyObject *file, const char *mode,
@@ -158,4 +158,4 @@ _io_open(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kw
exit:
return return_value;
}
-/*[clinic end generated code: output=a9de1ae79c960e81 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a2c1af38d943ccec input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/bufferedio.c.h b/Modules/_io/clinic/bufferedio.c.h
index 7b93929675f5..e78ca20ad5c4 100644
--- a/Modules/_io/clinic/bufferedio.c.h
+++ b/Modules/_io/clinic/bufferedio.c.h
@@ -91,7 +91,7 @@ PyDoc_STRVAR(_io__Buffered_peek__doc__,
"\n");
#define _IO__BUFFERED_PEEK_METHODDEF \
- {"peek", (PyCFunction)_io__Buffered_peek, METH_FASTCALL, _io__Buffered_peek__doc__},
+ {"peek", (PyCFunction)(void(*)(void))_io__Buffered_peek, METH_FASTCALL, _io__Buffered_peek__doc__},
static PyObject *
_io__Buffered_peek_impl(buffered *self, Py_ssize_t size);
@@ -118,7 +118,7 @@ PyDoc_STRVAR(_io__Buffered_read__doc__,
"\n");
#define _IO__BUFFERED_READ_METHODDEF \
- {"read", (PyCFunction)_io__Buffered_read, METH_FASTCALL, _io__Buffered_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io__Buffered_read, METH_FASTCALL, _io__Buffered_read__doc__},
static PyObject *
_io__Buffered_read_impl(buffered *self, Py_ssize_t n);
@@ -145,7 +145,7 @@ PyDoc_STRVAR(_io__Buffered_read1__doc__,
"\n");
#define _IO__BUFFERED_READ1_METHODDEF \
- {"read1", (PyCFunction)_io__Buffered_read1, METH_FASTCALL, _io__Buffered_read1__doc__},
+ {"read1", (PyCFunction)(void(*)(void))_io__Buffered_read1, METH_FASTCALL, _io__Buffered_read1__doc__},
static PyObject *
_io__Buffered_read1_impl(buffered *self, Py_ssize_t n);
@@ -234,7 +234,7 @@ PyDoc_STRVAR(_io__Buffered_readline__doc__,
"\n");
#define _IO__BUFFERED_READLINE_METHODDEF \
- {"readline", (PyCFunction)_io__Buffered_readline, METH_FASTCALL, _io__Buffered_readline__doc__},
+ {"readline", (PyCFunction)(void(*)(void))_io__Buffered_readline, METH_FASTCALL, _io__Buffered_readline__doc__},
static PyObject *
_io__Buffered_readline_impl(buffered *self, Py_ssize_t size);
@@ -261,7 +261,7 @@ PyDoc_STRVAR(_io__Buffered_seek__doc__,
"\n");
#define _IO__BUFFERED_SEEK_METHODDEF \
- {"seek", (PyCFunction)_io__Buffered_seek, METH_FASTCALL, _io__Buffered_seek__doc__},
+ {"seek", (PyCFunction)(void(*)(void))_io__Buffered_seek, METH_FASTCALL, _io__Buffered_seek__doc__},
static PyObject *
_io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence);
@@ -289,7 +289,7 @@ PyDoc_STRVAR(_io__Buffered_truncate__doc__,
"\n");
#define _IO__BUFFERED_TRUNCATE_METHODDEF \
- {"truncate", (PyCFunction)_io__Buffered_truncate, METH_FASTCALL, _io__Buffered_truncate__doc__},
+ {"truncate", (PyCFunction)(void(*)(void))_io__Buffered_truncate, METH_FASTCALL, _io__Buffered_truncate__doc__},
static PyObject *
_io__Buffered_truncate_impl(buffered *self, PyObject *pos);
@@ -476,4 +476,4 @@ _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=9a20dd4eaabb5d58 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=cb4bf8d50533953b input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/bytesio.c.h b/Modules/_io/clinic/bytesio.c.h
index 5c155cb3066e..536f75383799 100644
--- a/Modules/_io/clinic/bytesio.c.h
+++ b/Modules/_io/clinic/bytesio.c.h
@@ -158,7 +158,7 @@ PyDoc_STRVAR(_io_BytesIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READ_METHODDEF \
- {"read", (PyCFunction)_io_BytesIO_read, METH_FASTCALL, _io_BytesIO_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io_BytesIO_read, METH_FASTCALL, _io_BytesIO_read__doc__},
static PyObject *
_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size);
@@ -189,7 +189,7 @@ PyDoc_STRVAR(_io_BytesIO_read1__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READ1_METHODDEF \
- {"read1", (PyCFunction)_io_BytesIO_read1, METH_FASTCALL, _io_BytesIO_read1__doc__},
+ {"read1", (PyCFunction)(void(*)(void))_io_BytesIO_read1, METH_FASTCALL, _io_BytesIO_read1__doc__},
static PyObject *
_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size);
@@ -221,7 +221,7 @@ PyDoc_STRVAR(_io_BytesIO_readline__doc__,
"Return an empty bytes object at EOF.");
#define _IO_BYTESIO_READLINE_METHODDEF \
- {"readline", (PyCFunction)_io_BytesIO_readline, METH_FASTCALL, _io_BytesIO_readline__doc__},
+ {"readline", (PyCFunction)(void(*)(void))_io_BytesIO_readline, METH_FASTCALL, _io_BytesIO_readline__doc__},
static PyObject *
_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size);
@@ -253,7 +253,7 @@ PyDoc_STRVAR(_io_BytesIO_readlines__doc__,
"total number of bytes in the lines returned.");
#define _IO_BYTESIO_READLINES_METHODDEF \
- {"readlines", (PyCFunction)_io_BytesIO_readlines, METH_FASTCALL, _io_BytesIO_readlines__doc__},
+ {"readlines", (PyCFunction)(void(*)(void))_io_BytesIO_readlines, METH_FASTCALL, _io_BytesIO_readlines__doc__},
static PyObject *
_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg);
@@ -320,7 +320,7 @@ PyDoc_STRVAR(_io_BytesIO_truncate__doc__,
"The current file position is unchanged. Returns the new size.");
#define _IO_BYTESIO_TRUNCATE_METHODDEF \
- {"truncate", (PyCFunction)_io_BytesIO_truncate, METH_FASTCALL, _io_BytesIO_truncate__doc__},
+ {"truncate", (PyCFunction)(void(*)(void))_io_BytesIO_truncate, METH_FASTCALL, _io_BytesIO_truncate__doc__},
static PyObject *
_io_BytesIO_truncate_impl(bytesio *self, Py_ssize_t size);
@@ -354,7 +354,7 @@ PyDoc_STRVAR(_io_BytesIO_seek__doc__,
"Returns the new absolute position.");
#define _IO_BYTESIO_SEEK_METHODDEF \
- {"seek", (PyCFunction)_io_BytesIO_seek, METH_FASTCALL, _io_BytesIO_seek__doc__},
+ {"seek", (PyCFunction)(void(*)(void))_io_BytesIO_seek, METH_FASTCALL, _io_BytesIO_seek__doc__},
static PyObject *
_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence);
@@ -444,4 +444,4 @@ _io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=9ba9a68c8c5669e7 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=89538a941ae1267a input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/fileio.c.h b/Modules/_io/clinic/fileio.c.h
index 8a9958aaecf0..a66fc991a6fd 100644
--- a/Modules/_io/clinic/fileio.c.h
+++ b/Modules/_io/clinic/fileio.c.h
@@ -202,7 +202,7 @@ PyDoc_STRVAR(_io_FileIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO_FILEIO_READ_METHODDEF \
- {"read", (PyCFunction)_io_FileIO_read, METH_FASTCALL, _io_FileIO_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io_FileIO_read, METH_FASTCALL, _io_FileIO_read__doc__},
static PyObject *
_io_FileIO_read_impl(fileio *self, Py_ssize_t size);
@@ -274,7 +274,7 @@ PyDoc_STRVAR(_io_FileIO_seek__doc__,
"Note that not all file objects are seekable.");
#define _IO_FILEIO_SEEK_METHODDEF \
- {"seek", (PyCFunction)_io_FileIO_seek, METH_FASTCALL, _io_FileIO_seek__doc__},
+ {"seek", (PyCFunction)(void(*)(void))_io_FileIO_seek, METH_FASTCALL, _io_FileIO_seek__doc__},
static PyObject *
_io_FileIO_seek_impl(fileio *self, PyObject *pos, int whence);
@@ -328,7 +328,7 @@ PyDoc_STRVAR(_io_FileIO_truncate__doc__,
"The current file position is changed to the value of size.");
#define _IO_FILEIO_TRUNCATE_METHODDEF \
- {"truncate", (PyCFunction)_io_FileIO_truncate, METH_FASTCALL, _io_FileIO_truncate__doc__},
+ {"truncate", (PyCFunction)(void(*)(void))_io_FileIO_truncate, METH_FASTCALL, _io_FileIO_truncate__doc__},
static PyObject *
_io_FileIO_truncate_impl(fileio *self, PyObject *posobj);
@@ -373,4 +373,4 @@ _io_FileIO_isatty(fileio *self, PyObject *Py_UNUSED(ignored))
#ifndef _IO_FILEIO_TRUNCATE_METHODDEF
#define _IO_FILEIO_TRUNCATE_METHODDEF
#endif /* !defined(_IO_FILEIO_TRUNCATE_METHODDEF) */
-/*[clinic end generated code: output=a8796438c8b7c49a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=9d44e7035bce105d input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/iobase.c.h b/Modules/_io/clinic/iobase.c.h
index e6f72cd5ff9e..68eaaddce22d 100644
--- a/Modules/_io/clinic/iobase.c.h
+++ b/Modules/_io/clinic/iobase.c.h
@@ -174,7 +174,7 @@ PyDoc_STRVAR(_io__IOBase_readline__doc__,
"terminator(s) recognized.");
#define _IO__IOBASE_READLINE_METHODDEF \
- {"readline", (PyCFunction)_io__IOBase_readline, METH_FASTCALL, _io__IOBase_readline__doc__},
+ {"readline", (PyCFunction)(void(*)(void))_io__IOBase_readline, METH_FASTCALL, _io__IOBase_readline__doc__},
static PyObject *
_io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit);
@@ -206,7 +206,7 @@ PyDoc_STRVAR(_io__IOBase_readlines__doc__,
"lines so far exceeds hint.");
#define _IO__IOBASE_READLINES_METHODDEF \
- {"readlines", (PyCFunction)_io__IOBase_readlines, METH_FASTCALL, _io__IOBase_readlines__doc__},
+ {"readlines", (PyCFunction)(void(*)(void))_io__IOBase_readlines, METH_FASTCALL, _io__IOBase_readlines__doc__},
static PyObject *
_io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint);
@@ -241,7 +241,7 @@ PyDoc_STRVAR(_io__RawIOBase_read__doc__,
"\n");
#define _IO__RAWIOBASE_READ_METHODDEF \
- {"read", (PyCFunction)_io__RawIOBase_read, METH_FASTCALL, _io__RawIOBase_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io__RawIOBase_read, METH_FASTCALL, _io__RawIOBase_read__doc__},
static PyObject *
_io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n);
@@ -279,4 +279,4 @@ _io__RawIOBase_readall(PyObject *self, PyObject *Py_UNUSED(ignored))
{
return _io__RawIOBase_readall_impl(self);
}
-/*[clinic end generated code: output=64989ec3dbf44a7c input=a9049054013a1b77]*/
+/*[clinic end generated code: output=cde4b0e96a4e69e3 input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/stringio.c.h b/Modules/_io/clinic/stringio.c.h
index 72b2540d47aa..3181688f109f 100644
--- a/Modules/_io/clinic/stringio.c.h
+++ b/Modules/_io/clinic/stringio.c.h
@@ -48,7 +48,7 @@ PyDoc_STRVAR(_io_StringIO_read__doc__,
"is reached. Return an empty string at EOF.");
#define _IO_STRINGIO_READ_METHODDEF \
- {"read", (PyCFunction)_io_StringIO_read, METH_FASTCALL, _io_StringIO_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io_StringIO_read, METH_FASTCALL, _io_StringIO_read__doc__},
static PyObject *
_io_StringIO_read_impl(stringio *self, Py_ssize_t size);
@@ -78,7 +78,7 @@ PyDoc_STRVAR(_io_StringIO_readline__doc__,
"Returns an empty string if EOF is hit immediately.");
#define _IO_STRINGIO_READLINE_METHODDEF \
- {"readline", (PyCFunction)_io_StringIO_readline, METH_FASTCALL, _io_StringIO_readline__doc__},
+ {"readline", (PyCFunction)(void(*)(void))_io_StringIO_readline, METH_FASTCALL, _io_StringIO_readline__doc__},
static PyObject *
_io_StringIO_readline_impl(stringio *self, Py_ssize_t size);
@@ -110,7 +110,7 @@ PyDoc_STRVAR(_io_StringIO_truncate__doc__,
"Returns the new absolute position.");
#define _IO_STRINGIO_TRUNCATE_METHODDEF \
- {"truncate", (PyCFunction)_io_StringIO_truncate, METH_FASTCALL, _io_StringIO_truncate__doc__},
+ {"truncate", (PyCFunction)(void(*)(void))_io_StringIO_truncate, METH_FASTCALL, _io_StringIO_truncate__doc__},
static PyObject *
_io_StringIO_truncate_impl(stringio *self, Py_ssize_t size);
@@ -144,7 +144,7 @@ PyDoc_STRVAR(_io_StringIO_seek__doc__,
"Returns the new absolute position.");
#define _IO_STRINGIO_SEEK_METHODDEF \
- {"seek", (PyCFunction)_io_StringIO_seek, METH_FASTCALL, _io_StringIO_seek__doc__},
+ {"seek", (PyCFunction)(void(*)(void))_io_StringIO_seek, METH_FASTCALL, _io_StringIO_seek__doc__},
static PyObject *
_io_StringIO_seek_impl(stringio *self, Py_ssize_t pos, int whence);
@@ -286,4 +286,4 @@ _io_StringIO_seekable(stringio *self, PyObject *Py_UNUSED(ignored))
{
return _io_StringIO_seekable_impl(self);
}
-/*[clinic end generated code: output=73c4d6e5cc3b1a58 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=00c3c7a1c6ea6773 input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/textio.c.h b/Modules/_io/clinic/textio.c.h
index 60f5dab75c72..3ad3d67b112f 100644
--- a/Modules/_io/clinic/textio.c.h
+++ b/Modules/_io/clinic/textio.c.h
@@ -46,7 +46,7 @@ PyDoc_STRVAR(_io_IncrementalNewlineDecoder_decode__doc__,
"\n");
#define _IO_INCREMENTALNEWLINEDECODER_DECODE_METHODDEF \
- {"decode", (PyCFunction)_io_IncrementalNewlineDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _io_IncrementalNewlineDecoder_decode__doc__},
+ {"decode", (PyCFunction)(void(*)(void))_io_IncrementalNewlineDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _io_IncrementalNewlineDecoder_decode__doc__},
static PyObject *
_io_IncrementalNewlineDecoder_decode_impl(nldecoder_object *self,
@@ -186,7 +186,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_reconfigure__doc__,
"This also does an implicit stream flush.");
#define _IO_TEXTIOWRAPPER_RECONFIGURE_METHODDEF \
- {"reconfigure", (PyCFunction)_io_TextIOWrapper_reconfigure, METH_FASTCALL|METH_KEYWORDS, _io_TextIOWrapper_reconfigure__doc__},
+ {"reconfigure", (PyCFunction)(void(*)(void))_io_TextIOWrapper_reconfigure, METH_FASTCALL|METH_KEYWORDS, _io_TextIOWrapper_reconfigure__doc__},
static PyObject *
_io_TextIOWrapper_reconfigure_impl(textio *self, PyObject *encoding,
@@ -265,7 +265,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_read__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_READ_METHODDEF \
- {"read", (PyCFunction)_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
static PyObject *
_io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n);
@@ -292,7 +292,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_readline__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_READLINE_METHODDEF \
- {"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
+ {"readline", (PyCFunction)(void(*)(void))_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
static PyObject *
_io_TextIOWrapper_readline_impl(textio *self, Py_ssize_t size);
@@ -319,7 +319,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_seek__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_SEEK_METHODDEF \
- {"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
+ {"seek", (PyCFunction)(void(*)(void))_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
static PyObject *
_io_TextIOWrapper_seek_impl(textio *self, PyObject *cookieObj, int whence);
@@ -364,7 +364,7 @@ PyDoc_STRVAR(_io_TextIOWrapper_truncate__doc__,
"\n");
#define _IO_TEXTIOWRAPPER_TRUNCATE_METHODDEF \
- {"truncate", (PyCFunction)_io_TextIOWrapper_truncate, METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
+ {"truncate", (PyCFunction)(void(*)(void))_io_TextIOWrapper_truncate, METH_FASTCALL, _io_TextIOWrapper_truncate__doc__},
static PyObject *
_io_TextIOWrapper_truncate_impl(textio *self, PyObject *pos);
@@ -504,4 +504,4 @@ _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
{
return _io_TextIOWrapper_close_impl(self);
}
-/*[clinic end generated code: output=b5be870b0039d577 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a811badd76bfe92e input=a9049054013a1b77]*/
diff --git a/Modules/_io/clinic/winconsoleio.c.h b/Modules/_io/clinic/winconsoleio.c.h
index 2291225ead3d..6e72da11dda4 100644
--- a/Modules/_io/clinic/winconsoleio.c.h
+++ b/Modules/_io/clinic/winconsoleio.c.h
@@ -209,7 +209,7 @@ PyDoc_STRVAR(_io__WindowsConsoleIO_read__doc__,
"Return an empty bytes object at EOF.");
#define _IO__WINDOWSCONSOLEIO_READ_METHODDEF \
- {"read", (PyCFunction)_io__WindowsConsoleIO_read, METH_FASTCALL, _io__WindowsConsoleIO_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_io__WindowsConsoleIO_read, METH_FASTCALL, _io__WindowsConsoleIO_read__doc__},
static PyObject *
_io__WindowsConsoleIO_read_impl(winconsoleio *self, Py_ssize_t size);
@@ -328,4 +328,4 @@ _io__WindowsConsoleIO_isatty(winconsoleio *self, PyObject *Py_UNUSED(ignored))
#ifndef _IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF
#define _IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF
#endif /* !defined(_IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF) */
-/*[clinic end generated code: output=6d351a8200a8e848 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=080af41338394b49 input=a9049054013a1b77]*/
diff --git a/Modules/cjkcodecs/clinic/multibytecodec.c.h b/Modules/cjkcodecs/clinic/multibytecodec.c.h
index a58bb646a411..74e45bd0b58d 100644
--- a/Modules/cjkcodecs/clinic/multibytecodec.c.h
+++ b/Modules/cjkcodecs/clinic/multibytecodec.c.h
@@ -14,7 +14,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteCodec_encode__doc__,
"registered with codecs.register_error that can handle UnicodeEncodeErrors.");
#define _MULTIBYTECODEC_MULTIBYTECODEC_ENCODE_METHODDEF \
- {"encode", (PyCFunction)_multibytecodec_MultibyteCodec_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_encode__doc__},
+ {"encode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteCodec_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_encode__doc__},
static PyObject *
_multibytecodec_MultibyteCodec_encode_impl(MultibyteCodecObject *self,
@@ -52,7 +52,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteCodec_decode__doc__,
"codecs.register_error that is able to handle UnicodeDecodeErrors.\"");
#define _MULTIBYTECODEC_MULTIBYTECODEC_DECODE_METHODDEF \
- {"decode", (PyCFunction)_multibytecodec_MultibyteCodec_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_decode__doc__},
+ {"decode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteCodec_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteCodec_decode__doc__},
static PyObject *
_multibytecodec_MultibyteCodec_decode_impl(MultibyteCodecObject *self,
@@ -89,7 +89,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalEncoder_encode__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALENCODER_ENCODE_METHODDEF \
- {"encode", (PyCFunction)_multibytecodec_MultibyteIncrementalEncoder_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalEncoder_encode__doc__},
+ {"encode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteIncrementalEncoder_encode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalEncoder_encode__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalEncoder_encode_impl(MultibyteIncrementalEncoderObject *self,
@@ -182,7 +182,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteIncrementalDecoder_decode__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTEINCREMENTALDECODER_DECODE_METHODDEF \
- {"decode", (PyCFunction)_multibytecodec_MultibyteIncrementalDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
+ {"decode", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteIncrementalDecoder_decode, METH_FASTCALL|METH_KEYWORDS, _multibytecodec_MultibyteIncrementalDecoder_decode__doc__},
static PyObject *
_multibytecodec_MultibyteIncrementalDecoder_decode_impl(MultibyteIncrementalDecoderObject *self,
@@ -280,7 +280,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_read__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READ_METHODDEF \
- {"read", (PyCFunction)_multibytecodec_MultibyteStreamReader_read, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_read, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_read__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_read_impl(MultibyteStreamReaderObject *self,
@@ -309,7 +309,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readline__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINE_METHODDEF \
- {"readline", (PyCFunction)_multibytecodec_MultibyteStreamReader_readline, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
+ {"readline", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_readline, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readline__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_readline_impl(MultibyteStreamReaderObject *self,
@@ -338,7 +338,7 @@ PyDoc_STRVAR(_multibytecodec_MultibyteStreamReader_readlines__doc__,
"\n");
#define _MULTIBYTECODEC_MULTIBYTESTREAMREADER_READLINES_METHODDEF \
- {"readlines", (PyCFunction)_multibytecodec_MultibyteStreamReader_readlines, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
+ {"readlines", (PyCFunction)(void(*)(void))_multibytecodec_MultibyteStreamReader_readlines, METH_FASTCALL, _multibytecodec_MultibyteStreamReader_readlines__doc__},
static PyObject *
_multibytecodec_MultibyteStreamReader_readlines_impl(MultibyteStreamReaderObject *self,
@@ -418,4 +418,4 @@ PyDoc_STRVAR(_multibytecodec___create_codec__doc__,
#define _MULTIBYTECODEC___CREATE_CODEC_METHODDEF \
{"__create_codec", (PyCFunction)_multibytecodec___create_codec, METH_O, _multibytecodec___create_codec__doc__},
-/*[clinic end generated code: output=2fa0a38494716b97 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=4c1dc8015ee5abb4 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_abc.c.h b/Modules/clinic/_abc.c.h
index b1ec371d1551..22ddb6c100fb 100644
--- a/Modules/clinic/_abc.c.h
+++ b/Modules/clinic/_abc.c.h
@@ -53,7 +53,7 @@ PyDoc_STRVAR(_abc__abc_register__doc__,
"Internal ABC helper for subclasss registration. Should be never used outside abc module.");
#define _ABC__ABC_REGISTER_METHODDEF \
- {"_abc_register", (PyCFunction)_abc__abc_register, METH_FASTCALL, _abc__abc_register__doc__},
+ {"_abc_register", (PyCFunction)(void(*)(void))_abc__abc_register, METH_FASTCALL, _abc__abc_register__doc__},
static PyObject *
_abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass);
@@ -83,7 +83,7 @@ PyDoc_STRVAR(_abc__abc_instancecheck__doc__,
"Internal ABC helper for instance checks. Should be never used outside abc module.");
#define _ABC__ABC_INSTANCECHECK_METHODDEF \
- {"_abc_instancecheck", (PyCFunction)_abc__abc_instancecheck, METH_FASTCALL, _abc__abc_instancecheck__doc__},
+ {"_abc_instancecheck", (PyCFunction)(void(*)(void))_abc__abc_instancecheck, METH_FASTCALL, _abc__abc_instancecheck__doc__},
static PyObject *
_abc__abc_instancecheck_impl(PyObject *module, PyObject *self,
@@ -114,7 +114,7 @@ PyDoc_STRVAR(_abc__abc_subclasscheck__doc__,
"Internal ABC helper for subclasss checks. Should be never used outside abc module.");
#define _ABC__ABC_SUBCLASSCHECK_METHODDEF \
- {"_abc_subclasscheck", (PyCFunction)_abc__abc_subclasscheck, METH_FASTCALL, _abc__abc_subclasscheck__doc__},
+ {"_abc_subclasscheck", (PyCFunction)(void(*)(void))_abc__abc_subclasscheck, METH_FASTCALL, _abc__abc_subclasscheck__doc__},
static PyObject *
_abc__abc_subclasscheck_impl(PyObject *module, PyObject *self,
@@ -159,4 +159,4 @@ _abc_get_cache_token(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _abc_get_cache_token_impl(module);
}
-/*[clinic end generated code: output=9d6f861a8f45bc6f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=606db3cb658d9240 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_asynciomodule.c.h b/Modules/clinic/_asynciomodule.c.h
index 4f5326fd9e7c..860b57f9ee38 100644
--- a/Modules/clinic/_asynciomodule.c.h
+++ b/Modules/clinic/_asynciomodule.c.h
@@ -120,7 +120,7 @@ PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__,
"scheduled with call_soon.");
#define _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF \
- {"add_done_callback", (PyCFunction)_asyncio_Future_add_done_callback, METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
+ {"add_done_callback", (PyCFunction)(void(*)(void))_asyncio_Future_add_done_callback, METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
static PyObject *
_asyncio_Future_add_done_callback_impl(FutureObj *self, PyObject *fn,
@@ -293,7 +293,7 @@ PyDoc_STRVAR(_asyncio_Task_current_task__doc__,
"None is returned when called not in the context of a Task.");
#define _ASYNCIO_TASK_CURRENT_TASK_METHODDEF \
- {"current_task", (PyCFunction)_asyncio_Task_current_task, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_current_task__doc__},
+ {"current_task", (PyCFunction)(void(*)(void))_asyncio_Task_current_task, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_current_task__doc__},
static PyObject *
_asyncio_Task_current_task_impl(PyTypeObject *type, PyObject *loop);
@@ -325,7 +325,7 @@ PyDoc_STRVAR(_asyncio_Task_all_tasks__doc__,
"By default all tasks for the current event loop are returned.");
#define _ASYNCIO_TASK_ALL_TASKS_METHODDEF \
- {"all_tasks", (PyCFunction)_asyncio_Task_all_tasks, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_all_tasks__doc__},
+ {"all_tasks", (PyCFunction)(void(*)(void))_asyncio_Task_all_tasks, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, _asyncio_Task_all_tasks__doc__},
static PyObject *
_asyncio_Task_all_tasks_impl(PyTypeObject *type, PyObject *loop);
@@ -425,7 +425,7 @@ PyDoc_STRVAR(_asyncio_Task_get_stack__doc__,
"returned for a suspended coroutine.");
#define _ASYNCIO_TASK_GET_STACK_METHODDEF \
- {"get_stack", (PyCFunction)_asyncio_Task_get_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
+ {"get_stack", (PyCFunction)(void(*)(void))_asyncio_Task_get_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
static PyObject *
_asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit);
@@ -461,7 +461,7 @@ PyDoc_STRVAR(_asyncio_Task_print_stack__doc__,
"to sys.stderr.");
#define _ASYNCIO_TASK_PRINT_STACK_METHODDEF \
- {"print_stack", (PyCFunction)_asyncio_Task_print_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
+ {"print_stack", (PyCFunction)(void(*)(void))_asyncio_Task_print_stack, METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
static PyObject *
_asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit,
@@ -614,7 +614,7 @@ PyDoc_STRVAR(_asyncio__register_task__doc__,
"Returns None.");
#define _ASYNCIO__REGISTER_TASK_METHODDEF \
- {"_register_task", (PyCFunction)_asyncio__register_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__register_task__doc__},
+ {"_register_task", (PyCFunction)(void(*)(void))_asyncio__register_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__register_task__doc__},
static PyObject *
_asyncio__register_task_impl(PyObject *module, PyObject *task);
@@ -646,7 +646,7 @@ PyDoc_STRVAR(_asyncio__unregister_task__doc__,
"Returns None.");
#define _ASYNCIO__UNREGISTER_TASK_METHODDEF \
- {"_unregister_task", (PyCFunction)_asyncio__unregister_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__unregister_task__doc__},
+ {"_unregister_task", (PyCFunction)(void(*)(void))_asyncio__unregister_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__unregister_task__doc__},
static PyObject *
_asyncio__unregister_task_impl(PyObject *module, PyObject *task);
@@ -680,7 +680,7 @@ PyDoc_STRVAR(_asyncio__enter_task__doc__,
"Returns None.");
#define _ASYNCIO__ENTER_TASK_METHODDEF \
- {"_enter_task", (PyCFunction)_asyncio__enter_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__enter_task__doc__},
+ {"_enter_task", (PyCFunction)(void(*)(void))_asyncio__enter_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__enter_task__doc__},
static PyObject *
_asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task);
@@ -715,7 +715,7 @@ PyDoc_STRVAR(_asyncio__leave_task__doc__,
"Returns None.");
#define _ASYNCIO__LEAVE_TASK_METHODDEF \
- {"_leave_task", (PyCFunction)_asyncio__leave_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__leave_task__doc__},
+ {"_leave_task", (PyCFunction)(void(*)(void))_asyncio__leave_task, METH_FASTCALL|METH_KEYWORDS, _asyncio__leave_task__doc__},
static PyObject *
_asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task);
@@ -738,4 +738,4 @@ _asyncio__leave_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
-/*[clinic end generated code: output=67da879c9f841505 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fd474bdc8f03d5ae input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_bz2module.c.h b/Modules/clinic/_bz2module.c.h
index 601bcc690d95..f538719efc95 100644
--- a/Modules/clinic/_bz2module.c.h
+++ b/Modules/clinic/_bz2module.c.h
@@ -115,7 +115,7 @@ PyDoc_STRVAR(_bz2_BZ2Decompressor_decompress__doc__,
"the unused_data attribute.");
#define _BZ2_BZ2DECOMPRESSOR_DECOMPRESS_METHODDEF \
- {"decompress", (PyCFunction)_bz2_BZ2Decompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _bz2_BZ2Decompressor_decompress__doc__},
+ {"decompress", (PyCFunction)(void(*)(void))_bz2_BZ2Decompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _bz2_BZ2Decompressor_decompress__doc__},
static PyObject *
_bz2_BZ2Decompressor_decompress_impl(BZ2Decompressor *self, Py_buffer *data,
@@ -174,4 +174,4 @@ _bz2_BZ2Decompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=564a0313177fff63 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=e47f4255d265b07d input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h
index 2f660fd3b4db..06f0572201ae 100644
--- a/Modules/clinic/_codecsmodule.c.h
+++ b/Modules/clinic/_codecsmodule.c.h
@@ -55,7 +55,7 @@ PyDoc_STRVAR(_codecs_encode__doc__,
"codecs.register_error that can handle ValueErrors.");
#define _CODECS_ENCODE_METHODDEF \
- {"encode", (PyCFunction)_codecs_encode, METH_FASTCALL|METH_KEYWORDS, _codecs_encode__doc__},
+ {"encode", (PyCFunction)(void(*)(void))_codecs_encode, METH_FASTCALL|METH_KEYWORDS, _codecs_encode__doc__},
static PyObject *
_codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,
@@ -94,7 +94,7 @@ PyDoc_STRVAR(_codecs_decode__doc__,
"codecs.register_error that can handle ValueErrors.");
#define _CODECS_DECODE_METHODDEF \
- {"decode", (PyCFunction)_codecs_decode, METH_FASTCALL|METH_KEYWORDS, _codecs_decode__doc__},
+ {"decode", (PyCFunction)(void(*)(void))_codecs_decode, METH_FASTCALL|METH_KEYWORDS, _codecs_decode__doc__},
static PyObject *
_codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,
@@ -153,7 +153,7 @@ PyDoc_STRVAR(_codecs_escape_decode__doc__,
"\n");
#define _CODECS_ESCAPE_DECODE_METHODDEF \
- {"escape_decode", (PyCFunction)_codecs_escape_decode, METH_FASTCALL, _codecs_escape_decode__doc__},
+ {"escape_decode", (PyCFunction)(void(*)(void))_codecs_escape_decode, METH_FASTCALL, _codecs_escape_decode__doc__},
static PyObject *
_codecs_escape_decode_impl(PyObject *module, Py_buffer *data,
@@ -187,7 +187,7 @@ PyDoc_STRVAR(_codecs_escape_encode__doc__,
"\n");
#define _CODECS_ESCAPE_ENCODE_METHODDEF \
- {"escape_encode", (PyCFunction)_codecs_escape_encode, METH_FASTCALL, _codecs_escape_encode__doc__},
+ {"escape_encode", (PyCFunction)(void(*)(void))_codecs_escape_encode, METH_FASTCALL, _codecs_escape_encode__doc__},
static PyObject *
_codecs_escape_encode_impl(PyObject *module, PyObject *data,
@@ -216,7 +216,7 @@ PyDoc_STRVAR(_codecs_unicode_internal_decode__doc__,
"\n");
#define _CODECS_UNICODE_INTERNAL_DECODE_METHODDEF \
- {"unicode_internal_decode", (PyCFunction)_codecs_unicode_internal_decode, METH_FASTCALL, _codecs_unicode_internal_decode__doc__},
+ {"unicode_internal_decode", (PyCFunction)(void(*)(void))_codecs_unicode_internal_decode, METH_FASTCALL, _codecs_unicode_internal_decode__doc__},
static PyObject *
_codecs_unicode_internal_decode_impl(PyObject *module, PyObject *obj,
@@ -245,7 +245,7 @@ PyDoc_STRVAR(_codecs_utf_7_decode__doc__,
"\n");
#define _CODECS_UTF_7_DECODE_METHODDEF \
- {"utf_7_decode", (PyCFunction)_codecs_utf_7_decode, METH_FASTCALL, _codecs_utf_7_decode__doc__},
+ {"utf_7_decode", (PyCFunction)(void(*)(void))_codecs_utf_7_decode, METH_FASTCALL, _codecs_utf_7_decode__doc__},
static PyObject *
_codecs_utf_7_decode_impl(PyObject *module, Py_buffer *data,
@@ -280,7 +280,7 @@ PyDoc_STRVAR(_codecs_utf_8_decode__doc__,
"\n");
#define _CODECS_UTF_8_DECODE_METHODDEF \
- {"utf_8_decode", (PyCFunction)_codecs_utf_8_decode, METH_FASTCALL, _codecs_utf_8_decode__doc__},
+ {"utf_8_decode", (PyCFunction)(void(*)(void))_codecs_utf_8_decode, METH_FASTCALL, _codecs_utf_8_decode__doc__},
static PyObject *
_codecs_utf_8_decode_impl(PyObject *module, Py_buffer *data,
@@ -315,7 +315,7 @@ PyDoc_STRVAR(_codecs_utf_16_decode__doc__,
"\n");
#define _CODECS_UTF_16_DECODE_METHODDEF \
- {"utf_16_decode", (PyCFunction)_codecs_utf_16_decode, METH_FASTCALL, _codecs_utf_16_decode__doc__},
+ {"utf_16_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_decode, METH_FASTCALL, _codecs_utf_16_decode__doc__},
static PyObject *
_codecs_utf_16_decode_impl(PyObject *module, Py_buffer *data,
@@ -350,7 +350,7 @@ PyDoc_STRVAR(_codecs_utf_16_le_decode__doc__,
"\n");
#define _CODECS_UTF_16_LE_DECODE_METHODDEF \
- {"utf_16_le_decode", (PyCFunction)_codecs_utf_16_le_decode, METH_FASTCALL, _codecs_utf_16_le_decode__doc__},
+ {"utf_16_le_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_le_decode, METH_FASTCALL, _codecs_utf_16_le_decode__doc__},
static PyObject *
_codecs_utf_16_le_decode_impl(PyObject *module, Py_buffer *data,
@@ -385,7 +385,7 @@ PyDoc_STRVAR(_codecs_utf_16_be_decode__doc__,
"\n");
#define _CODECS_UTF_16_BE_DECODE_METHODDEF \
- {"utf_16_be_decode", (PyCFunction)_codecs_utf_16_be_decode, METH_FASTCALL, _codecs_utf_16_be_decode__doc__},
+ {"utf_16_be_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_be_decode, METH_FASTCALL, _codecs_utf_16_be_decode__doc__},
static PyObject *
_codecs_utf_16_be_decode_impl(PyObject *module, Py_buffer *data,
@@ -421,7 +421,7 @@ PyDoc_STRVAR(_codecs_utf_16_ex_decode__doc__,
"\n");
#define _CODECS_UTF_16_EX_DECODE_METHODDEF \
- {"utf_16_ex_decode", (PyCFunction)_codecs_utf_16_ex_decode, METH_FASTCALL, _codecs_utf_16_ex_decode__doc__},
+ {"utf_16_ex_decode", (PyCFunction)(void(*)(void))_codecs_utf_16_ex_decode, METH_FASTCALL, _codecs_utf_16_ex_decode__doc__},
static PyObject *
_codecs_utf_16_ex_decode_impl(PyObject *module, Py_buffer *data,
@@ -457,7 +457,7 @@ PyDoc_STRVAR(_codecs_utf_32_decode__doc__,
"\n");
#define _CODECS_UTF_32_DECODE_METHODDEF \
- {"utf_32_decode", (PyCFunction)_codecs_utf_32_decode, METH_FASTCALL, _codecs_utf_32_decode__doc__},
+ {"utf_32_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_decode, METH_FASTCALL, _codecs_utf_32_decode__doc__},
static PyObject *
_codecs_utf_32_decode_impl(PyObject *module, Py_buffer *data,
@@ -492,7 +492,7 @@ PyDoc_STRVAR(_codecs_utf_32_le_decode__doc__,
"\n");
#define _CODECS_UTF_32_LE_DECODE_METHODDEF \
- {"utf_32_le_decode", (PyCFunction)_codecs_utf_32_le_decode, METH_FASTCALL, _codecs_utf_32_le_decode__doc__},
+ {"utf_32_le_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_le_decode, METH_FASTCALL, _codecs_utf_32_le_decode__doc__},
static PyObject *
_codecs_utf_32_le_decode_impl(PyObject *module, Py_buffer *data,
@@ -527,7 +527,7 @@ PyDoc_STRVAR(_codecs_utf_32_be_decode__doc__,
"\n");
#define _CODECS_UTF_32_BE_DECODE_METHODDEF \
- {"utf_32_be_decode", (PyCFunction)_codecs_utf_32_be_decode, METH_FASTCALL, _codecs_utf_32_be_decode__doc__},
+ {"utf_32_be_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_be_decode, METH_FASTCALL, _codecs_utf_32_be_decode__doc__},
static PyObject *
_codecs_utf_32_be_decode_impl(PyObject *module, Py_buffer *data,
@@ -563,7 +563,7 @@ PyDoc_STRVAR(_codecs_utf_32_ex_decode__doc__,
"\n");
#define _CODECS_UTF_32_EX_DECODE_METHODDEF \
- {"utf_32_ex_decode", (PyCFunction)_codecs_utf_32_ex_decode, METH_FASTCALL, _codecs_utf_32_ex_decode__doc__},
+ {"utf_32_ex_decode", (PyCFunction)(void(*)(void))_codecs_utf_32_ex_decode, METH_FASTCALL, _codecs_utf_32_ex_decode__doc__},
static PyObject *
_codecs_utf_32_ex_decode_impl(PyObject *module, Py_buffer *data,
@@ -599,7 +599,7 @@ PyDoc_STRVAR(_codecs_unicode_escape_decode__doc__,
"\n");
#define _CODECS_UNICODE_ESCAPE_DECODE_METHODDEF \
- {"unicode_escape_decode", (PyCFunction)_codecs_unicode_escape_decode, METH_FASTCALL, _codecs_unicode_escape_decode__doc__},
+ {"unicode_escape_decode", (PyCFunction)(void(*)(void))_codecs_unicode_escape_decode, METH_FASTCALL, _codecs_unicode_escape_decode__doc__},
static PyObject *
_codecs_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
@@ -633,7 +633,7 @@ PyDoc_STRVAR(_codecs_raw_unicode_escape_decode__doc__,
"\n");
#define _CODECS_RAW_UNICODE_ESCAPE_DECODE_METHODDEF \
- {"raw_unicode_escape_decode", (PyCFunction)_codecs_raw_unicode_escape_decode, METH_FASTCALL, _codecs_raw_unicode_escape_decode__doc__},
+ {"raw_unicode_escape_decode", (PyCFunction)(void(*)(void))_codecs_raw_unicode_escape_decode, METH_FASTCALL, _codecs_raw_unicode_escape_decode__doc__},
static PyObject *
_codecs_raw_unicode_escape_decode_impl(PyObject *module, Py_buffer *data,
@@ -667,7 +667,7 @@ PyDoc_STRVAR(_codecs_latin_1_decode__doc__,
"\n");
#define _CODECS_LATIN_1_DECODE_METHODDEF \
- {"latin_1_decode", (PyCFunction)_codecs_latin_1_decode, METH_FASTCALL, _codecs_latin_1_decode__doc__},
+ {"latin_1_decode", (PyCFunction)(void(*)(void))_codecs_latin_1_decode, METH_FASTCALL, _codecs_latin_1_decode__doc__},
static PyObject *
_codecs_latin_1_decode_impl(PyObject *module, Py_buffer *data,
@@ -701,7 +701,7 @@ PyDoc_STRVAR(_codecs_ascii_decode__doc__,
"\n");
#define _CODECS_ASCII_DECODE_METHODDEF \
- {"ascii_decode", (PyCFunction)_codecs_ascii_decode, METH_FASTCALL, _codecs_ascii_decode__doc__},
+ {"ascii_decode", (PyCFunction)(void(*)(void))_codecs_ascii_decode, METH_FASTCALL, _codecs_ascii_decode__doc__},
static PyObject *
_codecs_ascii_decode_impl(PyObject *module, Py_buffer *data,
@@ -735,7 +735,7 @@ PyDoc_STRVAR(_codecs_charmap_decode__doc__,
"\n");
#define _CODECS_CHARMAP_DECODE_METHODDEF \
- {"charmap_decode", (PyCFunction)_codecs_charmap_decode, METH_FASTCALL, _codecs_charmap_decode__doc__},
+ {"charmap_decode", (PyCFunction)(void(*)(void))_codecs_charmap_decode, METH_FASTCALL, _codecs_charmap_decode__doc__},
static PyObject *
_codecs_charmap_decode_impl(PyObject *module, Py_buffer *data,
@@ -772,7 +772,7 @@ PyDoc_STRVAR(_codecs_mbcs_decode__doc__,
"\n");
#define _CODECS_MBCS_DECODE_METHODDEF \
- {"mbcs_decode", (PyCFunction)_codecs_mbcs_decode, METH_FASTCALL, _codecs_mbcs_decode__doc__},
+ {"mbcs_decode", (PyCFunction)(void(*)(void))_codecs_mbcs_decode, METH_FASTCALL, _codecs_mbcs_decode__doc__},
static PyObject *
_codecs_mbcs_decode_impl(PyObject *module, Py_buffer *data,
@@ -811,7 +811,7 @@ PyDoc_STRVAR(_codecs_oem_decode__doc__,
"\n");
#define _CODECS_OEM_DECODE_METHODDEF \
- {"oem_decode", (PyCFunction)_codecs_oem_decode, METH_FASTCALL, _codecs_oem_decode__doc__},
+ {"oem_decode", (PyCFunction)(void(*)(void))_codecs_oem_decode, METH_FASTCALL, _codecs_oem_decode__doc__},
static PyObject *
_codecs_oem_decode_impl(PyObject *module, Py_buffer *data,
@@ -850,7 +850,7 @@ PyDoc_STRVAR(_codecs_code_page_decode__doc__,
"\n");
#define _CODECS_CODE_PAGE_DECODE_METHODDEF \
- {"code_page_decode", (PyCFunction)_codecs_code_page_decode, METH_FASTCALL, _codecs_code_page_decode__doc__},
+ {"code_page_decode", (PyCFunction)(void(*)(void))_codecs_code_page_decode, METH_FASTCALL, _codecs_code_page_decode__doc__},
static PyObject *
_codecs_code_page_decode_impl(PyObject *module, int codepage,
@@ -888,7 +888,7 @@ PyDoc_STRVAR(_codecs_readbuffer_encode__doc__,
"\n");
#define _CODECS_READBUFFER_ENCODE_METHODDEF \
- {"readbuffer_encode", (PyCFunction)_codecs_readbuffer_encode, METH_FASTCALL, _codecs_readbuffer_encode__doc__},
+ {"readbuffer_encode", (PyCFunction)(void(*)(void))_codecs_readbuffer_encode, METH_FASTCALL, _codecs_readbuffer_encode__doc__},
static PyObject *
_codecs_readbuffer_encode_impl(PyObject *module, Py_buffer *data,
@@ -922,7 +922,7 @@ PyDoc_STRVAR(_codecs_unicode_internal_encode__doc__,
"\n");
#define _CODECS_UNICODE_INTERNAL_ENCODE_METHODDEF \
- {"unicode_internal_encode", (PyCFunction)_codecs_unicode_internal_encode, METH_FASTCALL, _codecs_unicode_internal_encode__doc__},
+ {"unicode_internal_encode", (PyCFunction)(void(*)(void))_codecs_unicode_internal_encode, METH_FASTCALL, _codecs_unicode_internal_encode__doc__},
static PyObject *
_codecs_unicode_internal_encode_impl(PyObject *module, PyObject *obj,
@@ -951,7 +951,7 @@ PyDoc_STRVAR(_codecs_utf_7_encode__doc__,
"\n");
#define _CODECS_UTF_7_ENCODE_METHODDEF \
- {"utf_7_encode", (PyCFunction)_codecs_utf_7_encode, METH_FASTCALL, _codecs_utf_7_encode__doc__},
+ {"utf_7_encode", (PyCFunction)(void(*)(void))_codecs_utf_7_encode, METH_FASTCALL, _codecs_utf_7_encode__doc__},
static PyObject *
_codecs_utf_7_encode_impl(PyObject *module, PyObject *str,
@@ -980,7 +980,7 @@ PyDoc_STRVAR(_codecs_utf_8_encode__doc__,
"\n");
#define _CODECS_UTF_8_ENCODE_METHODDEF \
- {"utf_8_encode", (PyCFunction)_codecs_utf_8_encode, METH_FASTCALL, _codecs_utf_8_encode__doc__},
+ {"utf_8_encode", (PyCFunction)(void(*)(void))_codecs_utf_8_encode, METH_FASTCALL, _codecs_utf_8_encode__doc__},
static PyObject *
_codecs_utf_8_encode_impl(PyObject *module, PyObject *str,
@@ -1009,7 +1009,7 @@ PyDoc_STRVAR(_codecs_utf_16_encode__doc__,
"\n");
#define _CODECS_UTF_16_ENCODE_METHODDEF \
- {"utf_16_encode", (PyCFunction)_codecs_utf_16_encode, METH_FASTCALL, _codecs_utf_16_encode__doc__},
+ {"utf_16_encode", (PyCFunction)(void(*)(void))_codecs_utf_16_encode, METH_FASTCALL, _codecs_utf_16_encode__doc__},
static PyObject *
_codecs_utf_16_encode_impl(PyObject *module, PyObject *str,
@@ -1039,7 +1039,7 @@ PyDoc_STRVAR(_codecs_utf_16_le_encode__doc__,
"\n");
#define _CODECS_UTF_16_LE_ENCODE_METHODDEF \
- {"utf_16_le_encode", (PyCFunction)_codecs_utf_16_le_encode, METH_FASTCALL, _codecs_utf_16_le_encode__doc__},
+ {"utf_16_le_encode", (PyCFunction)(void(*)(void))_codecs_utf_16_le_encode, METH_FASTCALL, _codecs_utf_16_le_encode__doc__},
static PyObject *
_codecs_utf_16_le_encode_impl(PyObject *module, PyObject *str,
@@ -1068,7 +1068,7 @@ PyDoc_STRVAR(_codecs_utf_16_be_encode__doc__,
"\n");
#define _CODECS_UTF_16_BE_ENCODE_METHODDEF \
- {"utf_16_be_encode", (PyCFunction)_codecs_utf_16_be_encode, METH_FASTCALL, _codecs_utf_16_be_encode__doc__},
+ {"utf_16_be_encode", (PyCFunction)(void(*)(void))_codecs_utf_16_be_encode, METH_FASTCALL, _codecs_utf_16_be_encode__doc__},
static PyObject *
_codecs_utf_16_be_encode_impl(PyObject *module, PyObject *str,
@@ -1097,7 +1097,7 @@ PyDoc_STRVAR(_codecs_utf_32_encode__doc__,
"\n");
#define _CODECS_UTF_32_ENCODE_METHODDEF \
- {"utf_32_encode", (PyCFunction)_codecs_utf_32_encode, METH_FASTCALL, _codecs_utf_32_encode__doc__},
+ {"utf_32_encode", (PyCFunction)(void(*)(void))_codecs_utf_32_encode, METH_FASTCALL, _codecs_utf_32_encode__doc__},
static PyObject *
_codecs_utf_32_encode_impl(PyObject *module, PyObject *str,
@@ -1127,7 +1127,7 @@ PyDoc_STRVAR(_codecs_utf_32_le_encode__doc__,
"\n");
#define _CODECS_UTF_32_LE_ENCODE_METHODDEF \
- {"utf_32_le_encode", (PyCFunction)_codecs_utf_32_le_encode, METH_FASTCALL, _codecs_utf_32_le_encode__doc__},
+ {"utf_32_le_encode", (PyCFunction)(void(*)(void))_codecs_utf_32_le_encode, METH_FASTCALL, _codecs_utf_32_le_encode__doc__},
static PyObject *
_codecs_utf_32_le_encode_impl(PyObject *module, PyObject *str,
@@ -1156,7 +1156,7 @@ PyDoc_STRVAR(_codecs_utf_32_be_encode__doc__,
"\n");
#define _CODECS_UTF_32_BE_ENCODE_METHODDEF \
- {"utf_32_be_encode", (PyCFunction)_codecs_utf_32_be_encode, METH_FASTCALL, _codecs_utf_32_be_encode__doc__},
+ {"utf_32_be_encode", (PyCFunction)(void(*)(void))_codecs_utf_32_be_encode, METH_FASTCALL, _codecs_utf_32_be_encode__doc__},
static PyObject *
_codecs_utf_32_be_encode_impl(PyObject *module, PyObject *str,
@@ -1185,7 +1185,7 @@ PyDoc_STRVAR(_codecs_unicode_escape_encode__doc__,
"\n");
#define _CODECS_UNICODE_ESCAPE_ENCODE_METHODDEF \
- {"unicode_escape_encode", (PyCFunction)_codecs_unicode_escape_encode, METH_FASTCALL, _codecs_unicode_escape_encode__doc__},
+ {"unicode_escape_encode", (PyCFunction)(void(*)(void))_codecs_unicode_escape_encode, METH_FASTCALL, _codecs_unicode_escape_encode__doc__},
static PyObject *
_codecs_unicode_escape_encode_impl(PyObject *module, PyObject *str,
@@ -1214,7 +1214,7 @@ PyDoc_STRVAR(_codecs_raw_unicode_escape_encode__doc__,
"\n");
#define _CODECS_RAW_UNICODE_ESCAPE_ENCODE_METHODDEF \
- {"raw_unicode_escape_encode", (PyCFunction)_codecs_raw_unicode_escape_encode, METH_FASTCALL, _codecs_raw_unicode_escape_encode__doc__},
+ {"raw_unicode_escape_encode", (PyCFunction)(void(*)(void))_codecs_raw_unicode_escape_encode, METH_FASTCALL, _codecs_raw_unicode_escape_encode__doc__},
static PyObject *
_codecs_raw_unicode_escape_encode_impl(PyObject *module, PyObject *str,
@@ -1243,7 +1243,7 @@ PyDoc_STRVAR(_codecs_latin_1_encode__doc__,
"\n");
#define _CODECS_LATIN_1_ENCODE_METHODDEF \
- {"latin_1_encode", (PyCFunction)_codecs_latin_1_encode, METH_FASTCALL, _codecs_latin_1_encode__doc__},
+ {"latin_1_encode", (PyCFunction)(void(*)(void))_codecs_latin_1_encode, METH_FASTCALL, _codecs_latin_1_encode__doc__},
static PyObject *
_codecs_latin_1_encode_impl(PyObject *module, PyObject *str,
@@ -1272,7 +1272,7 @@ PyDoc_STRVAR(_codecs_ascii_encode__doc__,
"\n");
#define _CODECS_ASCII_ENCODE_METHODDEF \
- {"ascii_encode", (PyCFunction)_codecs_ascii_encode, METH_FASTCALL, _codecs_ascii_encode__doc__},
+ {"ascii_encode", (PyCFunction)(void(*)(void))_codecs_ascii_encode, METH_FASTCALL, _codecs_ascii_encode__doc__},
static PyObject *
_codecs_ascii_encode_impl(PyObject *module, PyObject *str,
@@ -1301,7 +1301,7 @@ PyDoc_STRVAR(_codecs_charmap_encode__doc__,
"\n");
#define _CODECS_CHARMAP_ENCODE_METHODDEF \
- {"charmap_encode", (PyCFunction)_codecs_charmap_encode, METH_FASTCALL, _codecs_charmap_encode__doc__},
+ {"charmap_encode", (PyCFunction)(void(*)(void))_codecs_charmap_encode, METH_FASTCALL, _codecs_charmap_encode__doc__},
static PyObject *
_codecs_charmap_encode_impl(PyObject *module, PyObject *str,
@@ -1359,7 +1359,7 @@ PyDoc_STRVAR(_codecs_mbcs_encode__doc__,
"\n");
#define _CODECS_MBCS_ENCODE_METHODDEF \
- {"mbcs_encode", (PyCFunction)_codecs_mbcs_encode, METH_FASTCALL, _codecs_mbcs_encode__doc__},
+ {"mbcs_encode", (PyCFunction)(void(*)(void))_codecs_mbcs_encode, METH_FASTCALL, _codecs_mbcs_encode__doc__},
static PyObject *
_codecs_mbcs_encode_impl(PyObject *module, PyObject *str, const char *errors);
@@ -1391,7 +1391,7 @@ PyDoc_STRVAR(_codecs_oem_encode__doc__,
"\n");
#define _CODECS_OEM_ENCODE_METHODDEF \
- {"oem_encode", (PyCFunction)_codecs_oem_encode, METH_FASTCALL, _codecs_oem_encode__doc__},
+ {"oem_encode", (PyCFunction)(void(*)(void))_codecs_oem_encode, METH_FASTCALL, _codecs_oem_encode__doc__},
static PyObject *
_codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors);
@@ -1423,7 +1423,7 @@ PyDoc_STRVAR(_codecs_code_page_encode__doc__,
"\n");
#define _CODECS_CODE_PAGE_ENCODE_METHODDEF \
- {"code_page_encode", (PyCFunction)_codecs_code_page_encode, METH_FASTCALL, _codecs_code_page_encode__doc__},
+ {"code_page_encode", (PyCFunction)(void(*)(void))_codecs_code_page_encode, METH_FASTCALL, _codecs_code_page_encode__doc__},
static PyObject *
_codecs_code_page_encode_impl(PyObject *module, int code_page, PyObject *str,
@@ -1460,7 +1460,7 @@ PyDoc_STRVAR(_codecs_register_error__doc__,
"error and must return a (replacement, new position) tuple.");
#define _CODECS_REGISTER_ERROR_METHODDEF \
- {"register_error", (PyCFunction)_codecs_register_error, METH_FASTCALL, _codecs_register_error__doc__},
+ {"register_error", (PyCFunction)(void(*)(void))_codecs_register_error, METH_FASTCALL, _codecs_register_error__doc__},
static PyObject *
_codecs_register_error_impl(PyObject *module, const char *errors,
@@ -1536,4 +1536,4 @@ _codecs_lookup_error(PyObject *module, PyObject *arg)
#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]*/
diff --git a/Modules/clinic/_cryptmodule.c.h b/Modules/clinic/_cryptmodule.c.h
index 71eb53cd5e6c..baa31e2d2fbe 100644
--- a/Modules/clinic/_cryptmodule.c.h
+++ b/Modules/clinic/_cryptmodule.c.h
@@ -14,7 +14,7 @@ PyDoc_STRVAR(crypt_crypt__doc__,
"results for a given *word*.");
#define CRYPT_CRYPT_METHODDEF \
- {"crypt", (PyCFunction)crypt_crypt, METH_FASTCALL, crypt_crypt__doc__},
+ {"crypt", (PyCFunction)(void(*)(void))crypt_crypt, METH_FASTCALL, crypt_crypt__doc__},
static PyObject *
crypt_crypt_impl(PyObject *module, const char *word, const char *salt);
@@ -35,4 +35,4 @@ crypt_crypt(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=8d803e53466b1cd3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=79001dbfdd623ff9 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_curses_panel.c.h b/Modules/clinic/_curses_panel.c.h
index e11c68d864a6..4f3f593ba3ca 100644
--- a/Modules/clinic/_curses_panel.c.h
+++ b/Modules/clinic/_curses_panel.c.h
@@ -137,7 +137,7 @@ PyDoc_STRVAR(_curses_panel_panel_move__doc__,
"Move the panel to the screen coordinates (y, x).");
#define _CURSES_PANEL_PANEL_MOVE_METHODDEF \
- {"move", (PyCFunction)_curses_panel_panel_move, METH_FASTCALL, _curses_panel_panel_move__doc__},
+ {"move", (PyCFunction)(void(*)(void))_curses_panel_panel_move, METH_FASTCALL, _curses_panel_panel_move__doc__},
static PyObject *
_curses_panel_panel_move_impl(PyCursesPanelObject *self, int y, int x);
@@ -314,4 +314,4 @@ _curses_panel_update_panels(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _curses_panel_update_panels_impl(module);
}
-/*[clinic end generated code: output=96f627ca0b08b96d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=66e49cb9726a638f input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_cursesmodule.c.h b/Modules/clinic/_cursesmodule.c.h
index b32797fc74ee..ac921d5761f8 100644
--- a/Modules/clinic/_cursesmodule.c.h
+++ b/Modules/clinic/_cursesmodule.c.h
@@ -233,7 +233,7 @@ PyDoc_STRVAR(_curses_window_bkgd__doc__,
" Background attributes.");
#define _CURSES_WINDOW_BKGD_METHODDEF \
- {"bkgd", (PyCFunction)_curses_window_bkgd, METH_FASTCALL, _curses_window_bkgd__doc__},
+ {"bkgd", (PyCFunction)(void(*)(void))_curses_window_bkgd, METH_FASTCALL, _curses_window_bkgd__doc__},
static PyObject *
_curses_window_bkgd_impl(PyCursesWindowObject *self, PyObject *ch, long attr);
@@ -348,7 +348,7 @@ PyDoc_STRVAR(_curses_window_bkgdset__doc__,
" Background attributes.");
#define _CURSES_WINDOW_BKGDSET_METHODDEF \
- {"bkgdset", (PyCFunction)_curses_window_bkgdset, METH_FASTCALL, _curses_window_bkgdset__doc__},
+ {"bkgdset", (PyCFunction)(void(*)(void))_curses_window_bkgdset, METH_FASTCALL, _curses_window_bkgdset__doc__},
static PyObject *
_curses_window_bkgdset_impl(PyCursesWindowObject *self, PyObject *ch,
@@ -403,7 +403,7 @@ PyDoc_STRVAR(_curses_window_border__doc__,
"used for that parameter.");
#define _CURSES_WINDOW_BORDER_METHODDEF \
- {"border", (PyCFunction)_curses_window_border, METH_FASTCALL, _curses_window_border__doc__},
+ {"border", (PyCFunction)(void(*)(void))_curses_window_border, METH_FASTCALL, _curses_window_border__doc__},
static PyObject *
_curses_window_border_impl(PyCursesWindowObject *self, PyObject *ls,
@@ -592,7 +592,7 @@ PyDoc_STRVAR(_curses_window_echochar__doc__,
" Attributes for the character.");
#define _CURSES_WINDOW_ECHOCHAR_METHODDEF \
- {"echochar", (PyCFunction)_curses_window_echochar, METH_FASTCALL, _curses_window_echochar__doc__},
+ {"echochar", (PyCFunction)(void(*)(void))_curses_window_echochar, METH_FASTCALL, _curses_window_echochar__doc__},
static PyObject *
_curses_window_echochar_impl(PyCursesWindowObject *self, PyObject *ch,
@@ -629,7 +629,7 @@ PyDoc_STRVAR(_curses_window_enclose__doc__,
" X-coordinate.");
#define _CURSES_WINDOW_ENCLOSE_METHODDEF \
- {"enclose", (PyCFunction)_curses_window_enclose, METH_FASTCALL, _curses_window_enclose__doc__},
+ {"enclose", (PyCFunction)(void(*)(void))_curses_window_enclose, METH_FASTCALL, _curses_window_enclose__doc__},
static long
_curses_window_enclose_impl(PyCursesWindowObject *self, int y, int x);
@@ -1426,7 +1426,7 @@ PyDoc_STRVAR(_curses_window_redrawln__doc__,
"They should be completely redrawn on the next refresh() call.");
#define _CURSES_WINDOW_REDRAWLN_METHODDEF \
- {"redrawln", (PyCFunction)_curses_window_redrawln, METH_FASTCALL, _curses_window_redrawln__doc__},
+ {"redrawln", (PyCFunction)(void(*)(void))_curses_window_redrawln, METH_FASTCALL, _curses_window_redrawln__doc__},
static PyObject *
_curses_window_redrawln_impl(PyCursesWindowObject *self, int beg, int num);
@@ -1517,7 +1517,7 @@ PyDoc_STRVAR(_curses_window_setscrreg__doc__,
"All scrolling actions will take place in this region.");
#define _CURSES_WINDOW_SETSCRREG_METHODDEF \
- {"setscrreg", (PyCFunction)_curses_window_setscrreg, METH_FASTCALL, _curses_window_setscrreg__doc__},
+ {"setscrreg", (PyCFunction)(void(*)(void))_curses_window_setscrreg, METH_FASTCALL, _curses_window_setscrreg__doc__},
static PyObject *
_curses_window_setscrreg_impl(PyCursesWindowObject *self, int top,
@@ -1843,7 +1843,7 @@ PyDoc_STRVAR(_curses_cbreak__doc__,
"Calling first raw() then cbreak() leaves the terminal in cbreak mode.");
#define _CURSES_CBREAK_METHODDEF \
- {"cbreak", (PyCFunction)_curses_cbreak, METH_FASTCALL, _curses_cbreak__doc__},
+ {"cbreak", (PyCFunction)(void(*)(void))_curses_cbreak, METH_FASTCALL, _curses_cbreak__doc__},
static PyObject *
_curses_cbreak_impl(PyObject *module, int flag);
@@ -2069,7 +2069,7 @@ PyDoc_STRVAR(_curses_echo__doc__,
"In echo mode, each character input is echoed to the screen as it is entered.");
#define _CURSES_ECHO_METHODDEF \
- {"echo", (PyCFunction)_curses_echo, METH_FASTCALL, _curses_echo__doc__},
+ {"echo", (PyCFunction)(void(*)(void))_curses_echo, METH_FASTCALL, _curses_echo__doc__},
static PyObject *
_curses_echo_impl(PyObject *module, int flag);
@@ -2227,7 +2227,7 @@ PyDoc_STRVAR(_curses_ungetmouse__doc__,
"The following getmouse() will return the given state data.");
#define _CURSES_UNGETMOUSE_METHODDEF \
- {"ungetmouse", (PyCFunction)_curses_ungetmouse, METH_FASTCALL, _curses_ungetmouse__doc__},
+ {"ungetmouse", (PyCFunction)(void(*)(void))_curses_ungetmouse, METH_FASTCALL, _curses_ungetmouse__doc__},
static PyObject *
_curses_ungetmouse_impl(PyObject *module, short id, int x, int y, int z,
@@ -2407,7 +2407,7 @@ PyDoc_STRVAR(_curses_init_color__doc__,
"most terminals; it is active only if can_change_color() returns 1.");
#define _CURSES_INIT_COLOR_METHODDEF \
- {"init_color", (PyCFunction)_curses_init_color, METH_FASTCALL, _curses_init_color__doc__},
+ {"init_color", (PyCFunction)(void(*)(void))_curses_init_color, METH_FASTCALL, _curses_init_color__doc__},
static PyObject *
_curses_init_color_impl(PyObject *module, short color_number, short r,
@@ -2449,7 +2449,7 @@ PyDoc_STRVAR(_curses_init_pair__doc__,
"all occurrences of that color-pair are changed to the new definition.");
#define _CURSES_INIT_PAIR_METHODDEF \
- {"init_pair", (PyCFunction)_curses_init_pair, METH_FASTCALL, _curses_init_pair__doc__},
+ {"init_pair", (PyCFunction)(void(*)(void))_curses_init_pair, METH_FASTCALL, _curses_init_pair__doc__},
static PyObject *
_curses_init_pair_impl(PyObject *module, short pair_number, short fg,
@@ -2507,7 +2507,7 @@ PyDoc_STRVAR(_curses_setupterm__doc__,
" If not supplied, the file descriptor for sys.stdout will be used.");
#define _CURSES_SETUPTERM_METHODDEF \
- {"setupterm", (PyCFunction)_curses_setupterm, METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
+ {"setupterm", (PyCFunction)(void(*)(void))_curses_setupterm, METH_FASTCALL|METH_KEYWORDS, _curses_setupterm__doc__},
static PyObject *
_curses_setupterm_impl(PyObject *module, const char *term, int fd);
@@ -2589,7 +2589,7 @@ PyDoc_STRVAR(_curses_is_term_resized__doc__,
" Width.");
#define _CURSES_IS_TERM_RESIZED_METHODDEF \
- {"is_term_resized", (PyCFunction)_curses_is_term_resized, METH_FASTCALL, _curses_is_term_resized__doc__},
+ {"is_term_resized", (PyCFunction)(void(*)(void))_curses_is_term_resized, METH_FASTCALL, _curses_is_term_resized__doc__},
static PyObject *
_curses_is_term_resized_impl(PyObject *module, int nlines, int ncols);
@@ -2828,7 +2828,7 @@ PyDoc_STRVAR(_curses_newpad__doc__,
" Width.");
#define _CURSES_NEWPAD_METHODDEF \
- {"newpad", (PyCFunction)_curses_newpad, METH_FASTCALL, _curses_newpad__doc__},
+ {"newpad", (PyCFunction)(void(*)(void))_curses_newpad, METH_FASTCALL, _curses_newpad__doc__},
static PyObject *
_curses_newpad_impl(PyObject *module, int nlines, int ncols);
@@ -2918,7 +2918,7 @@ PyDoc_STRVAR(_curses_nl__doc__,
"newline into return and line-feed on output. Newline mode is initially on.");
#define _CURSES_NL_METHODDEF \
- {"nl", (PyCFunction)_curses_nl, METH_FASTCALL, _curses_nl__doc__},
+ {"nl", (PyCFunction)(void(*)(void))_curses_nl, METH_FASTCALL, _curses_nl__doc__},
static PyObject *
_curses_nl_impl(PyObject *module, int flag);
@@ -3142,7 +3142,7 @@ PyDoc_STRVAR(_curses_qiflush__doc__,
"will be flushed when the INTR, QUIT and SUSP characters are read.");
#define _CURSES_QIFLUSH_METHODDEF \
- {"qiflush", (PyCFunction)_curses_qiflush, METH_FASTCALL, _curses_qiflush__doc__},
+ {"qiflush", (PyCFunction)(void(*)(void))_curses_qiflush, METH_FASTCALL, _curses_qiflush__doc__},
static PyObject *
_curses_qiflush_impl(PyObject *module, int flag);
@@ -3208,7 +3208,7 @@ PyDoc_STRVAR(_curses_raw__doc__,
"curses input functions one by one.");
#define _CURSES_RAW_METHODDEF \
- {"raw", (PyCFunction)_curses_raw, METH_FASTCALL, _curses_raw__doc__},
+ {"raw", (PyCFunction)(void(*)(void))_curses_raw, METH_FASTCALL, _curses_raw__doc__},
static PyObject *
_curses_raw_impl(PyObject *module, int flag);
@@ -3300,7 +3300,7 @@ PyDoc_STRVAR(_curses_resizeterm__doc__,
"window dimensions (in particular the SIGWINCH handler).");
#define _CURSES_RESIZETERM_METHODDEF \
- {"resizeterm", (PyCFunction)_curses_resizeterm, METH_FASTCALL, _curses_resizeterm__doc__},
+ {"resizeterm", (PyCFunction)(void(*)(void))_curses_resizeterm, METH_FASTCALL, _curses_resizeterm__doc__},
static PyObject *
_curses_resizeterm_impl(PyObject *module, int nlines, int ncols);
@@ -3344,7 +3344,7 @@ PyDoc_STRVAR(_curses_resize_term__doc__,
"without additional interaction with the application.");
#define _CURSES_RESIZE_TERM_METHODDEF \
- {"resize_term", (PyCFunction)_curses_resize_term, METH_FASTCALL, _curses_resize_term__doc__},
+ {"resize_term", (PyCFunction)(void(*)(void))_curses_resize_term, METH_FASTCALL, _curses_resize_term__doc__},
static PyObject *
_curses_resize_term_impl(PyObject *module, int nlines, int ncols);
@@ -3402,7 +3402,7 @@ PyDoc_STRVAR(_curses_setsyx__doc__,
"If y and x are both -1, then leaveok is set.");
#define _CURSES_SETSYX_METHODDEF \
- {"setsyx", (PyCFunction)_curses_setsyx, METH_FASTCALL, _curses_setsyx__doc__},
+ {"setsyx", (PyCFunction)(void(*)(void))_curses_setsyx, METH_FASTCALL, _curses_setsyx__doc__},
static PyObject *
_curses_setsyx_impl(PyObject *module, int y, int x);
@@ -3597,7 +3597,7 @@ PyDoc_STRVAR(_curses_tparm__doc__,
" Parameterized byte string obtained from the terminfo database.");
#define _CURSES_TPARM_METHODDEF \
- {"tparm", (PyCFunction)_curses_tparm, METH_FASTCALL, _curses_tparm__doc__},
+ {"tparm", (PyCFunction)(void(*)(void))_curses_tparm, METH_FASTCALL, _curses_tparm__doc__},
static PyObject *
_curses_tparm_impl(PyObject *module, const char *str, int i1, int i2, int i3,
@@ -3838,4 +3838,4 @@ _curses_use_default_colors(PyObject *module, PyObject *Py_UNUSED(ignored))
#ifndef _CURSES_USE_DEFAULT_COLORS_METHODDEF
#define _CURSES_USE_DEFAULT_COLORS_METHODDEF
#endif /* !defined(_CURSES_USE_DEFAULT_COLORS_METHODDEF) */
-/*[clinic end generated code: output=763ffe3abc3a97c7 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=177ad1d0b5586aaa input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_datetimemodule.c.h b/Modules/clinic/_datetimemodule.c.h
index 0f917ddd2e18..36b4fcac47e5 100644
--- a/Modules/clinic/_datetimemodule.c.h
+++ b/Modules/clinic/_datetimemodule.c.h
@@ -26,7 +26,7 @@ PyDoc_STRVAR(datetime_datetime_now__doc__,
"If no tz is specified, uses local timezone.");
#define DATETIME_DATETIME_NOW_METHODDEF \
- {"now", (PyCFunction)datetime_datetime_now, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, datetime_datetime_now__doc__},
+ {"now", (PyCFunction)(void(*)(void))datetime_datetime_now, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, datetime_datetime_now__doc__},
static PyObject *
datetime_datetime_now_impl(PyTypeObject *type, PyObject *tz);
@@ -48,4 +48,4 @@ datetime_datetime_now(PyTypeObject *type, PyObject *const *args, Py_ssize_t narg
exit:
return return_value;
}
-/*[clinic end generated code: output=7fd14bd67749da23 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b3d746843403a8ce input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_dbmmodule.c.h b/Modules/clinic/_dbmmodule.c.h
index 574cc5ee174b..c0908623c973 100644
--- a/Modules/clinic/_dbmmodule.c.h
+++ b/Modules/clinic/_dbmmodule.c.h
@@ -45,7 +45,7 @@ PyDoc_STRVAR(_dbm_dbm_get__doc__,
"Return the value for key if present, otherwise default.");
#define _DBM_DBM_GET_METHODDEF \
- {"get", (PyCFunction)_dbm_dbm_get, METH_FASTCALL, _dbm_dbm_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))_dbm_dbm_get, METH_FASTCALL, _dbm_dbm_get__doc__},
static PyObject *
_dbm_dbm_get_impl(dbmobject *self, const char *key,
@@ -78,7 +78,7 @@ PyDoc_STRVAR(_dbm_dbm_setdefault__doc__,
"If key is not in the database, it is inserted with default as the value.");
#define _DBM_DBM_SETDEFAULT_METHODDEF \
- {"setdefault", (PyCFunction)_dbm_dbm_setdefault, METH_FASTCALL, _dbm_dbm_setdefault__doc__},
+ {"setdefault", (PyCFunction)(void(*)(void))_dbm_dbm_setdefault, METH_FASTCALL, _dbm_dbm_setdefault__doc__},
static PyObject *
_dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
@@ -118,7 +118,7 @@ PyDoc_STRVAR(dbmopen__doc__,
" (e.g. os.O_RDWR).");
#define DBMOPEN_METHODDEF \
- {"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
+ {"open", (PyCFunction)(void(*)(void))dbmopen, METH_FASTCALL, dbmopen__doc__},
static PyObject *
dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
@@ -141,4 +141,4 @@ dbmopen(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=1cba297bc8d7c2c2 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=e4585e78f5821b5b input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_elementtree.c.h b/Modules/clinic/_elementtree.c.h
index 78b9be89a3e6..f7dc12eacfad 100644
--- a/Modules/clinic/_elementtree.c.h
+++ b/Modules/clinic/_elementtree.c.h
@@ -154,7 +154,7 @@ PyDoc_STRVAR(_elementtree_Element_find__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF \
- {"find", (PyCFunction)_elementtree_Element_find, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
+ {"find", (PyCFunction)(void(*)(void))_elementtree_Element_find, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_find__doc__},
static PyObject *
_elementtree_Element_find_impl(ElementObject *self, PyObject *path,
@@ -185,7 +185,7 @@ PyDoc_STRVAR(_elementtree_Element_findtext__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF \
- {"findtext", (PyCFunction)_elementtree_Element_findtext, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
+ {"findtext", (PyCFunction)(void(*)(void))_elementtree_Element_findtext, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
static PyObject *
_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path,
@@ -218,7 +218,7 @@ PyDoc_STRVAR(_elementtree_Element_findall__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF \
- {"findall", (PyCFunction)_elementtree_Element_findall, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
+ {"findall", (PyCFunction)(void(*)(void))_elementtree_Element_findall, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_findall__doc__},
static PyObject *
_elementtree_Element_findall_impl(ElementObject *self, PyObject *path,
@@ -249,7 +249,7 @@ PyDoc_STRVAR(_elementtree_Element_iterfind__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF \
- {"iterfind", (PyCFunction)_elementtree_Element_iterfind, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
+ {"iterfind", (PyCFunction)(void(*)(void))_elementtree_Element_iterfind, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
static PyObject *
_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path,
@@ -280,7 +280,7 @@ PyDoc_STRVAR(_elementtree_Element_get__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_GET_METHODDEF \
- {"get", (PyCFunction)_elementtree_Element_get, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))_elementtree_Element_get, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_get__doc__},
static PyObject *
_elementtree_Element_get_impl(ElementObject *self, PyObject *key,
@@ -328,7 +328,7 @@ PyDoc_STRVAR(_elementtree_Element_iter__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF \
- {"iter", (PyCFunction)_elementtree_Element_iter, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
+ {"iter", (PyCFunction)(void(*)(void))_elementtree_Element_iter, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_iter__doc__},
static PyObject *
_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag);
@@ -357,7 +357,7 @@ PyDoc_STRVAR(_elementtree_Element_getiterator__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_GETITERATOR_METHODDEF \
- {"getiterator", (PyCFunction)_elementtree_Element_getiterator, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_getiterator__doc__},
+ {"getiterator", (PyCFunction)(void(*)(void))_elementtree_Element_getiterator, METH_FASTCALL|METH_KEYWORDS, _elementtree_Element_getiterator__doc__},
static PyObject *
_elementtree_Element_getiterator_impl(ElementObject *self, PyObject *tag);
@@ -403,7 +403,7 @@ PyDoc_STRVAR(_elementtree_Element_insert__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF \
- {"insert", (PyCFunction)_elementtree_Element_insert, METH_FASTCALL, _elementtree_Element_insert__doc__},
+ {"insert", (PyCFunction)(void(*)(void))_elementtree_Element_insert, METH_FASTCALL, _elementtree_Element_insert__doc__},
static PyObject *
_elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,
@@ -466,7 +466,7 @@ PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF \
- {"makeelement", (PyCFunction)_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__},
+ {"makeelement", (PyCFunction)(void(*)(void))_elementtree_Element_makeelement, METH_FASTCALL, _elementtree_Element_makeelement__doc__},
static PyObject *
_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag,
@@ -522,7 +522,7 @@ PyDoc_STRVAR(_elementtree_Element_set__doc__,
"\n");
#define _ELEMENTTREE_ELEMENT_SET_METHODDEF \
- {"set", (PyCFunction)_elementtree_Element_set, METH_FASTCALL, _elementtree_Element_set__doc__},
+ {"set", (PyCFunction)(void(*)(void))_elementtree_Element_set, METH_FASTCALL, _elementtree_Element_set__doc__},
static PyObject *
_elementtree_Element_set_impl(ElementObject *self, PyObject *key,
@@ -607,7 +607,7 @@ PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
"\n");
#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF \
- {"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
+ {"start", (PyCFunction)(void(*)(void))_elementtree_TreeBuilder_start, METH_FASTCALL, _elementtree_TreeBuilder_start__doc__},
static PyObject *
_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
@@ -693,7 +693,7 @@ PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
"\n");
#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF \
- {"_setevents", (PyCFunction)_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
+ {"_setevents", (PyCFunction)(void(*)(void))_elementtree_XMLParser__setevents, METH_FASTCALL, _elementtree_XMLParser__setevents__doc__},
static PyObject *
_elementtree_XMLParser__setevents_impl(XMLParserObject *self,
@@ -717,4 +717,4 @@ _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *const *args,
exit:
return return_value;
}
-/*[clinic end generated code: output=1bff22415aabb78b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=f1efdb511a5b027b input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_gdbmmodule.c.h b/Modules/clinic/_gdbmmodule.c.h
index 7bdc4321df29..5edc440b181e 100644
--- a/Modules/clinic/_gdbmmodule.c.h
+++ b/Modules/clinic/_gdbmmodule.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(_gdbm_gdbm_get__doc__,
"Get the value for key, or default if not present.");
#define _GDBM_GDBM_GET_METHODDEF \
- {"get", (PyCFunction)_gdbm_gdbm_get, METH_FASTCALL, _gdbm_gdbm_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))_gdbm_gdbm_get, METH_FASTCALL, _gdbm_gdbm_get__doc__},
static PyObject *
_gdbm_gdbm_get_impl(dbmobject *self, PyObject *key, PyObject *default_value);
@@ -39,7 +39,7 @@ PyDoc_STRVAR(_gdbm_gdbm_setdefault__doc__,
"Get value for key, or set it to default and return default if not present.");
#define _GDBM_GDBM_SETDEFAULT_METHODDEF \
- {"setdefault", (PyCFunction)_gdbm_gdbm_setdefault, METH_FASTCALL, _gdbm_gdbm_setdefault__doc__},
+ {"setdefault", (PyCFunction)(void(*)(void))_gdbm_gdbm_setdefault, METH_FASTCALL, _gdbm_gdbm_setdefault__doc__},
static PyObject *
_gdbm_gdbm_setdefault_impl(dbmobject *self, PyObject *key,
@@ -231,7 +231,7 @@ PyDoc_STRVAR(dbmopen__doc__,
"when the database has to be created. It defaults to octal 0o666.");
#define DBMOPEN_METHODDEF \
- {"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
+ {"open", (PyCFunction)(void(*)(void))dbmopen, METH_FASTCALL, dbmopen__doc__},
static PyObject *
dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
@@ -254,4 +254,4 @@ dbmopen(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=dec05ff9c5aeaeae input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5ca4361417bf96cb input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_hashopenssl.c.h b/Modules/clinic/_hashopenssl.c.h
index 070f8290f26f..3dad45de6712 100644
--- a/Modules/clinic/_hashopenssl.c.h
+++ b/Modules/clinic/_hashopenssl.c.h
@@ -12,7 +12,7 @@ PyDoc_STRVAR(_hashlib_scrypt__doc__,
"scrypt password-based key derivation function.");
#define _HASHLIB_SCRYPT_METHODDEF \
- {"scrypt", (PyCFunction)_hashlib_scrypt, METH_FASTCALL|METH_KEYWORDS, _hashlib_scrypt__doc__},
+ {"scrypt", (PyCFunction)(void(*)(void))_hashlib_scrypt, METH_FASTCALL|METH_KEYWORDS, _hashlib_scrypt__doc__},
static PyObject *
_hashlib_scrypt_impl(PyObject *module, Py_buffer *password, Py_buffer *salt,
@@ -61,7 +61,7 @@ PyDoc_STRVAR(_hashlib_hmac_digest__doc__,
"Single-shot HMAC.");
#define _HASHLIB_HMAC_DIGEST_METHODDEF \
- {"hmac_digest", (PyCFunction)_hashlib_hmac_digest, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_digest__doc__},
+ {"hmac_digest", (PyCFunction)(void(*)(void))_hashlib_hmac_digest, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_digest__doc__},
static PyObject *
_hashlib_hmac_digest_impl(PyObject *module, Py_buffer *key, Py_buffer *msg,
@@ -99,4 +99,4 @@ _hashlib_hmac_digest(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
#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]*/
diff --git a/Modules/clinic/_heapqmodule.c.h b/Modules/clinic/_heapqmodule.c.h
index 5e346df241f0..0b5d0d7bbaba 100644
--- a/Modules/clinic/_heapqmodule.c.h
+++ b/Modules/clinic/_heapqmodule.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(_heapq_heappush__doc__,
"Push item onto heap, maintaining the heap invariant.");
#define _HEAPQ_HEAPPUSH_METHODDEF \
- {"heappush", (PyCFunction)_heapq_heappush, METH_FASTCALL, _heapq_heappush__doc__},
+ {"heappush", (PyCFunction)(void(*)(void))_heapq_heappush, METH_FASTCALL, _heapq_heappush__doc__},
static PyObject *
_heapq_heappush_impl(PyObject *module, PyObject *heap, PyObject *item);
@@ -56,7 +56,7 @@ PyDoc_STRVAR(_heapq_heapreplace__doc__,
" item = heapreplace(heap, item)");
#define _HEAPQ_HEAPREPLACE_METHODDEF \
- {"heapreplace", (PyCFunction)_heapq_heapreplace, METH_FASTCALL, _heapq_heapreplace__doc__},
+ {"heapreplace", (PyCFunction)(void(*)(void))_heapq_heapreplace, METH_FASTCALL, _heapq_heapreplace__doc__},
static PyObject *
_heapq_heapreplace_impl(PyObject *module, PyObject *heap, PyObject *item);
@@ -89,7 +89,7 @@ PyDoc_STRVAR(_heapq_heappushpop__doc__,
"a separate call to heappop().");
#define _HEAPQ_HEAPPUSHPOP_METHODDEF \
- {"heappushpop", (PyCFunction)_heapq_heappushpop, METH_FASTCALL, _heapq_heappushpop__doc__},
+ {"heappushpop", (PyCFunction)(void(*)(void))_heapq_heappushpop, METH_FASTCALL, _heapq_heappushpop__doc__},
static PyObject *
_heapq_heappushpop_impl(PyObject *module, PyObject *heap, PyObject *item);
@@ -137,7 +137,7 @@ PyDoc_STRVAR(_heapq__heapreplace_max__doc__,
"Maxheap variant of heapreplace.");
#define _HEAPQ__HEAPREPLACE_MAX_METHODDEF \
- {"_heapreplace_max", (PyCFunction)_heapq__heapreplace_max, METH_FASTCALL, _heapq__heapreplace_max__doc__},
+ {"_heapreplace_max", (PyCFunction)(void(*)(void))_heapq__heapreplace_max, METH_FASTCALL, _heapq__heapreplace_max__doc__},
static PyObject *
_heapq__heapreplace_max_impl(PyObject *module, PyObject *heap,
@@ -169,4 +169,4 @@ PyDoc_STRVAR(_heapq__heapify_max__doc__,
#define _HEAPQ__HEAPIFY_MAX_METHODDEF \
{"_heapify_max", (PyCFunction)_heapq__heapify_max, METH_O, _heapq__heapify_max__doc__},
-/*[clinic end generated code: output=0bb0dd0df473ab14 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b73e874eeb9977b6 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_lzmamodule.c.h b/Modules/clinic/_lzmamodule.c.h
index ed7eb5df0522..3e938c3cf1e2 100644
--- a/Modules/clinic/_lzmamodule.c.h
+++ b/Modules/clinic/_lzmamodule.c.h
@@ -81,7 +81,7 @@ PyDoc_STRVAR(_lzma_LZMADecompressor_decompress__doc__,
"the unused_data attribute.");
#define _LZMA_LZMADECOMPRESSOR_DECOMPRESS_METHODDEF \
- {"decompress", (PyCFunction)_lzma_LZMADecompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _lzma_LZMADecompressor_decompress__doc__},
+ {"decompress", (PyCFunction)(void(*)(void))_lzma_LZMADecompressor_decompress, METH_FASTCALL|METH_KEYWORDS, _lzma_LZMADecompressor_decompress__doc__},
static PyObject *
_lzma_LZMADecompressor_decompress_impl(Decompressor *self, Py_buffer *data,
@@ -229,7 +229,7 @@ PyDoc_STRVAR(_lzma__decode_filter_properties__doc__,
"The result does not include the filter ID itself, only the options.");
#define _LZMA__DECODE_FILTER_PROPERTIES_METHODDEF \
- {"_decode_filter_properties", (PyCFunction)_lzma__decode_filter_properties, METH_FASTCALL, _lzma__decode_filter_properties__doc__},
+ {"_decode_filter_properties", (PyCFunction)(void(*)(void))_lzma__decode_filter_properties, METH_FASTCALL, _lzma__decode_filter_properties__doc__},
static PyObject *
_lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
@@ -256,4 +256,4 @@ _lzma__decode_filter_properties(PyObject *module, PyObject *const *args, Py_ssiz
return return_value;
}
-/*[clinic end generated code: output=38c2d52362bf3712 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=2acfd7c4b68530a6 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_opcode.c.h b/Modules/clinic/_opcode.c.h
index b162d84e5db4..2104a52915c4 100644
--- a/Modules/clinic/_opcode.c.h
+++ b/Modules/clinic/_opcode.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(_opcode_stack_effect__doc__,
"Compute the stack effect of the opcode.");
#define _OPCODE_STACK_EFFECT_METHODDEF \
- {"stack_effect", (PyCFunction)_opcode_stack_effect, METH_FASTCALL|METH_KEYWORDS, _opcode_stack_effect__doc__},
+ {"stack_effect", (PyCFunction)(void(*)(void))_opcode_stack_effect, METH_FASTCALL|METH_KEYWORDS, _opcode_stack_effect__doc__},
static int
_opcode_stack_effect_impl(PyObject *module, int opcode, PyObject *oparg,
@@ -39,4 +39,4 @@ _opcode_stack_effect(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
-/*[clinic end generated code: output=bbf6c4cfc91edc29 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=871941eea3d855c6 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_operator.c.h b/Modules/clinic/_operator.c.h
index 9313f9524545..9d7b20c1cc0e 100644
--- a/Modules/clinic/_operator.c.h
+++ b/Modules/clinic/_operator.c.h
@@ -37,7 +37,7 @@ PyDoc_STRVAR(_operator_add__doc__,
"Same as a + b.");
#define _OPERATOR_ADD_METHODDEF \
- {"add", (PyCFunction)_operator_add, METH_FASTCALL, _operator_add__doc__},
+ {"add", (PyCFunction)(void(*)(void))_operator_add, METH_FASTCALL, _operator_add__doc__},
static PyObject *
_operator_add_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -67,7 +67,7 @@ PyDoc_STRVAR(_operator_sub__doc__,
"Same as a - b.");
#define _OPERATOR_SUB_METHODDEF \
- {"sub", (PyCFunction)_operator_sub, METH_FASTCALL, _operator_sub__doc__},
+ {"sub", (PyCFunction)(void(*)(void))_operator_sub, METH_FASTCALL, _operator_sub__doc__},
static PyObject *
_operator_sub_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -97,7 +97,7 @@ PyDoc_STRVAR(_operator_mul__doc__,
"Same as a * b.");
#define _OPERATOR_MUL_METHODDEF \
- {"mul", (PyCFunction)_operator_mul, METH_FASTCALL, _operator_mul__doc__},
+ {"mul", (PyCFunction)(void(*)(void))_operator_mul, METH_FASTCALL, _operator_mul__doc__},
static PyObject *
_operator_mul_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -127,7 +127,7 @@ PyDoc_STRVAR(_operator_matmul__doc__,
"Same as a @ b.");
#define _OPERATOR_MATMUL_METHODDEF \
- {"matmul", (PyCFunction)_operator_matmul, METH_FASTCALL, _operator_matmul__doc__},
+ {"matmul", (PyCFunction)(void(*)(void))_operator_matmul, METH_FASTCALL, _operator_matmul__doc__},
static PyObject *
_operator_matmul_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -157,7 +157,7 @@ PyDoc_STRVAR(_operator_floordiv__doc__,
"Same as a // b.");
#define _OPERATOR_FLOORDIV_METHODDEF \
- {"floordiv", (PyCFunction)_operator_floordiv, METH_FASTCALL, _operator_floordiv__doc__},
+ {"floordiv", (PyCFunction)(void(*)(void))_operator_floordiv, METH_FASTCALL, _operator_floordiv__doc__},
static PyObject *
_operator_floordiv_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -187,7 +187,7 @@ PyDoc_STRVAR(_operator_truediv__doc__,
"Same as a / b.");
#define _OPERATOR_TRUEDIV_METHODDEF \
- {"truediv", (PyCFunction)_operator_truediv, METH_FASTCALL, _operator_truediv__doc__},
+ {"truediv", (PyCFunction)(void(*)(void))_operator_truediv, METH_FASTCALL, _operator_truediv__doc__},
static PyObject *
_operator_truediv_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -217,7 +217,7 @@ PyDoc_STRVAR(_operator_mod__doc__,
"Same as a % b.");
#define _OPERATOR_MOD_METHODDEF \
- {"mod", (PyCFunction)_operator_mod, METH_FASTCALL, _operator_mod__doc__},
+ {"mod", (PyCFunction)(void(*)(void))_operator_mod, METH_FASTCALL, _operator_mod__doc__},
static PyObject *
_operator_mod_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -292,7 +292,7 @@ PyDoc_STRVAR(_operator_lshift__doc__,
"Same as a << b.");
#define _OPERATOR_LSHIFT_METHODDEF \
- {"lshift", (PyCFunction)_operator_lshift, METH_FASTCALL, _operator_lshift__doc__},
+ {"lshift", (PyCFunction)(void(*)(void))_operator_lshift, METH_FASTCALL, _operator_lshift__doc__},
static PyObject *
_operator_lshift_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -322,7 +322,7 @@ PyDoc_STRVAR(_operator_rshift__doc__,
"Same as a >> b.");
#define _OPERATOR_RSHIFT_METHODDEF \
- {"rshift", (PyCFunction)_operator_rshift, METH_FASTCALL, _operator_rshift__doc__},
+ {"rshift", (PyCFunction)(void(*)(void))_operator_rshift, METH_FASTCALL, _operator_rshift__doc__},
static PyObject *
_operator_rshift_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -380,7 +380,7 @@ PyDoc_STRVAR(_operator_and___doc__,
"Same as a & b.");
#define _OPERATOR_AND__METHODDEF \
- {"and_", (PyCFunction)_operator_and_, METH_FASTCALL, _operator_and___doc__},
+ {"and_", (PyCFunction)(void(*)(void))_operator_and_, METH_FASTCALL, _operator_and___doc__},
static PyObject *
_operator_and__impl(PyObject *module, PyObject *a, PyObject *b);
@@ -410,7 +410,7 @@ PyDoc_STRVAR(_operator_xor__doc__,
"Same as a ^ b.");
#define _OPERATOR_XOR_METHODDEF \
- {"xor", (PyCFunction)_operator_xor, METH_FASTCALL, _operator_xor__doc__},
+ {"xor", (PyCFunction)(void(*)(void))_operator_xor, METH_FASTCALL, _operator_xor__doc__},
static PyObject *
_operator_xor_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -440,7 +440,7 @@ PyDoc_STRVAR(_operator_or___doc__,
"Same as a | b.");
#define _OPERATOR_OR__METHODDEF \
- {"or_", (PyCFunction)_operator_or_, METH_FASTCALL, _operator_or___doc__},
+ {"or_", (PyCFunction)(void(*)(void))_operator_or_, METH_FASTCALL, _operator_or___doc__},
static PyObject *
_operator_or__impl(PyObject *module, PyObject *a, PyObject *b);
@@ -470,7 +470,7 @@ PyDoc_STRVAR(_operator_iadd__doc__,
"Same as a += b.");
#define _OPERATOR_IADD_METHODDEF \
- {"iadd", (PyCFunction)_operator_iadd, METH_FASTCALL, _operator_iadd__doc__},
+ {"iadd", (PyCFunction)(void(*)(void))_operator_iadd, METH_FASTCALL, _operator_iadd__doc__},
static PyObject *
_operator_iadd_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -500,7 +500,7 @@ PyDoc_STRVAR(_operator_isub__doc__,
"Same as a -= b.");
#define _OPERATOR_ISUB_METHODDEF \
- {"isub", (PyCFunction)_operator_isub, METH_FASTCALL, _operator_isub__doc__},
+ {"isub", (PyCFunction)(void(*)(void))_operator_isub, METH_FASTCALL, _operator_isub__doc__},
static PyObject *
_operator_isub_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -530,7 +530,7 @@ PyDoc_STRVAR(_operator_imul__doc__,
"Same as a *= b.");
#define _OPERATOR_IMUL_METHODDEF \
- {"imul", (PyCFunction)_operator_imul, METH_FASTCALL, _operator_imul__doc__},
+ {"imul", (PyCFunction)(void(*)(void))_operator_imul, METH_FASTCALL, _operator_imul__doc__},
static PyObject *
_operator_imul_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -560,7 +560,7 @@ PyDoc_STRVAR(_operator_imatmul__doc__,
"Same as a @= b.");
#define _OPERATOR_IMATMUL_METHODDEF \
- {"imatmul", (PyCFunction)_operator_imatmul, METH_FASTCALL, _operator_imatmul__doc__},
+ {"imatmul", (PyCFunction)(void(*)(void))_operator_imatmul, METH_FASTCALL, _operator_imatmul__doc__},
static PyObject *
_operator_imatmul_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -590,7 +590,7 @@ PyDoc_STRVAR(_operator_ifloordiv__doc__,
"Same as a //= b.");
#define _OPERATOR_IFLOORDIV_METHODDEF \
- {"ifloordiv", (PyCFunction)_operator_ifloordiv, METH_FASTCALL, _operator_ifloordiv__doc__},
+ {"ifloordiv", (PyCFunction)(void(*)(void))_operator_ifloordiv, METH_FASTCALL, _operator_ifloordiv__doc__},
static PyObject *
_operator_ifloordiv_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -620,7 +620,7 @@ PyDoc_STRVAR(_operator_itruediv__doc__,
"Same as a /= b.");
#define _OPERATOR_ITRUEDIV_METHODDEF \
- {"itruediv", (PyCFunction)_operator_itruediv, METH_FASTCALL, _operator_itruediv__doc__},
+ {"itruediv", (PyCFunction)(void(*)(void))_operator_itruediv, METH_FASTCALL, _operator_itruediv__doc__},
static PyObject *
_operator_itruediv_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -650,7 +650,7 @@ PyDoc_STRVAR(_operator_imod__doc__,
"Same as a %= b.");
#define _OPERATOR_IMOD_METHODDEF \
- {"imod", (PyCFunction)_operator_imod, METH_FASTCALL, _operator_imod__doc__},
+ {"imod", (PyCFunction)(void(*)(void))_operator_imod, METH_FASTCALL, _operator_imod__doc__},
static PyObject *
_operator_imod_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -680,7 +680,7 @@ PyDoc_STRVAR(_operator_ilshift__doc__,
"Same as a <<= b.");
#define _OPERATOR_ILSHIFT_METHODDEF \
- {"ilshift", (PyCFunction)_operator_ilshift, METH_FASTCALL, _operator_ilshift__doc__},
+ {"ilshift", (PyCFunction)(void(*)(void))_operator_ilshift, METH_FASTCALL, _operator_ilshift__doc__},
static PyObject *
_operator_ilshift_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -710,7 +710,7 @@ PyDoc_STRVAR(_operator_irshift__doc__,
"Same as a >>= b.");
#define _OPERATOR_IRSHIFT_METHODDEF \
- {"irshift", (PyCFunction)_operator_irshift, METH_FASTCALL, _operator_irshift__doc__},
+ {"irshift", (PyCFunction)(void(*)(void))_operator_irshift, METH_FASTCALL, _operator_irshift__doc__},
static PyObject *
_operator_irshift_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -740,7 +740,7 @@ PyDoc_STRVAR(_operator_iand__doc__,
"Same as a &= b.");
#define _OPERATOR_IAND_METHODDEF \
- {"iand", (PyCFunction)_operator_iand, METH_FASTCALL, _operator_iand__doc__},
+ {"iand", (PyCFunction)(void(*)(void))_operator_iand, METH_FASTCALL, _operator_iand__doc__},
static PyObject *
_operator_iand_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -770,7 +770,7 @@ PyDoc_STRVAR(_operator_ixor__doc__,
"Same as a ^= b.");
#define _OPERATOR_IXOR_METHODDEF \
- {"ixor", (PyCFunction)_operator_ixor, METH_FASTCALL, _operator_ixor__doc__},
+ {"ixor", (PyCFunction)(void(*)(void))_operator_ixor, METH_FASTCALL, _operator_ixor__doc__},
static PyObject *
_operator_ixor_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -800,7 +800,7 @@ PyDoc_STRVAR(_operator_ior__doc__,
"Same as a |= b.");
#define _OPERATOR_IOR_METHODDEF \
- {"ior", (PyCFunction)_operator_ior, METH_FASTCALL, _operator_ior__doc__},
+ {"ior", (PyCFunction)(void(*)(void))_operator_ior, METH_FASTCALL, _operator_ior__doc__},
static PyObject *
_operator_ior_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -830,7 +830,7 @@ PyDoc_STRVAR(_operator_concat__doc__,
"Same as a + b, for a and b sequences.");
#define _OPERATOR_CONCAT_METHODDEF \
- {"concat", (PyCFunction)_operator_concat, METH_FASTCALL, _operator_concat__doc__},
+ {"concat", (PyCFunction)(void(*)(void))_operator_concat, METH_FASTCALL, _operator_concat__doc__},
static PyObject *
_operator_concat_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -860,7 +860,7 @@ PyDoc_STRVAR(_operator_iconcat__doc__,
"Same as a += b, for a and b sequences.");
#define _OPERATOR_ICONCAT_METHODDEF \
- {"iconcat", (PyCFunction)_operator_iconcat, METH_FASTCALL, _operator_iconcat__doc__},
+ {"iconcat", (PyCFunction)(void(*)(void))_operator_iconcat, METH_FASTCALL, _operator_iconcat__doc__},
static PyObject *
_operator_iconcat_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -890,7 +890,7 @@ PyDoc_STRVAR(_operator_contains__doc__,
"Same as b in a (note reversed operands).");
#define _OPERATOR_CONTAINS_METHODDEF \
- {"contains", (PyCFunction)_operator_contains, METH_FASTCALL, _operator_contains__doc__},
+ {"contains", (PyCFunction)(void(*)(void))_operator_contains, METH_FASTCALL, _operator_contains__doc__},
static int
_operator_contains_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -925,7 +925,7 @@ PyDoc_STRVAR(_operator_indexOf__doc__,
"Return the first index of b in a.");
#define _OPERATOR_INDEXOF_METHODDEF \
- {"indexOf", (PyCFunction)_operator_indexOf, METH_FASTCALL, _operator_indexOf__doc__},
+ {"indexOf", (PyCFunction)(void(*)(void))_operator_indexOf, METH_FASTCALL, _operator_indexOf__doc__},
static Py_ssize_t
_operator_indexOf_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -960,7 +960,7 @@ PyDoc_STRVAR(_operator_countOf__doc__,
"Return the number of times b occurs in a.");
#define _OPERATOR_COUNTOF_METHODDEF \
- {"countOf", (PyCFunction)_operator_countOf, METH_FASTCALL, _operator_countOf__doc__},
+ {"countOf", (PyCFunction)(void(*)(void))_operator_countOf, METH_FASTCALL, _operator_countOf__doc__},
static Py_ssize_t
_operator_countOf_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -995,7 +995,7 @@ PyDoc_STRVAR(_operator_getitem__doc__,
"Same as a[b].");
#define _OPERATOR_GETITEM_METHODDEF \
- {"getitem", (PyCFunction)_operator_getitem, METH_FASTCALL, _operator_getitem__doc__},
+ {"getitem", (PyCFunction)(void(*)(void))_operator_getitem, METH_FASTCALL, _operator_getitem__doc__},
static PyObject *
_operator_getitem_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1025,7 +1025,7 @@ PyDoc_STRVAR(_operator_setitem__doc__,
"Same as a[b] = c.");
#define _OPERATOR_SETITEM_METHODDEF \
- {"setitem", (PyCFunction)_operator_setitem, METH_FASTCALL, _operator_setitem__doc__},
+ {"setitem", (PyCFunction)(void(*)(void))_operator_setitem, METH_FASTCALL, _operator_setitem__doc__},
static PyObject *
_operator_setitem_impl(PyObject *module, PyObject *a, PyObject *b,
@@ -1057,7 +1057,7 @@ PyDoc_STRVAR(_operator_delitem__doc__,
"Same as del a[b].");
#define _OPERATOR_DELITEM_METHODDEF \
- {"delitem", (PyCFunction)_operator_delitem, METH_FASTCALL, _operator_delitem__doc__},
+ {"delitem", (PyCFunction)(void(*)(void))_operator_delitem, METH_FASTCALL, _operator_delitem__doc__},
static PyObject *
_operator_delitem_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1087,7 +1087,7 @@ PyDoc_STRVAR(_operator_eq__doc__,
"Same as a == b.");
#define _OPERATOR_EQ_METHODDEF \
- {"eq", (PyCFunction)_operator_eq, METH_FASTCALL, _operator_eq__doc__},
+ {"eq", (PyCFunction)(void(*)(void))_operator_eq, METH_FASTCALL, _operator_eq__doc__},
static PyObject *
_operator_eq_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1117,7 +1117,7 @@ PyDoc_STRVAR(_operator_ne__doc__,
"Same as a != b.");
#define _OPERATOR_NE_METHODDEF \
- {"ne", (PyCFunction)_operator_ne, METH_FASTCALL, _operator_ne__doc__},
+ {"ne", (PyCFunction)(void(*)(void))_operator_ne, METH_FASTCALL, _operator_ne__doc__},
static PyObject *
_operator_ne_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1147,7 +1147,7 @@ PyDoc_STRVAR(_operator_lt__doc__,
"Same as a < b.");
#define _OPERATOR_LT_METHODDEF \
- {"lt", (PyCFunction)_operator_lt, METH_FASTCALL, _operator_lt__doc__},
+ {"lt", (PyCFunction)(void(*)(void))_operator_lt, METH_FASTCALL, _operator_lt__doc__},
static PyObject *
_operator_lt_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1177,7 +1177,7 @@ PyDoc_STRVAR(_operator_le__doc__,
"Same as a <= b.");
#define _OPERATOR_LE_METHODDEF \
- {"le", (PyCFunction)_operator_le, METH_FASTCALL, _operator_le__doc__},
+ {"le", (PyCFunction)(void(*)(void))_operator_le, METH_FASTCALL, _operator_le__doc__},
static PyObject *
_operator_le_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1207,7 +1207,7 @@ PyDoc_STRVAR(_operator_gt__doc__,
"Same as a > b.");
#define _OPERATOR_GT_METHODDEF \
- {"gt", (PyCFunction)_operator_gt, METH_FASTCALL, _operator_gt__doc__},
+ {"gt", (PyCFunction)(void(*)(void))_operator_gt, METH_FASTCALL, _operator_gt__doc__},
static PyObject *
_operator_gt_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1237,7 +1237,7 @@ PyDoc_STRVAR(_operator_ge__doc__,
"Same as a >= b.");
#define _OPERATOR_GE_METHODDEF \
- {"ge", (PyCFunction)_operator_ge, METH_FASTCALL, _operator_ge__doc__},
+ {"ge", (PyCFunction)(void(*)(void))_operator_ge, METH_FASTCALL, _operator_ge__doc__},
static PyObject *
_operator_ge_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1267,7 +1267,7 @@ PyDoc_STRVAR(_operator_pow__doc__,
"Same as a ** b.");
#define _OPERATOR_POW_METHODDEF \
- {"pow", (PyCFunction)_operator_pow, METH_FASTCALL, _operator_pow__doc__},
+ {"pow", (PyCFunction)(void(*)(void))_operator_pow, METH_FASTCALL, _operator_pow__doc__},
static PyObject *
_operator_pow_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1297,7 +1297,7 @@ PyDoc_STRVAR(_operator_ipow__doc__,
"Same as a **= b.");
#define _OPERATOR_IPOW_METHODDEF \
- {"ipow", (PyCFunction)_operator_ipow, METH_FASTCALL, _operator_ipow__doc__},
+ {"ipow", (PyCFunction)(void(*)(void))_operator_ipow, METH_FASTCALL, _operator_ipow__doc__},
static PyObject *
_operator_ipow_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1336,7 +1336,7 @@ PyDoc_STRVAR(_operator_is___doc__,
"Same as a is b.");
#define _OPERATOR_IS__METHODDEF \
- {"is_", (PyCFunction)_operator_is_, METH_FASTCALL, _operator_is___doc__},
+ {"is_", (PyCFunction)(void(*)(void))_operator_is_, METH_FASTCALL, _operator_is___doc__},
static PyObject *
_operator_is__impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1366,7 +1366,7 @@ PyDoc_STRVAR(_operator_is_not__doc__,
"Same as a is not b.");
#define _OPERATOR_IS_NOT_METHODDEF \
- {"is_not", (PyCFunction)_operator_is_not, METH_FASTCALL, _operator_is_not__doc__},
+ {"is_not", (PyCFunction)(void(*)(void))_operator_is_not, METH_FASTCALL, _operator_is_not__doc__},
static PyObject *
_operator_is_not_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1402,7 +1402,7 @@ PyDoc_STRVAR(_operator_length_hint__doc__,
"The result will be an integer >= 0.");
#define _OPERATOR_LENGTH_HINT_METHODDEF \
- {"length_hint", (PyCFunction)_operator_length_hint, METH_FASTCALL, _operator_length_hint__doc__},
+ {"length_hint", (PyCFunction)(void(*)(void))_operator_length_hint, METH_FASTCALL, _operator_length_hint__doc__},
static Py_ssize_t
_operator_length_hint_impl(PyObject *module, PyObject *obj,
@@ -1447,7 +1447,7 @@ PyDoc_STRVAR(_operator__compare_digest__doc__,
"types and lengths of a and b--but not their values.");
#define _OPERATOR__COMPARE_DIGEST_METHODDEF \
- {"_compare_digest", (PyCFunction)_operator__compare_digest, METH_FASTCALL, _operator__compare_digest__doc__},
+ {"_compare_digest", (PyCFunction)(void(*)(void))_operator__compare_digest, METH_FASTCALL, _operator__compare_digest__doc__},
static PyObject *
_operator__compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -1469,4 +1469,4 @@ _operator__compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t na
exit:
return return_value;
}
-/*[clinic end generated code: output=d840f7ea76af2372 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=424b884884ab20b7 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_pickle.c.h b/Modules/clinic/_pickle.c.h
index 6d9072832cea..3f6be4bd8049 100644
--- a/Modules/clinic/_pickle.c.h
+++ b/Modules/clinic/_pickle.c.h
@@ -199,7 +199,7 @@ PyDoc_STRVAR(_pickle_Unpickler_find_class__doc__,
"needed. Both arguments passed are str objects.");
#define _PICKLE_UNPICKLER_FIND_CLASS_METHODDEF \
- {"find_class", (PyCFunction)_pickle_Unpickler_find_class, METH_FASTCALL, _pickle_Unpickler_find_class__doc__},
+ {"find_class", (PyCFunction)(void(*)(void))_pickle_Unpickler_find_class, METH_FASTCALL, _pickle_Unpickler_find_class__doc__},
static PyObject *
_pickle_Unpickler_find_class_impl(UnpicklerObject *self,
@@ -385,7 +385,7 @@ PyDoc_STRVAR(_pickle_dump__doc__,
"2, so that the pickle data stream is readable with Python 2.");
#define _PICKLE_DUMP_METHODDEF \
- {"dump", (PyCFunction)_pickle_dump, METH_FASTCALL|METH_KEYWORDS, _pickle_dump__doc__},
+ {"dump", (PyCFunction)(void(*)(void))_pickle_dump, METH_FASTCALL|METH_KEYWORDS, _pickle_dump__doc__},
static PyObject *
_pickle_dump_impl(PyObject *module, PyObject *obj, PyObject *file,
@@ -432,7 +432,7 @@ PyDoc_STRVAR(_pickle_dumps__doc__,
"Python 2, so that the pickle data stream is readable with Python 2.");
#define _PICKLE_DUMPS_METHODDEF \
- {"dumps", (PyCFunction)_pickle_dumps, METH_FASTCALL|METH_KEYWORDS, _pickle_dumps__doc__},
+ {"dumps", (PyCFunction)(void(*)(void))_pickle_dumps, METH_FASTCALL|METH_KEYWORDS, _pickle_dumps__doc__},
static PyObject *
_pickle_dumps_impl(PyObject *module, PyObject *obj, PyObject *protocol,
@@ -488,7 +488,7 @@ PyDoc_STRVAR(_pickle_load__doc__,
"string instances as bytes objects.");
#define _PICKLE_LOAD_METHODDEF \
- {"load", (PyCFunction)_pickle_load, METH_FASTCALL|METH_KEYWORDS, _pickle_load__doc__},
+ {"load", (PyCFunction)(void(*)(void))_pickle_load, METH_FASTCALL|METH_KEYWORDS, _pickle_load__doc__},
static PyObject *
_pickle_load_impl(PyObject *module, PyObject *file, int fix_imports,
@@ -536,7 +536,7 @@ PyDoc_STRVAR(_pickle_loads__doc__,
"string instances as bytes objects.");
#define _PICKLE_LOADS_METHODDEF \
- {"loads", (PyCFunction)_pickle_loads, METH_FASTCALL|METH_KEYWORDS, _pickle_loads__doc__},
+ {"loads", (PyCFunction)(void(*)(void))_pickle_loads, METH_FASTCALL|METH_KEYWORDS, _pickle_loads__doc__},
static PyObject *
_pickle_loads_impl(PyObject *module, PyObject *data, int fix_imports,
@@ -562,4 +562,4 @@ _pickle_loads(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec
exit:
return return_value;
}
-/*[clinic end generated code: output=6fc104b8299c82dd input=a9049054013a1b77]*/
+/*[clinic end generated code: output=4b32d63ff58b64d8 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_queuemodule.c.h b/Modules/clinic/_queuemodule.c.h
index 97247fd8a129..a19fe78e3a01 100644
--- a/Modules/clinic/_queuemodule.c.h
+++ b/Modules/clinic/_queuemodule.c.h
@@ -40,7 +40,7 @@ PyDoc_STRVAR(_queue_SimpleQueue_put__doc__,
"never blocks. They are provided for compatibility with the Queue class.");
#define _QUEUE_SIMPLEQUEUE_PUT_METHODDEF \
- {"put", (PyCFunction)_queue_SimpleQueue_put, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put__doc__},
+ {"put", (PyCFunction)(void(*)(void))_queue_SimpleQueue_put, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put__doc__},
static PyObject *
_queue_SimpleQueue_put_impl(simplequeueobject *self, PyObject *item,
@@ -76,7 +76,7 @@ PyDoc_STRVAR(_queue_SimpleQueue_put_nowait__doc__,
"for compatibility with the Queue class.");
#define _QUEUE_SIMPLEQUEUE_PUT_NOWAIT_METHODDEF \
- {"put_nowait", (PyCFunction)_queue_SimpleQueue_put_nowait, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put_nowait__doc__},
+ {"put_nowait", (PyCFunction)(void(*)(void))_queue_SimpleQueue_put_nowait, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_put_nowait__doc__},
static PyObject *
_queue_SimpleQueue_put_nowait_impl(simplequeueobject *self, PyObject *item);
@@ -114,7 +114,7 @@ PyDoc_STRVAR(_queue_SimpleQueue_get__doc__,
"in that case).");
#define _QUEUE_SIMPLEQUEUE_GET_METHODDEF \
- {"get", (PyCFunction)_queue_SimpleQueue_get, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))_queue_SimpleQueue_get, METH_FASTCALL|METH_KEYWORDS, _queue_SimpleQueue_get__doc__},
static PyObject *
_queue_SimpleQueue_get_impl(simplequeueobject *self, int block,
@@ -215,4 +215,4 @@ _queue_SimpleQueue_qsize(simplequeueobject *self, PyObject *Py_UNUSED(ignored))
exit:
return return_value;
}
-/*[clinic end generated code: output=8badc3bb85263689 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=c12ce9050f153304 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_sre.c.h b/Modules/clinic/_sre.c.h
index 2a7ca6bca1a0..fbc5ba44f0b9 100644
--- a/Modules/clinic/_sre.c.h
+++ b/Modules/clinic/_sre.c.h
@@ -160,7 +160,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_match__doc__,
"Matches zero or more characters at the beginning of the string.");
#define _SRE_SRE_PATTERN_MATCH_METHODDEF \
- {"match", (PyCFunction)_sre_SRE_Pattern_match, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_match__doc__},
+ {"match", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_match, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_match__doc__},
static PyObject *
_sre_SRE_Pattern_match_impl(PatternObject *self, PyObject *string,
@@ -193,7 +193,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_fullmatch__doc__,
"Matches against all of the string.");
#define _SRE_SRE_PATTERN_FULLMATCH_METHODDEF \
- {"fullmatch", (PyCFunction)_sre_SRE_Pattern_fullmatch, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_fullmatch__doc__},
+ {"fullmatch", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_fullmatch, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_fullmatch__doc__},
static PyObject *
_sre_SRE_Pattern_fullmatch_impl(PatternObject *self, PyObject *string,
@@ -228,7 +228,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_search__doc__,
"Return None if no position in the string matches.");
#define _SRE_SRE_PATTERN_SEARCH_METHODDEF \
- {"search", (PyCFunction)_sre_SRE_Pattern_search, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_search__doc__},
+ {"search", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_search, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_search__doc__},
static PyObject *
_sre_SRE_Pattern_search_impl(PatternObject *self, PyObject *string,
@@ -261,7 +261,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_findall__doc__,
"Return a list of all non-overlapping matches of pattern in string.");
#define _SRE_SRE_PATTERN_FINDALL_METHODDEF \
- {"findall", (PyCFunction)_sre_SRE_Pattern_findall, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_findall__doc__},
+ {"findall", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_findall, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_findall__doc__},
static PyObject *
_sre_SRE_Pattern_findall_impl(PatternObject *self, PyObject *string,
@@ -296,7 +296,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_finditer__doc__,
"For each match, the iterator returns a match object.");
#define _SRE_SRE_PATTERN_FINDITER_METHODDEF \
- {"finditer", (PyCFunction)_sre_SRE_Pattern_finditer, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_finditer__doc__},
+ {"finditer", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_finditer, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_finditer__doc__},
static PyObject *
_sre_SRE_Pattern_finditer_impl(PatternObject *self, PyObject *string,
@@ -328,7 +328,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_scanner__doc__,
"\n");
#define _SRE_SRE_PATTERN_SCANNER_METHODDEF \
- {"scanner", (PyCFunction)_sre_SRE_Pattern_scanner, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_scanner__doc__},
+ {"scanner", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_scanner, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_scanner__doc__},
static PyObject *
_sre_SRE_Pattern_scanner_impl(PatternObject *self, PyObject *string,
@@ -361,7 +361,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_split__doc__,
"Split string by the occurrences of pattern.");
#define _SRE_SRE_PATTERN_SPLIT_METHODDEF \
- {"split", (PyCFunction)_sre_SRE_Pattern_split, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_split__doc__},
+ {"split", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_split, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_split__doc__},
static PyObject *
_sre_SRE_Pattern_split_impl(PatternObject *self, PyObject *string,
@@ -393,7 +393,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_sub__doc__,
"Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl.");
#define _SRE_SRE_PATTERN_SUB_METHODDEF \
- {"sub", (PyCFunction)_sre_SRE_Pattern_sub, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_sub__doc__},
+ {"sub", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_sub, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_sub__doc__},
static PyObject *
_sre_SRE_Pattern_sub_impl(PatternObject *self, PyObject *repl,
@@ -426,7 +426,7 @@ PyDoc_STRVAR(_sre_SRE_Pattern_subn__doc__,
"Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl.");
#define _SRE_SRE_PATTERN_SUBN_METHODDEF \
- {"subn", (PyCFunction)_sre_SRE_Pattern_subn, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_subn__doc__},
+ {"subn", (PyCFunction)(void(*)(void))_sre_SRE_Pattern_subn, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Pattern_subn__doc__},
static PyObject *
_sre_SRE_Pattern_subn_impl(PatternObject *self, PyObject *repl,
@@ -484,7 +484,7 @@ PyDoc_STRVAR(_sre_compile__doc__,
"\n");
#define _SRE_COMPILE_METHODDEF \
- {"compile", (PyCFunction)_sre_compile, METH_FASTCALL|METH_KEYWORDS, _sre_compile__doc__},
+ {"compile", (PyCFunction)(void(*)(void))_sre_compile, METH_FASTCALL|METH_KEYWORDS, _sre_compile__doc__},
static PyObject *
_sre_compile_impl(PyObject *module, PyObject *pattern, int flags,
@@ -521,7 +521,7 @@ PyDoc_STRVAR(_sre_SRE_Match_expand__doc__,
"Return the string obtained by doing backslash substitution on the string template, as done by the sub() method.");
#define _SRE_SRE_MATCH_EXPAND_METHODDEF \
- {"expand", (PyCFunction)_sre_SRE_Match_expand, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_expand__doc__},
+ {"expand", (PyCFunction)(void(*)(void))_sre_SRE_Match_expand, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_expand__doc__},
static PyObject *
_sre_SRE_Match_expand_impl(MatchObject *self, PyObject *template);
@@ -554,7 +554,7 @@ PyDoc_STRVAR(_sre_SRE_Match_groups__doc__,
" Is used for groups that did not participate in the match.");
#define _SRE_SRE_MATCH_GROUPS_METHODDEF \
- {"groups", (PyCFunction)_sre_SRE_Match_groups, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groups__doc__},
+ {"groups", (PyCFunction)(void(*)(void))_sre_SRE_Match_groups, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groups__doc__},
static PyObject *
_sre_SRE_Match_groups_impl(MatchObject *self, PyObject *default_value);
@@ -587,7 +587,7 @@ PyDoc_STRVAR(_sre_SRE_Match_groupdict__doc__,
" Is used for groups that did not participate in the match.");
#define _SRE_SRE_MATCH_GROUPDICT_METHODDEF \
- {"groupdict", (PyCFunction)_sre_SRE_Match_groupdict, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groupdict__doc__},
+ {"groupdict", (PyCFunction)(void(*)(void))_sre_SRE_Match_groupdict, METH_FASTCALL|METH_KEYWORDS, _sre_SRE_Match_groupdict__doc__},
static PyObject *
_sre_SRE_Match_groupdict_impl(MatchObject *self, PyObject *default_value);
@@ -617,7 +617,7 @@ PyDoc_STRVAR(_sre_SRE_Match_start__doc__,
"Return index of the start of the substring matched by group.");
#define _SRE_SRE_MATCH_START_METHODDEF \
- {"start", (PyCFunction)_sre_SRE_Match_start, METH_FASTCALL, _sre_SRE_Match_start__doc__},
+ {"start", (PyCFunction)(void(*)(void))_sre_SRE_Match_start, METH_FASTCALL, _sre_SRE_Match_start__doc__},
static Py_ssize_t
_sre_SRE_Match_start_impl(MatchObject *self, PyObject *group);
@@ -651,7 +651,7 @@ PyDoc_STRVAR(_sre_SRE_Match_end__doc__,
"Return index of the end of the substring matched by group.");
#define _SRE_SRE_MATCH_END_METHODDEF \
- {"end", (PyCFunction)_sre_SRE_Match_end, METH_FASTCALL, _sre_SRE_Match_end__doc__},
+ {"end", (PyCFunction)(void(*)(void))_sre_SRE_Match_end, METH_FASTCALL, _sre_SRE_Match_end__doc__},
static Py_ssize_t
_sre_SRE_Match_end_impl(MatchObject *self, PyObject *group);
@@ -685,7 +685,7 @@ PyDoc_STRVAR(_sre_SRE_Match_span__doc__,
"For match object m, return the 2-tuple (m.start(group), m.end(group)).");
#define _SRE_SRE_MATCH_SPAN_METHODDEF \
- {"span", (PyCFunction)_sre_SRE_Match_span, METH_FASTCALL, _sre_SRE_Match_span__doc__},
+ {"span", (PyCFunction)(void(*)(void))_sre_SRE_Match_span, METH_FASTCALL, _sre_SRE_Match_span__doc__},
static PyObject *
_sre_SRE_Match_span_impl(MatchObject *self, PyObject *group);
@@ -765,4 +765,4 @@ _sre_SRE_Scanner_search(ScannerObject *self, PyObject *Py_UNUSED(ignored))
{
return _sre_SRE_Scanner_search_impl(self);
}
-/*[clinic end generated code: output=4b807104b65c1e0e input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5edeca5ec36b5f34 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_ssl.c.h b/Modules/clinic/_ssl.c.h
index 186e6432c2e3..82dc19781140 100644
--- a/Modules/clinic/_ssl.c.h
+++ b/Modules/clinic/_ssl.c.h
@@ -60,7 +60,7 @@ PyDoc_STRVAR(_ssl__SSLSocket_getpeercert__doc__,
"return the certificate even if it wasn\'t validated.");
#define _SSL__SSLSOCKET_GETPEERCERT_METHODDEF \
- {"getpeercert", (PyCFunction)_ssl__SSLSocket_getpeercert, METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
+ {"getpeercert", (PyCFunction)(void(*)(void))_ssl__SSLSocket_getpeercert, METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
static PyObject *
_ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode);
@@ -318,7 +318,7 @@ PyDoc_STRVAR(_ssl__SSLSocket_get_channel_binding__doc__,
"Only \'tls-unique\' channel binding data from RFC 5929 is supported.");
#define _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF \
- {"get_channel_binding", (PyCFunction)_ssl__SSLSocket_get_channel_binding, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
+ {"get_channel_binding", (PyCFunction)(void(*)(void))_ssl__SSLSocket_get_channel_binding, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
static PyObject *
_ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
@@ -500,7 +500,7 @@ PyDoc_STRVAR(_ssl__SSLContext_load_cert_chain__doc__,
"\n");
#define _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF \
- {"load_cert_chain", (PyCFunction)_ssl__SSLContext_load_cert_chain, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
+ {"load_cert_chain", (PyCFunction)(void(*)(void))_ssl__SSLContext_load_cert_chain, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
static PyObject *
_ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
@@ -532,7 +532,7 @@ PyDoc_STRVAR(_ssl__SSLContext_load_verify_locations__doc__,
"\n");
#define _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF \
- {"load_verify_locations", (PyCFunction)_ssl__SSLContext_load_verify_locations, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
+ {"load_verify_locations", (PyCFunction)(void(*)(void))_ssl__SSLContext_load_verify_locations, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
static PyObject *
_ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
@@ -575,7 +575,7 @@ PyDoc_STRVAR(_ssl__SSLContext__wrap_socket__doc__,
"\n");
#define _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF \
- {"_wrap_socket", (PyCFunction)_ssl__SSLContext__wrap_socket, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
+ {"_wrap_socket", (PyCFunction)(void(*)(void))_ssl__SSLContext__wrap_socket, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
static PyObject *
_ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
@@ -611,7 +611,7 @@ PyDoc_STRVAR(_ssl__SSLContext__wrap_bio__doc__,
"\n");
#define _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF \
- {"_wrap_bio", (PyCFunction)_ssl__SSLContext__wrap_bio, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
+ {"_wrap_bio", (PyCFunction)(void(*)(void))_ssl__SSLContext__wrap_bio, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
static PyObject *
_ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
@@ -725,7 +725,7 @@ PyDoc_STRVAR(_ssl__SSLContext_get_ca_certs__doc__,
"been used at least once.");
#define _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF \
- {"get_ca_certs", (PyCFunction)_ssl__SSLContext_get_ca_certs, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
+ {"get_ca_certs", (PyCFunction)(void(*)(void))_ssl__SSLContext_get_ca_certs, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
static PyObject *
_ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form);
@@ -782,7 +782,7 @@ PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__,
"distinguish between the two.");
#define _SSL_MEMORYBIO_READ_METHODDEF \
- {"read", (PyCFunction)_ssl_MemoryBIO_read, METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))_ssl_MemoryBIO_read, METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
static PyObject *
_ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len);
@@ -867,7 +867,7 @@ PyDoc_STRVAR(_ssl_RAND_add__doc__,
"string. See RFC 4086.");
#define _SSL_RAND_ADD_METHODDEF \
- {"RAND_add", (PyCFunction)_ssl_RAND_add, METH_FASTCALL, _ssl_RAND_add__doc__},
+ {"RAND_add", (PyCFunction)(void(*)(void))_ssl_RAND_add, METH_FASTCALL, _ssl_RAND_add__doc__},
static PyObject *
_ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy);
@@ -1036,7 +1036,7 @@ PyDoc_STRVAR(_ssl_txt2obj__doc__,
"long name are also matched.");
#define _SSL_TXT2OBJ_METHODDEF \
- {"txt2obj", (PyCFunction)_ssl_txt2obj, METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
+ {"txt2obj", (PyCFunction)(void(*)(void))_ssl_txt2obj, METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
static PyObject *
_ssl_txt2obj_impl(PyObject *module, const char *txt, int name);
@@ -1102,7 +1102,7 @@ PyDoc_STRVAR(_ssl_enum_certificates__doc__,
"a set of OIDs or the boolean True.");
#define _SSL_ENUM_CERTIFICATES_METHODDEF \
- {"enum_certificates", (PyCFunction)_ssl_enum_certificates, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
+ {"enum_certificates", (PyCFunction)(void(*)(void))_ssl_enum_certificates, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
static PyObject *
_ssl_enum_certificates_impl(PyObject *module, const char *store_name);
@@ -1141,7 +1141,7 @@ PyDoc_STRVAR(_ssl_enum_crls__doc__,
"X509_ASN_ENCODING or PKCS_7_ASN_ENCODING.");
#define _SSL_ENUM_CRLS_METHODDEF \
- {"enum_crls", (PyCFunction)_ssl_enum_crls, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
+ {"enum_crls", (PyCFunction)(void(*)(void))_ssl_enum_crls, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
static PyObject *
_ssl_enum_crls_impl(PyObject *module, const char *store_name);
@@ -1193,4 +1193,4 @@ _ssl_enum_crls(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje
#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]*/
diff --git a/Modules/clinic/_struct.c.h b/Modules/clinic/_struct.c.h
index 2ecadfb1de97..b1fa067bdd3b 100644
--- a/Modules/clinic/_struct.c.h
+++ b/Modules/clinic/_struct.c.h
@@ -85,7 +85,7 @@ PyDoc_STRVAR(Struct_unpack_from__doc__,
"See help(struct) for more on format strings.");
#define STRUCT_UNPACK_FROM_METHODDEF \
- {"unpack_from", (PyCFunction)Struct_unpack_from, METH_FASTCALL|METH_KEYWORDS, Struct_unpack_from__doc__},
+ {"unpack_from", (PyCFunction)(void(*)(void))Struct_unpack_from, METH_FASTCALL|METH_KEYWORDS, Struct_unpack_from__doc__},
static PyObject *
Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
@@ -193,7 +193,7 @@ PyDoc_STRVAR(unpack__doc__,
"See help(struct) for more on format strings.");
#define UNPACK_METHODDEF \
- {"unpack", (PyCFunction)unpack, METH_FASTCALL, unpack__doc__},
+ {"unpack", (PyCFunction)(void(*)(void))unpack, METH_FASTCALL, unpack__doc__},
static PyObject *
unpack_impl(PyObject *module, PyStructObject *s_object, Py_buffer *buffer);
@@ -233,7 +233,7 @@ PyDoc_STRVAR(unpack_from__doc__,
"See help(struct) for more on format strings.");
#define UNPACK_FROM_METHODDEF \
- {"unpack_from", (PyCFunction)unpack_from, METH_FASTCALL|METH_KEYWORDS, unpack_from__doc__},
+ {"unpack_from", (PyCFunction)(void(*)(void))unpack_from, METH_FASTCALL|METH_KEYWORDS, unpack_from__doc__},
static PyObject *
unpack_from_impl(PyObject *module, PyStructObject *s_object,
@@ -278,7 +278,7 @@ PyDoc_STRVAR(iter_unpack__doc__,
"Requires that the bytes length be a multiple of the format struct size.");
#define ITER_UNPACK_METHODDEF \
- {"iter_unpack", (PyCFunction)iter_unpack, METH_FASTCALL, iter_unpack__doc__},
+ {"iter_unpack", (PyCFunction)(void(*)(void))iter_unpack, METH_FASTCALL, iter_unpack__doc__},
static PyObject *
iter_unpack_impl(PyObject *module, PyStructObject *s_object,
@@ -303,4 +303,4 @@ iter_unpack(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
return return_value;
}
-/*[clinic end generated code: output=d79b009652ae0b89 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a73b0453174e4b51 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_tkinter.c.h b/Modules/clinic/_tkinter.c.h
index a9dd73911b81..a09bc2d8ed3a 100644
--- a/Modules/clinic/_tkinter.c.h
+++ b/Modules/clinic/_tkinter.c.h
@@ -256,7 +256,7 @@ PyDoc_STRVAR(_tkinter_tkapp_createcommand__doc__,
"\n");
#define _TKINTER_TKAPP_CREATECOMMAND_METHODDEF \
- {"createcommand", (PyCFunction)_tkinter_tkapp_createcommand, METH_FASTCALL, _tkinter_tkapp_createcommand__doc__},
+ {"createcommand", (PyCFunction)(void(*)(void))_tkinter_tkapp_createcommand, METH_FASTCALL, _tkinter_tkapp_createcommand__doc__},
static PyObject *
_tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
@@ -313,7 +313,7 @@ PyDoc_STRVAR(_tkinter_tkapp_createfilehandler__doc__,
"\n");
#define _TKINTER_TKAPP_CREATEFILEHANDLER_METHODDEF \
- {"createfilehandler", (PyCFunction)_tkinter_tkapp_createfilehandler, METH_FASTCALL, _tkinter_tkapp_createfilehandler__doc__},
+ {"createfilehandler", (PyCFunction)(void(*)(void))_tkinter_tkapp_createfilehandler, METH_FASTCALL, _tkinter_tkapp_createfilehandler__doc__},
static PyObject *
_tkinter_tkapp_createfilehandler_impl(TkappObject *self, PyObject *file,
@@ -374,7 +374,7 @@ PyDoc_STRVAR(_tkinter_tkapp_createtimerhandler__doc__,
"\n");
#define _TKINTER_TKAPP_CREATETIMERHANDLER_METHODDEF \
- {"createtimerhandler", (PyCFunction)_tkinter_tkapp_createtimerhandler, METH_FASTCALL, _tkinter_tkapp_createtimerhandler__doc__},
+ {"createtimerhandler", (PyCFunction)(void(*)(void))_tkinter_tkapp_createtimerhandler, METH_FASTCALL, _tkinter_tkapp_createtimerhandler__doc__},
static PyObject *
_tkinter_tkapp_createtimerhandler_impl(TkappObject *self, int milliseconds,
@@ -403,7 +403,7 @@ PyDoc_STRVAR(_tkinter_tkapp_mainloop__doc__,
"\n");
#define _TKINTER_TKAPP_MAINLOOP_METHODDEF \
- {"mainloop", (PyCFunction)_tkinter_tkapp_mainloop, METH_FASTCALL, _tkinter_tkapp_mainloop__doc__},
+ {"mainloop", (PyCFunction)(void(*)(void))_tkinter_tkapp_mainloop, METH_FASTCALL, _tkinter_tkapp_mainloop__doc__},
static PyObject *
_tkinter_tkapp_mainloop_impl(TkappObject *self, int threshold);
@@ -430,7 +430,7 @@ PyDoc_STRVAR(_tkinter_tkapp_dooneevent__doc__,
"\n");
#define _TKINTER_TKAPP_DOONEEVENT_METHODDEF \
- {"dooneevent", (PyCFunction)_tkinter_tkapp_dooneevent, METH_FASTCALL, _tkinter_tkapp_dooneevent__doc__},
+ {"dooneevent", (PyCFunction)(void(*)(void))_tkinter_tkapp_dooneevent, METH_FASTCALL, _tkinter_tkapp_dooneevent__doc__},
static PyObject *
_tkinter_tkapp_dooneevent_impl(TkappObject *self, int flags);
@@ -543,7 +543,7 @@ PyDoc_STRVAR(_tkinter_create__doc__,
" if not None, then pass -use to wish");
#define _TKINTER_CREATE_METHODDEF \
- {"create", (PyCFunction)_tkinter_create, METH_FASTCALL, _tkinter_create__doc__},
+ {"create", (PyCFunction)(void(*)(void))_tkinter_create, METH_FASTCALL, _tkinter_create__doc__},
static PyObject *
_tkinter_create_impl(PyObject *module, const char *screenName,
@@ -638,4 +638,4 @@ _tkinter_getbusywaitinterval(PyObject *module, PyObject *Py_UNUSED(ignored))
#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]*/
diff --git a/Modules/clinic/_tracemalloc.c.h b/Modules/clinic/_tracemalloc.c.h
index 2ad397072078..aa736ec2fd0c 100644
--- a/Modules/clinic/_tracemalloc.c.h
+++ b/Modules/clinic/_tracemalloc.c.h
@@ -84,7 +84,7 @@ PyDoc_STRVAR(_tracemalloc_start__doc__,
"trace to nframe.");
#define _TRACEMALLOC_START_METHODDEF \
- {"start", (PyCFunction)_tracemalloc_start, METH_FASTCALL, _tracemalloc_start__doc__},
+ {"start", (PyCFunction)(void(*)(void))_tracemalloc_start, METH_FASTCALL, _tracemalloc_start__doc__},
static PyObject *
_tracemalloc_start_impl(PyObject *module, int nframe);
@@ -185,4 +185,4 @@ _tracemalloc_get_traced_memory(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return _tracemalloc_get_traced_memory_impl(module);
}
-/*[clinic end generated code: output=d98afded69c89d52 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d4a2dd3eaba9f72d input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_weakref.c.h b/Modules/clinic/_weakref.c.h
index 1c3aea13ef8d..21f00ffd205c 100644
--- a/Modules/clinic/_weakref.c.h
+++ b/Modules/clinic/_weakref.c.h
@@ -37,7 +37,7 @@ PyDoc_STRVAR(_weakref__remove_dead_weakref__doc__,
"Atomically remove key from dict if it points to a dead weakref.");
#define _WEAKREF__REMOVE_DEAD_WEAKREF_METHODDEF \
- {"_remove_dead_weakref", (PyCFunction)_weakref__remove_dead_weakref, METH_FASTCALL, _weakref__remove_dead_weakref__doc__},
+ {"_remove_dead_weakref", (PyCFunction)(void(*)(void))_weakref__remove_dead_weakref, METH_FASTCALL, _weakref__remove_dead_weakref__doc__},
static PyObject *
_weakref__remove_dead_weakref_impl(PyObject *module, PyObject *dct,
@@ -59,4 +59,4 @@ _weakref__remove_dead_weakref(PyObject *module, PyObject *const *args, Py_ssize_
exit:
return return_value;
}
-/*[clinic end generated code: output=b6a61a4f365a3f0a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=927e889feb8a7dc4 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/_winapi.c.h b/Modules/clinic/_winapi.c.h
index c66522ebab6d..f82b46d7381c 100644
--- a/Modules/clinic/_winapi.c.h
+++ b/Modules/clinic/_winapi.c.h
@@ -95,7 +95,7 @@ PyDoc_STRVAR(_winapi_ConnectNamedPipe__doc__,
"\n");
#define _WINAPI_CONNECTNAMEDPIPE_METHODDEF \
- {"ConnectNamedPipe", (PyCFunction)_winapi_ConnectNamedPipe, METH_FASTCALL|METH_KEYWORDS, _winapi_ConnectNamedPipe__doc__},
+ {"ConnectNamedPipe", (PyCFunction)(void(*)(void))_winapi_ConnectNamedPipe, METH_FASTCALL|METH_KEYWORDS, _winapi_ConnectNamedPipe__doc__},
static PyObject *
_winapi_ConnectNamedPipe_impl(PyObject *module, HANDLE handle,
@@ -128,7 +128,7 @@ PyDoc_STRVAR(_winapi_CreateFile__doc__,
"\n");
#define _WINAPI_CREATEFILE_METHODDEF \
- {"CreateFile", (PyCFunction)_winapi_CreateFile, METH_FASTCALL, _winapi_CreateFile__doc__},
+ {"CreateFile", (PyCFunction)(void(*)(void))_winapi_CreateFile, METH_FASTCALL, _winapi_CreateFile__doc__},
static HANDLE
_winapi_CreateFile_impl(PyObject *module, LPCTSTR file_name,
@@ -173,7 +173,7 @@ PyDoc_STRVAR(_winapi_CreateJunction__doc__,
"\n");
#define _WINAPI_CREATEJUNCTION_METHODDEF \
- {"CreateJunction", (PyCFunction)_winapi_CreateJunction, METH_FASTCALL, _winapi_CreateJunction__doc__},
+ {"CreateJunction", (PyCFunction)(void(*)(void))_winapi_CreateJunction, METH_FASTCALL, _winapi_CreateJunction__doc__},
static PyObject *
_winapi_CreateJunction_impl(PyObject *module, LPWSTR src_path,
@@ -204,7 +204,7 @@ PyDoc_STRVAR(_winapi_CreateNamedPipe__doc__,
"\n");
#define _WINAPI_CREATENAMEDPIPE_METHODDEF \
- {"CreateNamedPipe", (PyCFunction)_winapi_CreateNamedPipe, METH_FASTCALL, _winapi_CreateNamedPipe__doc__},
+ {"CreateNamedPipe", (PyCFunction)(void(*)(void))_winapi_CreateNamedPipe, METH_FASTCALL, _winapi_CreateNamedPipe__doc__},
static HANDLE
_winapi_CreateNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD open_mode,
@@ -256,7 +256,7 @@ PyDoc_STRVAR(_winapi_CreatePipe__doc__,
"Returns a 2-tuple of handles, to the read and write ends of the pipe.");
#define _WINAPI_CREATEPIPE_METHODDEF \
- {"CreatePipe", (PyCFunction)_winapi_CreatePipe, METH_FASTCALL, _winapi_CreatePipe__doc__},
+ {"CreatePipe", (PyCFunction)(void(*)(void))_winapi_CreatePipe, METH_FASTCALL, _winapi_CreatePipe__doc__},
static PyObject *
_winapi_CreatePipe_impl(PyObject *module, PyObject *pipe_attrs, DWORD size);
@@ -295,7 +295,7 @@ PyDoc_STRVAR(_winapi_CreateProcess__doc__,
"process ID, and thread ID.");
#define _WINAPI_CREATEPROCESS_METHODDEF \
- {"CreateProcess", (PyCFunction)_winapi_CreateProcess, METH_FASTCALL, _winapi_CreateProcess__doc__},
+ {"CreateProcess", (PyCFunction)(void(*)(void))_winapi_CreateProcess, METH_FASTCALL, _winapi_CreateProcess__doc__},
static PyObject *
_winapi_CreateProcess_impl(PyObject *module, Py_UNICODE *application_name,
@@ -342,7 +342,7 @@ PyDoc_STRVAR(_winapi_DuplicateHandle__doc__,
"through both handles.");
#define _WINAPI_DUPLICATEHANDLE_METHODDEF \
- {"DuplicateHandle", (PyCFunction)_winapi_DuplicateHandle, METH_FASTCALL, _winapi_DuplicateHandle__doc__},
+ {"DuplicateHandle", (PyCFunction)(void(*)(void))_winapi_DuplicateHandle, METH_FASTCALL, _winapi_DuplicateHandle__doc__},
static HANDLE
_winapi_DuplicateHandle_impl(PyObject *module, HANDLE source_process_handle,
@@ -604,7 +604,7 @@ PyDoc_STRVAR(_winapi_OpenProcess__doc__,
"\n");
#define _WINAPI_OPENPROCESS_METHODDEF \
- {"OpenProcess", (PyCFunction)_winapi_OpenProcess, METH_FASTCALL, _winapi_OpenProcess__doc__},
+ {"OpenProcess", (PyCFunction)(void(*)(void))_winapi_OpenProcess, METH_FASTCALL, _winapi_OpenProcess__doc__},
static HANDLE
_winapi_OpenProcess_impl(PyObject *module, DWORD desired_access,
@@ -642,7 +642,7 @@ PyDoc_STRVAR(_winapi_PeekNamedPipe__doc__,
"\n");
#define _WINAPI_PEEKNAMEDPIPE_METHODDEF \
- {"PeekNamedPipe", (PyCFunction)_winapi_PeekNamedPipe, METH_FASTCALL, _winapi_PeekNamedPipe__doc__},
+ {"PeekNamedPipe", (PyCFunction)(void(*)(void))_winapi_PeekNamedPipe, METH_FASTCALL, _winapi_PeekNamedPipe__doc__},
static PyObject *
_winapi_PeekNamedPipe_impl(PyObject *module, HANDLE handle, int size);
@@ -670,7 +670,7 @@ PyDoc_STRVAR(_winapi_ReadFile__doc__,
"\n");
#define _WINAPI_READFILE_METHODDEF \
- {"ReadFile", (PyCFunction)_winapi_ReadFile, METH_FASTCALL|METH_KEYWORDS, _winapi_ReadFile__doc__},
+ {"ReadFile", (PyCFunction)(void(*)(void))_winapi_ReadFile, METH_FASTCALL|METH_KEYWORDS, _winapi_ReadFile__doc__},
static PyObject *
_winapi_ReadFile_impl(PyObject *module, HANDLE handle, DWORD size,
@@ -703,7 +703,7 @@ PyDoc_STRVAR(_winapi_SetNamedPipeHandleState__doc__,
"\n");
#define _WINAPI_SETNAMEDPIPEHANDLESTATE_METHODDEF \
- {"SetNamedPipeHandleState", (PyCFunction)_winapi_SetNamedPipeHandleState, METH_FASTCALL, _winapi_SetNamedPipeHandleState__doc__},
+ {"SetNamedPipeHandleState", (PyCFunction)(void(*)(void))_winapi_SetNamedPipeHandleState, METH_FASTCALL, _winapi_SetNamedPipeHandleState__doc__},
static PyObject *
_winapi_SetNamedPipeHandleState_impl(PyObject *module, HANDLE named_pipe,
@@ -737,7 +737,7 @@ PyDoc_STRVAR(_winapi_TerminateProcess__doc__,
"Terminate the specified process and all of its threads.");
#define _WINAPI_TERMINATEPROCESS_METHODDEF \
- {"TerminateProcess", (PyCFunction)_winapi_TerminateProcess, METH_FASTCALL, _winapi_TerminateProcess__doc__},
+ {"TerminateProcess", (PyCFunction)(void(*)(void))_winapi_TerminateProcess, METH_FASTCALL, _winapi_TerminateProcess__doc__},
static PyObject *
_winapi_TerminateProcess_impl(PyObject *module, HANDLE handle,
@@ -766,7 +766,7 @@ PyDoc_STRVAR(_winapi_WaitNamedPipe__doc__,
"\n");
#define _WINAPI_WAITNAMEDPIPE_METHODDEF \
- {"WaitNamedPipe", (PyCFunction)_winapi_WaitNamedPipe, METH_FASTCALL, _winapi_WaitNamedPipe__doc__},
+ {"WaitNamedPipe", (PyCFunction)(void(*)(void))_winapi_WaitNamedPipe, METH_FASTCALL, _winapi_WaitNamedPipe__doc__},
static PyObject *
_winapi_WaitNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD timeout);
@@ -795,7 +795,7 @@ PyDoc_STRVAR(_winapi_WaitForMultipleObjects__doc__,
"\n");
#define _WINAPI_WAITFORMULTIPLEOBJECTS_METHODDEF \
- {"WaitForMultipleObjects", (PyCFunction)_winapi_WaitForMultipleObjects, METH_FASTCALL, _winapi_WaitForMultipleObjects__doc__},
+ {"WaitForMultipleObjects", (PyCFunction)(void(*)(void))_winapi_WaitForMultipleObjects, METH_FASTCALL, _winapi_WaitForMultipleObjects__doc__},
static PyObject *
_winapi_WaitForMultipleObjects_impl(PyObject *module, PyObject *handle_seq,
@@ -830,7 +830,7 @@ PyDoc_STRVAR(_winapi_WaitForSingleObject__doc__,
"in milliseconds.");
#define _WINAPI_WAITFORSINGLEOBJECT_METHODDEF \
- {"WaitForSingleObject", (PyCFunction)_winapi_WaitForSingleObject, METH_FASTCALL, _winapi_WaitForSingleObject__doc__},
+ {"WaitForSingleObject", (PyCFunction)(void(*)(void))_winapi_WaitForSingleObject, METH_FASTCALL, _winapi_WaitForSingleObject__doc__},
static long
_winapi_WaitForSingleObject_impl(PyObject *module, HANDLE handle,
@@ -864,7 +864,7 @@ PyDoc_STRVAR(_winapi_WriteFile__doc__,
"\n");
#define _WINAPI_WRITEFILE_METHODDEF \
- {"WriteFile", (PyCFunction)_winapi_WriteFile, METH_FASTCALL|METH_KEYWORDS, _winapi_WriteFile__doc__},
+ {"WriteFile", (PyCFunction)(void(*)(void))_winapi_WriteFile, METH_FASTCALL|METH_KEYWORDS, _winapi_WriteFile__doc__},
static PyObject *
_winapi_WriteFile_impl(PyObject *module, HANDLE handle, PyObject *buffer,
@@ -914,7 +914,7 @@ PyDoc_STRVAR(_winapi_GetFileType__doc__,
"\n");
#define _WINAPI_GETFILETYPE_METHODDEF \
- {"GetFileType", (PyCFunction)_winapi_GetFileType, METH_FASTCALL|METH_KEYWORDS, _winapi_GetFileType__doc__},
+ {"GetFileType", (PyCFunction)(void(*)(void))_winapi_GetFileType, METH_FASTCALL|METH_KEYWORDS, _winapi_GetFileType__doc__},
static DWORD
_winapi_GetFileType_impl(PyObject *module, HANDLE handle);
@@ -941,4 +941,4 @@ _winapi_GetFileType(PyObject *module, PyObject *const *args, Py_ssize_t nargs, P
exit:
return return_value;
}
-/*[clinic end generated code: output=baaf3d379b91be0a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=915dd640329de0c0 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/arraymodule.c.h b/Modules/clinic/arraymodule.c.h
index b03a507914a8..aa9938868f41 100644
--- a/Modules/clinic/arraymodule.c.h
+++ b/Modules/clinic/arraymodule.c.h
@@ -65,7 +65,7 @@ PyDoc_STRVAR(array_array_pop__doc__,
"i defaults to -1.");
#define ARRAY_ARRAY_POP_METHODDEF \
- {"pop", (PyCFunction)array_array_pop, METH_FASTCALL, array_array_pop__doc__},
+ {"pop", (PyCFunction)(void(*)(void))array_array_pop, METH_FASTCALL, array_array_pop__doc__},
static PyObject *
array_array_pop_impl(arrayobject *self, Py_ssize_t i);
@@ -102,7 +102,7 @@ PyDoc_STRVAR(array_array_insert__doc__,
"Insert a new item v into the array before position i.");
#define ARRAY_ARRAY_INSERT_METHODDEF \
- {"insert", (PyCFunction)array_array_insert, METH_FASTCALL, array_array_insert__doc__},
+ {"insert", (PyCFunction)(void(*)(void))array_array_insert, METH_FASTCALL, array_array_insert__doc__},
static PyObject *
array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v);
@@ -200,7 +200,7 @@ PyDoc_STRVAR(array_array_fromfile__doc__,
"Read n objects from the file object f and append them to the end of the array.");
#define ARRAY_ARRAY_FROMFILE_METHODDEF \
- {"fromfile", (PyCFunction)array_array_fromfile, METH_FASTCALL, array_array_fromfile__doc__},
+ {"fromfile", (PyCFunction)(void(*)(void))array_array_fromfile, METH_FASTCALL, array_array_fromfile__doc__},
static PyObject *
array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n);
@@ -443,7 +443,7 @@ PyDoc_STRVAR(array__array_reconstructor__doc__,
"Internal. Used for pickling support.");
#define ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF \
- {"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_FASTCALL, array__array_reconstructor__doc__},
+ {"_array_reconstructor", (PyCFunction)(void(*)(void))array__array_reconstructor, METH_FASTCALL, array__array_reconstructor__doc__},
static PyObject *
array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
@@ -505,4 +505,4 @@ PyDoc_STRVAR(array_arrayiterator___setstate____doc__,
#define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF \
{"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__},
-/*[clinic end generated code: output=1289bde2a095a712 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3a4c6f3deb597bfd input=a9049054013a1b77]*/
diff --git a/Modules/clinic/audioop.c.h b/Modules/clinic/audioop.c.h
index cc8d818e1d8d..1eae9aaf5d80 100644
--- a/Modules/clinic/audioop.c.h
+++ b/Modules/clinic/audioop.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(audioop_getsample__doc__,
"Return the value of sample index from the fragment.");
#define AUDIOOP_GETSAMPLE_METHODDEF \
- {"getsample", (PyCFunction)audioop_getsample, METH_FASTCALL, audioop_getsample__doc__},
+ {"getsample", (PyCFunction)(void(*)(void))audioop_getsample, METH_FASTCALL, audioop_getsample__doc__},
static PyObject *
audioop_getsample_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -45,7 +45,7 @@ PyDoc_STRVAR(audioop_max__doc__,
"Return the maximum of the absolute value of all samples in a fragment.");
#define AUDIOOP_MAX_METHODDEF \
- {"max", (PyCFunction)audioop_max, METH_FASTCALL, audioop_max__doc__},
+ {"max", (PyCFunction)(void(*)(void))audioop_max, METH_FASTCALL, audioop_max__doc__},
static PyObject *
audioop_max_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -79,7 +79,7 @@ PyDoc_STRVAR(audioop_minmax__doc__,
"Return the minimum and maximum values of all samples in the sound fragment.");
#define AUDIOOP_MINMAX_METHODDEF \
- {"minmax", (PyCFunction)audioop_minmax, METH_FASTCALL, audioop_minmax__doc__},
+ {"minmax", (PyCFunction)(void(*)(void))audioop_minmax, METH_FASTCALL, audioop_minmax__doc__},
static PyObject *
audioop_minmax_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -113,7 +113,7 @@ PyDoc_STRVAR(audioop_avg__doc__,
"Return the average over all samples in the fragment.");
#define AUDIOOP_AVG_METHODDEF \
- {"avg", (PyCFunction)audioop_avg, METH_FASTCALL, audioop_avg__doc__},
+ {"avg", (PyCFunction)(void(*)(void))audioop_avg, METH_FASTCALL, audioop_avg__doc__},
static PyObject *
audioop_avg_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -147,7 +147,7 @@ PyDoc_STRVAR(audioop_rms__doc__,
"Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n).");
#define AUDIOOP_RMS_METHODDEF \
- {"rms", (PyCFunction)audioop_rms, METH_FASTCALL, audioop_rms__doc__},
+ {"rms", (PyCFunction)(void(*)(void))audioop_rms, METH_FASTCALL, audioop_rms__doc__},
static PyObject *
audioop_rms_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -181,7 +181,7 @@ PyDoc_STRVAR(audioop_findfit__doc__,
"Try to match reference as well as possible to a portion of fragment.");
#define AUDIOOP_FINDFIT_METHODDEF \
- {"findfit", (PyCFunction)audioop_findfit, METH_FASTCALL, audioop_findfit__doc__},
+ {"findfit", (PyCFunction)(void(*)(void))audioop_findfit, METH_FASTCALL, audioop_findfit__doc__},
static PyObject *
audioop_findfit_impl(PyObject *module, Py_buffer *fragment,
@@ -220,7 +220,7 @@ PyDoc_STRVAR(audioop_findfactor__doc__,
"Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal.");
#define AUDIOOP_FINDFACTOR_METHODDEF \
- {"findfactor", (PyCFunction)audioop_findfactor, METH_FASTCALL, audioop_findfactor__doc__},
+ {"findfactor", (PyCFunction)(void(*)(void))audioop_findfactor, METH_FASTCALL, audioop_findfactor__doc__},
static PyObject *
audioop_findfactor_impl(PyObject *module, Py_buffer *fragment,
@@ -259,7 +259,7 @@ PyDoc_STRVAR(audioop_findmax__doc__,
"Search fragment for a slice of specified number of samples with maximum energy.");
#define AUDIOOP_FINDMAX_METHODDEF \
- {"findmax", (PyCFunction)audioop_findmax, METH_FASTCALL, audioop_findmax__doc__},
+ {"findmax", (PyCFunction)(void(*)(void))audioop_findmax, METH_FASTCALL, audioop_findmax__doc__},
static PyObject *
audioop_findmax_impl(PyObject *module, Py_buffer *fragment,
@@ -294,7 +294,7 @@ PyDoc_STRVAR(audioop_avgpp__doc__,
"Return the average peak-peak value over all samples in the fragment.");
#define AUDIOOP_AVGPP_METHODDEF \
- {"avgpp", (PyCFunction)audioop_avgpp, METH_FASTCALL, audioop_avgpp__doc__},
+ {"avgpp", (PyCFunction)(void(*)(void))audioop_avgpp, METH_FASTCALL, audioop_avgpp__doc__},
static PyObject *
audioop_avgpp_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -328,7 +328,7 @@ PyDoc_STRVAR(audioop_maxpp__doc__,
"Return the maximum peak-peak value in the sound fragment.");
#define AUDIOOP_MAXPP_METHODDEF \
- {"maxpp", (PyCFunction)audioop_maxpp, METH_FASTCALL, audioop_maxpp__doc__},
+ {"maxpp", (PyCFunction)(void(*)(void))audioop_maxpp, METH_FASTCALL, audioop_maxpp__doc__},
static PyObject *
audioop_maxpp_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -362,7 +362,7 @@ PyDoc_STRVAR(audioop_cross__doc__,
"Return the number of zero crossings in the fragment passed as an argument.");
#define AUDIOOP_CROSS_METHODDEF \
- {"cross", (PyCFunction)audioop_cross, METH_FASTCALL, audioop_cross__doc__},
+ {"cross", (PyCFunction)(void(*)(void))audioop_cross, METH_FASTCALL, audioop_cross__doc__},
static PyObject *
audioop_cross_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -396,7 +396,7 @@ PyDoc_STRVAR(audioop_mul__doc__,
"Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor.");
#define AUDIOOP_MUL_METHODDEF \
- {"mul", (PyCFunction)audioop_mul, METH_FASTCALL, audioop_mul__doc__},
+ {"mul", (PyCFunction)(void(*)(void))audioop_mul, METH_FASTCALL, audioop_mul__doc__},
static PyObject *
audioop_mul_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -432,7 +432,7 @@ PyDoc_STRVAR(audioop_tomono__doc__,
"Convert a stereo fragment to a mono fragment.");
#define AUDIOOP_TOMONO_METHODDEF \
- {"tomono", (PyCFunction)audioop_tomono, METH_FASTCALL, audioop_tomono__doc__},
+ {"tomono", (PyCFunction)(void(*)(void))audioop_tomono, METH_FASTCALL, audioop_tomono__doc__},
static PyObject *
audioop_tomono_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -469,7 +469,7 @@ PyDoc_STRVAR(audioop_tostereo__doc__,
"Generate a stereo fragment from a mono fragment.");
#define AUDIOOP_TOSTEREO_METHODDEF \
- {"tostereo", (PyCFunction)audioop_tostereo, METH_FASTCALL, audioop_tostereo__doc__},
+ {"tostereo", (PyCFunction)(void(*)(void))audioop_tostereo, METH_FASTCALL, audioop_tostereo__doc__},
static PyObject *
audioop_tostereo_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -506,7 +506,7 @@ PyDoc_STRVAR(audioop_add__doc__,
"Return a fragment which is the addition of the two samples passed as parameters.");
#define AUDIOOP_ADD_METHODDEF \
- {"add", (PyCFunction)audioop_add, METH_FASTCALL, audioop_add__doc__},
+ {"add", (PyCFunction)(void(*)(void))audioop_add, METH_FASTCALL, audioop_add__doc__},
static PyObject *
audioop_add_impl(PyObject *module, Py_buffer *fragment1,
@@ -546,7 +546,7 @@ PyDoc_STRVAR(audioop_bias__doc__,
"Return a fragment that is the original fragment with a bias added to each sample.");
#define AUDIOOP_BIAS_METHODDEF \
- {"bias", (PyCFunction)audioop_bias, METH_FASTCALL, audioop_bias__doc__},
+ {"bias", (PyCFunction)(void(*)(void))audioop_bias, METH_FASTCALL, audioop_bias__doc__},
static PyObject *
audioop_bias_impl(PyObject *module, Py_buffer *fragment, int width, int bias);
@@ -581,7 +581,7 @@ PyDoc_STRVAR(audioop_reverse__doc__,
"Reverse the samples in a fragment and returns the modified fragment.");
#define AUDIOOP_REVERSE_METHODDEF \
- {"reverse", (PyCFunction)audioop_reverse, METH_FASTCALL, audioop_reverse__doc__},
+ {"reverse", (PyCFunction)(void(*)(void))audioop_reverse, METH_FASTCALL, audioop_reverse__doc__},
static PyObject *
audioop_reverse_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -615,7 +615,7 @@ PyDoc_STRVAR(audioop_byteswap__doc__,
"Convert big-endian samples to little-endian and vice versa.");
#define AUDIOOP_BYTESWAP_METHODDEF \
- {"byteswap", (PyCFunction)audioop_byteswap, METH_FASTCALL, audioop_byteswap__doc__},
+ {"byteswap", (PyCFunction)(void(*)(void))audioop_byteswap, METH_FASTCALL, audioop_byteswap__doc__},
static PyObject *
audioop_byteswap_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -649,7 +649,7 @@ PyDoc_STRVAR(audioop_lin2lin__doc__,
"Convert samples between 1-, 2-, 3- and 4-byte formats.");
#define AUDIOOP_LIN2LIN_METHODDEF \
- {"lin2lin", (PyCFunction)audioop_lin2lin, METH_FASTCALL, audioop_lin2lin__doc__},
+ {"lin2lin", (PyCFunction)(void(*)(void))audioop_lin2lin, METH_FASTCALL, audioop_lin2lin__doc__},
static PyObject *
audioop_lin2lin_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -686,7 +686,7 @@ PyDoc_STRVAR(audioop_ratecv__doc__,
"Convert the frame rate of the input fragment.");
#define AUDIOOP_RATECV_METHODDEF \
- {"ratecv", (PyCFunction)audioop_ratecv, METH_FASTCALL, audioop_ratecv__doc__},
+ {"ratecv", (PyCFunction)(void(*)(void))audioop_ratecv, METH_FASTCALL, audioop_ratecv__doc__},
static PyObject *
audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -728,7 +728,7 @@ PyDoc_STRVAR(audioop_lin2ulaw__doc__,
"Convert samples in the audio fragment to u-LAW encoding.");
#define AUDIOOP_LIN2ULAW_METHODDEF \
- {"lin2ulaw", (PyCFunction)audioop_lin2ulaw, METH_FASTCALL, audioop_lin2ulaw__doc__},
+ {"lin2ulaw", (PyCFunction)(void(*)(void))audioop_lin2ulaw, METH_FASTCALL, audioop_lin2ulaw__doc__},
static PyObject *
audioop_lin2ulaw_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -762,7 +762,7 @@ PyDoc_STRVAR(audioop_ulaw2lin__doc__,
"Convert sound fragments in u-LAW encoding to linearly encoded sound fragments.");
#define AUDIOOP_ULAW2LIN_METHODDEF \
- {"ulaw2lin", (PyCFunction)audioop_ulaw2lin, METH_FASTCALL, audioop_ulaw2lin__doc__},
+ {"ulaw2lin", (PyCFunction)(void(*)(void))audioop_ulaw2lin, METH_FASTCALL, audioop_ulaw2lin__doc__},
static PyObject *
audioop_ulaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -796,7 +796,7 @@ PyDoc_STRVAR(audioop_lin2alaw__doc__,
"Convert samples in the audio fragment to a-LAW encoding.");
#define AUDIOOP_LIN2ALAW_METHODDEF \
- {"lin2alaw", (PyCFunction)audioop_lin2alaw, METH_FASTCALL, audioop_lin2alaw__doc__},
+ {"lin2alaw", (PyCFunction)(void(*)(void))audioop_lin2alaw, METH_FASTCALL, audioop_lin2alaw__doc__},
static PyObject *
audioop_lin2alaw_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -830,7 +830,7 @@ PyDoc_STRVAR(audioop_alaw2lin__doc__,
"Convert sound fragments in a-LAW encoding to linearly encoded sound fragments.");
#define AUDIOOP_ALAW2LIN_METHODDEF \
- {"alaw2lin", (PyCFunction)audioop_alaw2lin, METH_FASTCALL, audioop_alaw2lin__doc__},
+ {"alaw2lin", (PyCFunction)(void(*)(void))audioop_alaw2lin, METH_FASTCALL, audioop_alaw2lin__doc__},
static PyObject *
audioop_alaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
@@ -864,7 +864,7 @@ PyDoc_STRVAR(audioop_lin2adpcm__doc__,
"Convert samples to 4 bit Intel/DVI ADPCM encoding.");
#define AUDIOOP_LIN2ADPCM_METHODDEF \
- {"lin2adpcm", (PyCFunction)audioop_lin2adpcm, METH_FASTCALL, audioop_lin2adpcm__doc__},
+ {"lin2adpcm", (PyCFunction)(void(*)(void))audioop_lin2adpcm, METH_FASTCALL, audioop_lin2adpcm__doc__},
static PyObject *
audioop_lin2adpcm_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -900,7 +900,7 @@ PyDoc_STRVAR(audioop_adpcm2lin__doc__,
"Decode an Intel/DVI ADPCM coded fragment to a linear fragment.");
#define AUDIOOP_ADPCM2LIN_METHODDEF \
- {"adpcm2lin", (PyCFunction)audioop_adpcm2lin, METH_FASTCALL, audioop_adpcm2lin__doc__},
+ {"adpcm2lin", (PyCFunction)(void(*)(void))audioop_adpcm2lin, METH_FASTCALL, audioop_adpcm2lin__doc__},
static PyObject *
audioop_adpcm2lin_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -928,4 +928,4 @@ audioop_adpcm2lin(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
return return_value;
}
-/*[clinic end generated code: output=2f88b8827ee0aa9b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d197b1559196a48a input=a9049054013a1b77]*/
diff --git a/Modules/clinic/binascii.c.h b/Modules/clinic/binascii.c.h
index 8099cbd4cce6..07ab24c2f7f4 100644
--- a/Modules/clinic/binascii.c.h
+++ b/Modules/clinic/binascii.c.h
@@ -40,7 +40,7 @@ PyDoc_STRVAR(binascii_b2a_uu__doc__,
"Uuencode line of data.");
#define BINASCII_B2A_UU_METHODDEF \
- {"b2a_uu", (PyCFunction)binascii_b2a_uu, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
+ {"b2a_uu", (PyCFunction)(void(*)(void))binascii_b2a_uu, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_uu__doc__},
static PyObject *
binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick);
@@ -107,7 +107,7 @@ PyDoc_STRVAR(binascii_b2a_base64__doc__,
"Base64-code line of data.");
#define BINASCII_B2A_BASE64_METHODDEF \
- {"b2a_base64", (PyCFunction)binascii_b2a_base64, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
+ {"b2a_base64", (PyCFunction)(void(*)(void))binascii_b2a_base64, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_base64__doc__},
static PyObject *
binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline);
@@ -270,7 +270,7 @@ PyDoc_STRVAR(binascii_crc_hqx__doc__,
"Compute CRC-CCITT incrementally.");
#define BINASCII_CRC_HQX_METHODDEF \
- {"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
+ {"crc_hqx", (PyCFunction)(void(*)(void))binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
static unsigned int
binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
@@ -309,7 +309,7 @@ PyDoc_STRVAR(binascii_crc32__doc__,
"Compute CRC-32 incrementally.");
#define BINASCII_CRC32_METHODDEF \
- {"crc32", (PyCFunction)binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
+ {"crc32", (PyCFunction)(void(*)(void))binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
static unsigned int
binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
@@ -484,7 +484,7 @@ PyDoc_STRVAR(binascii_a2b_qp__doc__,
"Decode a string of qp-encoded data.");
#define BINASCII_A2B_QP_METHODDEF \
- {"a2b_qp", (PyCFunction)binascii_a2b_qp, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
+ {"a2b_qp", (PyCFunction)(void(*)(void))binascii_a2b_qp, METH_FASTCALL|METH_KEYWORDS, binascii_a2b_qp__doc__},
static PyObject *
binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header);
@@ -523,7 +523,7 @@ PyDoc_STRVAR(binascii_b2a_qp__doc__,
"are both encoded. When quotetabs is set, space and tabs are encoded.");
#define BINASCII_B2A_QP_METHODDEF \
- {"b2a_qp", (PyCFunction)binascii_b2a_qp, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
+ {"b2a_qp", (PyCFunction)(void(*)(void))binascii_b2a_qp, METH_FASTCALL|METH_KEYWORDS, binascii_b2a_qp__doc__},
static PyObject *
binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs,
@@ -554,4 +554,4 @@ binascii_b2a_qp(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObj
return return_value;
}
-/*[clinic end generated code: output=815f1c453fd6568f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3f45e15ce8b563b7 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/cmathmodule.c.h b/Modules/clinic/cmathmodule.c.h
index 9b3c62eeb7a4..021c87df4e3c 100644
--- a/Modules/clinic/cmathmodule.c.h
+++ b/Modules/clinic/cmathmodule.c.h
@@ -641,7 +641,7 @@ PyDoc_STRVAR(cmath_log__doc__,
"If the base not specified, returns the natural logarithm (base e) of z.");
#define CMATH_LOG_METHODDEF \
- {"log", (PyCFunction)cmath_log, METH_FASTCALL, cmath_log__doc__},
+ {"log", (PyCFunction)(void(*)(void))cmath_log, METH_FASTCALL, cmath_log__doc__},
static PyObject *
cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj);
@@ -726,7 +726,7 @@ PyDoc_STRVAR(cmath_rect__doc__,
"Convert from polar coordinates to rectangular coordinates.");
#define CMATH_RECT_METHODDEF \
- {"rect", (PyCFunction)cmath_rect, METH_FASTCALL, cmath_rect__doc__},
+ {"rect", (PyCFunction)(void(*)(void))cmath_rect, METH_FASTCALL, cmath_rect__doc__},
static PyObject *
cmath_rect_impl(PyObject *module, double r, double phi);
@@ -851,7 +851,7 @@ PyDoc_STRVAR(cmath_isclose__doc__,
"not close to anything, even itself. inf and -inf are only close to themselves.");
#define CMATH_ISCLOSE_METHODDEF \
- {"isclose", (PyCFunction)cmath_isclose, METH_FASTCALL|METH_KEYWORDS, cmath_isclose__doc__},
+ {"isclose", (PyCFunction)(void(*)(void))cmath_isclose, METH_FASTCALL|METH_KEYWORDS, cmath_isclose__doc__},
static int
cmath_isclose_impl(PyObject *module, Py_complex a, Py_complex b,
@@ -882,4 +882,4 @@ cmath_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec
exit:
return return_value;
}
-/*[clinic end generated code: output=dd93c3a6aeb42ebb input=a9049054013a1b77]*/
+/*[clinic end generated code: output=17f6f65a229b1ef9 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/fcntlmodule.c.h b/Modules/clinic/fcntlmodule.c.h
index f61c526a958c..7b5a280045cc 100644
--- a/Modules/clinic/fcntlmodule.c.h
+++ b/Modules/clinic/fcntlmodule.c.h
@@ -19,7 +19,7 @@ PyDoc_STRVAR(fcntl_fcntl__doc__,
"corresponding to the return value of the fcntl call in the C code.");
#define FCNTL_FCNTL_METHODDEF \
- {"fcntl", (PyCFunction)fcntl_fcntl, METH_FASTCALL, fcntl_fcntl__doc__},
+ {"fcntl", (PyCFunction)(void(*)(void))fcntl_fcntl, METH_FASTCALL, fcntl_fcntl__doc__},
static PyObject *
fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg);
@@ -76,7 +76,7 @@ PyDoc_STRVAR(fcntl_ioctl__doc__,
"code.");
#define FCNTL_IOCTL_METHODDEF \
- {"ioctl", (PyCFunction)fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
+ {"ioctl", (PyCFunction)(void(*)(void))fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
static PyObject *
fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,
@@ -111,7 +111,7 @@ PyDoc_STRVAR(fcntl_flock__doc__,
"function is emulated using fcntl()).");
#define FCNTL_FLOCK_METHODDEF \
- {"flock", (PyCFunction)fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
+ {"flock", (PyCFunction)(void(*)(void))fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
static PyObject *
fcntl_flock_impl(PyObject *module, int fd, int code);
@@ -161,7 +161,7 @@ PyDoc_STRVAR(fcntl_lockf__doc__,
" 2 - relative to the end of the file (SEEK_END)");
#define FCNTL_LOCKF_METHODDEF \
- {"lockf", (PyCFunction)fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
+ {"lockf", (PyCFunction)(void(*)(void))fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
static PyObject *
fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
@@ -186,4 +186,4 @@ fcntl_lockf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=2f6e70ae67ec8ac9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fc1a781750750a14 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/gcmodule.c.h b/Modules/clinic/gcmodule.c.h
index 0330c8113bcc..1c4be667da5a 100644
--- a/Modules/clinic/gcmodule.c.h
+++ b/Modules/clinic/gcmodule.c.h
@@ -79,7 +79,7 @@ PyDoc_STRVAR(gc_collect__doc__,
"The number of unreachable objects is returned.");
#define GC_COLLECT_METHODDEF \
- {"collect", (PyCFunction)gc_collect, METH_FASTCALL|METH_KEYWORDS, gc_collect__doc__},
+ {"collect", (PyCFunction)(void(*)(void))gc_collect, METH_FASTCALL|METH_KEYWORDS, gc_collect__doc__},
static Py_ssize_t
gc_collect_impl(PyObject *module, int generation);
@@ -325,4 +325,4 @@ gc_get_freeze_count(PyObject *module, PyObject *Py_UNUSED(ignored))
exit:
return return_value;
}
-/*[clinic end generated code: output=21dc9270b10b7891 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ba67a1ab58780485 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/grpmodule.c.h b/Modules/clinic/grpmodule.c.h
index bb51b8a53ab4..c2e54c94e063 100644
--- a/Modules/clinic/grpmodule.c.h
+++ b/Modules/clinic/grpmodule.c.h
@@ -11,7 +11,7 @@ PyDoc_STRVAR(grp_getgrgid__doc__,
"If id is not valid, raise KeyError.");
#define GRP_GETGRGID_METHODDEF \
- {"getgrgid", (PyCFunction)grp_getgrgid, METH_FASTCALL|METH_KEYWORDS, grp_getgrgid__doc__},
+ {"getgrgid", (PyCFunction)(void(*)(void))grp_getgrgid, METH_FASTCALL|METH_KEYWORDS, grp_getgrgid__doc__},
static PyObject *
grp_getgrgid_impl(PyObject *module, PyObject *id);
@@ -43,7 +43,7 @@ PyDoc_STRVAR(grp_getgrnam__doc__,
"If name is not valid, raise KeyError.");
#define GRP_GETGRNAM_METHODDEF \
- {"getgrnam", (PyCFunction)grp_getgrnam, METH_FASTCALL|METH_KEYWORDS, grp_getgrnam__doc__},
+ {"getgrnam", (PyCFunction)(void(*)(void))grp_getgrnam, METH_FASTCALL|METH_KEYWORDS, grp_getgrnam__doc__},
static PyObject *
grp_getgrnam_impl(PyObject *module, PyObject *name);
@@ -86,4 +86,4 @@ grp_getgrall(PyObject *module, PyObject *Py_UNUSED(ignored))
{
return grp_getgrall_impl(module);
}
-/*[clinic end generated code: output=0ccba09e8ec14c81 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ab10233f6015bc0a input=a9049054013a1b77]*/
diff --git a/Modules/clinic/itertoolsmodule.c.h b/Modules/clinic/itertoolsmodule.c.h
index 476adc1f5c5d..b7d70a3492d3 100644
--- a/Modules/clinic/itertoolsmodule.c.h
+++ b/Modules/clinic/itertoolsmodule.c.h
@@ -131,7 +131,7 @@ PyDoc_STRVAR(itertools_tee__doc__,
"Returns a tuple of n independent iterators.");
#define ITERTOOLS_TEE_METHODDEF \
- {"tee", (PyCFunction)itertools_tee, METH_FASTCALL, itertools_tee__doc__},
+ {"tee", (PyCFunction)(void(*)(void))itertools_tee, METH_FASTCALL, itertools_tee__doc__},
static PyObject *
itertools_tee_impl(PyObject *module, PyObject *iterable, Py_ssize_t n);
@@ -510,4 +510,4 @@ itertools_count(PyTypeObject *type, PyObject *args, PyObject *kwargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=c8c47b766deeffc3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=916251f891fa84b9 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/mathmodule.c.h b/Modules/clinic/mathmodule.c.h
index b40a227dbea5..c8d80296f7b6 100644
--- a/Modules/clinic/mathmodule.c.h
+++ b/Modules/clinic/mathmodule.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(math_gcd__doc__,
"greatest common divisor of x and y");
#define MATH_GCD_METHODDEF \
- {"gcd", (PyCFunction)math_gcd, METH_FASTCALL, math_gcd__doc__},
+ {"gcd", (PyCFunction)(void(*)(void))math_gcd, METH_FASTCALL, math_gcd__doc__},
static PyObject *
math_gcd_impl(PyObject *module, PyObject *a, PyObject *b);
@@ -126,7 +126,7 @@ PyDoc_STRVAR(math_ldexp__doc__,
"This is essentially the inverse of frexp().");
#define MATH_LDEXP_METHODDEF \
- {"ldexp", (PyCFunction)math_ldexp, METH_FASTCALL, math_ldexp__doc__},
+ {"ldexp", (PyCFunction)(void(*)(void))math_ldexp, METH_FASTCALL, math_ldexp__doc__},
static PyObject *
math_ldexp_impl(PyObject *module, double x, PyObject *i);
@@ -247,7 +247,7 @@ PyDoc_STRVAR(math_fmod__doc__,
"x % y may differ.");
#define MATH_FMOD_METHODDEF \
- {"fmod", (PyCFunction)math_fmod, METH_FASTCALL, math_fmod__doc__},
+ {"fmod", (PyCFunction)(void(*)(void))math_fmod, METH_FASTCALL, math_fmod__doc__},
static PyObject *
math_fmod_impl(PyObject *module, double x, double y);
@@ -282,7 +282,7 @@ PyDoc_STRVAR(math_dist__doc__,
" sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))");
#define MATH_DIST_METHODDEF \
- {"dist", (PyCFunction)math_dist, METH_FASTCALL, math_dist__doc__},
+ {"dist", (PyCFunction)(void(*)(void))math_dist, METH_FASTCALL, math_dist__doc__},
static PyObject *
math_dist_impl(PyObject *module, PyObject *p, PyObject *q);
@@ -312,7 +312,7 @@ PyDoc_STRVAR(math_pow__doc__,
"Return x**y (x to the power of y).");
#define MATH_POW_METHODDEF \
- {"pow", (PyCFunction)math_pow, METH_FASTCALL, math_pow__doc__},
+ {"pow", (PyCFunction)(void(*)(void))math_pow, METH_FASTCALL, math_pow__doc__},
static PyObject *
math_pow_impl(PyObject *module, double x, double y);
@@ -492,7 +492,7 @@ PyDoc_STRVAR(math_isclose__doc__,
"only close to themselves.");
#define MATH_ISCLOSE_METHODDEF \
- {"isclose", (PyCFunction)math_isclose, METH_FASTCALL|METH_KEYWORDS, math_isclose__doc__},
+ {"isclose", (PyCFunction)(void(*)(void))math_isclose, METH_FASTCALL|METH_KEYWORDS, math_isclose__doc__},
static int
math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
@@ -523,4 +523,4 @@ math_isclose(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject
exit:
return return_value;
}
-/*[clinic end generated code: output=239c51a5acefbafb input=a9049054013a1b77]*/
+/*[clinic end generated code: output=8b1709a71e5fb855 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/md5module.c.h b/Modules/clinic/md5module.c.h
index fa1a0d68e834..67cb48c08473 100644
--- a/Modules/clinic/md5module.c.h
+++ b/Modules/clinic/md5module.c.h
@@ -72,7 +72,7 @@ PyDoc_STRVAR(_md5_md5__doc__,
"Return a new MD5 hash object; optionally initialized with a string.");
#define _MD5_MD5_METHODDEF \
- {"md5", (PyCFunction)_md5_md5, METH_FASTCALL|METH_KEYWORDS, _md5_md5__doc__},
+ {"md5", (PyCFunction)(void(*)(void))_md5_md5, METH_FASTCALL|METH_KEYWORDS, _md5_md5__doc__},
static PyObject *
_md5_md5_impl(PyObject *module, PyObject *string);
@@ -94,4 +94,4 @@ _md5_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kw
exit:
return return_value;
}
-/*[clinic end generated code: output=72aa003c308e26cf input=a9049054013a1b77]*/
+/*[clinic end generated code: output=83cb1aef575f13bc input=a9049054013a1b77]*/
diff --git a/Modules/clinic/posixmodule.c.h b/Modules/clinic/posixmodule.c.h
index 56010f408ccf..80690703ee2c 100644
--- a/Modules/clinic/posixmodule.c.h
+++ b/Modules/clinic/posixmodule.c.h
@@ -28,7 +28,7 @@ PyDoc_STRVAR(os_stat__doc__,
" an open file descriptor.");
#define OS_STAT_METHODDEF \
- {"stat", (PyCFunction)os_stat, METH_FASTCALL|METH_KEYWORDS, os_stat__doc__},
+ {"stat", (PyCFunction)(void(*)(void))os_stat, METH_FASTCALL|METH_KEYWORDS, os_stat__doc__},
static PyObject *
os_stat_impl(PyObject *module, path_t *path, int dir_fd, int follow_symlinks);
@@ -66,7 +66,7 @@ PyDoc_STRVAR(os_lstat__doc__,
"Equivalent to stat(path, follow_symlinks=False).");
#define OS_LSTAT_METHODDEF \
- {"lstat", (PyCFunction)os_lstat, METH_FASTCALL|METH_KEYWORDS, os_lstat__doc__},
+ {"lstat", (PyCFunction)(void(*)(void))os_lstat, METH_FASTCALL|METH_KEYWORDS, os_lstat__doc__},
static PyObject *
os_lstat_impl(PyObject *module, path_t *path, int dir_fd);
@@ -126,7 +126,7 @@ PyDoc_STRVAR(os_access__doc__,
" has the specified access to the path.");
#define OS_ACCESS_METHODDEF \
- {"access", (PyCFunction)os_access, METH_FASTCALL|METH_KEYWORDS, os_access__doc__},
+ {"access", (PyCFunction)(void(*)(void))os_access, METH_FASTCALL|METH_KEYWORDS, os_access__doc__},
static int
os_access_impl(PyObject *module, path_t *path, int mode, int dir_fd,
@@ -234,7 +234,7 @@ PyDoc_STRVAR(os_chdir__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_CHDIR_METHODDEF \
- {"chdir", (PyCFunction)os_chdir, METH_FASTCALL|METH_KEYWORDS, os_chdir__doc__},
+ {"chdir", (PyCFunction)(void(*)(void))os_chdir, METH_FASTCALL|METH_KEYWORDS, os_chdir__doc__},
static PyObject *
os_chdir_impl(PyObject *module, path_t *path);
@@ -272,7 +272,7 @@ PyDoc_STRVAR(os_fchdir__doc__,
"Equivalent to os.chdir(fd).");
#define OS_FCHDIR_METHODDEF \
- {"fchdir", (PyCFunction)os_fchdir, METH_FASTCALL|METH_KEYWORDS, os_fchdir__doc__},
+ {"fchdir", (PyCFunction)(void(*)(void))os_fchdir, METH_FASTCALL|METH_KEYWORDS, os_fchdir__doc__},
static PyObject *
os_fchdir_impl(PyObject *module, int fd);
@@ -324,7 +324,7 @@ PyDoc_STRVAR(os_chmod__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_CHMOD_METHODDEF \
- {"chmod", (PyCFunction)os_chmod, METH_FASTCALL|METH_KEYWORDS, os_chmod__doc__},
+ {"chmod", (PyCFunction)(void(*)(void))os_chmod, METH_FASTCALL|METH_KEYWORDS, os_chmod__doc__},
static PyObject *
os_chmod_impl(PyObject *module, path_t *path, int mode, int dir_fd,
@@ -365,7 +365,7 @@ PyDoc_STRVAR(os_fchmod__doc__,
"Equivalent to os.chmod(fd, mode).");
#define OS_FCHMOD_METHODDEF \
- {"fchmod", (PyCFunction)os_fchmod, METH_FASTCALL|METH_KEYWORDS, os_fchmod__doc__},
+ {"fchmod", (PyCFunction)(void(*)(void))os_fchmod, METH_FASTCALL|METH_KEYWORDS, os_fchmod__doc__},
static PyObject *
os_fchmod_impl(PyObject *module, int fd, int mode);
@@ -403,7 +403,7 @@ PyDoc_STRVAR(os_lchmod__doc__,
"Equivalent to chmod(path, mode, follow_symlinks=False).\"");
#define OS_LCHMOD_METHODDEF \
- {"lchmod", (PyCFunction)os_lchmod, METH_FASTCALL|METH_KEYWORDS, os_lchmod__doc__},
+ {"lchmod", (PyCFunction)(void(*)(void))os_lchmod, METH_FASTCALL|METH_KEYWORDS, os_lchmod__doc__},
static PyObject *
os_lchmod_impl(PyObject *module, path_t *path, int mode);
@@ -447,7 +447,7 @@ PyDoc_STRVAR(os_chflags__doc__,
"unavailable, using it will raise a NotImplementedError.");
#define OS_CHFLAGS_METHODDEF \
- {"chflags", (PyCFunction)os_chflags, METH_FASTCALL|METH_KEYWORDS, os_chflags__doc__},
+ {"chflags", (PyCFunction)(void(*)(void))os_chflags, METH_FASTCALL|METH_KEYWORDS, os_chflags__doc__},
static PyObject *
os_chflags_impl(PyObject *module, path_t *path, unsigned long flags,
@@ -490,7 +490,7 @@ PyDoc_STRVAR(os_lchflags__doc__,
"Equivalent to chflags(path, flags, follow_symlinks=False).");
#define OS_LCHFLAGS_METHODDEF \
- {"lchflags", (PyCFunction)os_lchflags, METH_FASTCALL|METH_KEYWORDS, os_lchflags__doc__},
+ {"lchflags", (PyCFunction)(void(*)(void))os_lchflags, METH_FASTCALL|METH_KEYWORDS, os_lchflags__doc__},
static PyObject *
os_lchflags_impl(PyObject *module, path_t *path, unsigned long flags);
@@ -528,7 +528,7 @@ PyDoc_STRVAR(os_chroot__doc__,
"Change root directory to path.");
#define OS_CHROOT_METHODDEF \
- {"chroot", (PyCFunction)os_chroot, METH_FASTCALL|METH_KEYWORDS, os_chroot__doc__},
+ {"chroot", (PyCFunction)(void(*)(void))os_chroot, METH_FASTCALL|METH_KEYWORDS, os_chroot__doc__},
static PyObject *
os_chroot_impl(PyObject *module, path_t *path);
@@ -565,7 +565,7 @@ PyDoc_STRVAR(os_fsync__doc__,
"Force write of fd to disk.");
#define OS_FSYNC_METHODDEF \
- {"fsync", (PyCFunction)os_fsync, METH_FASTCALL|METH_KEYWORDS, os_fsync__doc__},
+ {"fsync", (PyCFunction)(void(*)(void))os_fsync, METH_FASTCALL|METH_KEYWORDS, os_fsync__doc__},
static PyObject *
os_fsync_impl(PyObject *module, int fd);
@@ -621,7 +621,7 @@ PyDoc_STRVAR(os_fdatasync__doc__,
"Force write of fd to disk without forcing update of metadata.");
#define OS_FDATASYNC_METHODDEF \
- {"fdatasync", (PyCFunction)os_fdatasync, METH_FASTCALL|METH_KEYWORDS, os_fdatasync__doc__},
+ {"fdatasync", (PyCFunction)(void(*)(void))os_fdatasync, METH_FASTCALL|METH_KEYWORDS, os_fdatasync__doc__},
static PyObject *
os_fdatasync_impl(PyObject *module, int fd);
@@ -679,7 +679,7 @@ PyDoc_STRVAR(os_chown__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_CHOWN_METHODDEF \
- {"chown", (PyCFunction)os_chown, METH_FASTCALL|METH_KEYWORDS, os_chown__doc__},
+ {"chown", (PyCFunction)(void(*)(void))os_chown, METH_FASTCALL|METH_KEYWORDS, os_chown__doc__},
static PyObject *
os_chown_impl(PyObject *module, path_t *path, uid_t uid, gid_t gid,
@@ -723,7 +723,7 @@ PyDoc_STRVAR(os_fchown__doc__,
"Equivalent to os.chown(fd, uid, gid).");
#define OS_FCHOWN_METHODDEF \
- {"fchown", (PyCFunction)os_fchown, METH_FASTCALL|METH_KEYWORDS, os_fchown__doc__},
+ {"fchown", (PyCFunction)(void(*)(void))os_fchown, METH_FASTCALL|METH_KEYWORDS, os_fchown__doc__},
static PyObject *
os_fchown_impl(PyObject *module, int fd, uid_t uid, gid_t gid);
@@ -762,7 +762,7 @@ PyDoc_STRVAR(os_lchown__doc__,
"Equivalent to os.chown(path, uid, gid, follow_symlinks=False).");
#define OS_LCHOWN_METHODDEF \
- {"lchown", (PyCFunction)os_lchown, METH_FASTCALL|METH_KEYWORDS, os_lchown__doc__},
+ {"lchown", (PyCFunction)(void(*)(void))os_lchown, METH_FASTCALL|METH_KEYWORDS, os_lchown__doc__},
static PyObject *
os_lchown_impl(PyObject *module, path_t *path, uid_t uid, gid_t gid);
@@ -848,7 +848,7 @@ PyDoc_STRVAR(os_link__doc__,
" NotImplementedError.");
#define OS_LINK_METHODDEF \
- {"link", (PyCFunction)os_link, METH_FASTCALL|METH_KEYWORDS, os_link__doc__},
+ {"link", (PyCFunction)(void(*)(void))os_link, METH_FASTCALL|METH_KEYWORDS, os_link__doc__},
static PyObject *
os_link_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,
@@ -901,7 +901,7 @@ PyDoc_STRVAR(os_listdir__doc__,
"entries \'.\' and \'..\' even if they are present in the directory.");
#define OS_LISTDIR_METHODDEF \
- {"listdir", (PyCFunction)os_listdir, METH_FASTCALL|METH_KEYWORDS, os_listdir__doc__},
+ {"listdir", (PyCFunction)(void(*)(void))os_listdir, METH_FASTCALL|METH_KEYWORDS, os_listdir__doc__},
static PyObject *
os_listdir_impl(PyObject *module, path_t *path);
@@ -1016,7 +1016,7 @@ PyDoc_STRVAR(os__getvolumepathname__doc__,
"A helper function for ismount on Win32.");
#define OS__GETVOLUMEPATHNAME_METHODDEF \
- {"_getvolumepathname", (PyCFunction)os__getvolumepathname, METH_FASTCALL|METH_KEYWORDS, os__getvolumepathname__doc__},
+ {"_getvolumepathname", (PyCFunction)(void(*)(void))os__getvolumepathname, METH_FASTCALL|METH_KEYWORDS, os__getvolumepathname__doc__},
static PyObject *
os__getvolumepathname_impl(PyObject *module, path_t *path);
@@ -1058,7 +1058,7 @@ PyDoc_STRVAR(os_mkdir__doc__,
"The mode argument is ignored on Windows.");
#define OS_MKDIR_METHODDEF \
- {"mkdir", (PyCFunction)os_mkdir, METH_FASTCALL|METH_KEYWORDS, os_mkdir__doc__},
+ {"mkdir", (PyCFunction)(void(*)(void))os_mkdir, METH_FASTCALL|METH_KEYWORDS, os_mkdir__doc__},
static PyObject *
os_mkdir_impl(PyObject *module, path_t *path, int mode, int dir_fd);
@@ -1126,7 +1126,7 @@ PyDoc_STRVAR(os_getpriority__doc__,
"Return program scheduling priority.");
#define OS_GETPRIORITY_METHODDEF \
- {"getpriority", (PyCFunction)os_getpriority, METH_FASTCALL|METH_KEYWORDS, os_getpriority__doc__},
+ {"getpriority", (PyCFunction)(void(*)(void))os_getpriority, METH_FASTCALL|METH_KEYWORDS, os_getpriority__doc__},
static PyObject *
os_getpriority_impl(PyObject *module, int which, int who);
@@ -1161,7 +1161,7 @@ PyDoc_STRVAR(os_setpriority__doc__,
"Set program scheduling priority.");
#define OS_SETPRIORITY_METHODDEF \
- {"setpriority", (PyCFunction)os_setpriority, METH_FASTCALL|METH_KEYWORDS, os_setpriority__doc__},
+ {"setpriority", (PyCFunction)(void(*)(void))os_setpriority, METH_FASTCALL|METH_KEYWORDS, os_setpriority__doc__},
static PyObject *
os_setpriority_impl(PyObject *module, int which, int who, int priority);
@@ -1201,7 +1201,7 @@ PyDoc_STRVAR(os_rename__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_RENAME_METHODDEF \
- {"rename", (PyCFunction)os_rename, METH_FASTCALL|METH_KEYWORDS, os_rename__doc__},
+ {"rename", (PyCFunction)(void(*)(void))os_rename, METH_FASTCALL|METH_KEYWORDS, os_rename__doc__},
static PyObject *
os_rename_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,
@@ -1246,7 +1246,7 @@ PyDoc_STRVAR(os_replace__doc__,
" If they are unavailable, using them will raise a NotImplementedError.\"");
#define OS_REPLACE_METHODDEF \
- {"replace", (PyCFunction)os_replace, METH_FASTCALL|METH_KEYWORDS, os_replace__doc__},
+ {"replace", (PyCFunction)(void(*)(void))os_replace, METH_FASTCALL|METH_KEYWORDS, os_replace__doc__},
static PyObject *
os_replace_impl(PyObject *module, path_t *src, path_t *dst, int src_dir_fd,
@@ -1290,7 +1290,7 @@ PyDoc_STRVAR(os_rmdir__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_RMDIR_METHODDEF \
- {"rmdir", (PyCFunction)os_rmdir, METH_FASTCALL|METH_KEYWORDS, os_rmdir__doc__},
+ {"rmdir", (PyCFunction)(void(*)(void))os_rmdir, METH_FASTCALL|METH_KEYWORDS, os_rmdir__doc__},
static PyObject *
os_rmdir_impl(PyObject *module, path_t *path, int dir_fd);
@@ -1326,7 +1326,7 @@ PyDoc_STRVAR(os_system__doc__,
"Execute the command in a subshell.");
#define OS_SYSTEM_METHODDEF \
- {"system", (PyCFunction)os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
+ {"system", (PyCFunction)(void(*)(void))os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
static long
os_system_impl(PyObject *module, Py_UNICODE *command);
@@ -1365,7 +1365,7 @@ PyDoc_STRVAR(os_system__doc__,
"Execute the command in a subshell.");
#define OS_SYSTEM_METHODDEF \
- {"system", (PyCFunction)os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
+ {"system", (PyCFunction)(void(*)(void))os_system, METH_FASTCALL|METH_KEYWORDS, os_system__doc__},
static long
os_system_impl(PyObject *module, PyObject *command);
@@ -1437,7 +1437,7 @@ PyDoc_STRVAR(os_unlink__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_UNLINK_METHODDEF \
- {"unlink", (PyCFunction)os_unlink, METH_FASTCALL|METH_KEYWORDS, os_unlink__doc__},
+ {"unlink", (PyCFunction)(void(*)(void))os_unlink, METH_FASTCALL|METH_KEYWORDS, os_unlink__doc__},
static PyObject *
os_unlink_impl(PyObject *module, path_t *path, int dir_fd);
@@ -1476,7 +1476,7 @@ PyDoc_STRVAR(os_remove__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_REMOVE_METHODDEF \
- {"remove", (PyCFunction)os_remove, METH_FASTCALL|METH_KEYWORDS, os_remove__doc__},
+ {"remove", (PyCFunction)(void(*)(void))os_remove, METH_FASTCALL|METH_KEYWORDS, os_remove__doc__},
static PyObject *
os_remove_impl(PyObject *module, path_t *path, int dir_fd);
@@ -1558,7 +1558,7 @@ PyDoc_STRVAR(os_utime__doc__,
" If they are unavailable, using them will raise a NotImplementedError.");
#define OS_UTIME_METHODDEF \
- {"utime", (PyCFunction)os_utime, METH_FASTCALL|METH_KEYWORDS, os_utime__doc__},
+ {"utime", (PyCFunction)(void(*)(void))os_utime, METH_FASTCALL|METH_KEYWORDS, os_utime__doc__},
static PyObject *
os_utime_impl(PyObject *module, path_t *path, PyObject *times, PyObject *ns,
@@ -1596,7 +1596,7 @@ PyDoc_STRVAR(os__exit__doc__,
"Exit to the system with specified status, without normal exit processing.");
#define OS__EXIT_METHODDEF \
- {"_exit", (PyCFunction)os__exit, METH_FASTCALL|METH_KEYWORDS, os__exit__doc__},
+ {"_exit", (PyCFunction)(void(*)(void))os__exit, METH_FASTCALL|METH_KEYWORDS, os__exit__doc__},
static PyObject *
os__exit_impl(PyObject *module, int status);
@@ -1633,7 +1633,7 @@ PyDoc_STRVAR(os_execv__doc__,
" Tuple or list of strings.");
#define OS_EXECV_METHODDEF \
- {"execv", (PyCFunction)os_execv, METH_FASTCALL, os_execv__doc__},
+ {"execv", (PyCFunction)(void(*)(void))os_execv, METH_FASTCALL, os_execv__doc__},
static PyObject *
os_execv_impl(PyObject *module, path_t *path, PyObject *argv);
@@ -1676,7 +1676,7 @@ PyDoc_STRVAR(os_execve__doc__,
" Dictionary of strings mapping to strings.");
#define OS_EXECVE_METHODDEF \
- {"execve", (PyCFunction)os_execve, METH_FASTCALL|METH_KEYWORDS, os_execve__doc__},
+ {"execve", (PyCFunction)(void(*)(void))os_execve, METH_FASTCALL|METH_KEYWORDS, os_execve__doc__},
static PyObject *
os_execve_impl(PyObject *module, path_t *path, PyObject *argv, PyObject *env);
@@ -1736,7 +1736,7 @@ PyDoc_STRVAR(os_posix_spawn__doc__,
" A tuple with the scheduler policy (optional) and parameters.");
#define OS_POSIX_SPAWN_METHODDEF \
- {"posix_spawn", (PyCFunction)os_posix_spawn, METH_FASTCALL|METH_KEYWORDS, os_posix_spawn__doc__},
+ {"posix_spawn", (PyCFunction)(void(*)(void))os_posix_spawn, METH_FASTCALL|METH_KEYWORDS, os_posix_spawn__doc__},
static PyObject *
os_posix_spawn_impl(PyObject *module, path_t *path, PyObject *argv,
@@ -1791,7 +1791,7 @@ PyDoc_STRVAR(os_spawnv__doc__,
" Tuple or list of strings.");
#define OS_SPAWNV_METHODDEF \
- {"spawnv", (PyCFunction)os_spawnv, METH_FASTCALL, os_spawnv__doc__},
+ {"spawnv", (PyCFunction)(void(*)(void))os_spawnv, METH_FASTCALL, os_spawnv__doc__},
static PyObject *
os_spawnv_impl(PyObject *module, int mode, path_t *path, PyObject *argv);
@@ -1837,7 +1837,7 @@ PyDoc_STRVAR(os_spawnve__doc__,
" Dictionary of strings mapping to strings.");
#define OS_SPAWNVE_METHODDEF \
- {"spawnve", (PyCFunction)os_spawnve, METH_FASTCALL, os_spawnve__doc__},
+ {"spawnve", (PyCFunction)(void(*)(void))os_spawnve, METH_FASTCALL, os_spawnve__doc__},
static PyObject *
os_spawnve_impl(PyObject *module, int mode, path_t *path, PyObject *argv,
@@ -1887,7 +1887,7 @@ PyDoc_STRVAR(os_register_at_fork__doc__,
"\'after_in_child\' and \'after_in_parent\' callbacks are called in order.");
#define OS_REGISTER_AT_FORK_METHODDEF \
- {"register_at_fork", (PyCFunction)os_register_at_fork, METH_FASTCALL|METH_KEYWORDS, os_register_at_fork__doc__},
+ {"register_at_fork", (PyCFunction)(void(*)(void))os_register_at_fork, METH_FASTCALL|METH_KEYWORDS, os_register_at_fork__doc__},
static PyObject *
os_register_at_fork_impl(PyObject *module, PyObject *before,
@@ -1972,7 +1972,7 @@ PyDoc_STRVAR(os_sched_get_priority_max__doc__,
"Get the maximum scheduling priority for policy.");
#define OS_SCHED_GET_PRIORITY_MAX_METHODDEF \
- {"sched_get_priority_max", (PyCFunction)os_sched_get_priority_max, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_max__doc__},
+ {"sched_get_priority_max", (PyCFunction)(void(*)(void))os_sched_get_priority_max, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_max__doc__},
static PyObject *
os_sched_get_priority_max_impl(PyObject *module, int policy);
@@ -2006,7 +2006,7 @@ PyDoc_STRVAR(os_sched_get_priority_min__doc__,
"Get the minimum scheduling priority for policy.");
#define OS_SCHED_GET_PRIORITY_MIN_METHODDEF \
- {"sched_get_priority_min", (PyCFunction)os_sched_get_priority_min, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_min__doc__},
+ {"sched_get_priority_min", (PyCFunction)(void(*)(void))os_sched_get_priority_min, METH_FASTCALL|METH_KEYWORDS, os_sched_get_priority_min__doc__},
static PyObject *
os_sched_get_priority_min_impl(PyObject *module, int policy);
@@ -2110,7 +2110,7 @@ PyDoc_STRVAR(os_sched_setscheduler__doc__,
"param is an instance of sched_param.");
#define OS_SCHED_SETSCHEDULER_METHODDEF \
- {"sched_setscheduler", (PyCFunction)os_sched_setscheduler, METH_FASTCALL, os_sched_setscheduler__doc__},
+ {"sched_setscheduler", (PyCFunction)(void(*)(void))os_sched_setscheduler, METH_FASTCALL, os_sched_setscheduler__doc__},
static PyObject *
os_sched_setscheduler_impl(PyObject *module, pid_t pid, int policy,
@@ -2182,7 +2182,7 @@ PyDoc_STRVAR(os_sched_setparam__doc__,
"param should be an instance of sched_param.");
#define OS_SCHED_SETPARAM_METHODDEF \
- {"sched_setparam", (PyCFunction)os_sched_setparam, METH_FASTCALL, os_sched_setparam__doc__},
+ {"sched_setparam", (PyCFunction)(void(*)(void))os_sched_setparam, METH_FASTCALL, os_sched_setparam__doc__},
static PyObject *
os_sched_setparam_impl(PyObject *module, pid_t pid,
@@ -2278,7 +2278,7 @@ PyDoc_STRVAR(os_sched_setaffinity__doc__,
"mask should be an iterable of integers identifying CPUs.");
#define OS_SCHED_SETAFFINITY_METHODDEF \
- {"sched_setaffinity", (PyCFunction)os_sched_setaffinity, METH_FASTCALL, os_sched_setaffinity__doc__},
+ {"sched_setaffinity", (PyCFunction)(void(*)(void))os_sched_setaffinity, METH_FASTCALL, os_sched_setaffinity__doc__},
static PyObject *
os_sched_setaffinity_impl(PyObject *module, pid_t pid, PyObject *mask);
@@ -2506,7 +2506,7 @@ PyDoc_STRVAR(os_getpgid__doc__,
"Call the system call getpgid(), and return the result.");
#define OS_GETPGID_METHODDEF \
- {"getpgid", (PyCFunction)os_getpgid, METH_FASTCALL|METH_KEYWORDS, os_getpgid__doc__},
+ {"getpgid", (PyCFunction)(void(*)(void))os_getpgid, METH_FASTCALL|METH_KEYWORDS, os_getpgid__doc__},
static PyObject *
os_getpgid_impl(PyObject *module, pid_t pid);
@@ -2653,7 +2653,7 @@ PyDoc_STRVAR(os_kill__doc__,
"Kill a process with a signal.");
#define OS_KILL_METHODDEF \
- {"kill", (PyCFunction)os_kill, METH_FASTCALL, os_kill__doc__},
+ {"kill", (PyCFunction)(void(*)(void))os_kill, METH_FASTCALL, os_kill__doc__},
static PyObject *
os_kill_impl(PyObject *module, pid_t pid, Py_ssize_t signal);
@@ -2686,7 +2686,7 @@ PyDoc_STRVAR(os_killpg__doc__,
"Kill a process group with a signal.");
#define OS_KILLPG_METHODDEF \
- {"killpg", (PyCFunction)os_killpg, METH_FASTCALL, os_killpg__doc__},
+ {"killpg", (PyCFunction)(void(*)(void))os_killpg, METH_FASTCALL, os_killpg__doc__},
static PyObject *
os_killpg_impl(PyObject *module, pid_t pgid, int signal);
@@ -2843,7 +2843,7 @@ PyDoc_STRVAR(os_setreuid__doc__,
"Set the current process\'s real and effective user ids.");
#define OS_SETREUID_METHODDEF \
- {"setreuid", (PyCFunction)os_setreuid, METH_FASTCALL, os_setreuid__doc__},
+ {"setreuid", (PyCFunction)(void(*)(void))os_setreuid, METH_FASTCALL, os_setreuid__doc__},
static PyObject *
os_setreuid_impl(PyObject *module, uid_t ruid, uid_t euid);
@@ -2876,7 +2876,7 @@ PyDoc_STRVAR(os_setregid__doc__,
"Set the current process\'s real and effective group ids.");
#define OS_SETREGID_METHODDEF \
- {"setregid", (PyCFunction)os_setregid, METH_FASTCALL, os_setregid__doc__},
+ {"setregid", (PyCFunction)(void(*)(void))os_setregid, METH_FASTCALL, os_setregid__doc__},
static PyObject *
os_setregid_impl(PyObject *module, gid_t rgid, gid_t egid);
@@ -2956,7 +2956,7 @@ PyDoc_STRVAR(os_wait3__doc__,
" (pid, status, rusage)");
#define OS_WAIT3_METHODDEF \
- {"wait3", (PyCFunction)os_wait3, METH_FASTCALL|METH_KEYWORDS, os_wait3__doc__},
+ {"wait3", (PyCFunction)(void(*)(void))os_wait3, METH_FASTCALL|METH_KEYWORDS, os_wait3__doc__},
static PyObject *
os_wait3_impl(PyObject *module, int options);
@@ -2993,7 +2993,7 @@ PyDoc_STRVAR(os_wait4__doc__,
" (pid, status, rusage)");
#define OS_WAIT4_METHODDEF \
- {"wait4", (PyCFunction)os_wait4, METH_FASTCALL|METH_KEYWORDS, os_wait4__doc__},
+ {"wait4", (PyCFunction)(void(*)(void))os_wait4, METH_FASTCALL|METH_KEYWORDS, os_wait4__doc__},
static PyObject *
os_wait4_impl(PyObject *module, pid_t pid, int options);
@@ -3039,7 +3039,7 @@ PyDoc_STRVAR(os_waitid__doc__,
"no children in a waitable state.");
#define OS_WAITID_METHODDEF \
- {"waitid", (PyCFunction)os_waitid, METH_FASTCALL, os_waitid__doc__},
+ {"waitid", (PyCFunction)(void(*)(void))os_waitid, METH_FASTCALL, os_waitid__doc__},
static PyObject *
os_waitid_impl(PyObject *module, idtype_t idtype, id_t id, int options);
@@ -3078,7 +3078,7 @@ PyDoc_STRVAR(os_waitpid__doc__,
"The options argument is ignored on Windows.");
#define OS_WAITPID_METHODDEF \
- {"waitpid", (PyCFunction)os_waitpid, METH_FASTCALL, os_waitpid__doc__},
+ {"waitpid", (PyCFunction)(void(*)(void))os_waitpid, METH_FASTCALL, os_waitpid__doc__},
static PyObject *
os_waitpid_impl(PyObject *module, pid_t pid, int options);
@@ -3116,7 +3116,7 @@ PyDoc_STRVAR(os_waitpid__doc__,
"The options argument is ignored on Windows.");
#define OS_WAITPID_METHODDEF \
- {"waitpid", (PyCFunction)os_waitpid, METH_FASTCALL, os_waitpid__doc__},
+ {"waitpid", (PyCFunction)(void(*)(void))os_waitpid, METH_FASTCALL, os_waitpid__doc__},
static PyObject *
os_waitpid_impl(PyObject *module, intptr_t pid, int options);
@@ -3180,7 +3180,7 @@ PyDoc_STRVAR(os_readlink__doc__,
"using it will raise a NotImplementedError.");
#define OS_READLINK_METHODDEF \
- {"readlink", (PyCFunction)os_readlink, METH_FASTCALL|METH_KEYWORDS, os_readlink__doc__},
+ {"readlink", (PyCFunction)(void(*)(void))os_readlink, METH_FASTCALL|METH_KEYWORDS, os_readlink__doc__},
static PyObject *
os_readlink_impl(PyObject *module, path_t *path, int dir_fd);
@@ -3228,7 +3228,7 @@ PyDoc_STRVAR(os_symlink__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_SYMLINK_METHODDEF \
- {"symlink", (PyCFunction)os_symlink, METH_FASTCALL|METH_KEYWORDS, os_symlink__doc__},
+ {"symlink", (PyCFunction)(void(*)(void))os_symlink, METH_FASTCALL|METH_KEYWORDS, os_symlink__doc__},
static PyObject *
os_symlink_impl(PyObject *module, path_t *src, path_t *dst,
@@ -3350,7 +3350,7 @@ PyDoc_STRVAR(os_setpgid__doc__,
"Call the system call setpgid(pid, pgrp).");
#define OS_SETPGID_METHODDEF \
- {"setpgid", (PyCFunction)os_setpgid, METH_FASTCALL, os_setpgid__doc__},
+ {"setpgid", (PyCFunction)(void(*)(void))os_setpgid, METH_FASTCALL, os_setpgid__doc__},
static PyObject *
os_setpgid_impl(PyObject *module, pid_t pid, pid_t pgrp);
@@ -3414,7 +3414,7 @@ PyDoc_STRVAR(os_tcsetpgrp__doc__,
"Set the process group associated with the terminal specified by fd.");
#define OS_TCSETPGRP_METHODDEF \
- {"tcsetpgrp", (PyCFunction)os_tcsetpgrp, METH_FASTCALL, os_tcsetpgrp__doc__},
+ {"tcsetpgrp", (PyCFunction)(void(*)(void))os_tcsetpgrp, METH_FASTCALL, os_tcsetpgrp__doc__},
static PyObject *
os_tcsetpgrp_impl(PyObject *module, int fd, pid_t pgid);
@@ -3450,7 +3450,7 @@ PyDoc_STRVAR(os_open__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_OPEN_METHODDEF \
- {"open", (PyCFunction)os_open, METH_FASTCALL|METH_KEYWORDS, os_open__doc__},
+ {"open", (PyCFunction)(void(*)(void))os_open, METH_FASTCALL|METH_KEYWORDS, os_open__doc__},
static int
os_open_impl(PyObject *module, path_t *path, int flags, int mode, int dir_fd);
@@ -3491,7 +3491,7 @@ PyDoc_STRVAR(os_close__doc__,
"Close a file descriptor.");
#define OS_CLOSE_METHODDEF \
- {"close", (PyCFunction)os_close, METH_FASTCALL|METH_KEYWORDS, os_close__doc__},
+ {"close", (PyCFunction)(void(*)(void))os_close, METH_FASTCALL|METH_KEYWORDS, os_close__doc__},
static PyObject *
os_close_impl(PyObject *module, int fd);
@@ -3521,7 +3521,7 @@ PyDoc_STRVAR(os_closerange__doc__,
"Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
#define OS_CLOSERANGE_METHODDEF \
- {"closerange", (PyCFunction)os_closerange, METH_FASTCALL, os_closerange__doc__},
+ {"closerange", (PyCFunction)(void(*)(void))os_closerange, METH_FASTCALL, os_closerange__doc__},
static PyObject *
os_closerange_impl(PyObject *module, int fd_low, int fd_high);
@@ -3582,7 +3582,7 @@ PyDoc_STRVAR(os_dup2__doc__,
"Duplicate file descriptor.");
#define OS_DUP2_METHODDEF \
- {"dup2", (PyCFunction)os_dup2, METH_FASTCALL|METH_KEYWORDS, os_dup2__doc__},
+ {"dup2", (PyCFunction)(void(*)(void))os_dup2, METH_FASTCALL|METH_KEYWORDS, os_dup2__doc__},
static int
os_dup2_impl(PyObject *module, int fd, int fd2, int inheritable);
@@ -3628,7 +3628,7 @@ PyDoc_STRVAR(os_lockf__doc__,
" The number of bytes to lock, starting at the current position.");
#define OS_LOCKF_METHODDEF \
- {"lockf", (PyCFunction)os_lockf, METH_FASTCALL, os_lockf__doc__},
+ {"lockf", (PyCFunction)(void(*)(void))os_lockf, METH_FASTCALL, os_lockf__doc__},
static PyObject *
os_lockf_impl(PyObject *module, int fd, int command, Py_off_t length);
@@ -3663,7 +3663,7 @@ PyDoc_STRVAR(os_lseek__doc__,
"relative to the beginning of the file.");
#define OS_LSEEK_METHODDEF \
- {"lseek", (PyCFunction)os_lseek, METH_FASTCALL, os_lseek__doc__},
+ {"lseek", (PyCFunction)(void(*)(void))os_lseek, METH_FASTCALL, os_lseek__doc__},
static Py_off_t
os_lseek_impl(PyObject *module, int fd, Py_off_t position, int how);
@@ -3698,7 +3698,7 @@ PyDoc_STRVAR(os_read__doc__,
"Read from a file descriptor. Returns a bytes object.");
#define OS_READ_METHODDEF \
- {"read", (PyCFunction)os_read, METH_FASTCALL, os_read__doc__},
+ {"read", (PyCFunction)(void(*)(void))os_read, METH_FASTCALL, os_read__doc__},
static PyObject *
os_read_impl(PyObject *module, int fd, Py_ssize_t length);
@@ -3737,7 +3737,7 @@ PyDoc_STRVAR(os_readv__doc__,
"which may be less than the total capacity of all the buffers.");
#define OS_READV_METHODDEF \
- {"readv", (PyCFunction)os_readv, METH_FASTCALL, os_readv__doc__},
+ {"readv", (PyCFunction)(void(*)(void))os_readv, METH_FASTCALL, os_readv__doc__},
static Py_ssize_t
os_readv_impl(PyObject *module, int fd, PyObject *buffers);
@@ -3778,7 +3778,7 @@ PyDoc_STRVAR(os_pread__doc__,
"the beginning of the file. The file offset remains unchanged.");
#define OS_PREAD_METHODDEF \
- {"pread", (PyCFunction)os_pread, METH_FASTCALL, os_pread__doc__},
+ {"pread", (PyCFunction)(void(*)(void))os_pread, METH_FASTCALL, os_pread__doc__},
static PyObject *
os_pread_impl(PyObject *module, int fd, int length, Py_off_t offset);
@@ -3826,7 +3826,7 @@ PyDoc_STRVAR(os_preadv__doc__,
"Using non-zero flags requires Linux 4.6 or newer.");
#define OS_PREADV_METHODDEF \
- {"preadv", (PyCFunction)os_preadv, METH_FASTCALL, os_preadv__doc__},
+ {"preadv", (PyCFunction)(void(*)(void))os_preadv, METH_FASTCALL, os_preadv__doc__},
static Py_ssize_t
os_preadv_impl(PyObject *module, int fd, PyObject *buffers, Py_off_t offset,
@@ -3865,7 +3865,7 @@ PyDoc_STRVAR(os_write__doc__,
"Write a bytes object to a file descriptor.");
#define OS_WRITE_METHODDEF \
- {"write", (PyCFunction)os_write, METH_FASTCALL, os_write__doc__},
+ {"write", (PyCFunction)(void(*)(void))os_write, METH_FASTCALL, os_write__doc__},
static Py_ssize_t
os_write_impl(PyObject *module, int fd, Py_buffer *data);
@@ -3906,7 +3906,7 @@ PyDoc_STRVAR(os__fcopyfile__doc__,
"Efficiently copy content or metadata of 2 regular file descriptors (macOS).");
#define OS__FCOPYFILE_METHODDEF \
- {"_fcopyfile", (PyCFunction)os__fcopyfile, METH_FASTCALL, os__fcopyfile__doc__},
+ {"_fcopyfile", (PyCFunction)(void(*)(void))os__fcopyfile, METH_FASTCALL, os__fcopyfile__doc__},
static PyObject *
os__fcopyfile_impl(PyObject *module, int infd, int outfd, int flags);
@@ -3941,7 +3941,7 @@ PyDoc_STRVAR(os_fstat__doc__,
"Equivalent to os.stat(fd).");
#define OS_FSTAT_METHODDEF \
- {"fstat", (PyCFunction)os_fstat, METH_FASTCALL|METH_KEYWORDS, os_fstat__doc__},
+ {"fstat", (PyCFunction)(void(*)(void))os_fstat, METH_FASTCALL|METH_KEYWORDS, os_fstat__doc__},
static PyObject *
os_fstat_impl(PyObject *module, int fd);
@@ -4073,7 +4073,7 @@ PyDoc_STRVAR(os_writev__doc__,
"buffers must be a sequence of bytes-like objects.");
#define OS_WRITEV_METHODDEF \
- {"writev", (PyCFunction)os_writev, METH_FASTCALL, os_writev__doc__},
+ {"writev", (PyCFunction)(void(*)(void))os_writev, METH_FASTCALL, os_writev__doc__},
static Py_ssize_t
os_writev_impl(PyObject *module, int fd, PyObject *buffers);
@@ -4115,7 +4115,7 @@ PyDoc_STRVAR(os_pwrite__doc__,
"current file offset.");
#define OS_PWRITE_METHODDEF \
- {"pwrite", (PyCFunction)os_pwrite, METH_FASTCALL, os_pwrite__doc__},
+ {"pwrite", (PyCFunction)(void(*)(void))os_pwrite, METH_FASTCALL, os_pwrite__doc__},
static Py_ssize_t
os_pwrite_impl(PyObject *module, int fd, Py_buffer *buffer, Py_off_t offset);
@@ -4173,7 +4173,7 @@ PyDoc_STRVAR(os_pwritev__doc__,
"Using non-zero flags requires Linux 4.7 or newer.");
#define OS_PWRITEV_METHODDEF \
- {"pwritev", (PyCFunction)os_pwritev, METH_FASTCALL, os_pwritev__doc__},
+ {"pwritev", (PyCFunction)(void(*)(void))os_pwritev, METH_FASTCALL, os_pwritev__doc__},
static Py_ssize_t
os_pwritev_impl(PyObject *module, int fd, PyObject *buffers, Py_off_t offset,
@@ -4219,7 +4219,7 @@ PyDoc_STRVAR(os_mkfifo__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_MKFIFO_METHODDEF \
- {"mkfifo", (PyCFunction)os_mkfifo, METH_FASTCALL|METH_KEYWORDS, os_mkfifo__doc__},
+ {"mkfifo", (PyCFunction)(void(*)(void))os_mkfifo, METH_FASTCALL|METH_KEYWORDS, os_mkfifo__doc__},
static PyObject *
os_mkfifo_impl(PyObject *module, path_t *path, int mode, int dir_fd);
@@ -4270,7 +4270,7 @@ PyDoc_STRVAR(os_mknod__doc__,
" If it is unavailable, using it will raise a NotImplementedError.");
#define OS_MKNOD_METHODDEF \
- {"mknod", (PyCFunction)os_mknod, METH_FASTCALL|METH_KEYWORDS, os_mknod__doc__},
+ {"mknod", (PyCFunction)(void(*)(void))os_mknod, METH_FASTCALL|METH_KEYWORDS, os_mknod__doc__},
static PyObject *
os_mknod_impl(PyObject *module, path_t *path, int mode, dev_t device,
@@ -4383,7 +4383,7 @@ PyDoc_STRVAR(os_makedev__doc__,
"Composes a raw device number from the major and minor device numbers.");
#define OS_MAKEDEV_METHODDEF \
- {"makedev", (PyCFunction)os_makedev, METH_FASTCALL, os_makedev__doc__},
+ {"makedev", (PyCFunction)(void(*)(void))os_makedev, METH_FASTCALL, os_makedev__doc__},
static dev_t
os_makedev_impl(PyObject *module, int major, int minor);
@@ -4421,7 +4421,7 @@ PyDoc_STRVAR(os_ftruncate__doc__,
"Truncate a file, specified by file descriptor, to a specific length.");
#define OS_FTRUNCATE_METHODDEF \
- {"ftruncate", (PyCFunction)os_ftruncate, METH_FASTCALL, os_ftruncate__doc__},
+ {"ftruncate", (PyCFunction)(void(*)(void))os_ftruncate, METH_FASTCALL, os_ftruncate__doc__},
static PyObject *
os_ftruncate_impl(PyObject *module, int fd, Py_off_t length);
@@ -4457,7 +4457,7 @@ PyDoc_STRVAR(os_truncate__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_TRUNCATE_METHODDEF \
- {"truncate", (PyCFunction)os_truncate, METH_FASTCALL|METH_KEYWORDS, os_truncate__doc__},
+ {"truncate", (PyCFunction)(void(*)(void))os_truncate, METH_FASTCALL|METH_KEYWORDS, os_truncate__doc__},
static PyObject *
os_truncate_impl(PyObject *module, path_t *path, Py_off_t length);
@@ -4498,7 +4498,7 @@ PyDoc_STRVAR(os_posix_fallocate__doc__,
"starting at offset bytes from the beginning and continuing for length bytes.");
#define OS_POSIX_FALLOCATE_METHODDEF \
- {"posix_fallocate", (PyCFunction)os_posix_fallocate, METH_FASTCALL, os_posix_fallocate__doc__},
+ {"posix_fallocate", (PyCFunction)(void(*)(void))os_posix_fallocate, METH_FASTCALL, os_posix_fallocate__doc__},
static PyObject *
os_posix_fallocate_impl(PyObject *module, int fd, Py_off_t offset,
@@ -4541,7 +4541,7 @@ PyDoc_STRVAR(os_posix_fadvise__doc__,
"POSIX_FADV_DONTNEED.");
#define OS_POSIX_FADVISE_METHODDEF \
- {"posix_fadvise", (PyCFunction)os_posix_fadvise, METH_FASTCALL, os_posix_fadvise__doc__},
+ {"posix_fadvise", (PyCFunction)(void(*)(void))os_posix_fadvise, METH_FASTCALL, os_posix_fadvise__doc__},
static PyObject *
os_posix_fadvise_impl(PyObject *module, int fd, Py_off_t offset,
@@ -4577,7 +4577,7 @@ PyDoc_STRVAR(os_putenv__doc__,
"Change or add an environment variable.");
#define OS_PUTENV_METHODDEF \
- {"putenv", (PyCFunction)os_putenv, METH_FASTCALL, os_putenv__doc__},
+ {"putenv", (PyCFunction)(void(*)(void))os_putenv, METH_FASTCALL, os_putenv__doc__},
static PyObject *
os_putenv_impl(PyObject *module, PyObject *name, PyObject *value);
@@ -4610,7 +4610,7 @@ PyDoc_STRVAR(os_putenv__doc__,
"Change or add an environment variable.");
#define OS_PUTENV_METHODDEF \
- {"putenv", (PyCFunction)os_putenv, METH_FASTCALL, os_putenv__doc__},
+ {"putenv", (PyCFunction)(void(*)(void))os_putenv, METH_FASTCALL, os_putenv__doc__},
static PyObject *
os_putenv_impl(PyObject *module, PyObject *name, PyObject *value);
@@ -4748,7 +4748,7 @@ PyDoc_STRVAR(os_WIFCONTINUED__doc__,
"job control stop.");
#define OS_WIFCONTINUED_METHODDEF \
- {"WIFCONTINUED", (PyCFunction)os_WIFCONTINUED, METH_FASTCALL|METH_KEYWORDS, os_WIFCONTINUED__doc__},
+ {"WIFCONTINUED", (PyCFunction)(void(*)(void))os_WIFCONTINUED, METH_FASTCALL|METH_KEYWORDS, os_WIFCONTINUED__doc__},
static int
os_WIFCONTINUED_impl(PyObject *module, int status);
@@ -4787,7 +4787,7 @@ PyDoc_STRVAR(os_WIFSTOPPED__doc__,
"Return True if the process returning status was stopped.");
#define OS_WIFSTOPPED_METHODDEF \
- {"WIFSTOPPED", (PyCFunction)os_WIFSTOPPED, METH_FASTCALL|METH_KEYWORDS, os_WIFSTOPPED__doc__},
+ {"WIFSTOPPED", (PyCFunction)(void(*)(void))os_WIFSTOPPED, METH_FASTCALL|METH_KEYWORDS, os_WIFSTOPPED__doc__},
static int
os_WIFSTOPPED_impl(PyObject *module, int status);
@@ -4826,7 +4826,7 @@ PyDoc_STRVAR(os_WIFSIGNALED__doc__,
"Return True if the process returning status was terminated by a signal.");
#define OS_WIFSIGNALED_METHODDEF \
- {"WIFSIGNALED", (PyCFunction)os_WIFSIGNALED, METH_FASTCALL|METH_KEYWORDS, os_WIFSIGNALED__doc__},
+ {"WIFSIGNALED", (PyCFunction)(void(*)(void))os_WIFSIGNALED, METH_FASTCALL|METH_KEYWORDS, os_WIFSIGNALED__doc__},
static int
os_WIFSIGNALED_impl(PyObject *module, int status);
@@ -4865,7 +4865,7 @@ PyDoc_STRVAR(os_WIFEXITED__doc__,
"Return True if the process returning status exited via the exit() system call.");
#define OS_WIFEXITED_METHODDEF \
- {"WIFEXITED", (PyCFunction)os_WIFEXITED, METH_FASTCALL|METH_KEYWORDS, os_WIFEXITED__doc__},
+ {"WIFEXITED", (PyCFunction)(void(*)(void))os_WIFEXITED, METH_FASTCALL|METH_KEYWORDS, os_WIFEXITED__doc__},
static int
os_WIFEXITED_impl(PyObject *module, int status);
@@ -4904,7 +4904,7 @@ PyDoc_STRVAR(os_WEXITSTATUS__doc__,
"Return the process return code from status.");
#define OS_WEXITSTATUS_METHODDEF \
- {"WEXITSTATUS", (PyCFunction)os_WEXITSTATUS, METH_FASTCALL|METH_KEYWORDS, os_WEXITSTATUS__doc__},
+ {"WEXITSTATUS", (PyCFunction)(void(*)(void))os_WEXITSTATUS, METH_FASTCALL|METH_KEYWORDS, os_WEXITSTATUS__doc__},
static int
os_WEXITSTATUS_impl(PyObject *module, int status);
@@ -4943,7 +4943,7 @@ PyDoc_STRVAR(os_WTERMSIG__doc__,
"Return the signal that terminated the process that provided the status value.");
#define OS_WTERMSIG_METHODDEF \
- {"WTERMSIG", (PyCFunction)os_WTERMSIG, METH_FASTCALL|METH_KEYWORDS, os_WTERMSIG__doc__},
+ {"WTERMSIG", (PyCFunction)(void(*)(void))os_WTERMSIG, METH_FASTCALL|METH_KEYWORDS, os_WTERMSIG__doc__},
static int
os_WTERMSIG_impl(PyObject *module, int status);
@@ -4982,7 +4982,7 @@ PyDoc_STRVAR(os_WSTOPSIG__doc__,
"Return the signal that stopped the process that provided the status value.");
#define OS_WSTOPSIG_METHODDEF \
- {"WSTOPSIG", (PyCFunction)os_WSTOPSIG, METH_FASTCALL|METH_KEYWORDS, os_WSTOPSIG__doc__},
+ {"WSTOPSIG", (PyCFunction)(void(*)(void))os_WSTOPSIG, METH_FASTCALL|METH_KEYWORDS, os_WSTOPSIG__doc__},
static int
os_WSTOPSIG_impl(PyObject *module, int status);
@@ -5058,7 +5058,7 @@ PyDoc_STRVAR(os_statvfs__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_STATVFS_METHODDEF \
- {"statvfs", (PyCFunction)os_statvfs, METH_FASTCALL|METH_KEYWORDS, os_statvfs__doc__},
+ {"statvfs", (PyCFunction)(void(*)(void))os_statvfs, METH_FASTCALL|METH_KEYWORDS, os_statvfs__doc__},
static PyObject *
os_statvfs_impl(PyObject *module, path_t *path);
@@ -5095,7 +5095,7 @@ PyDoc_STRVAR(os__getdiskusage__doc__,
"Return disk usage statistics about the given path as a (total, free) tuple.");
#define OS__GETDISKUSAGE_METHODDEF \
- {"_getdiskusage", (PyCFunction)os__getdiskusage, METH_FASTCALL|METH_KEYWORDS, os__getdiskusage__doc__},
+ {"_getdiskusage", (PyCFunction)(void(*)(void))os__getdiskusage, METH_FASTCALL|METH_KEYWORDS, os__getdiskusage__doc__},
static PyObject *
os__getdiskusage_impl(PyObject *module, path_t *path);
@@ -5134,7 +5134,7 @@ PyDoc_STRVAR(os_fpathconf__doc__,
"If there is no limit, return -1.");
#define OS_FPATHCONF_METHODDEF \
- {"fpathconf", (PyCFunction)os_fpathconf, METH_FASTCALL, os_fpathconf__doc__},
+ {"fpathconf", (PyCFunction)(void(*)(void))os_fpathconf, METH_FASTCALL, os_fpathconf__doc__},
static long
os_fpathconf_impl(PyObject *module, int fd, int name);
@@ -5176,7 +5176,7 @@ PyDoc_STRVAR(os_pathconf__doc__,
" If this functionality is unavailable, using it raises an exception.");
#define OS_PATHCONF_METHODDEF \
- {"pathconf", (PyCFunction)os_pathconf, METH_FASTCALL|METH_KEYWORDS, os_pathconf__doc__},
+ {"pathconf", (PyCFunction)(void(*)(void))os_pathconf, METH_FASTCALL|METH_KEYWORDS, os_pathconf__doc__},
static long
os_pathconf_impl(PyObject *module, path_t *path, int name);
@@ -5324,7 +5324,7 @@ PyDoc_STRVAR(os_startfile__doc__,
"the underlying Win32 ShellExecute function doesn\'t work if it is.");
#define OS_STARTFILE_METHODDEF \
- {"startfile", (PyCFunction)os_startfile, METH_FASTCALL|METH_KEYWORDS, os_startfile__doc__},
+ {"startfile", (PyCFunction)(void(*)(void))os_startfile, METH_FASTCALL|METH_KEYWORDS, os_startfile__doc__},
static PyObject *
os_startfile_impl(PyObject *module, path_t *filepath, Py_UNICODE *operation);
@@ -5389,7 +5389,7 @@ PyDoc_STRVAR(os_device_encoding__doc__,
"If the device is not a terminal, return None.");
#define OS_DEVICE_ENCODING_METHODDEF \
- {"device_encoding", (PyCFunction)os_device_encoding, METH_FASTCALL|METH_KEYWORDS, os_device_encoding__doc__},
+ {"device_encoding", (PyCFunction)(void(*)(void))os_device_encoding, METH_FASTCALL|METH_KEYWORDS, os_device_encoding__doc__},
static PyObject *
os_device_encoding_impl(PyObject *module, int fd);
@@ -5421,7 +5421,7 @@ PyDoc_STRVAR(os_setresuid__doc__,
"Set the current process\'s real, effective, and saved user ids.");
#define OS_SETRESUID_METHODDEF \
- {"setresuid", (PyCFunction)os_setresuid, METH_FASTCALL, os_setresuid__doc__},
+ {"setresuid", (PyCFunction)(void(*)(void))os_setresuid, METH_FASTCALL, os_setresuid__doc__},
static PyObject *
os_setresuid_impl(PyObject *module, uid_t ruid, uid_t euid, uid_t suid);
@@ -5455,7 +5455,7 @@ PyDoc_STRVAR(os_setresgid__doc__,
"Set the current process\'s real, effective, and saved group ids.");
#define OS_SETRESGID_METHODDEF \
- {"setresgid", (PyCFunction)os_setresgid, METH_FASTCALL, os_setresgid__doc__},
+ {"setresgid", (PyCFunction)(void(*)(void))os_setresgid, METH_FASTCALL, os_setresgid__doc__},
static PyObject *
os_setresgid_impl(PyObject *module, gid_t rgid, gid_t egid, gid_t sgid);
@@ -5538,7 +5538,7 @@ PyDoc_STRVAR(os_getxattr__doc__,
" the link points to.");
#define OS_GETXATTR_METHODDEF \
- {"getxattr", (PyCFunction)os_getxattr, METH_FASTCALL|METH_KEYWORDS, os_getxattr__doc__},
+ {"getxattr", (PyCFunction)(void(*)(void))os_getxattr, METH_FASTCALL|METH_KEYWORDS, os_getxattr__doc__},
static PyObject *
os_getxattr_impl(PyObject *module, path_t *path, path_t *attribute,
@@ -5586,7 +5586,7 @@ PyDoc_STRVAR(os_setxattr__doc__,
" the link points to.");
#define OS_SETXATTR_METHODDEF \
- {"setxattr", (PyCFunction)os_setxattr, METH_FASTCALL|METH_KEYWORDS, os_setxattr__doc__},
+ {"setxattr", (PyCFunction)(void(*)(void))os_setxattr, METH_FASTCALL|METH_KEYWORDS, os_setxattr__doc__},
static PyObject *
os_setxattr_impl(PyObject *module, path_t *path, path_t *attribute,
@@ -5639,7 +5639,7 @@ PyDoc_STRVAR(os_removexattr__doc__,
" the link points to.");
#define OS_REMOVEXATTR_METHODDEF \
- {"removexattr", (PyCFunction)os_removexattr, METH_FASTCALL|METH_KEYWORDS, os_removexattr__doc__},
+ {"removexattr", (PyCFunction)(void(*)(void))os_removexattr, METH_FASTCALL|METH_KEYWORDS, os_removexattr__doc__},
static PyObject *
os_removexattr_impl(PyObject *module, path_t *path, path_t *attribute,
@@ -5687,7 +5687,7 @@ PyDoc_STRVAR(os_listxattr__doc__,
" the link points to.");
#define OS_LISTXATTR_METHODDEF \
- {"listxattr", (PyCFunction)os_listxattr, METH_FASTCALL|METH_KEYWORDS, os_listxattr__doc__},
+ {"listxattr", (PyCFunction)(void(*)(void))os_listxattr, METH_FASTCALL|METH_KEYWORDS, os_listxattr__doc__},
static PyObject *
os_listxattr_impl(PyObject *module, path_t *path, int follow_symlinks);
@@ -5804,7 +5804,7 @@ PyDoc_STRVAR(os_set_inheritable__doc__,
"Set the inheritable flag of the specified file descriptor.");
#define OS_SET_INHERITABLE_METHODDEF \
- {"set_inheritable", (PyCFunction)os_set_inheritable, METH_FASTCALL, os_set_inheritable__doc__},
+ {"set_inheritable", (PyCFunction)(void(*)(void))os_set_inheritable, METH_FASTCALL, os_set_inheritable__doc__},
static PyObject *
os_set_inheritable_impl(PyObject *module, int fd, int inheritable);
@@ -5871,7 +5871,7 @@ PyDoc_STRVAR(os_set_handle_inheritable__doc__,
"Set the inheritable flag of the specified handle.");
#define OS_SET_HANDLE_INHERITABLE_METHODDEF \
- {"set_handle_inheritable", (PyCFunction)os_set_handle_inheritable, METH_FASTCALL, os_set_handle_inheritable__doc__},
+ {"set_handle_inheritable", (PyCFunction)(void(*)(void))os_set_handle_inheritable, METH_FASTCALL, os_set_handle_inheritable__doc__},
static PyObject *
os_set_handle_inheritable_impl(PyObject *module, intptr_t handle,
@@ -5946,7 +5946,7 @@ PyDoc_STRVAR(os_set_blocking__doc__,
"clear the O_NONBLOCK flag otherwise.");
#define OS_SET_BLOCKING_METHODDEF \
- {"set_blocking", (PyCFunction)os_set_blocking, METH_FASTCALL, os_set_blocking__doc__},
+ {"set_blocking", (PyCFunction)(void(*)(void))os_set_blocking, METH_FASTCALL, os_set_blocking__doc__},
static PyObject *
os_set_blocking_impl(PyObject *module, int fd, int blocking);
@@ -6005,7 +6005,7 @@ PyDoc_STRVAR(os_DirEntry_stat__doc__,
"Return stat_result object for the entry; cached per entry.");
#define OS_DIRENTRY_STAT_METHODDEF \
- {"stat", (PyCFunction)os_DirEntry_stat, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_stat__doc__},
+ {"stat", (PyCFunction)(void(*)(void))os_DirEntry_stat, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_stat__doc__},
static PyObject *
os_DirEntry_stat_impl(DirEntry *self, int follow_symlinks);
@@ -6035,7 +6035,7 @@ PyDoc_STRVAR(os_DirEntry_is_dir__doc__,
"Return True if the entry is a directory; cached per entry.");
#define OS_DIRENTRY_IS_DIR_METHODDEF \
- {"is_dir", (PyCFunction)os_DirEntry_is_dir, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_dir__doc__},
+ {"is_dir", (PyCFunction)(void(*)(void))os_DirEntry_is_dir, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_dir__doc__},
static int
os_DirEntry_is_dir_impl(DirEntry *self, int follow_symlinks);
@@ -6070,7 +6070,7 @@ PyDoc_STRVAR(os_DirEntry_is_file__doc__,
"Return True if the entry is a file; cached per entry.");
#define OS_DIRENTRY_IS_FILE_METHODDEF \
- {"is_file", (PyCFunction)os_DirEntry_is_file, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_file__doc__},
+ {"is_file", (PyCFunction)(void(*)(void))os_DirEntry_is_file, METH_FASTCALL|METH_KEYWORDS, os_DirEntry_is_file__doc__},
static int
os_DirEntry_is_file_impl(DirEntry *self, int follow_symlinks);
@@ -6147,7 +6147,7 @@ PyDoc_STRVAR(os_scandir__doc__,
"If path is None, uses the path=\'.\'.");
#define OS_SCANDIR_METHODDEF \
- {"scandir", (PyCFunction)os_scandir, METH_FASTCALL|METH_KEYWORDS, os_scandir__doc__},
+ {"scandir", (PyCFunction)(void(*)(void))os_scandir, METH_FASTCALL|METH_KEYWORDS, os_scandir__doc__},
static PyObject *
os_scandir_impl(PyObject *module, path_t *path);
@@ -6184,7 +6184,7 @@ PyDoc_STRVAR(os_fspath__doc__,
"types raise a TypeError.");
#define OS_FSPATH_METHODDEF \
- {"fspath", (PyCFunction)os_fspath, METH_FASTCALL|METH_KEYWORDS, os_fspath__doc__},
+ {"fspath", (PyCFunction)(void(*)(void))os_fspath, METH_FASTCALL|METH_KEYWORDS, os_fspath__doc__},
static PyObject *
os_fspath_impl(PyObject *module, PyObject *path);
@@ -6216,7 +6216,7 @@ PyDoc_STRVAR(os_getrandom__doc__,
"Obtain a series of random bytes.");
#define OS_GETRANDOM_METHODDEF \
- {"getrandom", (PyCFunction)os_getrandom, METH_FASTCALL|METH_KEYWORDS, os_getrandom__doc__},
+ {"getrandom", (PyCFunction)(void(*)(void))os_getrandom, METH_FASTCALL|METH_KEYWORDS, os_getrandom__doc__},
static PyObject *
os_getrandom_impl(PyObject *module, Py_ssize_t size, int flags);
@@ -6757,4 +6757,4 @@ os_getrandom(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject
#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]*/
diff --git a/Modules/clinic/pyexpat.c.h b/Modules/clinic/pyexpat.c.h
index b7687e5a3695..5e6db44c7c43 100644
--- a/Modules/clinic/pyexpat.c.h
+++ b/Modules/clinic/pyexpat.c.h
@@ -11,7 +11,7 @@ PyDoc_STRVAR(pyexpat_xmlparser_Parse__doc__,
"`isfinal\' should be true at end of input.");
#define PYEXPAT_XMLPARSER_PARSE_METHODDEF \
- {"Parse", (PyCFunction)pyexpat_xmlparser_Parse, METH_FASTCALL, pyexpat_xmlparser_Parse__doc__},
+ {"Parse", (PyCFunction)(void(*)(void))pyexpat_xmlparser_Parse, METH_FASTCALL, pyexpat_xmlparser_Parse__doc__},
static PyObject *
pyexpat_xmlparser_Parse_impl(xmlparseobject *self, PyObject *data,
@@ -116,7 +116,7 @@ PyDoc_STRVAR(pyexpat_xmlparser_ExternalEntityParserCreate__doc__,
"Create a parser for parsing an external entity based on the information passed to the ExternalEntityRefHandler.");
#define PYEXPAT_XMLPARSER_EXTERNALENTITYPARSERCREATE_METHODDEF \
- {"ExternalEntityParserCreate", (PyCFunction)pyexpat_xmlparser_ExternalEntityParserCreate, METH_FASTCALL, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
+ {"ExternalEntityParserCreate", (PyCFunction)(void(*)(void))pyexpat_xmlparser_ExternalEntityParserCreate, METH_FASTCALL, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
static PyObject *
pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
@@ -185,7 +185,7 @@ PyDoc_STRVAR(pyexpat_xmlparser_UseForeignDTD__doc__,
"information to the parser. \'flag\' defaults to True if not provided.");
#define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF \
- {"UseForeignDTD", (PyCFunction)pyexpat_xmlparser_UseForeignDTD, METH_FASTCALL, pyexpat_xmlparser_UseForeignDTD__doc__},
+ {"UseForeignDTD", (PyCFunction)(void(*)(void))pyexpat_xmlparser_UseForeignDTD, METH_FASTCALL, pyexpat_xmlparser_UseForeignDTD__doc__},
static PyObject *
pyexpat_xmlparser_UseForeignDTD_impl(xmlparseobject *self, int flag);
@@ -216,7 +216,7 @@ PyDoc_STRVAR(pyexpat_ParserCreate__doc__,
"Return a new XML parser object.");
#define PYEXPAT_PARSERCREATE_METHODDEF \
- {"ParserCreate", (PyCFunction)pyexpat_ParserCreate, METH_FASTCALL|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
+ {"ParserCreate", (PyCFunction)(void(*)(void))pyexpat_ParserCreate, METH_FASTCALL|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
static PyObject *
pyexpat_ParserCreate_impl(PyObject *module, const char *encoding,
@@ -272,4 +272,4 @@ pyexpat_ErrorString(PyObject *module, PyObject *arg)
#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]*/
diff --git a/Modules/clinic/resource.c.h b/Modules/clinic/resource.c.h
index 9163cac76c6f..cd9fae1df0ae 100644
--- a/Modules/clinic/resource.c.h
+++ b/Modules/clinic/resource.c.h
@@ -60,7 +60,7 @@ PyDoc_STRVAR(resource_setrlimit__doc__,
"\n");
#define RESOURCE_SETRLIMIT_METHODDEF \
- {"setrlimit", (PyCFunction)resource_setrlimit, METH_FASTCALL, resource_setrlimit__doc__},
+ {"setrlimit", (PyCFunction)(void(*)(void))resource_setrlimit, METH_FASTCALL, resource_setrlimit__doc__},
static PyObject *
resource_setrlimit_impl(PyObject *module, int resource, PyObject *limits);
@@ -157,4 +157,4 @@ resource_getpagesize(PyObject *module, PyObject *Py_UNUSED(ignored))
#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]*/
diff --git a/Modules/clinic/selectmodule.c.h b/Modules/clinic/selectmodule.c.h
index b87b3906f116..0a53ae2b9199 100644
--- a/Modules/clinic/selectmodule.c.h
+++ b/Modules/clinic/selectmodule.c.h
@@ -30,7 +30,7 @@ PyDoc_STRVAR(select_select__doc__,
"descriptors can be used.");
#define SELECT_SELECT_METHODDEF \
- {"select", (PyCFunction)select_select, METH_FASTCALL, select_select__doc__},
+ {"select", (PyCFunction)(void(*)(void))select_select, METH_FASTCALL, select_select__doc__},
static PyObject *
select_select_impl(PyObject *module, PyObject *rlist, PyObject *wlist,
@@ -70,7 +70,7 @@ PyDoc_STRVAR(select_poll_register__doc__,
" an optional bitmask describing the type of events to check for");
#define SELECT_POLL_REGISTER_METHODDEF \
- {"register", (PyCFunction)select_poll_register, METH_FASTCALL, select_poll_register__doc__},
+ {"register", (PyCFunction)(void(*)(void))select_poll_register, METH_FASTCALL, select_poll_register__doc__},
static PyObject *
select_poll_register_impl(pollObject *self, int fd, unsigned short eventmask);
@@ -109,7 +109,7 @@ PyDoc_STRVAR(select_poll_modify__doc__,
" a bitmask describing the type of events to check for");
#define SELECT_POLL_MODIFY_METHODDEF \
- {"modify", (PyCFunction)select_poll_modify, METH_FASTCALL, select_poll_modify__doc__},
+ {"modify", (PyCFunction)(void(*)(void))select_poll_modify, METH_FASTCALL, select_poll_modify__doc__},
static PyObject *
select_poll_modify_impl(pollObject *self, int fd, unsigned short eventmask);
@@ -176,7 +176,7 @@ PyDoc_STRVAR(select_poll_poll__doc__,
"report, as a list of (fd, event) 2-tuples.");
#define SELECT_POLL_POLL_METHODDEF \
- {"poll", (PyCFunction)select_poll_poll, METH_FASTCALL, select_poll_poll__doc__},
+ {"poll", (PyCFunction)(void(*)(void))select_poll_poll, METH_FASTCALL, select_poll_poll__doc__},
static PyObject *
select_poll_poll_impl(pollObject *self, PyObject *timeout_obj);
@@ -215,7 +215,7 @@ PyDoc_STRVAR(select_devpoll_register__doc__,
" an optional bitmask describing the type of events to check for");
#define SELECT_DEVPOLL_REGISTER_METHODDEF \
- {"register", (PyCFunction)select_devpoll_register, METH_FASTCALL, select_devpoll_register__doc__},
+ {"register", (PyCFunction)(void(*)(void))select_devpoll_register, METH_FASTCALL, select_devpoll_register__doc__},
static PyObject *
select_devpoll_register_impl(devpollObject *self, int fd,
@@ -255,7 +255,7 @@ PyDoc_STRVAR(select_devpoll_modify__doc__,
" an optional bitmask describing the type of events to check for");
#define SELECT_DEVPOLL_MODIFY_METHODDEF \
- {"modify", (PyCFunction)select_devpoll_modify, METH_FASTCALL, select_devpoll_modify__doc__},
+ {"modify", (PyCFunction)(void(*)(void))select_devpoll_modify, METH_FASTCALL, select_devpoll_modify__doc__},
static PyObject *
select_devpoll_modify_impl(devpollObject *self, int fd,
@@ -323,7 +323,7 @@ PyDoc_STRVAR(select_devpoll_poll__doc__,
"report, as a list of (fd, event) 2-tuples.");
#define SELECT_DEVPOLL_POLL_METHODDEF \
- {"poll", (PyCFunction)select_devpoll_poll, METH_FASTCALL, select_devpoll_poll__doc__},
+ {"poll", (PyCFunction)(void(*)(void))select_devpoll_poll, METH_FASTCALL, select_devpoll_poll__doc__},
static PyObject *
select_devpoll_poll_impl(devpollObject *self, PyObject *timeout_obj);
@@ -577,7 +577,7 @@ PyDoc_STRVAR(select_epoll_register__doc__,
"The epoll interface supports all file descriptors that support poll.");
#define SELECT_EPOLL_REGISTER_METHODDEF \
- {"register", (PyCFunction)select_epoll_register, METH_FASTCALL|METH_KEYWORDS, select_epoll_register__doc__},
+ {"register", (PyCFunction)(void(*)(void))select_epoll_register, METH_FASTCALL|METH_KEYWORDS, select_epoll_register__doc__},
static PyObject *
select_epoll_register_impl(pyEpoll_Object *self, int fd,
@@ -618,7 +618,7 @@ PyDoc_STRVAR(select_epoll_modify__doc__,
" a bit set composed of the various EPOLL constants");
#define SELECT_EPOLL_MODIFY_METHODDEF \
- {"modify", (PyCFunction)select_epoll_modify, METH_FASTCALL|METH_KEYWORDS, select_epoll_modify__doc__},
+ {"modify", (PyCFunction)(void(*)(void))select_epoll_modify, METH_FASTCALL|METH_KEYWORDS, select_epoll_modify__doc__},
static PyObject *
select_epoll_modify_impl(pyEpoll_Object *self, int fd,
@@ -657,7 +657,7 @@ PyDoc_STRVAR(select_epoll_unregister__doc__,
" the target file descriptor of the operation");
#define SELECT_EPOLL_UNREGISTER_METHODDEF \
- {"unregister", (PyCFunction)select_epoll_unregister, METH_FASTCALL|METH_KEYWORDS, select_epoll_unregister__doc__},
+ {"unregister", (PyCFunction)(void(*)(void))select_epoll_unregister, METH_FASTCALL|METH_KEYWORDS, select_epoll_unregister__doc__},
static PyObject *
select_epoll_unregister_impl(pyEpoll_Object *self, int fd);
@@ -700,7 +700,7 @@ PyDoc_STRVAR(select_epoll_poll__doc__,
"as a list of (fd, events) 2-tuples.");
#define SELECT_EPOLL_POLL_METHODDEF \
- {"poll", (PyCFunction)select_epoll_poll, METH_FASTCALL|METH_KEYWORDS, select_epoll_poll__doc__},
+ {"poll", (PyCFunction)(void(*)(void))select_epoll_poll, METH_FASTCALL|METH_KEYWORDS, select_epoll_poll__doc__},
static PyObject *
select_epoll_poll_impl(pyEpoll_Object *self, PyObject *timeout_obj,
@@ -756,7 +756,7 @@ PyDoc_STRVAR(select_epoll___exit____doc__,
"\n");
#define SELECT_EPOLL___EXIT___METHODDEF \
- {"__exit__", (PyCFunction)select_epoll___exit__, METH_FASTCALL, select_epoll___exit____doc__},
+ {"__exit__", (PyCFunction)(void(*)(void))select_epoll___exit__, METH_FASTCALL, select_epoll___exit____doc__},
static PyObject *
select_epoll___exit___impl(pyEpoll_Object *self, PyObject *exc_type,
@@ -922,7 +922,7 @@ PyDoc_STRVAR(select_kqueue_control__doc__,
" This accepts floats for smaller timeouts, too.");
#define SELECT_KQUEUE_CONTROL_METHODDEF \
- {"control", (PyCFunction)select_kqueue_control, METH_FASTCALL, select_kqueue_control__doc__},
+ {"control", (PyCFunction)(void(*)(void))select_kqueue_control, METH_FASTCALL, select_kqueue_control__doc__},
static PyObject *
select_kqueue_control_impl(kqueue_queue_Object *self, PyObject *changelist,
@@ -1047,4 +1047,4 @@ select_kqueue_control(kqueue_queue_Object *self, PyObject *const *args, Py_ssize
#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]*/
diff --git a/Modules/clinic/sha1module.c.h b/Modules/clinic/sha1module.c.h
index c84fcbac5f6f..af29173bae55 100644
--- a/Modules/clinic/sha1module.c.h
+++ b/Modules/clinic/sha1module.c.h
@@ -72,7 +72,7 @@ PyDoc_STRVAR(_sha1_sha1__doc__,
"Return a new SHA1 hash object; optionally initialized with a string.");
#define _SHA1_SHA1_METHODDEF \
- {"sha1", (PyCFunction)_sha1_sha1, METH_FASTCALL|METH_KEYWORDS, _sha1_sha1__doc__},
+ {"sha1", (PyCFunction)(void(*)(void))_sha1_sha1, METH_FASTCALL|METH_KEYWORDS, _sha1_sha1__doc__},
static PyObject *
_sha1_sha1_impl(PyObject *module, PyObject *string);
@@ -94,4 +94,4 @@ _sha1_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *
exit:
return return_value;
}
-/*[clinic end generated code: output=81d2424c0585bfd4 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3bae85313ee5a3b5 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/sha256module.c.h b/Modules/clinic/sha256module.c.h
index 45f78c8f795e..14a88a2be8f4 100644
--- a/Modules/clinic/sha256module.c.h
+++ b/Modules/clinic/sha256module.c.h
@@ -72,7 +72,7 @@ PyDoc_STRVAR(_sha256_sha256__doc__,
"Return a new SHA-256 hash object; optionally initialized with a string.");
#define _SHA256_SHA256_METHODDEF \
- {"sha256", (PyCFunction)_sha256_sha256, METH_FASTCALL|METH_KEYWORDS, _sha256_sha256__doc__},
+ {"sha256", (PyCFunction)(void(*)(void))_sha256_sha256, METH_FASTCALL|METH_KEYWORDS, _sha256_sha256__doc__},
static PyObject *
_sha256_sha256_impl(PyObject *module, PyObject *string);
@@ -102,7 +102,7 @@ PyDoc_STRVAR(_sha256_sha224__doc__,
"Return a new SHA-224 hash object; optionally initialized with a string.");
#define _SHA256_SHA224_METHODDEF \
- {"sha224", (PyCFunction)_sha256_sha224, METH_FASTCALL|METH_KEYWORDS, _sha256_sha224__doc__},
+ {"sha224", (PyCFunction)(void(*)(void))_sha256_sha224, METH_FASTCALL|METH_KEYWORDS, _sha256_sha224__doc__},
static PyObject *
_sha256_sha224_impl(PyObject *module, PyObject *string);
@@ -124,4 +124,4 @@ _sha256_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje
exit:
return return_value;
}
-/*[clinic end generated code: output=0086286cffcbc31c input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fb208641d4bc3b5f input=a9049054013a1b77]*/
diff --git a/Modules/clinic/sha512module.c.h b/Modules/clinic/sha512module.c.h
index 9d3a7c9e6d4a..7e08701937a5 100644
--- a/Modules/clinic/sha512module.c.h
+++ b/Modules/clinic/sha512module.c.h
@@ -72,7 +72,7 @@ PyDoc_STRVAR(_sha512_sha512__doc__,
"Return a new SHA-512 hash object; optionally initialized with a string.");
#define _SHA512_SHA512_METHODDEF \
- {"sha512", (PyCFunction)_sha512_sha512, METH_FASTCALL|METH_KEYWORDS, _sha512_sha512__doc__},
+ {"sha512", (PyCFunction)(void(*)(void))_sha512_sha512, METH_FASTCALL|METH_KEYWORDS, _sha512_sha512__doc__},
static PyObject *
_sha512_sha512_impl(PyObject *module, PyObject *string);
@@ -102,7 +102,7 @@ PyDoc_STRVAR(_sha512_sha384__doc__,
"Return a new SHA-384 hash object; optionally initialized with a string.");
#define _SHA512_SHA384_METHODDEF \
- {"sha384", (PyCFunction)_sha512_sha384, METH_FASTCALL|METH_KEYWORDS, _sha512_sha384__doc__},
+ {"sha384", (PyCFunction)(void(*)(void))_sha512_sha384, METH_FASTCALL|METH_KEYWORDS, _sha512_sha384__doc__},
static PyObject *
_sha512_sha384_impl(PyObject *module, PyObject *string);
@@ -124,4 +124,4 @@ _sha512_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObje
exit:
return return_value;
}
-/*[clinic end generated code: output=fcc3306fb6672222 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3706fa47bea06c0b input=a9049054013a1b77]*/
diff --git a/Modules/clinic/signalmodule.c.h b/Modules/clinic/signalmodule.c.h
index 4d7ac38372f2..912f989539d9 100644
--- a/Modules/clinic/signalmodule.c.h
+++ b/Modules/clinic/signalmodule.c.h
@@ -74,7 +74,7 @@ PyDoc_STRVAR(signal_signal__doc__,
"the first is the signal number, the second is the interrupted stack frame.");
#define SIGNAL_SIGNAL_METHODDEF \
- {"signal", (PyCFunction)signal_signal, METH_FASTCALL, signal_signal__doc__},
+ {"signal", (PyCFunction)(void(*)(void))signal_signal, METH_FASTCALL, signal_signal__doc__},
static PyObject *
signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
@@ -171,7 +171,7 @@ PyDoc_STRVAR(signal_siginterrupt__doc__,
"signal sig, else system calls will be interrupted.");
#define SIGNAL_SIGINTERRUPT_METHODDEF \
- {"siginterrupt", (PyCFunction)signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
+ {"siginterrupt", (PyCFunction)(void(*)(void))signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
static PyObject *
signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
@@ -209,7 +209,7 @@ PyDoc_STRVAR(signal_setitimer__doc__,
"Returns old values as a tuple: (delay, interval).");
#define SIGNAL_SETITIMER_METHODDEF \
- {"setitimer", (PyCFunction)signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
+ {"setitimer", (PyCFunction)(void(*)(void))signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
static PyObject *
signal_setitimer_impl(PyObject *module, int which, PyObject *seconds,
@@ -275,7 +275,7 @@ PyDoc_STRVAR(signal_pthread_sigmask__doc__,
"Fetch and/or change the signal mask of the calling thread.");
#define SIGNAL_PTHREAD_SIGMASK_METHODDEF \
- {"pthread_sigmask", (PyCFunction)signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
+ {"pthread_sigmask", (PyCFunction)(void(*)(void))signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
static PyObject *
signal_pthread_sigmask_impl(PyObject *module, int how, sigset_t mask);
@@ -428,7 +428,7 @@ PyDoc_STRVAR(signal_sigtimedwait__doc__,
"The timeout is specified in seconds, with floating point numbers allowed.");
#define SIGNAL_SIGTIMEDWAIT_METHODDEF \
- {"sigtimedwait", (PyCFunction)signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
+ {"sigtimedwait", (PyCFunction)(void(*)(void))signal_sigtimedwait, METH_FASTCALL, signal_sigtimedwait__doc__},
static PyObject *
signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
@@ -462,7 +462,7 @@ PyDoc_STRVAR(signal_pthread_kill__doc__,
"Send a signal to a thread.");
#define SIGNAL_PTHREAD_KILL_METHODDEF \
- {"pthread_kill", (PyCFunction)signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
+ {"pthread_kill", (PyCFunction)(void(*)(void))signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
static PyObject *
signal_pthread_kill_impl(PyObject *module, unsigned long thread_id,
@@ -534,4 +534,4 @@ signal_pthread_kill(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
#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]*/
diff --git a/Modules/clinic/symtablemodule.c.h b/Modules/clinic/symtablemodule.c.h
index 6f1e4fe0c731..b5e64e0313f8 100644
--- a/Modules/clinic/symtablemodule.c.h
+++ b/Modules/clinic/symtablemodule.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(_symtable_symtable__doc__,
"Return symbol and scope dictionaries used internally by compiler.");
#define _SYMTABLE_SYMTABLE_METHODDEF \
- {"symtable", (PyCFunction)_symtable_symtable, METH_FASTCALL, _symtable_symtable__doc__},
+ {"symtable", (PyCFunction)(void(*)(void))_symtable_symtable, METH_FASTCALL, _symtable_symtable__doc__},
static PyObject *
_symtable_symtable_impl(PyObject *module, const char *str,
@@ -32,4 +32,4 @@ _symtable_symtable(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=c18565060a6cae04 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=52ece07dd0e7a113 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/unicodedata.c.h b/Modules/clinic/unicodedata.c.h
index 54021fedba41..4799fb44279c 100644
--- a/Modules/clinic/unicodedata.c.h
+++ b/Modules/clinic/unicodedata.c.h
@@ -13,7 +13,7 @@ PyDoc_STRVAR(unicodedata_UCD_decimal__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_DECIMAL_METHODDEF \
- {"decimal", (PyCFunction)unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__},
+ {"decimal", (PyCFunction)(void(*)(void))unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__},
static PyObject *
unicodedata_UCD_decimal_impl(PyObject *self, int chr,
@@ -47,7 +47,7 @@ PyDoc_STRVAR(unicodedata_UCD_digit__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_DIGIT_METHODDEF \
- {"digit", (PyCFunction)unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__},
+ {"digit", (PyCFunction)(void(*)(void))unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__},
static PyObject *
unicodedata_UCD_digit_impl(PyObject *self, int chr, PyObject *default_value);
@@ -80,7 +80,7 @@ PyDoc_STRVAR(unicodedata_UCD_numeric__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_NUMERIC_METHODDEF \
- {"numeric", (PyCFunction)unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__},
+ {"numeric", (PyCFunction)(void(*)(void))unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__},
static PyObject *
unicodedata_UCD_numeric_impl(PyObject *self, int chr,
@@ -293,7 +293,7 @@ PyDoc_STRVAR(unicodedata_UCD_is_normalized__doc__,
"Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'.");
#define UNICODEDATA_UCD_IS_NORMALIZED_METHODDEF \
- {"is_normalized", (PyCFunction)unicodedata_UCD_is_normalized, METH_FASTCALL, unicodedata_UCD_is_normalized__doc__},
+ {"is_normalized", (PyCFunction)(void(*)(void))unicodedata_UCD_is_normalized, METH_FASTCALL, unicodedata_UCD_is_normalized__doc__},
static PyObject *
unicodedata_UCD_is_normalized_impl(PyObject *self, PyObject *form,
@@ -325,7 +325,7 @@ PyDoc_STRVAR(unicodedata_UCD_normalize__doc__,
"Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'.");
#define UNICODEDATA_UCD_NORMALIZE_METHODDEF \
- {"normalize", (PyCFunction)unicodedata_UCD_normalize, METH_FASTCALL, unicodedata_UCD_normalize__doc__},
+ {"normalize", (PyCFunction)(void(*)(void))unicodedata_UCD_normalize, METH_FASTCALL, unicodedata_UCD_normalize__doc__},
static PyObject *
unicodedata_UCD_normalize_impl(PyObject *self, PyObject *form,
@@ -358,7 +358,7 @@ PyDoc_STRVAR(unicodedata_UCD_name__doc__,
"ValueError is raised.");
#define UNICODEDATA_UCD_NAME_METHODDEF \
- {"name", (PyCFunction)unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__},
+ {"name", (PyCFunction)(void(*)(void))unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__},
static PyObject *
unicodedata_UCD_name_impl(PyObject *self, int chr, PyObject *default_value);
@@ -411,4 +411,4 @@ unicodedata_UCD_lookup(PyObject *self, PyObject *arg)
exit:
return return_value;
}
-/*[clinic end generated code: output=2c5fbf597c18f6b8 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=67f474927be668bf input=a9049054013a1b77]*/
diff --git a/Modules/clinic/zipimport.c.h b/Modules/clinic/zipimport.c.h
new file mode 100644
index 000000000000..aabe7a05ae9d
--- /dev/null
+++ b/Modules/clinic/zipimport.c.h
@@ -0,0 +1,325 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(zipimport_zipimporter___init____doc__,
+"zipimporter(archivepath, /)\n"
+"--\n"
+"\n"
+"Create a new zipimporter instance.\n"
+"\n"
+" archivepath\n"
+" A path-like object to a zipfile, or to a specific path inside\n"
+" a zipfile.\n"
+"\n"
+"\'archivepath\' must be a path-like object to a zipfile, or to a specific path\n"
+"inside a zipfile. For example, it can be \'/tmp/myimport.zip\', or\n"
+"\'/tmp/myimport.zip/mydirectory\', if mydirectory is a valid directory inside\n"
+"the archive.\n"
+"\n"
+"\'ZipImportError\' is raised if \'archivepath\' doesn\'t point to a valid Zip\n"
+"archive.\n"
+"\n"
+"The \'archive\' attribute of the zipimporter object contains the name of the\n"
+"zipfile targeted.");
+
+static int
+zipimport_zipimporter___init___impl(ZipImporter *self, PyObject *path);
+
+static int
+zipimport_zipimporter___init__(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+ int return_value = -1;
+ PyObject *path;
+
+ if ((Py_TYPE(self) == &ZipImporter_Type) &&
+ !_PyArg_NoKeywords("zipimporter", kwargs)) {
+ goto exit;
+ }
+ if (!PyArg_ParseTuple(args, "O&:zipimporter",
+ PyUnicode_FSDecoder, &path)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter___init___impl((ZipImporter *)self, path);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_find_module__doc__,
+"find_module($self, fullname, path=None, /)\n"
+"--\n"
+"\n"
+"Search for a module specified by \'fullname\'.\n"
+"\n"
+"\'fullname\' must be the fully qualified (dotted) module name. It returns the\n"
+"zipimporter instance itself if the module was found, or None if it wasn\'t.\n"
+"The optional \'path\' argument is ignored -- it\'s there for compatibility\n"
+"with the importer protocol.");
+
+#define ZIPIMPORT_ZIPIMPORTER_FIND_MODULE_METHODDEF \
+ {"find_module", (PyCFunction)(void *)zipimport_zipimporter_find_module, METH_FASTCALL, zipimport_zipimporter_find_module__doc__},
+
+static PyObject *
+zipimport_zipimporter_find_module_impl(ZipImporter *self, PyObject *fullname,
+ PyObject *path);
+
+static PyObject *
+zipimport_zipimporter_find_module(ZipImporter *self, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+ PyObject *path = Py_None;
+
+ if (!_PyArg_ParseStack(args, nargs, "U|O:find_module",
+ &fullname, &path)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_find_module_impl(self, fullname, path);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_find_loader__doc__,
+"find_loader($self, fullname, path=None, /)\n"
+"--\n"
+"\n"
+"Search for a module specified by \'fullname\'.\n"
+"\n"
+"\'fullname\' must be the fully qualified (dotted) module name. It returns the\n"
+"zipimporter instance itself if the module was found, a string containing the\n"
+"full path name if it\'s possibly a portion of a namespace package,\n"
+"or None otherwise. The optional \'path\' argument is ignored -- it\'s\n"
+"there for compatibility with the importer protocol.");
+
+#define ZIPIMPORT_ZIPIMPORTER_FIND_LOADER_METHODDEF \
+ {"find_loader", (PyCFunction)(void *)zipimport_zipimporter_find_loader, METH_FASTCALL, zipimport_zipimporter_find_loader__doc__},
+
+static PyObject *
+zipimport_zipimporter_find_loader_impl(ZipImporter *self, PyObject *fullname,
+ PyObject *path);
+
+static PyObject *
+zipimport_zipimporter_find_loader(ZipImporter *self, PyObject *const *args, Py_ssize_t nargs)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+ PyObject *path = Py_None;
+
+ if (!_PyArg_ParseStack(args, nargs, "U|O:find_loader",
+ &fullname, &path)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_find_loader_impl(self, fullname, path);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_load_module__doc__,
+"load_module($self, fullname, /)\n"
+"--\n"
+"\n"
+"Load the module specified by \'fullname\'.\n"
+"\n"
+"\'fullname\' must be the fully qualified (dotted) module name. It returns the\n"
+"imported module, or raises ZipImportError if it wasn\'t found.");
+
+#define ZIPIMPORT_ZIPIMPORTER_LOAD_MODULE_METHODDEF \
+ {"load_module", (PyCFunction)zipimport_zipimporter_load_module, METH_O, zipimport_zipimporter_load_module__doc__},
+
+static PyObject *
+zipimport_zipimporter_load_module_impl(ZipImporter *self, PyObject *fullname);
+
+static PyObject *
+zipimport_zipimporter_load_module(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+
+ if (!PyArg_Parse(arg, "U:load_module", &fullname)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_load_module_impl(self, fullname);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_get_filename__doc__,
+"get_filename($self, fullname, /)\n"
+"--\n"
+"\n"
+"Return the filename for the specified module.");
+
+#define ZIPIMPORT_ZIPIMPORTER_GET_FILENAME_METHODDEF \
+ {"get_filename", (PyCFunction)zipimport_zipimporter_get_filename, METH_O, zipimport_zipimporter_get_filename__doc__},
+
+static PyObject *
+zipimport_zipimporter_get_filename_impl(ZipImporter *self,
+ PyObject *fullname);
+
+static PyObject *
+zipimport_zipimporter_get_filename(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+
+ if (!PyArg_Parse(arg, "U:get_filename", &fullname)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_get_filename_impl(self, fullname);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_is_package__doc__,
+"is_package($self, fullname, /)\n"
+"--\n"
+"\n"
+"Return True if the module specified by fullname is a package.\n"
+"\n"
+"Raise ZipImportError if the module couldn\'t be found.");
+
+#define ZIPIMPORT_ZIPIMPORTER_IS_PACKAGE_METHODDEF \
+ {"is_package", (PyCFunction)zipimport_zipimporter_is_package, METH_O, zipimport_zipimporter_is_package__doc__},
+
+static PyObject *
+zipimport_zipimporter_is_package_impl(ZipImporter *self, PyObject *fullname);
+
+static PyObject *
+zipimport_zipimporter_is_package(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+
+ if (!PyArg_Parse(arg, "U:is_package", &fullname)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_is_package_impl(self, fullname);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_get_data__doc__,
+"get_data($self, pathname, /)\n"
+"--\n"
+"\n"
+"Return the data associated with \'pathname\'.\n"
+"\n"
+"Raise OSError if the file was not found.");
+
+#define ZIPIMPORT_ZIPIMPORTER_GET_DATA_METHODDEF \
+ {"get_data", (PyCFunction)zipimport_zipimporter_get_data, METH_O, zipimport_zipimporter_get_data__doc__},
+
+static PyObject *
+zipimport_zipimporter_get_data_impl(ZipImporter *self, PyObject *path);
+
+static PyObject *
+zipimport_zipimporter_get_data(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *path;
+
+ if (!PyArg_Parse(arg, "U:get_data", &path)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_get_data_impl(self, path);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_get_code__doc__,
+"get_code($self, fullname, /)\n"
+"--\n"
+"\n"
+"Return the code object for the specified module.\n"
+"\n"
+"Raise ZipImportError if the module couldn\'t be found.");
+
+#define ZIPIMPORT_ZIPIMPORTER_GET_CODE_METHODDEF \
+ {"get_code", (PyCFunction)zipimport_zipimporter_get_code, METH_O, zipimport_zipimporter_get_code__doc__},
+
+static PyObject *
+zipimport_zipimporter_get_code_impl(ZipImporter *self, PyObject *fullname);
+
+static PyObject *
+zipimport_zipimporter_get_code(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+
+ if (!PyArg_Parse(arg, "U:get_code", &fullname)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_get_code_impl(self, fullname);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_get_source__doc__,
+"get_source($self, fullname, /)\n"
+"--\n"
+"\n"
+"Return the source code for the specified module.\n"
+"\n"
+"Raise ZipImportError if the module couldn\'t be found, return None if the\n"
+"archive does contain the module, but has no source for it.");
+
+#define ZIPIMPORT_ZIPIMPORTER_GET_SOURCE_METHODDEF \
+ {"get_source", (PyCFunction)zipimport_zipimporter_get_source, METH_O, zipimport_zipimporter_get_source__doc__},
+
+static PyObject *
+zipimport_zipimporter_get_source_impl(ZipImporter *self, PyObject *fullname);
+
+static PyObject *
+zipimport_zipimporter_get_source(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+
+ if (!PyArg_Parse(arg, "U:get_source", &fullname)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_get_source_impl(self, fullname);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(zipimport_zipimporter_get_resource_reader__doc__,
+"get_resource_reader($self, fullname, /)\n"
+"--\n"
+"\n"
+"Return the ResourceReader for a package in a zip file.\n"
+"\n"
+"If \'fullname\' is a package within the zip file, return the \'ResourceReader\'\n"
+"object for the package. Otherwise return None.");
+
+#define ZIPIMPORT_ZIPIMPORTER_GET_RESOURCE_READER_METHODDEF \
+ {"get_resource_reader", (PyCFunction)zipimport_zipimporter_get_resource_reader, METH_O, zipimport_zipimporter_get_resource_reader__doc__},
+
+static PyObject *
+zipimport_zipimporter_get_resource_reader_impl(ZipImporter *self,
+ PyObject *fullname);
+
+static PyObject *
+zipimport_zipimporter_get_resource_reader(ZipImporter *self, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ PyObject *fullname;
+
+ if (!PyArg_Parse(arg, "U:get_resource_reader", &fullname)) {
+ goto exit;
+ }
+ return_value = zipimport_zipimporter_get_resource_reader_impl(self, fullname);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=854ce3502180dc1f input=a9049054013a1b77]*/
diff --git a/Modules/clinic/zlibmodule.c.h b/Modules/clinic/zlibmodule.c.h
index 99db052bf2fa..c5eeab7459c5 100644
--- a/Modules/clinic/zlibmodule.c.h
+++ b/Modules/clinic/zlibmodule.c.h
@@ -14,7 +14,7 @@ PyDoc_STRVAR(zlib_compress__doc__,
" Compression level, in 0-9 or -1.");
#define ZLIB_COMPRESS_METHODDEF \
- {"compress", (PyCFunction)zlib_compress, METH_FASTCALL|METH_KEYWORDS, zlib_compress__doc__},
+ {"compress", (PyCFunction)(void(*)(void))zlib_compress, METH_FASTCALL|METH_KEYWORDS, zlib_compress__doc__},
static PyObject *
zlib_compress_impl(PyObject *module, Py_buffer *data, int level);
@@ -57,7 +57,7 @@ PyDoc_STRVAR(zlib_decompress__doc__,
" The initial output buffer size.");
#define ZLIB_DECOMPRESS_METHODDEF \
- {"decompress", (PyCFunction)zlib_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_decompress__doc__},
+ {"decompress", (PyCFunction)(void(*)(void))zlib_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_decompress__doc__},
static PyObject *
zlib_decompress_impl(PyObject *module, Py_buffer *data, int wbits,
@@ -119,7 +119,7 @@ PyDoc_STRVAR(zlib_compressobj__doc__,
" containing subsequences that are likely to occur in the input data.");
#define ZLIB_COMPRESSOBJ_METHODDEF \
- {"compressobj", (PyCFunction)zlib_compressobj, METH_FASTCALL|METH_KEYWORDS, zlib_compressobj__doc__},
+ {"compressobj", (PyCFunction)(void(*)(void))zlib_compressobj, METH_FASTCALL|METH_KEYWORDS, zlib_compressobj__doc__},
static PyObject *
zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,
@@ -166,7 +166,7 @@ PyDoc_STRVAR(zlib_decompressobj__doc__,
" dictionary as used by the compressor that produced the input data.");
#define ZLIB_DECOMPRESSOBJ_METHODDEF \
- {"decompressobj", (PyCFunction)zlib_decompressobj, METH_FASTCALL|METH_KEYWORDS, zlib_decompressobj__doc__},
+ {"decompressobj", (PyCFunction)(void(*)(void))zlib_decompressobj, METH_FASTCALL|METH_KEYWORDS, zlib_decompressobj__doc__},
static PyObject *
zlib_decompressobj_impl(PyObject *module, int wbits, PyObject *zdict);
@@ -247,7 +247,7 @@ PyDoc_STRVAR(zlib_Decompress_decompress__doc__,
"Call the flush() method to clear these buffers.");
#define ZLIB_DECOMPRESS_DECOMPRESS_METHODDEF \
- {"decompress", (PyCFunction)zlib_Decompress_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_decompress__doc__},
+ {"decompress", (PyCFunction)(void(*)(void))zlib_Decompress_decompress, METH_FASTCALL|METH_KEYWORDS, zlib_Decompress_decompress__doc__},
static PyObject *
zlib_Decompress_decompress_impl(compobject *self, Py_buffer *data,
@@ -290,7 +290,7 @@ PyDoc_STRVAR(zlib_Compress_flush__doc__,
" can still be compressed.");
#define ZLIB_COMPRESS_FLUSH_METHODDEF \
- {"flush", (PyCFunction)zlib_Compress_flush, METH_FASTCALL, zlib_Compress_flush__doc__},
+ {"flush", (PyCFunction)(void(*)(void))zlib_Compress_flush, METH_FASTCALL, zlib_Compress_flush__doc__},
static PyObject *
zlib_Compress_flush_impl(compobject *self, int mode);
@@ -431,7 +431,7 @@ PyDoc_STRVAR(zlib_Decompress_flush__doc__,
" the initial size of the output buffer.");
#define ZLIB_DECOMPRESS_FLUSH_METHODDEF \
- {"flush", (PyCFunction)zlib_Decompress_flush, METH_FASTCALL, zlib_Decompress_flush__doc__},
+ {"flush", (PyCFunction)(void(*)(void))zlib_Decompress_flush, METH_FASTCALL, zlib_Decompress_flush__doc__},
static PyObject *
zlib_Decompress_flush_impl(compobject *self, Py_ssize_t length);
@@ -464,7 +464,7 @@ PyDoc_STRVAR(zlib_adler32__doc__,
"The returned checksum is an integer.");
#define ZLIB_ADLER32_METHODDEF \
- {"adler32", (PyCFunction)zlib_adler32, METH_FASTCALL, zlib_adler32__doc__},
+ {"adler32", (PyCFunction)(void(*)(void))zlib_adler32, METH_FASTCALL, zlib_adler32__doc__},
static PyObject *
zlib_adler32_impl(PyObject *module, Py_buffer *data, unsigned int value);
@@ -503,7 +503,7 @@ PyDoc_STRVAR(zlib_crc32__doc__,
"The returned checksum is an integer.");
#define ZLIB_CRC32_METHODDEF \
- {"crc32", (PyCFunction)zlib_crc32, METH_FASTCALL, zlib_crc32__doc__},
+ {"crc32", (PyCFunction)(void(*)(void))zlib_crc32, METH_FASTCALL, zlib_crc32__doc__},
static PyObject *
zlib_crc32_impl(PyObject *module, Py_buffer *data, unsigned int value);
@@ -553,4 +553,4 @@ zlib_crc32(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
#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]*/
diff --git a/Objects/clinic/bytearrayobject.c.h b/Objects/clinic/bytearrayobject.c.h
index d88883245ef6..f21353a17eae 100644
--- a/Objects/clinic/bytearrayobject.c.h
+++ b/Objects/clinic/bytearrayobject.c.h
@@ -51,7 +51,7 @@ PyDoc_STRVAR(bytearray_translate__doc__,
"The remaining characters are mapped through the given translation table.");
#define BYTEARRAY_TRANSLATE_METHODDEF \
- {"translate", (PyCFunction)bytearray_translate, METH_FASTCALL|METH_KEYWORDS, bytearray_translate__doc__},
+ {"translate", (PyCFunction)(void(*)(void))bytearray_translate, METH_FASTCALL|METH_KEYWORDS, bytearray_translate__doc__},
static PyObject *
bytearray_translate_impl(PyByteArrayObject *self, PyObject *table,
@@ -88,7 +88,7 @@ PyDoc_STRVAR(bytearray_maketrans__doc__,
"The bytes objects frm and to must be of the same length.");
#define BYTEARRAY_MAKETRANS_METHODDEF \
- {"maketrans", (PyCFunction)bytearray_maketrans, METH_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
+ {"maketrans", (PyCFunction)(void(*)(void))bytearray_maketrans, METH_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
static PyObject *
bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to);
@@ -133,7 +133,7 @@ PyDoc_STRVAR(bytearray_replace__doc__,
"replaced.");
#define BYTEARRAY_REPLACE_METHODDEF \
- {"replace", (PyCFunction)bytearray_replace, METH_FASTCALL, bytearray_replace__doc__},
+ {"replace", (PyCFunction)(void(*)(void))bytearray_replace, METH_FASTCALL, bytearray_replace__doc__},
static PyObject *
bytearray_replace_impl(PyByteArrayObject *self, Py_buffer *old,
@@ -181,7 +181,7 @@ PyDoc_STRVAR(bytearray_split__doc__,
" -1 (the default value) means no limit.");
#define BYTEARRAY_SPLIT_METHODDEF \
- {"split", (PyCFunction)bytearray_split, METH_FASTCALL|METH_KEYWORDS, bytearray_split__doc__},
+ {"split", (PyCFunction)(void(*)(void))bytearray_split, METH_FASTCALL|METH_KEYWORDS, bytearray_split__doc__},
static PyObject *
bytearray_split_impl(PyByteArrayObject *self, PyObject *sep,
@@ -256,7 +256,7 @@ PyDoc_STRVAR(bytearray_rsplit__doc__,
"Splitting is done starting at the end of the bytearray and working to the front.");
#define BYTEARRAY_RSPLIT_METHODDEF \
- {"rsplit", (PyCFunction)bytearray_rsplit, METH_FASTCALL|METH_KEYWORDS, bytearray_rsplit__doc__},
+ {"rsplit", (PyCFunction)(void(*)(void))bytearray_rsplit, METH_FASTCALL|METH_KEYWORDS, bytearray_rsplit__doc__},
static PyObject *
bytearray_rsplit_impl(PyByteArrayObject *self, PyObject *sep,
@@ -311,7 +311,7 @@ PyDoc_STRVAR(bytearray_insert__doc__,
" The item to be inserted.");
#define BYTEARRAY_INSERT_METHODDEF \
- {"insert", (PyCFunction)bytearray_insert, METH_FASTCALL, bytearray_insert__doc__},
+ {"insert", (PyCFunction)(void(*)(void))bytearray_insert, METH_FASTCALL, bytearray_insert__doc__},
static PyObject *
bytearray_insert_impl(PyByteArrayObject *self, Py_ssize_t index, int item);
@@ -388,7 +388,7 @@ PyDoc_STRVAR(bytearray_pop__doc__,
"If no index argument is given, will pop the last item.");
#define BYTEARRAY_POP_METHODDEF \
- {"pop", (PyCFunction)bytearray_pop, METH_FASTCALL, bytearray_pop__doc__},
+ {"pop", (PyCFunction)(void(*)(void))bytearray_pop, METH_FASTCALL, bytearray_pop__doc__},
static PyObject *
bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index);
@@ -448,7 +448,7 @@ PyDoc_STRVAR(bytearray_strip__doc__,
"If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
#define BYTEARRAY_STRIP_METHODDEF \
- {"strip", (PyCFunction)bytearray_strip, METH_FASTCALL, bytearray_strip__doc__},
+ {"strip", (PyCFunction)(void(*)(void))bytearray_strip, METH_FASTCALL, bytearray_strip__doc__},
static PyObject *
bytearray_strip_impl(PyByteArrayObject *self, PyObject *bytes);
@@ -479,7 +479,7 @@ PyDoc_STRVAR(bytearray_lstrip__doc__,
"If the argument is omitted or None, strip leading ASCII whitespace.");
#define BYTEARRAY_LSTRIP_METHODDEF \
- {"lstrip", (PyCFunction)bytearray_lstrip, METH_FASTCALL, bytearray_lstrip__doc__},
+ {"lstrip", (PyCFunction)(void(*)(void))bytearray_lstrip, METH_FASTCALL, bytearray_lstrip__doc__},
static PyObject *
bytearray_lstrip_impl(PyByteArrayObject *self, PyObject *bytes);
@@ -510,7 +510,7 @@ PyDoc_STRVAR(bytearray_rstrip__doc__,
"If the argument is omitted or None, strip trailing ASCII whitespace.");
#define BYTEARRAY_RSTRIP_METHODDEF \
- {"rstrip", (PyCFunction)bytearray_rstrip, METH_FASTCALL, bytearray_rstrip__doc__},
+ {"rstrip", (PyCFunction)(void(*)(void))bytearray_rstrip, METH_FASTCALL, bytearray_rstrip__doc__},
static PyObject *
bytearray_rstrip_impl(PyByteArrayObject *self, PyObject *bytes);
@@ -548,7 +548,7 @@ PyDoc_STRVAR(bytearray_decode__doc__,
" can handle UnicodeDecodeErrors.");
#define BYTEARRAY_DECODE_METHODDEF \
- {"decode", (PyCFunction)bytearray_decode, METH_FASTCALL|METH_KEYWORDS, bytearray_decode__doc__},
+ {"decode", (PyCFunction)(void(*)(void))bytearray_decode, METH_FASTCALL|METH_KEYWORDS, bytearray_decode__doc__},
static PyObject *
bytearray_decode_impl(PyByteArrayObject *self, const char *encoding,
@@ -596,7 +596,7 @@ PyDoc_STRVAR(bytearray_splitlines__doc__,
"true.");
#define BYTEARRAY_SPLITLINES_METHODDEF \
- {"splitlines", (PyCFunction)bytearray_splitlines, METH_FASTCALL|METH_KEYWORDS, bytearray_splitlines__doc__},
+ {"splitlines", (PyCFunction)(void(*)(void))bytearray_splitlines, METH_FASTCALL|METH_KEYWORDS, bytearray_splitlines__doc__},
static PyObject *
bytearray_splitlines_impl(PyByteArrayObject *self, int keepends);
@@ -674,7 +674,7 @@ PyDoc_STRVAR(bytearray_reduce_ex__doc__,
"Return state information for pickling.");
#define BYTEARRAY_REDUCE_EX_METHODDEF \
- {"__reduce_ex__", (PyCFunction)bytearray_reduce_ex, METH_FASTCALL, bytearray_reduce_ex__doc__},
+ {"__reduce_ex__", (PyCFunction)(void(*)(void))bytearray_reduce_ex, METH_FASTCALL, bytearray_reduce_ex__doc__},
static PyObject *
bytearray_reduce_ex_impl(PyByteArrayObject *self, int proto);
@@ -712,4 +712,4 @@ bytearray_sizeof(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
{
return bytearray_sizeof_impl(self);
}
-/*[clinic end generated code: output=bb9051a369adb328 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b88bb192dddca6e1 input=a9049054013a1b77]*/
diff --git a/Objects/clinic/bytesobject.c.h b/Objects/clinic/bytesobject.c.h
index c781948ead0e..193d534fdd50 100644
--- a/Objects/clinic/bytesobject.c.h
+++ b/Objects/clinic/bytesobject.c.h
@@ -17,7 +17,7 @@ PyDoc_STRVAR(bytes_split__doc__,
" -1 (the default value) means no limit.");
#define BYTES_SPLIT_METHODDEF \
- {"split", (PyCFunction)bytes_split, METH_FASTCALL|METH_KEYWORDS, bytes_split__doc__},
+ {"split", (PyCFunction)(void(*)(void))bytes_split, METH_FASTCALL|METH_KEYWORDS, bytes_split__doc__},
static PyObject *
bytes_split_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit);
@@ -136,7 +136,7 @@ PyDoc_STRVAR(bytes_rsplit__doc__,
"Splitting is done starting at the end of the bytes and working to the front.");
#define BYTES_RSPLIT_METHODDEF \
- {"rsplit", (PyCFunction)bytes_rsplit, METH_FASTCALL|METH_KEYWORDS, bytes_rsplit__doc__},
+ {"rsplit", (PyCFunction)(void(*)(void))bytes_rsplit, METH_FASTCALL|METH_KEYWORDS, bytes_rsplit__doc__},
static PyObject *
bytes_rsplit_impl(PyBytesObject *self, PyObject *sep, Py_ssize_t maxsplit);
@@ -184,7 +184,7 @@ PyDoc_STRVAR(bytes_strip__doc__,
"If the argument is omitted or None, strip leading and trailing ASCII whitespace.");
#define BYTES_STRIP_METHODDEF \
- {"strip", (PyCFunction)bytes_strip, METH_FASTCALL, bytes_strip__doc__},
+ {"strip", (PyCFunction)(void(*)(void))bytes_strip, METH_FASTCALL, bytes_strip__doc__},
static PyObject *
bytes_strip_impl(PyBytesObject *self, PyObject *bytes);
@@ -215,7 +215,7 @@ PyDoc_STRVAR(bytes_lstrip__doc__,
"If the argument is omitted or None, strip leading ASCII whitespace.");
#define BYTES_LSTRIP_METHODDEF \
- {"lstrip", (PyCFunction)bytes_lstrip, METH_FASTCALL, bytes_lstrip__doc__},
+ {"lstrip", (PyCFunction)(void(*)(void))bytes_lstrip, METH_FASTCALL, bytes_lstrip__doc__},
static PyObject *
bytes_lstrip_impl(PyBytesObject *self, PyObject *bytes);
@@ -246,7 +246,7 @@ PyDoc_STRVAR(bytes_rstrip__doc__,
"If the argument is omitted or None, strip trailing ASCII whitespace.");
#define BYTES_RSTRIP_METHODDEF \
- {"rstrip", (PyCFunction)bytes_rstrip, METH_FASTCALL, bytes_rstrip__doc__},
+ {"rstrip", (PyCFunction)(void(*)(void))bytes_rstrip, METH_FASTCALL, bytes_rstrip__doc__},
static PyObject *
bytes_rstrip_impl(PyBytesObject *self, PyObject *bytes);
@@ -281,7 +281,7 @@ PyDoc_STRVAR(bytes_translate__doc__,
"The remaining characters are mapped through the given translation table.");
#define BYTES_TRANSLATE_METHODDEF \
- {"translate", (PyCFunction)bytes_translate, METH_FASTCALL|METH_KEYWORDS, bytes_translate__doc__},
+ {"translate", (PyCFunction)(void(*)(void))bytes_translate, METH_FASTCALL|METH_KEYWORDS, bytes_translate__doc__},
static PyObject *
bytes_translate_impl(PyBytesObject *self, PyObject *table,
@@ -318,7 +318,7 @@ PyDoc_STRVAR(bytes_maketrans__doc__,
"The bytes objects frm and to must be of the same length.");
#define BYTES_MAKETRANS_METHODDEF \
- {"maketrans", (PyCFunction)bytes_maketrans, METH_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
+ {"maketrans", (PyCFunction)(void(*)(void))bytes_maketrans, METH_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
static PyObject *
bytes_maketrans_impl(Py_buffer *frm, Py_buffer *to);
@@ -363,7 +363,7 @@ PyDoc_STRVAR(bytes_replace__doc__,
"replaced.");
#define BYTES_REPLACE_METHODDEF \
- {"replace", (PyCFunction)bytes_replace, METH_FASTCALL, bytes_replace__doc__},
+ {"replace", (PyCFunction)(void(*)(void))bytes_replace, METH_FASTCALL, bytes_replace__doc__},
static PyObject *
bytes_replace_impl(PyBytesObject *self, Py_buffer *old, Py_buffer *new,
@@ -412,7 +412,7 @@ PyDoc_STRVAR(bytes_decode__doc__,
" can handle UnicodeDecodeErrors.");
#define BYTES_DECODE_METHODDEF \
- {"decode", (PyCFunction)bytes_decode, METH_FASTCALL|METH_KEYWORDS, bytes_decode__doc__},
+ {"decode", (PyCFunction)(void(*)(void))bytes_decode, METH_FASTCALL|METH_KEYWORDS, bytes_decode__doc__},
static PyObject *
bytes_decode_impl(PyBytesObject *self, const char *encoding,
@@ -447,7 +447,7 @@ PyDoc_STRVAR(bytes_splitlines__doc__,
"true.");
#define BYTES_SPLITLINES_METHODDEF \
- {"splitlines", (PyCFunction)bytes_splitlines, METH_FASTCALL|METH_KEYWORDS, bytes_splitlines__doc__},
+ {"splitlines", (PyCFunction)(void(*)(void))bytes_splitlines, METH_FASTCALL|METH_KEYWORDS, bytes_splitlines__doc__},
static PyObject *
bytes_splitlines_impl(PyBytesObject *self, int keepends);
@@ -499,4 +499,4 @@ bytes_fromhex(PyTypeObject *type, PyObject *arg)
exit:
return return_value;
}
-/*[clinic end generated code: output=470acd12b2534765 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=07b33ac65362301b input=a9049054013a1b77]*/
diff --git a/Objects/clinic/dictobject.c.h b/Objects/clinic/dictobject.c.h
index 4f4c9fa9cb7a..5db3a426f459 100644
--- a/Objects/clinic/dictobject.c.h
+++ b/Objects/clinic/dictobject.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(dict_fromkeys__doc__,
"Create a new dictionary with keys from iterable and values set to value.");
#define DICT_FROMKEYS_METHODDEF \
- {"fromkeys", (PyCFunction)dict_fromkeys, METH_FASTCALL|METH_CLASS, dict_fromkeys__doc__},
+ {"fromkeys", (PyCFunction)(void(*)(void))dict_fromkeys, METH_FASTCALL|METH_CLASS, dict_fromkeys__doc__},
static PyObject *
dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value);
@@ -48,7 +48,7 @@ PyDoc_STRVAR(dict_get__doc__,
"Return the value for key if key is in the dictionary, else default.");
#define DICT_GET_METHODDEF \
- {"get", (PyCFunction)dict_get, METH_FASTCALL, dict_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))dict_get, METH_FASTCALL, dict_get__doc__},
static PyObject *
dict_get_impl(PyDictObject *self, PyObject *key, PyObject *default_value);
@@ -80,7 +80,7 @@ PyDoc_STRVAR(dict_setdefault__doc__,
"Return the value for key if key is in the dictionary, else default.");
#define DICT_SETDEFAULT_METHODDEF \
- {"setdefault", (PyCFunction)dict_setdefault, METH_FASTCALL, dict_setdefault__doc__},
+ {"setdefault", (PyCFunction)(void(*)(void))dict_setdefault, METH_FASTCALL, dict_setdefault__doc__},
static PyObject *
dict_setdefault_impl(PyDictObject *self, PyObject *key,
@@ -121,4 +121,4 @@ dict___reversed__(PyDictObject *self, PyObject *Py_UNUSED(ignored))
{
return dict___reversed___impl(self);
}
-/*[clinic end generated code: output=b9923851cbd9213a input=a9049054013a1b77]*/
+/*[clinic end generated code: output=193e08cb8099fe22 input=a9049054013a1b77]*/
diff --git a/Objects/clinic/floatobject.c.h b/Objects/clinic/floatobject.c.h
index ac3ff0c9f838..8ff2a2bebaa6 100644
--- a/Objects/clinic/floatobject.c.h
+++ b/Objects/clinic/floatobject.c.h
@@ -47,7 +47,7 @@ PyDoc_STRVAR(float___round____doc__,
"When an argument is passed, work like built-in round(x, ndigits).");
#define FLOAT___ROUND___METHODDEF \
- {"__round__", (PyCFunction)float___round__, METH_FASTCALL, float___round____doc__},
+ {"__round__", (PyCFunction)(void(*)(void))float___round__, METH_FASTCALL, float___round____doc__},
static PyObject *
float___round___impl(PyObject *self, PyObject *o_ndigits);
@@ -256,7 +256,7 @@ PyDoc_STRVAR(float___set_format____doc__,
"This affects how floats are converted to and from binary strings.");
#define FLOAT___SET_FORMAT___METHODDEF \
- {"__set_format__", (PyCFunction)float___set_format__, METH_FASTCALL|METH_CLASS, float___set_format____doc__},
+ {"__set_format__", (PyCFunction)(void(*)(void))float___set_format__, METH_FASTCALL|METH_CLASS, float___set_format____doc__},
static PyObject *
float___set_format___impl(PyTypeObject *type, const char *typestr,
@@ -305,4 +305,4 @@ float___format__(PyObject *self, PyObject *arg)
exit:
return return_value;
}
-/*[clinic end generated code: output=a3c366a156be61f9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=091dd499f5386a6c input=a9049054013a1b77]*/
diff --git a/Objects/clinic/listobject.c.h b/Objects/clinic/listobject.c.h
index 63da672ca3dd..0097481dbaed 100644
--- a/Objects/clinic/listobject.c.h
+++ b/Objects/clinic/listobject.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(list_insert__doc__,
"Insert object before index.");
#define LIST_INSERT_METHODDEF \
- {"insert", (PyCFunction)list_insert, METH_FASTCALL, list_insert__doc__},
+ {"insert", (PyCFunction)(void(*)(void))list_insert, METH_FASTCALL, list_insert__doc__},
static PyObject *
list_insert_impl(PyListObject *self, Py_ssize_t index, PyObject *object);
@@ -94,7 +94,7 @@ PyDoc_STRVAR(list_pop__doc__,
"Raises IndexError if list is empty or index is out of range.");
#define LIST_POP_METHODDEF \
- {"pop", (PyCFunction)list_pop, METH_FASTCALL, list_pop__doc__},
+ {"pop", (PyCFunction)(void(*)(void))list_pop, METH_FASTCALL, list_pop__doc__},
static PyObject *
list_pop_impl(PyListObject *self, Py_ssize_t index);
@@ -122,7 +122,7 @@ PyDoc_STRVAR(list_sort__doc__,
"Stable sort *IN PLACE*.");
#define LIST_SORT_METHODDEF \
- {"sort", (PyCFunction)list_sort, METH_FASTCALL|METH_KEYWORDS, list_sort__doc__},
+ {"sort", (PyCFunction)(void(*)(void))list_sort, METH_FASTCALL|METH_KEYWORDS, list_sort__doc__},
static PyObject *
list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse);
@@ -173,7 +173,7 @@ PyDoc_STRVAR(list_index__doc__,
"Raises ValueError if the value is not present.");
#define LIST_INDEX_METHODDEF \
- {"index", (PyCFunction)list_index, METH_FASTCALL, list_index__doc__},
+ {"index", (PyCFunction)(void(*)(void))list_index, METH_FASTCALL, list_index__doc__},
static PyObject *
list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
@@ -285,4 +285,4 @@ list___reversed__(PyListObject *self, PyObject *Py_UNUSED(ignored))
{
return list___reversed___impl(self);
}
-/*[clinic end generated code: output=d8cb29e6e6d79844 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=652ae4ee63a9de71 input=a9049054013a1b77]*/
diff --git a/Objects/clinic/longobject.c.h b/Objects/clinic/longobject.c.h
index 0e70fe5d8c44..3c33993e83c0 100644
--- a/Objects/clinic/longobject.c.h
+++ b/Objects/clinic/longobject.c.h
@@ -167,7 +167,7 @@ PyDoc_STRVAR(int_to_bytes__doc__,
" is raised.");
#define INT_TO_BYTES_METHODDEF \
- {"to_bytes", (PyCFunction)int_to_bytes, METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
+ {"to_bytes", (PyCFunction)(void(*)(void))int_to_bytes, METH_FASTCALL|METH_KEYWORDS, int_to_bytes__doc__},
static PyObject *
int_to_bytes_impl(PyObject *self, Py_ssize_t length, PyObject *byteorder,
@@ -214,7 +214,7 @@ PyDoc_STRVAR(int_from_bytes__doc__,
" Indicates whether two\'s complement is used to represent the integer.");
#define INT_FROM_BYTES_METHODDEF \
- {"from_bytes", (PyCFunction)int_from_bytes, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
+ {"from_bytes", (PyCFunction)(void(*)(void))int_from_bytes, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, int_from_bytes__doc__},
static PyObject *
int_from_bytes_impl(PyTypeObject *type, PyObject *bytes_obj,
@@ -239,4 +239,4 @@ int_from_bytes(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyOb
exit:
return return_value;
}
-/*[clinic end generated code: output=6d5e92d7dc803751 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=403ccd096555fd1e input=a9049054013a1b77]*/
diff --git a/Objects/clinic/odictobject.c.h b/Objects/clinic/odictobject.c.h
index 15a8bece0378..1aea36ec94c9 100644
--- a/Objects/clinic/odictobject.c.h
+++ b/Objects/clinic/odictobject.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(OrderedDict_fromkeys__doc__,
"Create a new ordered dictionary with keys from iterable and values set to value.");
#define ORDEREDDICT_FROMKEYS_METHODDEF \
- {"fromkeys", (PyCFunction)OrderedDict_fromkeys, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, OrderedDict_fromkeys__doc__},
+ {"fromkeys", (PyCFunction)(void(*)(void))OrderedDict_fromkeys, METH_FASTCALL|METH_KEYWORDS|METH_CLASS, OrderedDict_fromkeys__doc__},
static PyObject *
OrderedDict_fromkeys_impl(PyTypeObject *type, PyObject *seq, PyObject *value);
@@ -42,7 +42,7 @@ PyDoc_STRVAR(OrderedDict_setdefault__doc__,
"Return the value for key if key is in the dictionary, else default.");
#define ORDEREDDICT_SETDEFAULT_METHODDEF \
- {"setdefault", (PyCFunction)OrderedDict_setdefault, METH_FASTCALL|METH_KEYWORDS, OrderedDict_setdefault__doc__},
+ {"setdefault", (PyCFunction)(void(*)(void))OrderedDict_setdefault, METH_FASTCALL|METH_KEYWORDS, OrderedDict_setdefault__doc__},
static PyObject *
OrderedDict_setdefault_impl(PyODictObject *self, PyObject *key,
@@ -76,7 +76,7 @@ PyDoc_STRVAR(OrderedDict_popitem__doc__,
"Pairs are returned in LIFO order if last is true or FIFO order if false.");
#define ORDEREDDICT_POPITEM_METHODDEF \
- {"popitem", (PyCFunction)OrderedDict_popitem, METH_FASTCALL|METH_KEYWORDS, OrderedDict_popitem__doc__},
+ {"popitem", (PyCFunction)(void(*)(void))OrderedDict_popitem, METH_FASTCALL|METH_KEYWORDS, OrderedDict_popitem__doc__},
static PyObject *
OrderedDict_popitem_impl(PyODictObject *self, int last);
@@ -108,7 +108,7 @@ PyDoc_STRVAR(OrderedDict_move_to_end__doc__,
"Raise KeyError if the element does not exist.");
#define ORDEREDDICT_MOVE_TO_END_METHODDEF \
- {"move_to_end", (PyCFunction)OrderedDict_move_to_end, METH_FASTCALL|METH_KEYWORDS, OrderedDict_move_to_end__doc__},
+ {"move_to_end", (PyCFunction)(void(*)(void))OrderedDict_move_to_end, METH_FASTCALL|METH_KEYWORDS, OrderedDict_move_to_end__doc__},
static PyObject *
OrderedDict_move_to_end_impl(PyODictObject *self, PyObject *key, int last);
@@ -131,4 +131,4 @@ OrderedDict_move_to_end(PyODictObject *self, PyObject *const *args, Py_ssize_t n
exit:
return return_value;
}
-/*[clinic end generated code: output=7f23d569eda2a558 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=f6f189e1fe032e0b input=a9049054013a1b77]*/
diff --git a/Objects/clinic/tupleobject.c.h b/Objects/clinic/tupleobject.c.h
index bef900515b55..67d9f340e083 100644
--- a/Objects/clinic/tupleobject.c.h
+++ b/Objects/clinic/tupleobject.c.h
@@ -11,7 +11,7 @@ PyDoc_STRVAR(tuple_index__doc__,
"Raises ValueError if the value is not present.");
#define TUPLE_INDEX_METHODDEF \
- {"index", (PyCFunction)tuple_index, METH_FASTCALL, tuple_index__doc__},
+ {"index", (PyCFunction)(void(*)(void))tuple_index, METH_FASTCALL, tuple_index__doc__},
static PyObject *
tuple_index_impl(PyTupleObject *self, PyObject *value, Py_ssize_t start,
@@ -95,4 +95,4 @@ tuple___getnewargs__(PyTupleObject *self, PyObject *Py_UNUSED(ignored))
{
return tuple___getnewargs___impl(self);
}
-/*[clinic end generated code: output=0fbf4321fb4365ac input=a9049054013a1b77]*/
+/*[clinic end generated code: output=0a6ebd2d16b09c5d input=a9049054013a1b77]*/
diff --git a/Objects/clinic/unicodeobject.c.h b/Objects/clinic/unicodeobject.c.h
index 21937802d293..273ae9240636 100644
--- a/Objects/clinic/unicodeobject.c.h
+++ b/Objects/clinic/unicodeobject.c.h
@@ -71,7 +71,7 @@ PyDoc_STRVAR(unicode_center__doc__,
"Padding is done using the specified fill character (default is a space).");
#define UNICODE_CENTER_METHODDEF \
- {"center", (PyCFunction)unicode_center, METH_FASTCALL, unicode_center__doc__},
+ {"center", (PyCFunction)(void(*)(void))unicode_center, METH_FASTCALL, unicode_center__doc__},
static PyObject *
unicode_center_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
@@ -109,7 +109,7 @@ PyDoc_STRVAR(unicode_encode__doc__,
" codecs.register_error that can handle UnicodeEncodeErrors.");
#define UNICODE_ENCODE_METHODDEF \
- {"encode", (PyCFunction)unicode_encode, METH_FASTCALL|METH_KEYWORDS, unicode_encode__doc__},
+ {"encode", (PyCFunction)(void(*)(void))unicode_encode, METH_FASTCALL|METH_KEYWORDS, unicode_encode__doc__},
static PyObject *
unicode_encode_impl(PyObject *self, const char *encoding, const char *errors);
@@ -142,7 +142,7 @@ PyDoc_STRVAR(unicode_expandtabs__doc__,
"If tabsize is not given, a tab size of 8 characters is assumed.");
#define UNICODE_EXPANDTABS_METHODDEF \
- {"expandtabs", (PyCFunction)unicode_expandtabs, METH_FASTCALL|METH_KEYWORDS, unicode_expandtabs__doc__},
+ {"expandtabs", (PyCFunction)(void(*)(void))unicode_expandtabs, METH_FASTCALL|METH_KEYWORDS, unicode_expandtabs__doc__},
static PyObject *
unicode_expandtabs_impl(PyObject *self, int tabsize);
@@ -440,7 +440,7 @@ PyDoc_STRVAR(unicode_ljust__doc__,
"Padding is done using the specified fill character (default is a space).");
#define UNICODE_LJUST_METHODDEF \
- {"ljust", (PyCFunction)unicode_ljust, METH_FASTCALL, unicode_ljust__doc__},
+ {"ljust", (PyCFunction)(void(*)(void))unicode_ljust, METH_FASTCALL, unicode_ljust__doc__},
static PyObject *
unicode_ljust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
@@ -489,7 +489,7 @@ PyDoc_STRVAR(unicode_strip__doc__,
"If chars is given and not None, remove characters in chars instead.");
#define UNICODE_STRIP_METHODDEF \
- {"strip", (PyCFunction)unicode_strip, METH_FASTCALL, unicode_strip__doc__},
+ {"strip", (PyCFunction)(void(*)(void))unicode_strip, METH_FASTCALL, unicode_strip__doc__},
static PyObject *
unicode_strip_impl(PyObject *self, PyObject *chars);
@@ -520,7 +520,7 @@ PyDoc_STRVAR(unicode_lstrip__doc__,
"If chars is given and not None, remove characters in chars instead.");
#define UNICODE_LSTRIP_METHODDEF \
- {"lstrip", (PyCFunction)unicode_lstrip, METH_FASTCALL, unicode_lstrip__doc__},
+ {"lstrip", (PyCFunction)(void(*)(void))unicode_lstrip, METH_FASTCALL, unicode_lstrip__doc__},
static PyObject *
unicode_lstrip_impl(PyObject *self, PyObject *chars);
@@ -551,7 +551,7 @@ PyDoc_STRVAR(unicode_rstrip__doc__,
"If chars is given and not None, remove characters in chars instead.");
#define UNICODE_RSTRIP_METHODDEF \
- {"rstrip", (PyCFunction)unicode_rstrip, METH_FASTCALL, unicode_rstrip__doc__},
+ {"rstrip", (PyCFunction)(void(*)(void))unicode_rstrip, METH_FASTCALL, unicode_rstrip__doc__},
static PyObject *
unicode_rstrip_impl(PyObject *self, PyObject *chars);
@@ -587,7 +587,7 @@ PyDoc_STRVAR(unicode_replace__doc__,
"replaced.");
#define UNICODE_REPLACE_METHODDEF \
- {"replace", (PyCFunction)unicode_replace, METH_FASTCALL, unicode_replace__doc__},
+ {"replace", (PyCFunction)(void(*)(void))unicode_replace, METH_FASTCALL, unicode_replace__doc__},
static PyObject *
unicode_replace_impl(PyObject *self, PyObject *old, PyObject *new,
@@ -620,7 +620,7 @@ PyDoc_STRVAR(unicode_rjust__doc__,
"Padding is done using the specified fill character (default is a space).");
#define UNICODE_RJUST_METHODDEF \
- {"rjust", (PyCFunction)unicode_rjust, METH_FASTCALL, unicode_rjust__doc__},
+ {"rjust", (PyCFunction)(void(*)(void))unicode_rjust, METH_FASTCALL, unicode_rjust__doc__},
static PyObject *
unicode_rjust_impl(PyObject *self, Py_ssize_t width, Py_UCS4 fillchar);
@@ -657,7 +657,7 @@ PyDoc_STRVAR(unicode_split__doc__,
" -1 (the default value) means no limit.");
#define UNICODE_SPLIT_METHODDEF \
- {"split", (PyCFunction)unicode_split, METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
+ {"split", (PyCFunction)(void(*)(void))unicode_split, METH_FASTCALL|METH_KEYWORDS, unicode_split__doc__},
static PyObject *
unicode_split_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
@@ -730,7 +730,7 @@ PyDoc_STRVAR(unicode_rsplit__doc__,
"Splits are done starting at the end of the string and working to the front.");
#define UNICODE_RSPLIT_METHODDEF \
- {"rsplit", (PyCFunction)unicode_rsplit, METH_FASTCALL|METH_KEYWORDS, unicode_rsplit__doc__},
+ {"rsplit", (PyCFunction)(void(*)(void))unicode_rsplit, METH_FASTCALL|METH_KEYWORDS, unicode_rsplit__doc__},
static PyObject *
unicode_rsplit_impl(PyObject *self, PyObject *sep, Py_ssize_t maxsplit);
@@ -764,7 +764,7 @@ PyDoc_STRVAR(unicode_splitlines__doc__,
"true.");
#define UNICODE_SPLITLINES_METHODDEF \
- {"splitlines", (PyCFunction)unicode_splitlines, METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
+ {"splitlines", (PyCFunction)(void(*)(void))unicode_splitlines, METH_FASTCALL|METH_KEYWORDS, unicode_splitlines__doc__},
static PyObject *
unicode_splitlines_impl(PyObject *self, int keepends);
@@ -820,7 +820,7 @@ PyDoc_STRVAR(unicode_maketrans__doc__,
"must be a string, whose characters will be mapped to None in the result.");
#define UNICODE_MAKETRANS_METHODDEF \
- {"maketrans", (PyCFunction)unicode_maketrans, METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
+ {"maketrans", (PyCFunction)(void(*)(void))unicode_maketrans, METH_FASTCALL|METH_STATIC, unicode_maketrans__doc__},
static PyObject *
unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z);
@@ -951,4 +951,4 @@ unicode_sizeof(PyObject *self, PyObject *Py_UNUSED(ignored))
{
return unicode_sizeof_impl(self);
}
-/*[clinic end generated code: output=8bcd992b25733bcc input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d323802b67bfc6d8 input=a9049054013a1b77]*/
diff --git a/Objects/stringlib/clinic/transmogrify.h.h b/Objects/stringlib/clinic/transmogrify.h.h
index 6d266225c020..fb63060d450a 100644
--- a/Objects/stringlib/clinic/transmogrify.h.h
+++ b/Objects/stringlib/clinic/transmogrify.h.h
@@ -11,7 +11,7 @@ PyDoc_STRVAR(stringlib_expandtabs__doc__,
"If tabsize is not given, a tab size of 8 characters is assumed.");
#define STRINGLIB_EXPANDTABS_METHODDEF \
- {"expandtabs", (PyCFunction)stringlib_expandtabs, METH_FASTCALL|METH_KEYWORDS, stringlib_expandtabs__doc__},
+ {"expandtabs", (PyCFunction)(void(*)(void))stringlib_expandtabs, METH_FASTCALL|METH_KEYWORDS, stringlib_expandtabs__doc__},
static PyObject *
stringlib_expandtabs_impl(PyObject *self, int tabsize);
@@ -43,7 +43,7 @@ PyDoc_STRVAR(stringlib_ljust__doc__,
"Padding is done using the specified fill character.");
#define STRINGLIB_LJUST_METHODDEF \
- {"ljust", (PyCFunction)stringlib_ljust, METH_FASTCALL, stringlib_ljust__doc__},
+ {"ljust", (PyCFunction)(void(*)(void))stringlib_ljust, METH_FASTCALL, stringlib_ljust__doc__},
static PyObject *
stringlib_ljust_impl(PyObject *self, Py_ssize_t width, char fillchar);
@@ -74,7 +74,7 @@ PyDoc_STRVAR(stringlib_rjust__doc__,
"Padding is done using the specified fill character.");
#define STRINGLIB_RJUST_METHODDEF \
- {"rjust", (PyCFunction)stringlib_rjust, METH_FASTCALL, stringlib_rjust__doc__},
+ {"rjust", (PyCFunction)(void(*)(void))stringlib_rjust, METH_FASTCALL, stringlib_rjust__doc__},
static PyObject *
stringlib_rjust_impl(PyObject *self, Py_ssize_t width, char fillchar);
@@ -105,7 +105,7 @@ PyDoc_STRVAR(stringlib_center__doc__,
"Padding is done using the specified fill character.");
#define STRINGLIB_CENTER_METHODDEF \
- {"center", (PyCFunction)stringlib_center, METH_FASTCALL, stringlib_center__doc__},
+ {"center", (PyCFunction)(void(*)(void))stringlib_center, METH_FASTCALL, stringlib_center__doc__},
static PyObject *
stringlib_center_impl(PyObject *self, Py_ssize_t width, char fillchar);
@@ -155,4 +155,4 @@ stringlib_zfill(PyObject *self, PyObject *arg)
exit:
return return_value;
}
-/*[clinic end generated code: output=336620159a1fc70d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d09ba158d470566e input=a9049054013a1b77]*/
diff --git a/PC/clinic/_testconsole.c.h b/PC/clinic/_testconsole.c.h
index 8112e789ff69..2809f2aa6e68 100644
--- a/PC/clinic/_testconsole.c.h
+++ b/PC/clinic/_testconsole.c.h
@@ -11,7 +11,7 @@ PyDoc_STRVAR(_testconsole_write_input__doc__,
"Writes UTF-16-LE encoded bytes to the console as if typed by a user.");
#define _TESTCONSOLE_WRITE_INPUT_METHODDEF \
- {"write_input", (PyCFunction)_testconsole_write_input, METH_FASTCALL|METH_KEYWORDS, _testconsole_write_input__doc__},
+ {"write_input", (PyCFunction)(void(*)(void))_testconsole_write_input, METH_FASTCALL|METH_KEYWORDS, _testconsole_write_input__doc__},
static PyObject *
_testconsole_write_input_impl(PyObject *module, PyObject *file,
@@ -47,7 +47,7 @@ PyDoc_STRVAR(_testconsole_read_output__doc__,
"Reads a str from the console as written to stdout.");
#define _TESTCONSOLE_READ_OUTPUT_METHODDEF \
- {"read_output", (PyCFunction)_testconsole_read_output, METH_FASTCALL|METH_KEYWORDS, _testconsole_read_output__doc__},
+ {"read_output", (PyCFunction)(void(*)(void))_testconsole_read_output, METH_FASTCALL|METH_KEYWORDS, _testconsole_read_output__doc__},
static PyObject *
_testconsole_read_output_impl(PyObject *module, PyObject *file);
@@ -79,4 +79,4 @@ _testconsole_read_output(PyObject *module, PyObject *const *args, Py_ssize_t nar
#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]*/
diff --git a/PC/clinic/msvcrtmodule.c.h b/PC/clinic/msvcrtmodule.c.h
index 22ddfea80248..0466306b2404 100644
--- a/PC/clinic/msvcrtmodule.c.h
+++ b/PC/clinic/msvcrtmodule.c.h
@@ -37,7 +37,7 @@ PyDoc_STRVAR(msvcrt_locking__doc__,
"individually.");
#define MSVCRT_LOCKING_METHODDEF \
- {"locking", (PyCFunction)msvcrt_locking, METH_FASTCALL, msvcrt_locking__doc__},
+ {"locking", (PyCFunction)(void(*)(void))msvcrt_locking, METH_FASTCALL, msvcrt_locking__doc__},
static PyObject *
msvcrt_locking_impl(PyObject *module, int fd, int mode, long nbytes);
@@ -72,7 +72,7 @@ PyDoc_STRVAR(msvcrt_setmode__doc__,
"Return value is the previous mode.");
#define MSVCRT_SETMODE_METHODDEF \
- {"setmode", (PyCFunction)msvcrt_setmode, METH_FASTCALL, msvcrt_setmode__doc__},
+ {"setmode", (PyCFunction)(void(*)(void))msvcrt_setmode, METH_FASTCALL, msvcrt_setmode__doc__},
static long
msvcrt_setmode_impl(PyObject *module, int fd, int flags);
@@ -110,7 +110,7 @@ PyDoc_STRVAR(msvcrt_open_osfhandle__doc__,
"to os.fdopen() to create a file object.");
#define MSVCRT_OPEN_OSFHANDLE_METHODDEF \
- {"open_osfhandle", (PyCFunction)msvcrt_open_osfhandle, METH_FASTCALL, msvcrt_open_osfhandle__doc__},
+ {"open_osfhandle", (PyCFunction)(void(*)(void))msvcrt_open_osfhandle, METH_FASTCALL, msvcrt_open_osfhandle__doc__},
static long
msvcrt_open_osfhandle_impl(PyObject *module, void *handle, int flags);
@@ -424,7 +424,7 @@ PyDoc_STRVAR(msvcrt_CrtSetReportFile__doc__,
"Only available on Debug builds.");
#define MSVCRT_CRTSETREPORTFILE_METHODDEF \
- {"CrtSetReportFile", (PyCFunction)msvcrt_CrtSetReportFile, METH_FASTCALL, msvcrt_CrtSetReportFile__doc__},
+ {"CrtSetReportFile", (PyCFunction)(void(*)(void))msvcrt_CrtSetReportFile, METH_FASTCALL, msvcrt_CrtSetReportFile__doc__},
static void *
msvcrt_CrtSetReportFile_impl(PyObject *module, int type, void *file);
@@ -464,7 +464,7 @@ PyDoc_STRVAR(msvcrt_CrtSetReportMode__doc__,
"Only available on Debug builds.");
#define MSVCRT_CRTSETREPORTMODE_METHODDEF \
- {"CrtSetReportMode", (PyCFunction)msvcrt_CrtSetReportMode, METH_FASTCALL, msvcrt_CrtSetReportMode__doc__},
+ {"CrtSetReportMode", (PyCFunction)(void(*)(void))msvcrt_CrtSetReportMode, METH_FASTCALL, msvcrt_CrtSetReportMode__doc__},
static long
msvcrt_CrtSetReportMode_impl(PyObject *module, int type, int mode);
@@ -569,4 +569,4 @@ msvcrt_SetErrorMode(PyObject *module, PyObject *arg)
#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]*/
diff --git a/PC/clinic/winreg.c.h b/PC/clinic/winreg.c.h
index 69781a969285..1a5356335521 100644
--- a/PC/clinic/winreg.c.h
+++ b/PC/clinic/winreg.c.h
@@ -77,7 +77,7 @@ PyDoc_STRVAR(winreg_HKEYType___exit____doc__,
"\n");
#define WINREG_HKEYTYPE___EXIT___METHODDEF \
- {"__exit__", (PyCFunction)winreg_HKEYType___exit__, METH_FASTCALL|METH_KEYWORDS, winreg_HKEYType___exit____doc__},
+ {"__exit__", (PyCFunction)(void(*)(void))winreg_HKEYType___exit__, METH_FASTCALL|METH_KEYWORDS, winreg_HKEYType___exit____doc__},
static PyObject *
winreg_HKEYType___exit___impl(PyHKEYObject *self, PyObject *exc_type,
@@ -134,7 +134,7 @@ PyDoc_STRVAR(winreg_ConnectRegistry__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_CONNECTREGISTRY_METHODDEF \
- {"ConnectRegistry", (PyCFunction)winreg_ConnectRegistry, METH_FASTCALL, winreg_ConnectRegistry__doc__},
+ {"ConnectRegistry", (PyCFunction)(void(*)(void))winreg_ConnectRegistry, METH_FASTCALL, winreg_ConnectRegistry__doc__},
static HKEY
winreg_ConnectRegistry_impl(PyObject *module, Py_UNICODE *computer_name,
@@ -182,7 +182,7 @@ PyDoc_STRVAR(winreg_CreateKey__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_CREATEKEY_METHODDEF \
- {"CreateKey", (PyCFunction)winreg_CreateKey, METH_FASTCALL, winreg_CreateKey__doc__},
+ {"CreateKey", (PyCFunction)(void(*)(void))winreg_CreateKey, METH_FASTCALL, winreg_CreateKey__doc__},
static HKEY
winreg_CreateKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
@@ -235,7 +235,7 @@ PyDoc_STRVAR(winreg_CreateKeyEx__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_CREATEKEYEX_METHODDEF \
- {"CreateKeyEx", (PyCFunction)winreg_CreateKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_CreateKeyEx__doc__},
+ {"CreateKeyEx", (PyCFunction)(void(*)(void))winreg_CreateKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_CreateKeyEx__doc__},
static HKEY
winreg_CreateKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@@ -286,7 +286,7 @@ PyDoc_STRVAR(winreg_DeleteKey__doc__,
"is removed. If the function fails, an OSError exception is raised.");
#define WINREG_DELETEKEY_METHODDEF \
- {"DeleteKey", (PyCFunction)winreg_DeleteKey, METH_FASTCALL, winreg_DeleteKey__doc__},
+ {"DeleteKey", (PyCFunction)(void(*)(void))winreg_DeleteKey, METH_FASTCALL, winreg_DeleteKey__doc__},
static PyObject *
winreg_DeleteKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
@@ -334,7 +334,7 @@ PyDoc_STRVAR(winreg_DeleteKeyEx__doc__,
"On unsupported Windows versions, NotImplementedError is raised.");
#define WINREG_DELETEKEYEX_METHODDEF \
- {"DeleteKeyEx", (PyCFunction)winreg_DeleteKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},
+ {"DeleteKeyEx", (PyCFunction)(void(*)(void))winreg_DeleteKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},
static PyObject *
winreg_DeleteKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@@ -373,7 +373,7 @@ PyDoc_STRVAR(winreg_DeleteValue__doc__,
" A string that identifies the value to remove.");
#define WINREG_DELETEVALUE_METHODDEF \
- {"DeleteValue", (PyCFunction)winreg_DeleteValue, METH_FASTCALL, winreg_DeleteValue__doc__},
+ {"DeleteValue", (PyCFunction)(void(*)(void))winreg_DeleteValue, METH_FASTCALL, winreg_DeleteValue__doc__},
static PyObject *
winreg_DeleteValue_impl(PyObject *module, HKEY key, Py_UNICODE *value);
@@ -411,7 +411,7 @@ PyDoc_STRVAR(winreg_EnumKey__doc__,
"raised, indicating no more values are available.");
#define WINREG_ENUMKEY_METHODDEF \
- {"EnumKey", (PyCFunction)winreg_EnumKey, METH_FASTCALL, winreg_EnumKey__doc__},
+ {"EnumKey", (PyCFunction)(void(*)(void))winreg_EnumKey, METH_FASTCALL, winreg_EnumKey__doc__},
static PyObject *
winreg_EnumKey_impl(PyObject *module, HKEY key, int index);
@@ -458,7 +458,7 @@ PyDoc_STRVAR(winreg_EnumValue__doc__,
" An integer that identifies the type of the value data.");
#define WINREG_ENUMVALUE_METHODDEF \
- {"EnumValue", (PyCFunction)winreg_EnumValue, METH_FASTCALL, winreg_EnumValue__doc__},
+ {"EnumValue", (PyCFunction)(void(*)(void))winreg_EnumValue, METH_FASTCALL, winreg_EnumValue__doc__},
static PyObject *
winreg_EnumValue_impl(PyObject *module, HKEY key, int index);
@@ -576,7 +576,7 @@ PyDoc_STRVAR(winreg_LoadKey__doc__,
"tree.");
#define WINREG_LOADKEY_METHODDEF \
- {"LoadKey", (PyCFunction)winreg_LoadKey, METH_FASTCALL, winreg_LoadKey__doc__},
+ {"LoadKey", (PyCFunction)(void(*)(void))winreg_LoadKey, METH_FASTCALL, winreg_LoadKey__doc__},
static PyObject *
winreg_LoadKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@@ -620,7 +620,7 @@ PyDoc_STRVAR(winreg_OpenKey__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_OPENKEY_METHODDEF \
- {"OpenKey", (PyCFunction)winreg_OpenKey, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKey__doc__},
+ {"OpenKey", (PyCFunction)(void(*)(void))winreg_OpenKey, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKey__doc__},
static HKEY
winreg_OpenKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@@ -672,7 +672,7 @@ PyDoc_STRVAR(winreg_OpenKeyEx__doc__,
"If the function fails, an OSError exception is raised.");
#define WINREG_OPENKEYEX_METHODDEF \
- {"OpenKeyEx", (PyCFunction)winreg_OpenKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKeyEx__doc__},
+ {"OpenKeyEx", (PyCFunction)(void(*)(void))winreg_OpenKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKeyEx__doc__},
static HKEY
winreg_OpenKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@@ -761,7 +761,7 @@ PyDoc_STRVAR(winreg_QueryValue__doc__,
"completeness.");
#define WINREG_QUERYVALUE_METHODDEF \
- {"QueryValue", (PyCFunction)winreg_QueryValue, METH_FASTCALL, winreg_QueryValue__doc__},
+ {"QueryValue", (PyCFunction)(void(*)(void))winreg_QueryValue, METH_FASTCALL, winreg_QueryValue__doc__},
static PyObject *
winreg_QueryValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);
@@ -800,7 +800,7 @@ PyDoc_STRVAR(winreg_QueryValueEx__doc__,
"The return value is a tuple of the value and the type_id.");
#define WINREG_QUERYVALUEEX_METHODDEF \
- {"QueryValueEx", (PyCFunction)winreg_QueryValueEx, METH_FASTCALL, winreg_QueryValueEx__doc__},
+ {"QueryValueEx", (PyCFunction)(void(*)(void))winreg_QueryValueEx, METH_FASTCALL, winreg_QueryValueEx__doc__},
static PyObject *
winreg_QueryValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *name);
@@ -844,7 +844,7 @@ PyDoc_STRVAR(winreg_SaveKey__doc__,
"to the API.");
#define WINREG_SAVEKEY_METHODDEF \
- {"SaveKey", (PyCFunction)winreg_SaveKey, METH_FASTCALL, winreg_SaveKey__doc__},
+ {"SaveKey", (PyCFunction)(void(*)(void))winreg_SaveKey, METH_FASTCALL, winreg_SaveKey__doc__},
static PyObject *
winreg_SaveKey_impl(PyObject *module, HKEY key, Py_UNICODE *file_name);
@@ -893,7 +893,7 @@ PyDoc_STRVAR(winreg_SetValue__doc__,
"KEY_SET_VALUE access.");
#define WINREG_SETVALUE_METHODDEF \
- {"SetValue", (PyCFunction)winreg_SetValue, METH_FASTCALL, winreg_SetValue__doc__},
+ {"SetValue", (PyCFunction)(void(*)(void))winreg_SetValue, METH_FASTCALL, winreg_SetValue__doc__},
static PyObject *
winreg_SetValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,
@@ -964,7 +964,7 @@ PyDoc_STRVAR(winreg_SetValueEx__doc__,
"the configuration registry to help the registry perform efficiently.");
#define WINREG_SETVALUEEX_METHODDEF \
- {"SetValueEx", (PyCFunction)winreg_SetValueEx, METH_FASTCALL, winreg_SetValueEx__doc__},
+ {"SetValueEx", (PyCFunction)(void(*)(void))winreg_SetValueEx, METH_FASTCALL, winreg_SetValueEx__doc__},
static PyObject *
winreg_SetValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *value_name,
@@ -1091,4 +1091,4 @@ winreg_QueryReflectionKey(PyObject *module, PyObject *arg)
exit:
return return_value;
}
-/*[clinic end generated code: output=d1c8e2678015dd7d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=45a9aec9f9258c0a input=a9049054013a1b77]*/
diff --git a/PC/clinic/winsound.c.h b/PC/clinic/winsound.c.h
index 61be17dee19a..86514f5cfe96 100644
--- a/PC/clinic/winsound.c.h
+++ b/PC/clinic/winsound.c.h
@@ -14,7 +14,7 @@ PyDoc_STRVAR(winsound_PlaySound__doc__,
" Flag values, ored together. See module documentation.");
#define WINSOUND_PLAYSOUND_METHODDEF \
- {"PlaySound", (PyCFunction)winsound_PlaySound, METH_FASTCALL|METH_KEYWORDS, winsound_PlaySound__doc__},
+ {"PlaySound", (PyCFunction)(void(*)(void))winsound_PlaySound, METH_FASTCALL|METH_KEYWORDS, winsound_PlaySound__doc__},
static PyObject *
winsound_PlaySound_impl(PyObject *module, PyObject *sound, int flags);
@@ -51,7 +51,7 @@ PyDoc_STRVAR(winsound_Beep__doc__,
" How long the sound should play, in milliseconds.");
#define WINSOUND_BEEP_METHODDEF \
- {"Beep", (PyCFunction)winsound_Beep, METH_FASTCALL|METH_KEYWORDS, winsound_Beep__doc__},
+ {"Beep", (PyCFunction)(void(*)(void))winsound_Beep, METH_FASTCALL|METH_KEYWORDS, winsound_Beep__doc__},
static PyObject *
winsound_Beep_impl(PyObject *module, int frequency, int duration);
@@ -84,7 +84,7 @@ PyDoc_STRVAR(winsound_MessageBeep__doc__,
"x defaults to MB_OK.");
#define WINSOUND_MESSAGEBEEP_METHODDEF \
- {"MessageBeep", (PyCFunction)winsound_MessageBeep, METH_FASTCALL|METH_KEYWORDS, winsound_MessageBeep__doc__},
+ {"MessageBeep", (PyCFunction)(void(*)(void))winsound_MessageBeep, METH_FASTCALL|METH_KEYWORDS, winsound_MessageBeep__doc__},
static PyObject *
winsound_MessageBeep_impl(PyObject *module, int type);
@@ -106,4 +106,4 @@ winsound_MessageBeep(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
-/*[clinic end generated code: output=beeee8be95667b7d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=19e5f0fb15bcd5bc input=a9049054013a1b77]*/
diff --git a/Python/clinic/_warnings.c.h b/Python/clinic/_warnings.c.h
index 68fad2300659..d1e50de7d9da 100644
--- a/Python/clinic/_warnings.c.h
+++ b/Python/clinic/_warnings.c.h
@@ -9,7 +9,7 @@ PyDoc_STRVAR(warnings_warn__doc__,
"Issue a warning, or maybe ignore it or raise an exception.");
#define WARNINGS_WARN_METHODDEF \
- {"warn", (PyCFunction)warnings_warn, METH_FASTCALL|METH_KEYWORDS, warnings_warn__doc__},
+ {"warn", (PyCFunction)(void(*)(void))warnings_warn, METH_FASTCALL|METH_KEYWORDS, warnings_warn__doc__},
static PyObject *
warnings_warn_impl(PyObject *module, PyObject *message, PyObject *category,
@@ -35,4 +35,4 @@ warnings_warn(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObjec
exit:
return return_value;
}
-/*[clinic end generated code: output=86369ece63001d78 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=a4fbe6e2d1cc2091 input=a9049054013a1b77]*/
diff --git a/Python/clinic/bltinmodule.c.h b/Python/clinic/bltinmodule.c.h
index 121bbd4e65c1..4a798611b7c4 100644
--- a/Python/clinic/bltinmodule.c.h
+++ b/Python/clinic/bltinmodule.c.h
@@ -82,7 +82,7 @@ PyDoc_STRVAR(builtin_format__doc__,
"details.");
#define BUILTIN_FORMAT_METHODDEF \
- {"format", (PyCFunction)builtin_format, METH_FASTCALL, builtin_format__doc__},
+ {"format", (PyCFunction)(void(*)(void))builtin_format, METH_FASTCALL, builtin_format__doc__},
static PyObject *
builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec);
@@ -150,7 +150,7 @@ PyDoc_STRVAR(builtin_compile__doc__,
"in addition to any features explicitly specified.");
#define BUILTIN_COMPILE_METHODDEF \
- {"compile", (PyCFunction)builtin_compile, METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
+ {"compile", (PyCFunction)(void(*)(void))builtin_compile, METH_FASTCALL|METH_KEYWORDS, builtin_compile__doc__},
static PyObject *
builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
@@ -187,7 +187,7 @@ PyDoc_STRVAR(builtin_divmod__doc__,
"Return the tuple (x//y, x%y). Invariant: div*y + mod == x.");
#define BUILTIN_DIVMOD_METHODDEF \
- {"divmod", (PyCFunction)builtin_divmod, METH_FASTCALL, builtin_divmod__doc__},
+ {"divmod", (PyCFunction)(void(*)(void))builtin_divmod, METH_FASTCALL, builtin_divmod__doc__},
static PyObject *
builtin_divmod_impl(PyObject *module, PyObject *x, PyObject *y);
@@ -223,7 +223,7 @@ PyDoc_STRVAR(builtin_eval__doc__,
"If only globals is given, locals defaults to it.");
#define BUILTIN_EVAL_METHODDEF \
- {"eval", (PyCFunction)builtin_eval, METH_FASTCALL, builtin_eval__doc__},
+ {"eval", (PyCFunction)(void(*)(void))builtin_eval, METH_FASTCALL, builtin_eval__doc__},
static PyObject *
builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
@@ -261,7 +261,7 @@ PyDoc_STRVAR(builtin_exec__doc__,
"If only globals is given, locals defaults to it.");
#define BUILTIN_EXEC_METHODDEF \
- {"exec", (PyCFunction)builtin_exec, METH_FASTCALL, builtin_exec__doc__},
+ {"exec", (PyCFunction)(void(*)(void))builtin_exec, METH_FASTCALL, builtin_exec__doc__},
static PyObject *
builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
@@ -316,7 +316,7 @@ PyDoc_STRVAR(builtin_hasattr__doc__,
"This is done by calling getattr(obj, name) and catching AttributeError.");
#define BUILTIN_HASATTR_METHODDEF \
- {"hasattr", (PyCFunction)builtin_hasattr, METH_FASTCALL, builtin_hasattr__doc__},
+ {"hasattr", (PyCFunction)(void(*)(void))builtin_hasattr, METH_FASTCALL, builtin_hasattr__doc__},
static PyObject *
builtin_hasattr_impl(PyObject *module, PyObject *obj, PyObject *name);
@@ -360,7 +360,7 @@ PyDoc_STRVAR(builtin_setattr__doc__,
"setattr(x, \'y\', v) is equivalent to ``x.y = v\'\'");
#define BUILTIN_SETATTR_METHODDEF \
- {"setattr", (PyCFunction)builtin_setattr, METH_FASTCALL, builtin_setattr__doc__},
+ {"setattr", (PyCFunction)(void(*)(void))builtin_setattr, METH_FASTCALL, builtin_setattr__doc__},
static PyObject *
builtin_setattr_impl(PyObject *module, PyObject *obj, PyObject *name,
@@ -394,7 +394,7 @@ PyDoc_STRVAR(builtin_delattr__doc__,
"delattr(x, \'y\') is equivalent to ``del x.y\'\'");
#define BUILTIN_DELATTR_METHODDEF \
- {"delattr", (PyCFunction)builtin_delattr, METH_FASTCALL, builtin_delattr__doc__},
+ {"delattr", (PyCFunction)(void(*)(void))builtin_delattr, METH_FASTCALL, builtin_delattr__doc__},
static PyObject *
builtin_delattr_impl(PyObject *module, PyObject *obj, PyObject *name);
@@ -503,7 +503,7 @@ PyDoc_STRVAR(builtin_pow__doc__,
"invoked using the three argument form.");
#define BUILTIN_POW_METHODDEF \
- {"pow", (PyCFunction)builtin_pow, METH_FASTCALL, builtin_pow__doc__},
+ {"pow", (PyCFunction)(void(*)(void))builtin_pow, METH_FASTCALL, builtin_pow__doc__},
static PyObject *
builtin_pow_impl(PyObject *module, PyObject *x, PyObject *y, PyObject *z);
@@ -540,7 +540,7 @@ PyDoc_STRVAR(builtin_input__doc__,
"On *nix systems, readline is used if available.");
#define BUILTIN_INPUT_METHODDEF \
- {"input", (PyCFunction)builtin_input, METH_FASTCALL, builtin_input__doc__},
+ {"input", (PyCFunction)(void(*)(void))builtin_input, METH_FASTCALL, builtin_input__doc__},
static PyObject *
builtin_input_impl(PyObject *module, PyObject *prompt);
@@ -583,7 +583,7 @@ PyDoc_STRVAR(builtin_round__doc__,
"the return value has the same type as the number. ndigits may be negative.");
#define BUILTIN_ROUND_METHODDEF \
- {"round", (PyCFunction)builtin_round, METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
+ {"round", (PyCFunction)(void(*)(void))builtin_round, METH_FASTCALL|METH_KEYWORDS, builtin_round__doc__},
static PyObject *
builtin_round_impl(PyObject *module, PyObject *number, PyObject *ndigits);
@@ -618,7 +618,7 @@ PyDoc_STRVAR(builtin_sum__doc__,
"reject non-numeric types.");
#define BUILTIN_SUM_METHODDEF \
- {"sum", (PyCFunction)builtin_sum, METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
+ {"sum", (PyCFunction)(void(*)(void))builtin_sum, METH_FASTCALL|METH_KEYWORDS, builtin_sum__doc__},
static PyObject *
builtin_sum_impl(PyObject *module, PyObject *iterable, PyObject *start);
@@ -653,7 +653,7 @@ PyDoc_STRVAR(builtin_isinstance__doc__,
"or ...`` etc.");
#define BUILTIN_ISINSTANCE_METHODDEF \
- {"isinstance", (PyCFunction)builtin_isinstance, METH_FASTCALL, builtin_isinstance__doc__},
+ {"isinstance", (PyCFunction)(void(*)(void))builtin_isinstance, METH_FASTCALL, builtin_isinstance__doc__},
static PyObject *
builtin_isinstance_impl(PyObject *module, PyObject *obj,
@@ -688,7 +688,7 @@ PyDoc_STRVAR(builtin_issubclass__doc__,
"or ...`` etc.");
#define BUILTIN_ISSUBCLASS_METHODDEF \
- {"issubclass", (PyCFunction)builtin_issubclass, METH_FASTCALL, builtin_issubclass__doc__},
+ {"issubclass", (PyCFunction)(void(*)(void))builtin_issubclass, METH_FASTCALL, builtin_issubclass__doc__},
static PyObject *
builtin_issubclass_impl(PyObject *module, PyObject *cls,
@@ -711,4 +711,4 @@ builtin_issubclass(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
exit:
return return_value;
}
-/*[clinic end generated code: output=eb6d08a32e7c83b6 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fa8d97ac8695363b input=a9049054013a1b77]*/
diff --git a/Python/clinic/context.c.h b/Python/clinic/context.c.h
index 683b9d7902f7..32b1883ebe68 100644
--- a/Python/clinic/context.c.h
+++ b/Python/clinic/context.c.h
@@ -12,7 +12,7 @@ PyDoc_STRVAR(_contextvars_Context_get__doc__,
"return None.");
#define _CONTEXTVARS_CONTEXT_GET_METHODDEF \
- {"get", (PyCFunction)_contextvars_Context_get, METH_FASTCALL, _contextvars_Context_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))_contextvars_Context_get, METH_FASTCALL, _contextvars_Context_get__doc__},
static PyObject *
_contextvars_Context_get_impl(PyContext *self, PyObject *key,
@@ -123,7 +123,7 @@ PyDoc_STRVAR(_contextvars_ContextVar_get__doc__,
" * raise a LookupError.");
#define _CONTEXTVARS_CONTEXTVAR_GET_METHODDEF \
- {"get", (PyCFunction)_contextvars_ContextVar_get, METH_FASTCALL, _contextvars_ContextVar_get__doc__},
+ {"get", (PyCFunction)(void(*)(void))_contextvars_ContextVar_get, METH_FASTCALL, _contextvars_ContextVar_get__doc__},
static PyObject *
_contextvars_ContextVar_get_impl(PyContextVar *self, PyObject *default_value);
@@ -170,4 +170,4 @@ PyDoc_STRVAR(_contextvars_ContextVar_reset__doc__,
#define _CONTEXTVARS_CONTEXTVAR_RESET_METHODDEF \
{"reset", (PyCFunction)_contextvars_ContextVar_reset, METH_O, _contextvars_ContextVar_reset__doc__},
-/*[clinic end generated code: output=33414d13716d0648 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=9c93e22bcadbaa2b input=a9049054013a1b77]*/
diff --git a/Python/clinic/import.c.h b/Python/clinic/import.c.h
index 27b83ecc00a7..1eae8f2ee262 100644
--- a/Python/clinic/import.c.h
+++ b/Python/clinic/import.c.h
@@ -75,7 +75,7 @@ PyDoc_STRVAR(_imp__fix_co_filename__doc__,
" File path to use.");
#define _IMP__FIX_CO_FILENAME_METHODDEF \
- {"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_FASTCALL, _imp__fix_co_filename__doc__},
+ {"_fix_co_filename", (PyCFunction)(void(*)(void))_imp__fix_co_filename, METH_FASTCALL, _imp__fix_co_filename__doc__},
static PyObject *
_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
@@ -269,7 +269,7 @@ PyDoc_STRVAR(_imp_create_dynamic__doc__,
"Create an extension module.");
#define _IMP_CREATE_DYNAMIC_METHODDEF \
- {"create_dynamic", (PyCFunction)_imp_create_dynamic, METH_FASTCALL, _imp_create_dynamic__doc__},
+ {"create_dynamic", (PyCFunction)(void(*)(void))_imp_create_dynamic, METH_FASTCALL, _imp_create_dynamic__doc__},
static PyObject *
_imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file);
@@ -360,7 +360,7 @@ PyDoc_STRVAR(_imp_source_hash__doc__,
"\n");
#define _IMP_SOURCE_HASH_METHODDEF \
- {"source_hash", (PyCFunction)_imp_source_hash, METH_FASTCALL|METH_KEYWORDS, _imp_source_hash__doc__},
+ {"source_hash", (PyCFunction)(void(*)(void))_imp_source_hash, METH_FASTCALL|METH_KEYWORDS, _imp_source_hash__doc__},
static PyObject *
_imp_source_hash_impl(PyObject *module, long key, Py_buffer *source);
@@ -396,4 +396,4 @@ _imp_source_hash(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyOb
#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]*/
diff --git a/Python/clinic/marshal.c.h b/Python/clinic/marshal.c.h
index 1ae9332fd3f7..0df4935893c0 100644
--- a/Python/clinic/marshal.c.h
+++ b/Python/clinic/marshal.c.h
@@ -20,7 +20,7 @@ PyDoc_STRVAR(marshal_dump__doc__,
"to the file. The object will not be properly read back by load().");
#define MARSHAL_DUMP_METHODDEF \
- {"dump", (PyCFunction)marshal_dump, METH_FASTCALL, marshal_dump__doc__},
+ {"dump", (PyCFunction)(void(*)(void))marshal_dump, METH_FASTCALL, marshal_dump__doc__},
static PyObject *
marshal_dump_impl(PyObject *module, PyObject *value, PyObject *file,
@@ -78,7 +78,7 @@ PyDoc_STRVAR(marshal_dumps__doc__,
"unsupported type.");
#define MARSHAL_DUMPS_METHODDEF \
- {"dumps", (PyCFunction)marshal_dumps, METH_FASTCALL, marshal_dumps__doc__},
+ {"dumps", (PyCFunction)(void(*)(void))marshal_dumps, METH_FASTCALL, marshal_dumps__doc__},
static PyObject *
marshal_dumps_impl(PyObject *module, PyObject *value, int version);
@@ -134,4 +134,4 @@ marshal_loads(PyObject *module, PyObject *arg)
return return_value;
}
-/*[clinic end generated code: output=584eb2222d86fdc3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=cbb6128201bee7e0 input=a9049054013a1b77]*/
diff --git a/Python/clinic/sysmodule.c.h b/Python/clinic/sysmodule.c.h
index 3e1480513f6c..f9415aea70fc 100644
--- a/Python/clinic/sysmodule.c.h
+++ b/Python/clinic/sysmodule.c.h
@@ -13,7 +13,7 @@ PyDoc_STRVAR(sys_set_coroutine_origin_tracking_depth__doc__,
"to disable.");
#define SYS_SET_COROUTINE_ORIGIN_TRACKING_DEPTH_METHODDEF \
- {"set_coroutine_origin_tracking_depth", (PyCFunction)sys_set_coroutine_origin_tracking_depth, METH_FASTCALL|METH_KEYWORDS, sys_set_coroutine_origin_tracking_depth__doc__},
+ {"set_coroutine_origin_tracking_depth", (PyCFunction)(void(*)(void))sys_set_coroutine_origin_tracking_depth, METH_FASTCALL|METH_KEYWORDS, sys_set_coroutine_origin_tracking_depth__doc__},
static PyObject *
sys_set_coroutine_origin_tracking_depth_impl(PyObject *module, int depth);
@@ -63,4 +63,4 @@ sys_get_coroutine_origin_tracking_depth(PyObject *module, PyObject *Py_UNUSED(ig
exit:
return return_value;
}
-/*[clinic end generated code: output=4a3ac42b97d710ff input=a9049054013a1b77]*/
+/*[clinic end generated code: output=dfd3eb5b137a9861 input=a9049054013a1b77]*/
diff --git a/Tools/clinic/clinic.py b/Tools/clinic/clinic.py
index ca8096f43a6f..2df807144073 100755
--- a/Tools/clinic/clinic.py
+++ b/Tools/clinic/clinic.py
@@ -680,7 +680,7 @@ def output_templates(self, f):
methoddef_define = normalize_snippet("""
#define {methoddef_name} \\
- {{"{name}", (PyCFunction){c_basename}, {methoddef_flags}, {c_basename}__doc__}},
+ {{"{name}", {methoddef_cast}{c_basename}, {methoddef_flags}, {c_basename}__doc__}},
""")
if new_or_init and not f.docstring:
docstring_prototype = docstring_definition = ''
@@ -944,10 +944,16 @@ def insert_keywords(s):
parser_definition = insert_keywords(parser_definition)
+ if flags in ('METH_NOARGS', 'METH_O', 'METH_VARARGS'):
+ methoddef_cast = "(PyCFunction)"
+ else:
+ methoddef_cast = "(PyCFunction)(void(*)(void))"
+
if f.methoddef_flags:
flags += '|' + f.methoddef_flags
methoddef_define = methoddef_define.replace('{methoddef_flags}', flags)
+ methoddef_define = methoddef_define.replace('{methoddef_cast}', methoddef_cast)
methoddef_ifndef = ''
conditional = self.cpp.condition()
1
0
results for 4243df51fe43 on branch "default"
--------------------------------------------
test_collections leaked [7, -7, 1] memory blocks, sum=1
test_functools leaked [0, 3, 1] memory blocks, sum=4
test_multiprocessing_fork leaked [0, 0, -2] memory blocks, sum=-2
test_multiprocessing_forkserver leaked [2, 0, -2] memory blocks, sum=0
Command line was: ['./python', '-m', 'test.regrtest', '-uall', '-R', '3:3:/home/psf-users/antoine/refleaks/reflogcGo_H8', '--timeout', '7200']
1
0
![](https://secure.gravatar.com/avatar/cc7737cd64a84f1b5c61a160798e97ee.jpg?s=120&d=mm&r=g)
bpo-31241: Fix AST node position for list and generator comprehensions. (GH-10633)
by Serhiy Storchaka 27 Nov '18
by Serhiy Storchaka 27 Nov '18
27 Nov '18
https://github.com/python/cpython/commit/b619b097923155a7034c05c4018bf06af9…
commit: b619b097923155a7034c05c4018bf06af9f994d0
branch: master
author: Serhiy Storchaka <storchaka(a)gmail.com>
committer: GitHub <noreply(a)github.com>
date: 2018-11-27T09:40:29+02:00
summary:
bpo-31241: Fix AST node position for list and generator comprehensions. (GH-10633)
The lineno and col_offset attributes of AST nodes for list comprehensions,
generator expressions and tuples are now point to the opening parenthesis or
square brace. For tuples without parenthesis they point to the position
of the first item.
files:
A Misc/NEWS.d/next/Core and Builtins/2018-11-21-14-05-51.bpo-31241.Kin10-.rst
M Lib/test/test_ast.py
M Lib/test/test_exceptions.py
M Python/ast.c
M Python/importlib_zipimport.h
diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
index 0d51b1141925..db9a6caf42f1 100644
--- a/Lib/test/test_ast.py
+++ b/Lib/test/test_ast.py
@@ -55,6 +55,9 @@ def to_tuple(t):
"del v",
# Assign
"v = 1",
+ "a,b = c",
+ "(a,b) = c",
+ "[a,b] = c",
# AugAssign
"v += 1",
# For
@@ -90,9 +93,8 @@ def to_tuple(t):
"for v in v:continue",
# for statements with naked tuples (see http://bugs.python.org/issue6704)
"for a,b in c: pass",
- "[(a,b) for a,b in c]",
- "((a,b) for a,b in c)",
- "((a,b) for (a,b) in c)",
+ "for (a,b) in c: pass",
+ "for [a,b] in c: pass",
# Multiline generator expression (test for .lineno & .col_offset)
"""(
(
@@ -130,6 +132,8 @@ def to_tuple(t):
"@deco1\n@deco2()\nasync def f(): pass",
# Decorated ClassDef
"@deco1\n@deco2()\nclass C: pass",
+ # Decorator with generator argument
+ "@deco(a for a in b)\ndef f(): pass",
]
# These are compiled through "single"
@@ -168,12 +172,24 @@ def to_tuple(t):
"[a for b in c if d]",
# GeneratorExp
"(a for b in c if d)",
+ # Comprehensions with multiple for targets
+ "[(a,b) for a,b in c]",
+ "[(a,b) for (a,b) in c]",
+ "[(a,b) for [a,b] in c]",
+ "{(a,b) for a,b in c}",
+ "{(a,b) for (a,b) in c}",
+ "{(a,b) for [a,b] in c}",
+ "((a,b) for a,b in c)",
+ "((a,b) for (a,b) in c)",
+ "((a,b) for [a,b] in c)",
# Yield - yield expressions can't work outside a function
#
# Compare
"1 < 2 < 3",
# Call
"f(1,2,c=3,*d,**e)",
+ # Call with a generator argument
+ "f(a for a in b)",
# Num
"10",
# Str
@@ -1266,6 +1282,9 @@ def main():
('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Return', (1, 8), ('Constant', (1, 15), 1))], [], None)]),
('Module', [('Delete', (1, 0), [('Name', (1, 4), 'v', ('Del',))])]),
('Module', [('Assign', (1, 0), [('Name', (1, 0), 'v', ('Store',))], ('Constant', (1, 4), 1))]),
+('Module', [('Assign', (1, 0), [('Tuple', (1, 0), [('Name', (1, 0), 'a', ('Store',)), ('Name', (1, 2), 'b', ('Store',))], ('Store',))], ('Name', (1, 6), 'c', ('Load',)))]),
+('Module', [('Assign', (1, 0), [('Tuple', (1, 0), [('Name', (1, 1), 'a', ('Store',)), ('Name', (1, 3), 'b', ('Store',))], ('Store',))], ('Name', (1, 8), 'c', ('Load',)))]),
+('Module', [('Assign', (1, 0), [('List', (1, 0), [('Name', (1, 1), 'a', ('Store',)), ('Name', (1, 3), 'b', ('Store',))], ('Store',))], ('Name', (1, 8), 'c', ('Load',)))]),
('Module', [('AugAssign', (1, 0), ('Name', (1, 0), 'v', ('Store',)), ('Add',), ('Constant', (1, 5), 1))]),
('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Pass', (1, 11))], [])]),
('Module', [('While', (1, 0), ('Name', (1, 6), 'v', ('Load',)), [('Pass', (1, 8))], [])]),
@@ -1284,10 +1303,9 @@ def main():
('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Break', (1, 11))], [])]),
('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Continue', (1, 11))], [])]),
('Module', [('For', (1, 0), ('Tuple', (1, 4), [('Name', (1, 4), 'a', ('Store',)), ('Name', (1, 6), 'b', ('Store',))], ('Store',)), ('Name', (1, 11), 'c', ('Load',)), [('Pass', (1, 14))], [])]),
-('Module', [('Expr', (1, 0), ('ListComp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)]))]),
-('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)]))]),
-('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 12), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)]))]),
-('Module', [('Expr', (1, 0), ('GeneratorExp', (2, 4), ('Tuple', (3, 4), [('Name', (3, 4), 'Aa', ('Load',)), ('Name', (5, 7), 'Bb', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (8, 4), [('Name', (8, 4), 'Aa', ('Store',)), ('Name', (10, 4), 'Bb', ('Store',))], ('Store',)), ('Name', (10, 10), 'Cc', ('Load',)), [], 0)]))]),
+('Module', [('For', (1, 0), ('Tuple', (1, 4), [('Name', (1, 5), 'a', ('Store',)), ('Name', (1, 7), 'b', ('Store',))], ('Store',)), ('Name', (1, 13), 'c', ('Load',)), [('Pass', (1, 16))], [])]),
+('Module', [('For', (1, 0), ('List', (1, 4), [('Name', (1, 5), 'a', ('Store',)), ('Name', (1, 7), 'b', ('Store',))], ('Store',)), ('Name', (1, 13), 'c', ('Load',)), [('Pass', (1, 16))], [])]),
+('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 0), ('Tuple', (2, 4), [('Name', (3, 4), 'Aa', ('Load',)), ('Name', (5, 7), 'Bb', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (8, 4), [('Name', (8, 4), 'Aa', ('Store',)), ('Name', (10, 4), 'Bb', ('Store',))], ('Store',)), ('Name', (10, 10), 'Cc', ('Load',)), [], 0)]))]),
('Module', [('Expr', (1, 0), ('DictComp', (1, 0), ('Name', (1, 1), 'a', ('Load',)), ('Name', (1, 5), 'b', ('Load',)), [('comprehension', ('Name', (1, 11), 'w', ('Store',)), ('Name', (1, 16), 'x', ('Load',)), [], 0), ('comprehension', ('Name', (1, 22), 'm', ('Store',)), ('Name', (1, 27), 'p', ('Load',)), [('Name', (1, 32), 'g', ('Load',))], 0)]))]),
('Module', [('Expr', (1, 0), ('DictComp', (1, 0), ('Name', (1, 1), 'a', ('Load',)), ('Name', (1, 5), 'b', ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'v', ('Store',)), ('Name', (1, 13), 'w', ('Store',))], ('Store',)), ('Name', (1, 18), 'x', ('Load',)), [], 0)]))]),
('Module', [('Expr', (1, 0), ('SetComp', (1, 0), ('Name', (1, 1), 'r', ('Load',)), [('comprehension', ('Name', (1, 7), 'l', ('Store',)), ('Name', (1, 12), 'x', ('Load',)), [('Name', (1, 17), 'g', ('Load',))], 0)]))]),
@@ -1297,10 +1315,11 @@ def main():
('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('AsyncWith', (2, 1), [('withitem', ('Name', (2, 12), 'a', ('Load',)), ('Name', (2, 17), 'b', ('Store',)))], [('Expr', (2, 20), ('Constant', (2, 20), 1))])], [], None)]),
('Module', [('Expr', (1, 0), ('Dict', (1, 0), [None, ('Constant', (1, 10), 2)], [('Dict', (1, 3), [('Constant', (1, 4), 1)], [('Constant', (1, 6), 2)]), ('Constant', (1, 12), 3)]))]),
('Module', [('Expr', (1, 0), ('Set', (1, 0), [('Starred', (1, 1), ('Set', (1, 2), [('Constant', (1, 3), 1), ('Constant', (1, 6), 2)]), ('Load',)), ('Constant', (1, 10), 3)]))]),
-('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Expr', (2, 1), ('ListComp', (2, 2), ('Name', (2, 2), 'i', ('Load',)), [('comprehension', ('Name', (2, 14), 'b', ('Store',)), ('Name', (2, 19), 'c', ('Load',)), [], 1)]))], [], None)]),
+('Module', [('AsyncFunctionDef', (1, 0), 'f', ('arguments', [], None, [], [], None, []), [('Expr', (2, 1), ('ListComp', (2, 1), ('Name', (2, 2), 'i', ('Load',)), [('comprehension', ('Name', (2, 14), 'b', ('Store',)), ('Name', (2, 19), 'c', ('Load',)), [], 1)]))], [], None)]),
('Module', [('FunctionDef', (3, 0), 'f', ('arguments', [], None, [], [], None, []), [('Pass', (3, 9))], [('Name', (1, 1), 'deco1', ('Load',)), ('Call', (2, 0), ('Name', (2, 1), 'deco2', ('Load',)), [], [])], None)]),
('Module', [('AsyncFunctionDef', (3, 0), 'f', ('arguments', [], None, [], [], None, []), [('Pass', (3, 15))], [('Name', (1, 1), 'deco1', ('Load',)), ('Call', (2, 0), ('Name', (2, 1), 'deco2', ('Load',)), [], [])], None)]),
('Module', [('ClassDef', (3, 0), 'C', [], [], [('Pass', (3, 9))], [('Name', (1, 1), 'deco1', ('Load',)), ('Call', (2, 0), ('Name', (2, 1), 'deco2', ('Load',)), [], [])])]),
+('Module', [('FunctionDef', (2, 0), 'f', ('arguments', [], None, [], [], None, []), [('Pass', (2, 9))], [('Call', (1, 1), ('Name', (1, 1), 'deco', ('Load',)), [('GeneratorExp', (1, 5), ('Name', (1, 6), 'a', ('Load',)), [('comprehension', ('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 17), 'b', ('Load',)), [], 0)])], [])], None)]),
]
single_results = [
('Interactive', [('Expr', (1, 0), ('BinOp', (1, 0), ('Constant', (1, 0), 1), ('Add',), ('Constant', (1, 2), 2)))]),
@@ -1315,10 +1334,20 @@ def main():
('Expression', ('Dict', (1, 0), [], [])),
('Expression', ('Set', (1, 0), [('Constant', (1, 1), None)])),
('Expression', ('Dict', (1, 0), [('Constant', (2, 6), 1)], [('Constant', (4, 10), 2)])),
-('Expression', ('ListComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))], 0)])),
-('Expression', ('GeneratorExp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))], 0)])),
+('Expression', ('ListComp', (1, 0), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))], 0)])),
+('Expression', ('GeneratorExp', (1, 0), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))], 0)])),
+('Expression', ('ListComp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)])),
+('Expression', ('ListComp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)])),
+('Expression', ('ListComp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)])),
+('Expression', ('SetComp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)])),
+('Expression', ('SetComp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)])),
+('Expression', ('SetComp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)])),
+('Expression', ('GeneratorExp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [], 0)])),
+('Expression', ('GeneratorExp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)])),
+('Expression', ('GeneratorExp', (1, 0), ('Tuple', (1, 1), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [], 0)])),
('Expression', ('Compare', (1, 0), ('Constant', (1, 0), 1), [('Lt',), ('Lt',)], [('Constant', (1, 4), 2), ('Constant', (1, 8), 3)])),
('Expression', ('Call', (1, 0), ('Name', (1, 0), 'f', ('Load',)), [('Constant', (1, 2), 1), ('Constant', (1, 4), 2), ('Starred', (1, 10), ('Name', (1, 11), 'd', ('Load',)), ('Load',))], [('keyword', 'c', ('Constant', (1, 8), 3)), ('keyword', None, ('Name', (1, 15), 'e', ('Load',)))])),
+('Expression', ('Call', (1, 0), ('Name', (1, 0), 'f', ('Load',)), [('GeneratorExp', (1, 1), ('Name', (1, 2), 'a', ('Load',)), [('comprehension', ('Name', (1, 8), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Load',)), [], 0)])], [])),
('Expression', ('Constant', (1, 0), 10)),
('Expression', ('Constant', (1, 0), 'string')),
('Expression', ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',))),
@@ -1327,7 +1356,7 @@ def main():
('Expression', ('List', (1, 0), [('Constant', (1, 1), 1), ('Constant', (1, 3), 2), ('Constant', (1, 5), 3)], ('Load',))),
('Expression', ('List', (1, 0), [], ('Load',))),
('Expression', ('Tuple', (1, 0), [('Constant', (1, 0), 1), ('Constant', (1, 2), 2), ('Constant', (1, 4), 3)], ('Load',))),
-('Expression', ('Tuple', (1, 1), [('Constant', (1, 1), 1), ('Constant', (1, 3), 2), ('Constant', (1, 5), 3)], ('Load',))),
+('Expression', ('Tuple', (1, 0), [('Constant', (1, 1), 1), ('Constant', (1, 3), 2), ('Constant', (1, 5), 3)], ('Load',))),
('Expression', ('Tuple', (1, 0), [], ('Load',))),
('Expression', ('Call', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8), ('Attribute', (1, 8), ('Name', (1, 8), 'a', ('Load',)), 'b', ('Load',)), ('Slice', ('Constant', (1, 12), 1), ('Constant', (1, 14), 2), None), ('Load',))], [])),
]
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 535324880089..6ef529e2b015 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -204,7 +204,7 @@ def check(src, lineno, offset):
check('x = 0o9', 1, 6)
# Errors thrown by symtable.c
- check('x = [(yield i) for i in range(3)]', 1, 6)
+ check('x = [(yield i) for i in range(3)]', 1, 5)
check('def f():\n from _ import *', 1, 1)
check('def f(x, x):\n pass', 1, 1)
check('def f(x):\n nonlocal x', 2, 3)
diff --git a/Misc/NEWS.d/next/Core and Builtins/2018-11-21-14-05-51.bpo-31241.Kin10-.rst b/Misc/NEWS.d/next/Core and Builtins/2018-11-21-14-05-51.bpo-31241.Kin10-.rst
new file mode 100644
index 000000000000..a859a9b0d68e
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2018-11-21-14-05-51.bpo-31241.Kin10-.rst
@@ -0,0 +1,4 @@
+The *lineno* and *col_offset* attributes of AST nodes for list comprehensions,
+generator expressions and tuples are now point to the opening parenthesis or
+square brace. For tuples without parenthesis they point to the position of
+the first item.
diff --git a/Python/ast.c b/Python/ast.c
index 0d78cc511641..24d5843aabd2 100644
--- a/Python/ast.c
+++ b/Python/ast.c
@@ -577,7 +577,8 @@ static stmt_ty ast_for_with_stmt(struct compiling *, const node *, bool);
static stmt_ty ast_for_for_stmt(struct compiling *, const node *, bool);
/* Note different signature for ast_for_call */
-static expr_ty ast_for_call(struct compiling *, const node *, expr_ty, bool);
+static expr_ty ast_for_call(struct compiling *, const node *, expr_ty,
+ const node *);
static PyObject *parsenumber(struct compiling *, const char *);
static expr_ty parsestrplus(struct compiling *, const node *n);
@@ -931,6 +932,16 @@ forbidden_name(struct compiling *c, identifier name, const node *n,
return 0;
}
+static expr_ty
+copy_location(expr_ty e, const node *n)
+{
+ if (e) {
+ e->lineno = LINENO(n);
+ e->col_offset = n->n_col_offset;
+ }
+ return e;
+}
+
/* Set the context ctx for expr_ty e, recursively traversing e.
Only sets context for expr kinds that "can appear in assignment context"
@@ -1519,7 +1530,7 @@ ast_for_decorator(struct compiling *c, const node *n)
name_expr = NULL;
}
else {
- d = ast_for_call(c, CHILD(n, 3), name_expr, true);
+ d = ast_for_call(c, CHILD(n, 3), name_expr, CHILD(n, 2));
if (!d)
return NULL;
name_expr = NULL;
@@ -2129,10 +2140,16 @@ ast_for_atom(struct compiling *c, const node *n)
return ast_for_expr(c, ch);
/* testlist_comp: test ( comp_for | (',' test)* [','] ) */
- if ((NCH(ch) > 1) && (TYPE(CHILD(ch, 1)) == comp_for))
- return ast_for_genexp(c, ch);
+ if (NCH(ch) == 1) {
+ return ast_for_testlist(c, ch);
+ }
- return ast_for_testlist(c, ch);
+ if (TYPE(CHILD(ch, 1)) == comp_for) {
+ return copy_location(ast_for_genexp(c, ch), n);
+ }
+ else {
+ return copy_location(ast_for_testlist(c, ch), n);
+ }
case LSQB: /* list (or list comprehension) */
ch = CHILD(n, 1);
@@ -2147,8 +2164,9 @@ ast_for_atom(struct compiling *c, const node *n)
return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
}
- else
- return ast_for_listcomp(c, ch);
+ else {
+ return copy_location(ast_for_listcomp(c, ch), n);
+ }
case LBRACE: {
/* dictorsetmaker: ( ((test ':' test | '**' test)
* (comp_for | (',' (test ':' test | '**' test))* [','])) |
@@ -2187,11 +2205,7 @@ ast_for_atom(struct compiling *c, const node *n)
/* It's a dictionary display. */
res = ast_for_dictdisplay(c, ch);
}
- if (res) {
- res->lineno = LINENO(n);
- res->col_offset = n->n_col_offset;
- }
- return res;
+ return copy_location(res, n);
}
}
default:
@@ -2330,7 +2344,7 @@ ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr)
return Call(left_expr, NULL, NULL, LINENO(n),
n->n_col_offset, c->c_arena);
else
- return ast_for_call(c, CHILD(n, 1), left_expr, true);
+ return ast_for_call(c, CHILD(n, 1), left_expr, CHILD(n, 0));
}
else if (TYPE(CHILD(n, 0)) == DOT) {
PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1));
@@ -2667,7 +2681,8 @@ ast_for_expr(struct compiling *c, const node *n)
}
static expr_ty
-ast_for_call(struct compiling *c, const node *n, expr_ty func, bool allowgen)
+ast_for_call(struct compiling *c, const node *n, expr_ty func,
+ const node *maybegenbeg)
{
/*
arglist: argument (',' argument)* [',']
@@ -2690,7 +2705,7 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func, bool allowgen)
nargs++;
else if (TYPE(CHILD(ch, 1)) == comp_for) {
nargs++;
- if (!allowgen) {
+ if (!maybegenbeg) {
ast_error(c, ch, "invalid syntax");
return NULL;
}
@@ -2775,7 +2790,7 @@ ast_for_call(struct compiling *c, const node *n, expr_ty func, bool allowgen)
}
else if (TYPE(CHILD(ch, 1)) == comp_for) {
/* the lone generator expression */
- e = ast_for_genexp(c, ch);
+ e = copy_location(ast_for_genexp(c, ch), maybegenbeg);
if (!e)
return NULL;
asdl_seq_SET(args, nargs++, e);
@@ -3935,7 +3950,7 @@ ast_for_classdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)
if (!dummy_name)
return NULL;
dummy = Name(dummy_name, Load, LINENO(n), n->n_col_offset, c->c_arena);
- call = ast_for_call(c, CHILD(n, 3), dummy, false);
+ call = ast_for_call(c, CHILD(n, 3), dummy, NULL);
if (!call)
return NULL;
}
diff --git a/Python/importlib_zipimport.h b/Python/importlib_zipimport.h
index 2d6868ec80cf..e00010c11fc9 100644
--- a/Python/importlib_zipimport.h
+++ b/Python/importlib_zipimport.h
@@ -869,207 +869,207 @@ const unsigned char _Py_M__zipimport[] = {
132,0,0,0,90,6,109,107,116,105,109,101,41,2,218,1,
100,114,139,0,0,0,114,9,0,0,0,114,9,0,0,0,
114,10,0,0,0,218,14,95,112,97,114,115,101,95,100,111,
- 115,116,105,109,101,139,2,0,0,115,24,0,0,0,0,1,
+ 115,116,105,109,101,139,2,0,0,115,22,0,0,0,0,1,
4,1,10,1,10,1,6,1,6,1,10,1,10,1,2,0,
- 2,0,2,250,2,255,114,170,0,0,0,99,2,0,0,0,
- 0,0,0,0,6,0,0,0,10,0,0,0,67,0,0,0,
- 115,116,0,0,0,122,82,124,1,100,1,100,0,133,2,25,
- 0,100,2,107,6,115,22,116,0,130,1,124,1,100,0,100,
- 1,133,2,25,0,125,1,124,0,106,1,124,1,25,0,125,
- 2,124,2,100,3,25,0,125,3,124,2,100,4,25,0,125,
- 4,124,2,100,5,25,0,125,5,116,2,124,4,124,3,131,
- 2,124,5,102,2,87,0,83,0,4,0,116,3,116,4,116,
- 5,102,3,107,10,114,110,1,0,1,0,1,0,89,0,100,
- 6,83,0,88,0,100,0,83,0,41,7,78,114,14,0,0,
- 0,169,2,218,1,99,218,1,111,114,164,0,0,0,233,6,
- 0,0,0,233,3,0,0,0,41,2,114,0,0,0,0,114,
- 0,0,0,0,41,6,218,14,65,115,115,101,114,116,105,111,
- 110,69,114,114,111,114,114,28,0,0,0,114,170,0,0,0,
- 114,26,0,0,0,218,10,73,110,100,101,120,69,114,114,111,
- 114,114,155,0,0,0,41,6,114,32,0,0,0,114,13,0,
- 0,0,114,54,0,0,0,114,132,0,0,0,114,133,0,0,
- 0,90,17,117,110,99,111,109,112,114,101,115,115,101,100,95,
- 115,105,122,101,114,9,0,0,0,114,9,0,0,0,114,10,
- 0,0,0,114,152,0,0,0,152,2,0,0,115,20,0,0,
- 0,0,1,2,2,20,1,12,1,10,3,8,1,8,1,8,
- 1,16,1,20,1,114,152,0,0,0,99,2,0,0,0,0,
- 0,0,0,3,0,0,0,8,0,0,0,67,0,0,0,115,
- 86,0,0,0,124,1,100,1,100,0,133,2,25,0,100,2,
- 107,6,115,20,116,0,130,1,124,1,100,0,100,1,133,2,
- 25,0,125,1,122,14,124,0,106,1,124,1,25,0,125,2,
- 87,0,110,22,4,0,116,2,107,10,114,68,1,0,1,0,
- 1,0,89,0,100,0,83,0,88,0,116,3,124,0,106,4,
- 124,2,131,2,83,0,100,0,83,0,41,3,78,114,14,0,
- 0,0,114,171,0,0,0,41,5,114,176,0,0,0,114,28,
- 0,0,0,114,26,0,0,0,114,52,0,0,0,114,29,0,
- 0,0,41,3,114,32,0,0,0,114,13,0,0,0,114,54,
- 0,0,0,114,9,0,0,0,114,9,0,0,0,114,10,0,
- 0,0,114,150,0,0,0,171,2,0,0,115,14,0,0,0,
- 0,2,20,1,12,2,2,1,14,1,14,1,8,2,114,150,
- 0,0,0,99,2,0,0,0,0,0,0,0,11,0,0,0,
- 9,0,0,0,67,0,0,0,115,198,0,0,0,116,0,124,
- 0,124,1,131,2,125,2,116,1,68,0,93,160,92,3,125,
- 3,125,4,125,5,124,2,124,3,23,0,125,6,116,2,106,
- 3,100,1,124,0,106,4,116,5,124,6,100,2,100,3,141,
- 5,1,0,122,14,124,0,106,6,124,6,25,0,125,7,87,
- 0,110,20,4,0,116,7,107,10,114,88,1,0,1,0,1,
- 0,89,0,113,14,88,0,124,7,100,4,25,0,125,8,116,
- 8,124,0,106,4,124,7,131,2,125,9,124,4,114,132,116,
- 9,124,0,124,8,124,6,124,1,124,9,131,5,125,10,110,
- 10,116,10,124,8,124,9,131,2,125,10,124,10,100,0,107,
- 8,114,152,113,14,124,7,100,4,25,0,125,8,124,10,124,
- 5,124,8,102,3,2,0,1,0,83,0,113,14,116,11,100,
- 5,124,1,155,2,157,2,124,1,100,6,141,2,130,1,100,
- 0,83,0,41,7,78,122,13,116,114,121,105,110,103,32,123,
- 125,123,125,123,125,114,86,0,0,0,41,1,90,9,118,101,
- 114,98,111,115,105,116,121,114,0,0,0,0,114,57,0,0,
- 0,114,58,0,0,0,41,12,114,36,0,0,0,114,89,0,
- 0,0,114,76,0,0,0,114,77,0,0,0,114,29,0,0,
- 0,114,20,0,0,0,114,28,0,0,0,114,26,0,0,0,
- 114,52,0,0,0,114,156,0,0,0,114,162,0,0,0,114,
- 3,0,0,0,41,11,114,32,0,0,0,114,38,0,0,0,
- 114,13,0,0,0,114,90,0,0,0,114,91,0,0,0,114,
- 47,0,0,0,114,63,0,0,0,114,54,0,0,0,114,40,
- 0,0,0,114,127,0,0,0,114,46,0,0,0,114,9,0,
- 0,0,114,9,0,0,0,114,10,0,0,0,114,44,0,0,
- 0,186,2,0,0,115,36,0,0,0,0,1,10,1,14,1,
- 8,1,22,1,2,1,14,1,14,1,6,2,8,1,12,1,
- 4,1,18,2,10,1,8,3,2,1,8,1,16,2,114,44,
- 0,0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,
- 2,0,0,0,64,0,0,0,115,60,0,0,0,101,0,90,
- 1,100,0,90,2,100,1,90,3,100,2,90,4,100,3,100,
- 4,132,0,90,5,100,5,100,6,132,0,90,6,100,7,100,
- 8,132,0,90,7,100,9,100,10,132,0,90,8,100,11,100,
- 12,132,0,90,9,100,13,83,0,41,14,114,80,0,0,0,
- 122,165,80,114,105,118,97,116,101,32,99,108,97,115,115,32,
- 117,115,101,100,32,116,111,32,115,117,112,112,111,114,116,32,
- 90,105,112,73,109,112,111,114,116,46,103,101,116,95,114,101,
- 115,111,117,114,99,101,95,114,101,97,100,101,114,40,41,46,
- 10,10,32,32,32,32,84,104,105,115,32,99,108,97,115,115,
- 32,105,115,32,97,108,108,111,119,101,100,32,116,111,32,114,
- 101,102,101,114,101,110,99,101,32,97,108,108,32,116,104,101,
- 32,105,110,110,97,114,100,115,32,97,110,100,32,112,114,105,
- 118,97,116,101,32,112,97,114,116,115,32,111,102,10,32,32,
- 32,32,116,104,101,32,122,105,112,105,109,112,111,114,116,101,
- 114,46,10,32,32,32,32,70,99,3,0,0,0,0,0,0,
- 0,3,0,0,0,2,0,0,0,67,0,0,0,115,16,0,
- 0,0,124,1,124,0,95,0,124,2,124,0,95,1,100,0,
- 83,0,114,88,0,0,0,41,2,114,4,0,0,0,114,38,
- 0,0,0,41,3,114,32,0,0,0,114,4,0,0,0,114,
- 38,0,0,0,114,9,0,0,0,114,9,0,0,0,114,10,
- 0,0,0,114,34,0,0,0,220,2,0,0,115,4,0,0,
- 0,0,1,6,1,122,33,95,90,105,112,73,109,112,111,114,
- 116,82,101,115,111,117,114,99,101,82,101,97,100,101,114,46,
- 95,95,105,110,105,116,95,95,99,2,0,0,0,0,0,0,
- 0,5,0,0,0,8,0,0,0,67,0,0,0,115,92,0,
- 0,0,124,0,106,0,160,1,100,1,100,2,161,2,125,2,
- 124,2,155,0,100,2,124,1,155,0,157,3,125,3,100,3,
- 100,4,108,2,109,3,125,4,1,0,122,18,124,4,124,0,
- 106,4,160,5,124,3,161,1,131,1,87,0,83,0,4,0,
- 116,6,107,10,114,86,1,0,1,0,1,0,116,7,124,3,
- 131,1,130,1,89,0,110,2,88,0,100,0,83,0,41,5,
- 78,114,85,0,0,0,114,110,0,0,0,114,0,0,0,0,
- 41,1,218,7,66,121,116,101,115,73,79,41,8,114,38,0,
- 0,0,114,19,0,0,0,90,2,105,111,114,178,0,0,0,
- 114,4,0,0,0,114,55,0,0,0,114,22,0,0,0,218,
- 17,70,105,108,101,78,111,116,70,111,117,110,100,69,114,114,
- 111,114,41,5,114,32,0,0,0,218,8,114,101,115,111,117,
- 114,99,101,218,16,102,117,108,108,110,97,109,101,95,97,115,
- 95,112,97,116,104,114,13,0,0,0,114,178,0,0,0,114,
- 9,0,0,0,114,9,0,0,0,114,10,0,0,0,218,13,
- 111,112,101,110,95,114,101,115,111,117,114,99,101,224,2,0,
- 0,115,14,0,0,0,0,1,14,1,14,1,12,1,2,1,
- 18,1,14,1,122,38,95,90,105,112,73,109,112,111,114,116,
- 82,101,115,111,117,114,99,101,82,101,97,100,101,114,46,111,
- 112,101,110,95,114,101,115,111,117,114,99,101,99,2,0,0,
- 0,0,0,0,0,2,0,0,0,1,0,0,0,67,0,0,
- 0,115,8,0,0,0,116,0,130,1,100,0,83,0,114,88,
- 0,0,0,41,1,114,179,0,0,0,41,2,114,32,0,0,
- 0,114,180,0,0,0,114,9,0,0,0,114,9,0,0,0,
- 114,10,0,0,0,218,13,114,101,115,111,117,114,99,101,95,
- 112,97,116,104,233,2,0,0,115,2,0,0,0,0,4,122,
- 38,95,90,105,112,73,109,112,111,114,116,82,101,115,111,117,
- 114,99,101,82,101,97,100,101,114,46,114,101,115,111,117,114,
- 99,101,95,112,97,116,104,99,2,0,0,0,0,0,0,0,
- 4,0,0,0,8,0,0,0,67,0,0,0,115,72,0,0,
- 0,124,0,106,0,160,1,100,1,100,2,161,2,125,2,124,
- 2,155,0,100,2,124,1,155,0,157,3,125,3,122,16,124,
- 0,106,2,160,3,124,3,161,1,1,0,87,0,110,22,4,
- 0,116,4,107,10,114,66,1,0,1,0,1,0,89,0,100,
- 3,83,0,88,0,100,4,83,0,41,5,78,114,85,0,0,
- 0,114,110,0,0,0,70,84,41,5,114,38,0,0,0,114,
- 19,0,0,0,114,4,0,0,0,114,55,0,0,0,114,22,
- 0,0,0,41,4,114,32,0,0,0,114,59,0,0,0,114,
- 181,0,0,0,114,13,0,0,0,114,9,0,0,0,114,9,
- 0,0,0,114,10,0,0,0,218,11,105,115,95,114,101,115,
- 111,117,114,99,101,239,2,0,0,115,14,0,0,0,0,3,
- 14,1,14,1,2,1,16,1,14,1,8,1,122,36,95,90,
- 105,112,73,109,112,111,114,116,82,101,115,111,117,114,99,101,
- 82,101,97,100,101,114,46,105,115,95,114,101,115,111,117,114,
- 99,101,99,1,0,0,0,0,0,0,0,9,0,0,0,9,
- 0,0,0,99,0,0,0,115,186,0,0,0,100,1,100,2,
- 108,0,109,1,125,1,1,0,124,1,124,0,106,2,160,3,
- 124,0,106,4,161,1,131,1,125,2,124,2,160,5,124,0,
- 106,2,106,6,161,1,125,3,124,3,106,7,100,3,107,2,
- 115,58,116,8,130,1,124,3,106,9,125,4,116,10,131,0,
- 125,5,124,0,106,2,106,11,68,0,93,102,125,6,122,18,
- 124,1,124,6,131,1,160,5,124,4,161,1,125,7,87,0,
- 110,24,4,0,116,12,107,10,114,124,1,0,1,0,1,0,
- 89,0,113,78,89,0,110,2,88,0,124,7,106,9,106,7,
- 125,8,116,13,124,8,131,1,100,1,107,2,114,156,124,7,
- 106,7,86,0,1,0,113,78,124,8,124,5,107,7,114,78,
- 124,5,160,14,124,8,161,1,1,0,124,8,86,0,1,0,
- 113,78,100,0,83,0,41,4,78,114,0,0,0,0,41,1,
- 218,4,80,97,116,104,114,60,0,0,0,41,15,90,7,112,
- 97,116,104,108,105,98,114,185,0,0,0,114,4,0,0,0,
- 114,56,0,0,0,114,38,0,0,0,90,11,114,101,108,97,
- 116,105,118,101,95,116,111,114,29,0,0,0,114,59,0,0,
- 0,114,176,0,0,0,90,6,112,97,114,101,110,116,218,3,
- 115,101,116,114,28,0,0,0,114,23,0,0,0,114,51,0,
- 0,0,218,3,97,100,100,41,9,114,32,0,0,0,114,185,
- 0,0,0,90,13,102,117,108,108,110,97,109,101,95,112,97,
- 116,104,90,13,114,101,108,97,116,105,118,101,95,112,97,116,
- 104,90,12,112,97,99,107,97,103,101,95,112,97,116,104,90,
- 12,115,117,98,100,105,114,115,95,115,101,101,110,218,8,102,
- 105,108,101,110,97,109,101,90,8,114,101,108,97,116,105,118,
- 101,90,11,112,97,114,101,110,116,95,110,97,109,101,114,9,
- 0,0,0,114,9,0,0,0,114,10,0,0,0,218,8,99,
- 111,110,116,101,110,116,115,250,2,0,0,115,34,0,0,0,
- 0,8,12,1,18,1,14,3,14,1,6,1,6,1,12,1,
- 2,1,18,1,14,1,10,5,8,1,12,1,10,1,8,1,
- 10,1,122,33,95,90,105,112,73,109,112,111,114,116,82,101,
- 115,111,117,114,99,101,82,101,97,100,101,114,46,99,111,110,
- 116,101,110,116,115,78,41,10,114,6,0,0,0,114,7,0,
- 0,0,114,8,0,0,0,114,84,0,0,0,114,81,0,0,
- 0,114,34,0,0,0,114,182,0,0,0,114,183,0,0,0,
- 114,184,0,0,0,114,189,0,0,0,114,9,0,0,0,114,
- 9,0,0,0,114,9,0,0,0,114,10,0,0,0,114,80,
- 0,0,0,212,2,0,0,115,14,0,0,0,8,5,4,1,
- 4,2,8,4,8,9,8,6,8,11,114,80,0,0,0,41,
- 45,114,84,0,0,0,90,26,95,102,114,111,122,101,110,95,
- 105,109,112,111,114,116,108,105,98,95,101,120,116,101,114,110,
- 97,108,114,21,0,0,0,114,1,0,0,0,114,2,0,0,
- 0,90,17,95,102,114,111,122,101,110,95,105,109,112,111,114,
- 116,108,105,98,114,76,0,0,0,114,149,0,0,0,114,111,
- 0,0,0,114,153,0,0,0,114,67,0,0,0,114,132,0,
- 0,0,90,7,95,95,97,108,108,95,95,114,20,0,0,0,
- 90,15,112,97,116,104,95,115,101,112,97,114,97,116,111,114,
- 115,114,18,0,0,0,114,75,0,0,0,114,3,0,0,0,
- 114,25,0,0,0,218,4,116,121,112,101,114,70,0,0,0,
- 114,114,0,0,0,114,116,0,0,0,114,118,0,0,0,114,
- 4,0,0,0,114,89,0,0,0,114,36,0,0,0,114,37,
- 0,0,0,114,35,0,0,0,114,27,0,0,0,114,123,0,
- 0,0,114,143,0,0,0,114,145,0,0,0,114,52,0,0,
- 0,114,148,0,0,0,114,156,0,0,0,218,8,95,95,99,
- 111,100,101,95,95,114,154,0,0,0,114,160,0,0,0,114,
- 162,0,0,0,114,170,0,0,0,114,152,0,0,0,114,150,
- 0,0,0,114,44,0,0,0,114,80,0,0,0,114,9,0,
+ 2,0,2,249,114,170,0,0,0,99,2,0,0,0,0,0,
+ 0,0,6,0,0,0,10,0,0,0,67,0,0,0,115,116,
+ 0,0,0,122,82,124,1,100,1,100,0,133,2,25,0,100,
+ 2,107,6,115,22,116,0,130,1,124,1,100,0,100,1,133,
+ 2,25,0,125,1,124,0,106,1,124,1,25,0,125,2,124,
+ 2,100,3,25,0,125,3,124,2,100,4,25,0,125,4,124,
+ 2,100,5,25,0,125,5,116,2,124,4,124,3,131,2,124,
+ 5,102,2,87,0,83,0,4,0,116,3,116,4,116,5,102,
+ 3,107,10,114,110,1,0,1,0,1,0,89,0,100,6,83,
+ 0,88,0,100,0,83,0,41,7,78,114,14,0,0,0,169,
+ 2,218,1,99,218,1,111,114,164,0,0,0,233,6,0,0,
+ 0,233,3,0,0,0,41,2,114,0,0,0,0,114,0,0,
+ 0,0,41,6,218,14,65,115,115,101,114,116,105,111,110,69,
+ 114,114,111,114,114,28,0,0,0,114,170,0,0,0,114,26,
+ 0,0,0,218,10,73,110,100,101,120,69,114,114,111,114,114,
+ 155,0,0,0,41,6,114,32,0,0,0,114,13,0,0,0,
+ 114,54,0,0,0,114,132,0,0,0,114,133,0,0,0,90,
+ 17,117,110,99,111,109,112,114,101,115,115,101,100,95,115,105,
+ 122,101,114,9,0,0,0,114,9,0,0,0,114,10,0,0,
+ 0,114,152,0,0,0,152,2,0,0,115,20,0,0,0,0,
+ 1,2,2,20,1,12,1,10,3,8,1,8,1,8,1,16,
+ 1,20,1,114,152,0,0,0,99,2,0,0,0,0,0,0,
+ 0,3,0,0,0,8,0,0,0,67,0,0,0,115,86,0,
+ 0,0,124,1,100,1,100,0,133,2,25,0,100,2,107,6,
+ 115,20,116,0,130,1,124,1,100,0,100,1,133,2,25,0,
+ 125,1,122,14,124,0,106,1,124,1,25,0,125,2,87,0,
+ 110,22,4,0,116,2,107,10,114,68,1,0,1,0,1,0,
+ 89,0,100,0,83,0,88,0,116,3,124,0,106,4,124,2,
+ 131,2,83,0,100,0,83,0,41,3,78,114,14,0,0,0,
+ 114,171,0,0,0,41,5,114,176,0,0,0,114,28,0,0,
+ 0,114,26,0,0,0,114,52,0,0,0,114,29,0,0,0,
+ 41,3,114,32,0,0,0,114,13,0,0,0,114,54,0,0,
+ 0,114,9,0,0,0,114,9,0,0,0,114,10,0,0,0,
+ 114,150,0,0,0,171,2,0,0,115,14,0,0,0,0,2,
+ 20,1,12,2,2,1,14,1,14,1,8,2,114,150,0,0,
+ 0,99,2,0,0,0,0,0,0,0,11,0,0,0,9,0,
+ 0,0,67,0,0,0,115,198,0,0,0,116,0,124,0,124,
+ 1,131,2,125,2,116,1,68,0,93,160,92,3,125,3,125,
+ 4,125,5,124,2,124,3,23,0,125,6,116,2,106,3,100,
+ 1,124,0,106,4,116,5,124,6,100,2,100,3,141,5,1,
+ 0,122,14,124,0,106,6,124,6,25,0,125,7,87,0,110,
+ 20,4,0,116,7,107,10,114,88,1,0,1,0,1,0,89,
+ 0,113,14,88,0,124,7,100,4,25,0,125,8,116,8,124,
+ 0,106,4,124,7,131,2,125,9,124,4,114,132,116,9,124,
+ 0,124,8,124,6,124,1,124,9,131,5,125,10,110,10,116,
+ 10,124,8,124,9,131,2,125,10,124,10,100,0,107,8,114,
+ 152,113,14,124,7,100,4,25,0,125,8,124,10,124,5,124,
+ 8,102,3,2,0,1,0,83,0,113,14,116,11,100,5,124,
+ 1,155,2,157,2,124,1,100,6,141,2,130,1,100,0,83,
+ 0,41,7,78,122,13,116,114,121,105,110,103,32,123,125,123,
+ 125,123,125,114,86,0,0,0,41,1,90,9,118,101,114,98,
+ 111,115,105,116,121,114,0,0,0,0,114,57,0,0,0,114,
+ 58,0,0,0,41,12,114,36,0,0,0,114,89,0,0,0,
+ 114,76,0,0,0,114,77,0,0,0,114,29,0,0,0,114,
+ 20,0,0,0,114,28,0,0,0,114,26,0,0,0,114,52,
+ 0,0,0,114,156,0,0,0,114,162,0,0,0,114,3,0,
+ 0,0,41,11,114,32,0,0,0,114,38,0,0,0,114,13,
+ 0,0,0,114,90,0,0,0,114,91,0,0,0,114,47,0,
+ 0,0,114,63,0,0,0,114,54,0,0,0,114,40,0,0,
+ 0,114,127,0,0,0,114,46,0,0,0,114,9,0,0,0,
+ 114,9,0,0,0,114,10,0,0,0,114,44,0,0,0,186,
+ 2,0,0,115,36,0,0,0,0,1,10,1,14,1,8,1,
+ 22,1,2,1,14,1,14,1,6,2,8,1,12,1,4,1,
+ 18,2,10,1,8,3,2,1,8,1,16,2,114,44,0,0,
+ 0,99,0,0,0,0,0,0,0,0,0,0,0,0,2,0,
+ 0,0,64,0,0,0,115,60,0,0,0,101,0,90,1,100,
+ 0,90,2,100,1,90,3,100,2,90,4,100,3,100,4,132,
+ 0,90,5,100,5,100,6,132,0,90,6,100,7,100,8,132,
+ 0,90,7,100,9,100,10,132,0,90,8,100,11,100,12,132,
+ 0,90,9,100,13,83,0,41,14,114,80,0,0,0,122,165,
+ 80,114,105,118,97,116,101,32,99,108,97,115,115,32,117,115,
+ 101,100,32,116,111,32,115,117,112,112,111,114,116,32,90,105,
+ 112,73,109,112,111,114,116,46,103,101,116,95,114,101,115,111,
+ 117,114,99,101,95,114,101,97,100,101,114,40,41,46,10,10,
+ 32,32,32,32,84,104,105,115,32,99,108,97,115,115,32,105,
+ 115,32,97,108,108,111,119,101,100,32,116,111,32,114,101,102,
+ 101,114,101,110,99,101,32,97,108,108,32,116,104,101,32,105,
+ 110,110,97,114,100,115,32,97,110,100,32,112,114,105,118,97,
+ 116,101,32,112,97,114,116,115,32,111,102,10,32,32,32,32,
+ 116,104,101,32,122,105,112,105,109,112,111,114,116,101,114,46,
+ 10,32,32,32,32,70,99,3,0,0,0,0,0,0,0,3,
+ 0,0,0,2,0,0,0,67,0,0,0,115,16,0,0,0,
+ 124,1,124,0,95,0,124,2,124,0,95,1,100,0,83,0,
+ 114,88,0,0,0,41,2,114,4,0,0,0,114,38,0,0,
+ 0,41,3,114,32,0,0,0,114,4,0,0,0,114,38,0,
0,0,114,9,0,0,0,114,9,0,0,0,114,10,0,0,
- 0,218,8,60,109,111,100,117,108,101,62,13,0,0,0,115,
- 90,0,0,0,4,4,8,1,16,1,8,1,8,1,8,1,
- 8,1,8,1,8,2,8,3,6,1,14,3,16,4,4,2,
- 8,2,4,1,4,1,4,2,14,127,0,127,0,1,12,1,
- 12,1,2,1,2,253,2,255,2,9,8,4,8,9,8,31,
- 8,126,2,254,2,29,4,5,8,21,8,46,8,10,8,46,
- 10,5,8,7,8,6,8,13,8,19,8,15,8,26,
+ 0,114,34,0,0,0,220,2,0,0,115,4,0,0,0,0,
+ 1,6,1,122,33,95,90,105,112,73,109,112,111,114,116,82,
+ 101,115,111,117,114,99,101,82,101,97,100,101,114,46,95,95,
+ 105,110,105,116,95,95,99,2,0,0,0,0,0,0,0,5,
+ 0,0,0,8,0,0,0,67,0,0,0,115,92,0,0,0,
+ 124,0,106,0,160,1,100,1,100,2,161,2,125,2,124,2,
+ 155,0,100,2,124,1,155,0,157,3,125,3,100,3,100,4,
+ 108,2,109,3,125,4,1,0,122,18,124,4,124,0,106,4,
+ 160,5,124,3,161,1,131,1,87,0,83,0,4,0,116,6,
+ 107,10,114,86,1,0,1,0,1,0,116,7,124,3,131,1,
+ 130,1,89,0,110,2,88,0,100,0,83,0,41,5,78,114,
+ 85,0,0,0,114,110,0,0,0,114,0,0,0,0,41,1,
+ 218,7,66,121,116,101,115,73,79,41,8,114,38,0,0,0,
+ 114,19,0,0,0,90,2,105,111,114,178,0,0,0,114,4,
+ 0,0,0,114,55,0,0,0,114,22,0,0,0,218,17,70,
+ 105,108,101,78,111,116,70,111,117,110,100,69,114,114,111,114,
+ 41,5,114,32,0,0,0,218,8,114,101,115,111,117,114,99,
+ 101,218,16,102,117,108,108,110,97,109,101,95,97,115,95,112,
+ 97,116,104,114,13,0,0,0,114,178,0,0,0,114,9,0,
+ 0,0,114,9,0,0,0,114,10,0,0,0,218,13,111,112,
+ 101,110,95,114,101,115,111,117,114,99,101,224,2,0,0,115,
+ 14,0,0,0,0,1,14,1,14,1,12,1,2,1,18,1,
+ 14,1,122,38,95,90,105,112,73,109,112,111,114,116,82,101,
+ 115,111,117,114,99,101,82,101,97,100,101,114,46,111,112,101,
+ 110,95,114,101,115,111,117,114,99,101,99,2,0,0,0,0,
+ 0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,115,
+ 8,0,0,0,116,0,130,1,100,0,83,0,114,88,0,0,
+ 0,41,1,114,179,0,0,0,41,2,114,32,0,0,0,114,
+ 180,0,0,0,114,9,0,0,0,114,9,0,0,0,114,10,
+ 0,0,0,218,13,114,101,115,111,117,114,99,101,95,112,97,
+ 116,104,233,2,0,0,115,2,0,0,0,0,4,122,38,95,
+ 90,105,112,73,109,112,111,114,116,82,101,115,111,117,114,99,
+ 101,82,101,97,100,101,114,46,114,101,115,111,117,114,99,101,
+ 95,112,97,116,104,99,2,0,0,0,0,0,0,0,4,0,
+ 0,0,8,0,0,0,67,0,0,0,115,72,0,0,0,124,
+ 0,106,0,160,1,100,1,100,2,161,2,125,2,124,2,155,
+ 0,100,2,124,1,155,0,157,3,125,3,122,16,124,0,106,
+ 2,160,3,124,3,161,1,1,0,87,0,110,22,4,0,116,
+ 4,107,10,114,66,1,0,1,0,1,0,89,0,100,3,83,
+ 0,88,0,100,4,83,0,41,5,78,114,85,0,0,0,114,
+ 110,0,0,0,70,84,41,5,114,38,0,0,0,114,19,0,
+ 0,0,114,4,0,0,0,114,55,0,0,0,114,22,0,0,
+ 0,41,4,114,32,0,0,0,114,59,0,0,0,114,181,0,
+ 0,0,114,13,0,0,0,114,9,0,0,0,114,9,0,0,
+ 0,114,10,0,0,0,218,11,105,115,95,114,101,115,111,117,
+ 114,99,101,239,2,0,0,115,14,0,0,0,0,3,14,1,
+ 14,1,2,1,16,1,14,1,8,1,122,36,95,90,105,112,
+ 73,109,112,111,114,116,82,101,115,111,117,114,99,101,82,101,
+ 97,100,101,114,46,105,115,95,114,101,115,111,117,114,99,101,
+ 99,1,0,0,0,0,0,0,0,9,0,0,0,9,0,0,
+ 0,99,0,0,0,115,186,0,0,0,100,1,100,2,108,0,
+ 109,1,125,1,1,0,124,1,124,0,106,2,160,3,124,0,
+ 106,4,161,1,131,1,125,2,124,2,160,5,124,0,106,2,
+ 106,6,161,1,125,3,124,3,106,7,100,3,107,2,115,58,
+ 116,8,130,1,124,3,106,9,125,4,116,10,131,0,125,5,
+ 124,0,106,2,106,11,68,0,93,102,125,6,122,18,124,1,
+ 124,6,131,1,160,5,124,4,161,1,125,7,87,0,110,24,
+ 4,0,116,12,107,10,114,124,1,0,1,0,1,0,89,0,
+ 113,78,89,0,110,2,88,0,124,7,106,9,106,7,125,8,
+ 116,13,124,8,131,1,100,1,107,2,114,156,124,7,106,7,
+ 86,0,1,0,113,78,124,8,124,5,107,7,114,78,124,5,
+ 160,14,124,8,161,1,1,0,124,8,86,0,1,0,113,78,
+ 100,0,83,0,41,4,78,114,0,0,0,0,41,1,218,4,
+ 80,97,116,104,114,60,0,0,0,41,15,90,7,112,97,116,
+ 104,108,105,98,114,185,0,0,0,114,4,0,0,0,114,56,
+ 0,0,0,114,38,0,0,0,90,11,114,101,108,97,116,105,
+ 118,101,95,116,111,114,29,0,0,0,114,59,0,0,0,114,
+ 176,0,0,0,90,6,112,97,114,101,110,116,218,3,115,101,
+ 116,114,28,0,0,0,114,23,0,0,0,114,51,0,0,0,
+ 218,3,97,100,100,41,9,114,32,0,0,0,114,185,0,0,
+ 0,90,13,102,117,108,108,110,97,109,101,95,112,97,116,104,
+ 90,13,114,101,108,97,116,105,118,101,95,112,97,116,104,90,
+ 12,112,97,99,107,97,103,101,95,112,97,116,104,90,12,115,
+ 117,98,100,105,114,115,95,115,101,101,110,218,8,102,105,108,
+ 101,110,97,109,101,90,8,114,101,108,97,116,105,118,101,90,
+ 11,112,97,114,101,110,116,95,110,97,109,101,114,9,0,0,
+ 0,114,9,0,0,0,114,10,0,0,0,218,8,99,111,110,
+ 116,101,110,116,115,250,2,0,0,115,34,0,0,0,0,8,
+ 12,1,18,1,14,3,14,1,6,1,6,1,12,1,2,1,
+ 18,1,14,1,10,5,8,1,12,1,10,1,8,1,10,1,
+ 122,33,95,90,105,112,73,109,112,111,114,116,82,101,115,111,
+ 117,114,99,101,82,101,97,100,101,114,46,99,111,110,116,101,
+ 110,116,115,78,41,10,114,6,0,0,0,114,7,0,0,0,
+ 114,8,0,0,0,114,84,0,0,0,114,81,0,0,0,114,
+ 34,0,0,0,114,182,0,0,0,114,183,0,0,0,114,184,
+ 0,0,0,114,189,0,0,0,114,9,0,0,0,114,9,0,
+ 0,0,114,9,0,0,0,114,10,0,0,0,114,80,0,0,
+ 0,212,2,0,0,115,14,0,0,0,8,5,4,1,4,2,
+ 8,4,8,9,8,6,8,11,114,80,0,0,0,41,45,114,
+ 84,0,0,0,90,26,95,102,114,111,122,101,110,95,105,109,
+ 112,111,114,116,108,105,98,95,101,120,116,101,114,110,97,108,
+ 114,21,0,0,0,114,1,0,0,0,114,2,0,0,0,90,
+ 17,95,102,114,111,122,101,110,95,105,109,112,111,114,116,108,
+ 105,98,114,76,0,0,0,114,149,0,0,0,114,111,0,0,
+ 0,114,153,0,0,0,114,67,0,0,0,114,132,0,0,0,
+ 90,7,95,95,97,108,108,95,95,114,20,0,0,0,90,15,
+ 112,97,116,104,95,115,101,112,97,114,97,116,111,114,115,114,
+ 18,0,0,0,114,75,0,0,0,114,3,0,0,0,114,25,
+ 0,0,0,218,4,116,121,112,101,114,70,0,0,0,114,114,
+ 0,0,0,114,116,0,0,0,114,118,0,0,0,114,4,0,
+ 0,0,114,89,0,0,0,114,36,0,0,0,114,37,0,0,
+ 0,114,35,0,0,0,114,27,0,0,0,114,123,0,0,0,
+ 114,143,0,0,0,114,145,0,0,0,114,52,0,0,0,114,
+ 148,0,0,0,114,156,0,0,0,218,8,95,95,99,111,100,
+ 101,95,95,114,154,0,0,0,114,160,0,0,0,114,162,0,
+ 0,0,114,170,0,0,0,114,152,0,0,0,114,150,0,0,
+ 0,114,44,0,0,0,114,80,0,0,0,114,9,0,0,0,
+ 114,9,0,0,0,114,9,0,0,0,114,10,0,0,0,218,
+ 8,60,109,111,100,117,108,101,62,13,0,0,0,115,88,0,
+ 0,0,4,4,8,1,16,1,8,1,8,1,8,1,8,1,
+ 8,1,8,2,8,3,6,1,14,3,16,4,4,2,8,2,
+ 4,1,4,1,4,2,14,127,0,127,0,1,12,1,12,1,
+ 2,1,2,252,4,9,8,4,8,9,8,31,8,126,2,254,
+ 2,29,4,5,8,21,8,46,8,10,8,46,10,5,8,7,
+ 8,6,8,13,8,19,8,15,8,26,
};
1
0