Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

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.
This commit is contained in:
Serhiy Storchaka 2018-11-27 13:27:31 +02:00 committed by GitHub
parent 81524022d0
commit 62be74290a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 174 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Doc/extending/extending.rst
View File

@ -757,7 +757,7 @@ Philbrick (philbrick@hks.com)::
* only take two PyObject* parameters, and keywdarg_parrot() takes * only take two PyObject* parameters, and keywdarg_parrot() takes
* three. * 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."}, "Print a lovely skit to standard output."},
{NULL, NULL, 0, NULL} /* sentinel */ {NULL, NULL, 0, NULL} /* sentinel */
}; };

8
Modules/_bisectmodule.c
View File

@ -241,13 +241,13 @@ Optional args lo (default 0) and hi (default len(a)) bound the\n\
slice of a to be searched.\n"); slice of a to be searched.\n");
static PyMethodDef bisect_methods[] = { static PyMethodDef bisect_methods[] = {
{"bisect_right", (PyCFunction)bisect_right, {"bisect_right", (PyCFunction)(void(*)(void))bisect_right,
METH_VARARGS|METH_KEYWORDS, bisect_right_doc}, 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}, 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}, 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}, METH_VARARGS|METH_KEYWORDS, insort_left_doc},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };

6
Modules/_collectionsmodule.c
View File

@ -1573,9 +1573,9 @@ static PyMethodDef deque_methods[] = {
METH_O, extend_doc}, METH_O, extend_doc},
{"extendleft", (PyCFunction)deque_extendleft, {"extendleft", (PyCFunction)deque_extendleft,
METH_O, extendleft_doc}, METH_O, extendleft_doc},
{"index", (PyCFunction)deque_index, {"index", (PyCFunction)(void(*)(void))deque_index,
METH_FASTCALL, index_doc}, METH_FASTCALL, index_doc},
{"insert", (PyCFunction)deque_insert, {"insert", (PyCFunction)(void(*)(void))deque_insert,
METH_FASTCALL, insert_doc}, METH_FASTCALL, insert_doc},
{"pop", (PyCFunction)deque_pop, {"pop", (PyCFunction)deque_pop,
METH_NOARGS, pop_doc}, METH_NOARGS, pop_doc},
@ -1589,7 +1589,7 @@ static PyMethodDef deque_methods[] = {
METH_NOARGS, reversed_doc}, METH_NOARGS, reversed_doc},
{"reverse", (PyCFunction)deque_reverse, {"reverse", (PyCFunction)deque_reverse,
METH_NOARGS, reverse_doc}, METH_NOARGS, reverse_doc},
{"rotate", (PyCFunction)deque_rotate, {"rotate", (PyCFunction)(void(*)(void))deque_rotate,
METH_FASTCALL, rotate_doc}, METH_FASTCALL, rotate_doc},
{"__sizeof__", (PyCFunction)deque_sizeof, {"__sizeof__", (PyCFunction)deque_sizeof,
METH_NOARGS, sizeof_doc}, METH_NOARGS, sizeof_doc},

6
Modules/_csv.c
View File

@ -1583,13 +1583,13 @@ PyDoc_STRVAR(csv_field_size_limit_doc,
"the old limit is returned"); "the old limit is returned");
static struct PyMethodDef csv_methods[] = { static struct PyMethodDef csv_methods[] = {
{ "reader", (PyCFunction)csv_reader, { "reader", (PyCFunction)(void(*)(void))csv_reader,
METH_VARARGS | METH_KEYWORDS, csv_reader_doc}, METH_VARARGS | METH_KEYWORDS, csv_reader_doc},
{ "writer", (PyCFunction)csv_writer, { "writer", (PyCFunction)(void(*)(void))csv_writer,
METH_VARARGS | METH_KEYWORDS, csv_writer_doc}, METH_VARARGS | METH_KEYWORDS, csv_writer_doc},
{ "list_dialects", (PyCFunction)csv_list_dialects, { "list_dialects", (PyCFunction)csv_list_dialects,
METH_NOARGS, csv_list_dialects_doc}, 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}, METH_VARARGS | METH_KEYWORDS, csv_register_dialect_doc},
{ "unregister_dialect", (PyCFunction)csv_unregister_dialect, { "unregister_dialect", (PyCFunction)csv_unregister_dialect,
METH_O, csv_unregister_dialect_doc}, METH_O, csv_unregister_dialect_doc},

20
Modules/_datetimemodule.c
View File

@ -3255,7 +3255,7 @@ static PyMethodDef date_methods[] = {
{"ctime", (PyCFunction)date_ctime, METH_NOARGS, {"ctime", (PyCFunction)date_ctime, METH_NOARGS,
PyDoc_STR("Return ctime() style string.")}, 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.")}, PyDoc_STR("format -> strftime() style string.")},
{"__format__", (PyCFunction)date_format, METH_VARARGS, {"__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" PyDoc_STR("Return the day of the week represented by the date.\n"
"Monday == 0 ... Sunday == 6")}, "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.")}, PyDoc_STR("Return date with new specified fields.")},
{"__reduce__", (PyCFunction)date_reduce, METH_NOARGS, {"__reduce__", (PyCFunction)date_reduce, METH_NOARGS,
@ -4392,12 +4392,12 @@ time_reduce(PyDateTime_Time *self, PyObject *arg)
static PyMethodDef time_methods[] = { 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]]]]]" PyDoc_STR("Return string in ISO 8601 format, [HH[:MM[:SS[.mmm[uuu]]]]]"
"[+HH:MM].\n\n" "[+HH:MM].\n\n"
"timespec specifies what components of the time to include.\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.")}, PyDoc_STR("format -> strftime() style string.")},
{"__format__", (PyCFunction)date_format, METH_VARARGS, {"__format__", (PyCFunction)date_format, METH_VARARGS,
@ -4412,7 +4412,7 @@ static PyMethodDef time_methods[] = {
{"dst", (PyCFunction)time_dst, METH_NOARGS, {"dst", (PyCFunction)time_dst, METH_NOARGS,
PyDoc_STR("Return self.tzinfo.dst(self).")}, 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.")}, PyDoc_STR("Return time with new specified fields.")},
{"fromisoformat", (PyCFunction)time_fromisoformat, METH_O | METH_CLASS, {"fromisoformat", (PyCFunction)time_fromisoformat, METH_O | METH_CLASS,
@ -6025,7 +6025,7 @@ static PyMethodDef datetime_methods[] = {
METH_NOARGS | METH_CLASS, METH_NOARGS | METH_CLASS,
PyDoc_STR("Return a new datetime representing UTC day and time.")}, 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, METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("timestamp[, tz] -> tz's local time from POSIX timestamp.")}, 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 " PyDoc_STR("string, format -> new datetime parsed from a string "
"(like time.strptime()).")}, "(like time.strptime()).")},
{"combine", (PyCFunction)datetime_combine, {"combine", (PyCFunction)(void(*)(void))datetime_combine,
METH_VARARGS | METH_KEYWORDS | METH_CLASS, METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("date, time -> datetime with same date and time fields")}, 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, {"utctimetuple", (PyCFunction)datetime_utctimetuple, METH_NOARGS,
PyDoc_STR("Return UTC time tuple, compatible with time.localtime().")}, 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, " PyDoc_STR("[sep] -> string in ISO 8601 format, "
"YYYY-MM-DDT[HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM].\n" "YYYY-MM-DDT[HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM].\n"
"sep is used to separate the year from the time, and " "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, {"dst", (PyCFunction)datetime_dst, METH_NOARGS,
PyDoc_STR("Return self.tzinfo.dst(self).")}, 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.")}, 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")}, PyDoc_STR("tz -> convert to local time in new timezone tz\n")},
{"__reduce_ex__", (PyCFunction)datetime_reduce_ex, METH_VARARGS, {"__reduce_ex__", (PyCFunction)datetime_reduce_ex, METH_VARARGS,

76
Modules/_decimal/_decimal.c
View File

@ -4598,30 +4598,30 @@ static PyNumberMethods dec_number_methods =
static PyMethodDef dec_methods [] = static PyMethodDef dec_methods [] =
{ {
/* Unary arithmetic functions, optional context arg */ /* Unary arithmetic functions, optional context arg */
{ "exp", (PyCFunction)dec_mpd_qexp, METH_VARARGS|METH_KEYWORDS, doc_exp }, { "exp", (PyCFunction)(void(*)(void))dec_mpd_qexp, METH_VARARGS|METH_KEYWORDS, doc_exp },
{ "ln", (PyCFunction)dec_mpd_qln, METH_VARARGS|METH_KEYWORDS, doc_ln }, { "ln", (PyCFunction)(void(*)(void))dec_mpd_qln, METH_VARARGS|METH_KEYWORDS, doc_ln },
{ "log10", (PyCFunction)dec_mpd_qlog10, METH_VARARGS|METH_KEYWORDS, doc_log10 }, { "log10", (PyCFunction)(void(*)(void))dec_mpd_qlog10, METH_VARARGS|METH_KEYWORDS, doc_log10 },
{ "next_minus", (PyCFunction)dec_mpd_qnext_minus, METH_VARARGS|METH_KEYWORDS, doc_next_minus }, { "next_minus", (PyCFunction)(void(*)(void))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 }, { "next_plus", (PyCFunction)(void(*)(void))dec_mpd_qnext_plus, METH_VARARGS|METH_KEYWORDS, doc_next_plus },
{ "normalize", (PyCFunction)dec_mpd_qreduce, METH_VARARGS|METH_KEYWORDS, doc_normalize }, { "normalize", (PyCFunction)(void(*)(void))dec_mpd_qreduce, METH_VARARGS|METH_KEYWORDS, doc_normalize },
{ "to_integral", (PyCFunction)PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral }, { "to_integral", (PyCFunction)(void(*)(void))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_exact", (PyCFunction)(void(*)(void))PyDec_ToIntegralExact, METH_VARARGS|METH_KEYWORDS, doc_to_integral_exact },
{ "to_integral_value", (PyCFunction)PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral_value }, { "to_integral_value", (PyCFunction)(void(*)(void))PyDec_ToIntegralValue, METH_VARARGS|METH_KEYWORDS, doc_to_integral_value },
{ "sqrt", (PyCFunction)dec_mpd_qsqrt, METH_VARARGS|METH_KEYWORDS, doc_sqrt }, { "sqrt", (PyCFunction)(void(*)(void))dec_mpd_qsqrt, METH_VARARGS|METH_KEYWORDS, doc_sqrt },
/* Binary arithmetic functions, optional context arg */ /* Binary arithmetic functions, optional context arg */
{ "compare", (PyCFunction)dec_mpd_qcompare, METH_VARARGS|METH_KEYWORDS, doc_compare }, { "compare", (PyCFunction)(void(*)(void))dec_mpd_qcompare, METH_VARARGS|METH_KEYWORDS, doc_compare },
{ "compare_signal", (PyCFunction)dec_mpd_qcompare_signal, METH_VARARGS|METH_KEYWORDS, doc_compare_signal }, { "compare_signal", (PyCFunction)(void(*)(void))dec_mpd_qcompare_signal, METH_VARARGS|METH_KEYWORDS, doc_compare_signal },
{ "max", (PyCFunction)dec_mpd_qmax, METH_VARARGS|METH_KEYWORDS, doc_max }, { "max", (PyCFunction)(void(*)(void))dec_mpd_qmax, METH_VARARGS|METH_KEYWORDS, doc_max },
{ "max_mag", (PyCFunction)dec_mpd_qmax_mag, METH_VARARGS|METH_KEYWORDS, doc_max_mag }, { "max_mag", (PyCFunction)(void(*)(void))dec_mpd_qmax_mag, METH_VARARGS|METH_KEYWORDS, doc_max_mag },
{ "min", (PyCFunction)dec_mpd_qmin, METH_VARARGS|METH_KEYWORDS, doc_min }, { "min", (PyCFunction)(void(*)(void))dec_mpd_qmin, METH_VARARGS|METH_KEYWORDS, doc_min },
{ "min_mag", (PyCFunction)dec_mpd_qmin_mag, METH_VARARGS|METH_KEYWORDS, doc_min_mag }, { "min_mag", (PyCFunction)(void(*)(void))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 }, { "next_toward", (PyCFunction)(void(*)(void))dec_mpd_qnext_toward, METH_VARARGS|METH_KEYWORDS, doc_next_toward },
{ "quantize", (PyCFunction)dec_mpd_qquantize, METH_VARARGS|METH_KEYWORDS, doc_quantize }, { "quantize", (PyCFunction)(void(*)(void))dec_mpd_qquantize, METH_VARARGS|METH_KEYWORDS, doc_quantize },
{ "remainder_near", (PyCFunction)dec_mpd_qrem_near, METH_VARARGS|METH_KEYWORDS, doc_remainder_near }, { "remainder_near", (PyCFunction)(void(*)(void))dec_mpd_qrem_near, METH_VARARGS|METH_KEYWORDS, doc_remainder_near },
/* Ternary arithmetic functions, optional context arg */ /* 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 */ /* Boolean functions, no context arg */
{ "is_canonical", dec_mpd_iscanonical, METH_NOARGS, doc_is_canonical }, { "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 }, { "is_zero", dec_mpd_iszero, METH_NOARGS, doc_is_zero },
/* Boolean functions, optional context arg */ /* Boolean functions, optional context arg */
{ "is_normal", (PyCFunction)dec_mpd_isnormal, METH_VARARGS|METH_KEYWORDS, doc_is_normal }, { "is_normal", (PyCFunction)(void(*)(void))dec_mpd_isnormal, METH_VARARGS|METH_KEYWORDS, doc_is_normal },
{ "is_subnormal", (PyCFunction)dec_mpd_issubnormal, METH_VARARGS|METH_KEYWORDS, doc_is_subnormal }, { "is_subnormal", (PyCFunction)(void(*)(void))dec_mpd_issubnormal, METH_VARARGS|METH_KEYWORDS, doc_is_subnormal },
/* Unary functions, no context arg */ /* Unary functions, no context arg */
{ "adjusted", dec_mpd_adjexp, METH_NOARGS, doc_adjusted }, { "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 }, { "copy_negate", dec_mpd_qcopy_negate, METH_NOARGS, doc_copy_negate },
/* Unary functions, optional context arg */ /* Unary functions, optional context arg */
{ "logb", (PyCFunction)dec_mpd_qlogb, METH_VARARGS|METH_KEYWORDS, doc_logb }, { "logb", (PyCFunction)(void(*)(void))dec_mpd_qlogb, METH_VARARGS|METH_KEYWORDS, doc_logb },
{ "logical_invert", (PyCFunction)dec_mpd_qinvert, METH_VARARGS|METH_KEYWORDS, doc_logical_invert }, { "logical_invert", (PyCFunction)(void(*)(void))dec_mpd_qinvert, METH_VARARGS|METH_KEYWORDS, doc_logical_invert },
{ "number_class", (PyCFunction)dec_mpd_class, METH_VARARGS|METH_KEYWORDS, doc_number_class }, { "number_class", (PyCFunction)(void(*)(void))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 }, { "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 */ /* Binary functions, optional context arg for conversion errors */
{ "compare_total", (PyCFunction)dec_mpd_compare_total, METH_VARARGS|METH_KEYWORDS, doc_compare_total }, { "compare_total", (PyCFunction)(void(*)(void))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 }, { "compare_total_mag", (PyCFunction)(void(*)(void))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 }, { "copy_sign", (PyCFunction)(void(*)(void))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 }, { "same_quantum", (PyCFunction)(void(*)(void))dec_mpd_same_quantum, METH_VARARGS|METH_KEYWORDS, doc_same_quantum },
/* Binary functions, optional context arg */ /* Binary functions, optional context arg */
{ "logical_and", (PyCFunction)dec_mpd_qand, METH_VARARGS|METH_KEYWORDS, doc_logical_and }, { "logical_and", (PyCFunction)(void(*)(void))dec_mpd_qand, METH_VARARGS|METH_KEYWORDS, doc_logical_and },
{ "logical_or", (PyCFunction)dec_mpd_qor, METH_VARARGS|METH_KEYWORDS, doc_logical_or }, { "logical_or", (PyCFunction)(void(*)(void))dec_mpd_qor, METH_VARARGS|METH_KEYWORDS, doc_logical_or },
{ "logical_xor", (PyCFunction)dec_mpd_qxor, METH_VARARGS|METH_KEYWORDS, doc_logical_xor }, { "logical_xor", (PyCFunction)(void(*)(void))dec_mpd_qxor, METH_VARARGS|METH_KEYWORDS, doc_logical_xor },
{ "rotate", (PyCFunction)dec_mpd_qrotate, METH_VARARGS|METH_KEYWORDS, doc_rotate }, { "rotate", (PyCFunction)(void(*)(void))dec_mpd_qrotate, METH_VARARGS|METH_KEYWORDS, doc_rotate },
{ "scaleb", (PyCFunction)dec_mpd_qscaleb, METH_VARARGS|METH_KEYWORDS, doc_scaleb }, { "scaleb", (PyCFunction)(void(*)(void))dec_mpd_qscaleb, METH_VARARGS|METH_KEYWORDS, doc_scaleb },
{ "shift", (PyCFunction)dec_mpd_qshift, METH_VARARGS|METH_KEYWORDS, doc_shift }, { "shift", (PyCFunction)(void(*)(void))dec_mpd_qshift, METH_VARARGS|METH_KEYWORDS, doc_shift },
/* Miscellaneous */ /* Miscellaneous */
{ "from_float", dec_from_float, METH_O|METH_CLASS, doc_from_float }, { "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 }, { "subtract", ctx_mpd_qsub, METH_VARARGS, doc_ctx_subtract },
/* Binary or ternary arithmetic functions */ /* 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 */ /* Ternary arithmetic functions */
{ "fma", ctx_mpd_qfma, METH_VARARGS, doc_ctx_fma }, { "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}, { "getcontext", (PyCFunction)PyDec_GetCurrentContext, METH_NOARGS, doc_getcontext},
{ "setcontext", (PyCFunction)PyDec_SetCurrentContext, METH_O, doc_setcontext}, { "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 #ifdef EXTRA_FUNCTIONALITY
{ "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context}, { "IEEEContext", (PyCFunction)ieee_context, METH_O, doc_ieee_context},
#endif #endif

2
Modules/_elementtree.c
View File

@ -3968,7 +3968,7 @@ static PyTypeObject XMLParser_Type = {
/* python module interface */ /* python module interface */
static PyMethodDef _functions[] = { static PyMethodDef _functions[] = {
{"SubElement", (PyCFunction) subelement, METH_VARARGS | METH_KEYWORDS}, {"SubElement", (PyCFunction)(void(*)(void)) subelement, METH_VARARGS | METH_KEYWORDS},
{NULL, NULL} {NULL, NULL}
}; };

2
Modules/_functoolsmodule.c
View File

@ -1236,7 +1236,7 @@ PyDoc_STRVAR(module_doc,
static PyMethodDef module_methods[] = { static PyMethodDef module_methods[] = {
{"reduce", functools_reduce, METH_VARARGS, functools_reduce_doc}, {"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}, METH_VARARGS | METH_KEYWORDS, functools_cmp_to_key_doc},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };

6
Modules/_hashopenssl.c
View File

@ -1011,7 +1011,7 @@ generate_hash_name_list(void)
/* a PyMethodDef structure for the constructor */ /* a PyMethodDef structure for the constructor */
#define CONSTRUCTOR_METH_DEF(NAME) \ #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 \ PyDoc_STR("Returns a " #NAME \
" hash object; optionally initialized with a string") \ " hash object; optionally initialized with a string") \
} }
@ -1034,9 +1034,9 @@ GEN_CONSTRUCTOR(sha512)
/* List of functions exported by this module */ /* List of functions exported by this module */
static struct PyMethodDef EVP_functions[] = { 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 #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__}, pbkdf2_hmac__doc__},
#endif #endif
_HASHLIB_SCRYPT_METHODDEF _HASHLIB_SCRYPT_METHODDEF

2
Modules/_lsprof.c
View File

@ -778,7 +778,7 @@ profiler_init(ProfilerObject *pObj, PyObject *args, PyObject *kw)
static PyMethodDef profiler_methods[] = { static PyMethodDef profiler_methods[] = {
{"getstats", (PyCFunction)profiler_getstats, {"getstats", (PyCFunction)profiler_getstats,
METH_NOARGS, getstats_doc}, METH_NOARGS, getstats_doc},
{"enable", (PyCFunction)profiler_enable, {"enable", (PyCFunction)(void(*)(void))profiler_enable,
METH_VARARGS | METH_KEYWORDS, enable_doc}, METH_VARARGS | METH_KEYWORDS, enable_doc},
{"disable", (PyCFunction)profiler_disable, {"disable", (PyCFunction)profiler_disable,
METH_NOARGS, disable_doc}, METH_NOARGS, disable_doc},

4
Modules/_multiprocessing/semaphore.c
View File

@ -581,11 +581,11 @@ semlock_afterfork(SemLockObject *self, PyObject *Py_UNUSED(ignored))
*/ */
static PyMethodDef semlock_methods[] = { 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"}, "acquire the semaphore/lock"},
{"release", (PyCFunction)semlock_release, METH_NOARGS, {"release", (PyCFunction)semlock_release, METH_NOARGS,
"release the semaphore/lock"}, "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"}, "enter the semaphore/lock"},
{"__exit__", (PyCFunction)semlock_release, METH_VARARGS, {"__exit__", (PyCFunction)semlock_release, METH_VARARGS,
"exit the semaphore/lock"}, "exit the semaphore/lock"},

14
Modules/_sqlite/connection.c
View File

@ -1764,7 +1764,7 @@ static PyGetSetDef connection_getset[] = {
}; };
static PyMethodDef connection_methods[] = { 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.")}, PyDoc_STR("Return a cursor for the connection.")},
{"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS, {"close", (PyCFunction)pysqlite_connection_close, METH_NOARGS,
PyDoc_STR("Closes the connection.")}, PyDoc_STR("Closes the connection.")},
@ -1772,11 +1772,11 @@ static PyMethodDef connection_methods[] = {
PyDoc_STR("Commit the current transaction.")}, PyDoc_STR("Commit the current transaction.")},
{"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS, {"rollback", (PyCFunction)pysqlite_connection_rollback, METH_NOARGS,
PyDoc_STR("Roll back the current transaction.")}, 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.")}, 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.")}, 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.")}, PyDoc_STR("Sets authorizer callback. Non-standard.")},
#ifdef HAVE_LOAD_EXTENSION #ifdef HAVE_LOAD_EXTENSION
{"enable_load_extension", (PyCFunction)pysqlite_enable_load_extension, METH_VARARGS, {"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, {"load_extension", (PyCFunction)pysqlite_load_extension, METH_VARARGS,
PyDoc_STR("Load SQLite extension module. Non-standard.")}, PyDoc_STR("Load SQLite extension module. Non-standard.")},
#endif #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.")}, 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.")}, PyDoc_STR("Sets a trace callback called for each SQL statement (passed as unicode). Non-standard.")},
{"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS, {"execute", (PyCFunction)pysqlite_connection_execute, METH_VARARGS,
PyDoc_STR("Executes a SQL statement. Non-standard.")}, PyDoc_STR("Executes a SQL statement. Non-standard.")},
@ -1801,7 +1801,7 @@ static PyMethodDef connection_methods[] = {
{"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS, {"iterdump", (PyCFunction)pysqlite_connection_iterdump, METH_NOARGS,
PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")}, PyDoc_STR("Returns iterator to the dump of the database in an SQL text format. Non-standard.")},
#ifdef HAVE_BACKUP_API #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.")}, PyDoc_STR("Makes a backup of the database. Non-standard.")},
#endif #endif
{"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS, {"__enter__", (PyCFunction)pysqlite_connection_enter, METH_NOARGS,

2
Modules/_sqlite/cursor.c
View File

@ -908,7 +908,7 @@ static PyMethodDef cursor_methods[] = {
PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")}, PyDoc_STR("Executes a multiple SQL statements at once. Non-standard.")},
{"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS, {"fetchone", (PyCFunction)pysqlite_cursor_fetchone, METH_NOARGS,
PyDoc_STR("Fetches one row from the resultset.")}, 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.")}, PyDoc_STR("Fetches several rows from the resultset.")},
{"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS, {"fetchall", (PyCFunction)pysqlite_cursor_fetchall, METH_NOARGS,
PyDoc_STR("Fetches all rows from the resultset.")}, PyDoc_STR("Fetches all rows from the resultset.")},

6
Modules/_sqlite/module.c
View File

@ -245,12 +245,12 @@ static void converters_init(PyObject* dict)
} }
static PyMethodDef module_methods[] = { static PyMethodDef module_methods[] = {
{"connect", (PyCFunction)module_connect, {"connect", (PyCFunction)(void(*)(void))module_connect,
METH_VARARGS | METH_KEYWORDS, module_connect_doc}, 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}, METH_VARARGS | METH_KEYWORDS, module_complete_doc},
#ifdef HAVE_SHARED_CACHE #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}, METH_VARARGS | METH_KEYWORDS, module_enable_shared_cache_doc},
#endif #endif
{"register_adapter", (PyCFunction)module_register_adapter, {"register_adapter", (PyCFunction)module_register_adapter,

8
Modules/_struct.c
View File

@ -2006,8 +2006,8 @@ s_sizeof(PyStructObject *self, void *unused)
static struct PyMethodDef s_methods[] = { static struct PyMethodDef s_methods[] = {
STRUCT_ITER_UNPACK_METHODDEF STRUCT_ITER_UNPACK_METHODDEF
{"pack", (PyCFunction)s_pack, METH_FASTCALL, s_pack__doc__}, {"pack", (PyCFunction)(void(*)(void))s_pack, METH_FASTCALL, s_pack__doc__},
{"pack_into", (PyCFunction)s_pack_into, METH_FASTCALL, s_pack_into__doc__}, {"pack_into", (PyCFunction)(void(*)(void))s_pack_into, METH_FASTCALL, s_pack_into__doc__},
STRUCT_UNPACK_METHODDEF STRUCT_UNPACK_METHODDEF
STRUCT_UNPACK_FROM_METHODDEF STRUCT_UNPACK_FROM_METHODDEF
{"__sizeof__", (PyCFunction)s_sizeof, METH_NOARGS, s_sizeof__doc__}, {"__sizeof__", (PyCFunction)s_sizeof, METH_NOARGS, s_sizeof__doc__},
@ -2264,8 +2264,8 @@ static struct PyMethodDef module_functions[] = {
_CLEARCACHE_METHODDEF _CLEARCACHE_METHODDEF
CALCSIZE_METHODDEF CALCSIZE_METHODDEF
ITER_UNPACK_METHODDEF ITER_UNPACK_METHODDEF
{"pack", (PyCFunction)pack, METH_FASTCALL, pack_doc}, {"pack", (PyCFunction)(void(*)(void))pack, METH_FASTCALL, pack_doc},
{"pack_into", (PyCFunction)pack_into, METH_FASTCALL, pack_into_doc}, {"pack_into", (PyCFunction)(void(*)(void))pack_into, METH_FASTCALL, pack_into_doc},
UNPACK_METHODDEF UNPACK_METHODDEF
UNPACK_FROM_METHODDEF UNPACK_FROM_METHODDEF
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */

2
Modules/_testbuffer.c
View File

@ -2635,7 +2635,7 @@ static PyMethodDef ndarray_methods [] =
{ {
{ "tolist", ndarray_tolist, METH_NOARGS, NULL }, { "tolist", ndarray_tolist, METH_NOARGS, NULL },
{ "tobytes", ndarray_tobytes, 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 }, { "pop", ndarray_pop, METH_NOARGS, NULL },
{ "add_suboffsets", ndarray_add_suboffsets, METH_NOARGS, NULL }, { "add_suboffsets", ndarray_add_suboffsets, METH_NOARGS, NULL },
{ "memoryview_from_buffer", ndarray_memoryview_from_buffer, METH_NOARGS, NULL }, { "memoryview_from_buffer", ndarray_memoryview_from_buffer, METH_NOARGS, NULL },

14
Modules/_testcapimodule.c
View File

@ -4787,14 +4787,14 @@ static PyMethodDef TestMethods[] = {
{"getbuffer_with_null_view", getbuffer_with_null_view, METH_O}, {"getbuffer_with_null_view", getbuffer_with_null_view, METH_O},
{"test_buildvalue_N", test_buildvalue_N, METH_NOARGS}, {"test_buildvalue_N", test_buildvalue_N, METH_NOARGS},
{"get_args", get_args, METH_VARARGS}, {"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_tuple", getargs_tuple, METH_VARARGS},
{"getargs_keywords", (PyCFunction)getargs_keywords, {"getargs_keywords", (PyCFunction)(void(*)(void))getargs_keywords,
METH_VARARGS|METH_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}, METH_VARARGS|METH_KEYWORDS},
{"getargs_positional_only_and_keywords", {"getargs_positional_only_and_keywords",
(PyCFunction)getargs_positional_only_and_keywords, (PyCFunction)(void(*)(void))getargs_positional_only_and_keywords,
METH_VARARGS|METH_KEYWORDS}, METH_VARARGS|METH_KEYWORDS},
{"getargs_b", getargs_b, METH_VARARGS}, {"getargs_b", getargs_b, METH_VARARGS},
{"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}, {"set_exc_info", test_set_exc_info, METH_VARARGS},
{"argparsing", argparsing, METH_VARARGS}, {"argparsing", argparsing, METH_VARARGS},
{"code_newempty", code_newempty, 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}, METH_VARARGS | METH_KEYWORDS},
{"make_memoryview_from_NULL_pointer", make_memoryview_from_NULL_pointer, {"make_memoryview_from_NULL_pointer", make_memoryview_from_NULL_pointer,
METH_NOARGS}, METH_NOARGS},
@ -4960,7 +4960,7 @@ static PyMethodDef TestMethods[] = {
{"get_mapping_items", get_mapping_items, METH_O}, {"get_mapping_items", get_mapping_items, METH_O},
{"test_pythread_tss_key_state", test_pythread_tss_key_state, METH_VARARGS}, {"test_pythread_tss_key_state", test_pythread_tss_key_state, METH_VARARGS},
{"hamt", new_hamt, METH_NOARGS}, {"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}, {"EncodeLocaleEx", encode_locale_ex, METH_VARARGS},
{"DecodeLocaleEx", decode_locale_ex, METH_VARARGS}, {"DecodeLocaleEx", decode_locale_ex, METH_VARARGS},
{"get_global_config", get_global_config, METH_NOARGS}, {"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[] = { 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 */ {NULL} /* sentinel */
}; };

10
Modules/_threadmodule.c
View File

@ -204,9 +204,9 @@ lock_repr(lockobject *self)
} }
static PyMethodDef lock_methods[] = { 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}, 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}, METH_VARARGS | METH_KEYWORDS, acquire_doc},
{"release_lock", (PyCFunction)lock_PyThread_release_lock, {"release_lock", (PyCFunction)lock_PyThread_release_lock,
METH_NOARGS, release_doc}, METH_NOARGS, release_doc},
@ -216,7 +216,7 @@ static PyMethodDef lock_methods[] = {
METH_NOARGS, locked_doc}, METH_NOARGS, locked_doc},
{"locked", (PyCFunction)lock_locked_lock, {"locked", (PyCFunction)lock_locked_lock,
METH_NOARGS, locked_doc}, METH_NOARGS, locked_doc},
{"__enter__", (PyCFunction)lock_PyThread_acquire_lock, {"__enter__", (PyCFunction)(void(*)(void))lock_PyThread_acquire_lock,
METH_VARARGS | METH_KEYWORDS, acquire_doc}, METH_VARARGS | METH_KEYWORDS, acquire_doc},
{"__exit__", (PyCFunction)lock_PyThread_release_lock, {"__exit__", (PyCFunction)lock_PyThread_release_lock,
METH_VARARGS, release_doc}, METH_VARARGS, release_doc},
@ -466,7 +466,7 @@ rlock_repr(rlockobject *self)
static PyMethodDef rlock_methods[] = { static PyMethodDef rlock_methods[] = {
{"acquire", (PyCFunction)rlock_acquire, {"acquire", (PyCFunction)(void(*)(void))rlock_acquire,
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc}, METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"release", (PyCFunction)rlock_release, {"release", (PyCFunction)rlock_release,
METH_NOARGS, rlock_release_doc}, METH_NOARGS, rlock_release_doc},
@ -476,7 +476,7 @@ static PyMethodDef rlock_methods[] = {
METH_VARARGS, rlock_acquire_restore_doc}, METH_VARARGS, rlock_acquire_restore_doc},
{"_release_save", (PyCFunction)rlock_release_save, {"_release_save", (PyCFunction)rlock_release_save,
METH_NOARGS, rlock_release_save_doc}, METH_NOARGS, rlock_release_save_doc},
{"__enter__", (PyCFunction)rlock_acquire, {"__enter__", (PyCFunction)(void(*)(void))rlock_acquire,
METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc}, METH_VARARGS | METH_KEYWORDS, rlock_acquire_doc},
{"__exit__", (PyCFunction)rlock_release, {"__exit__", (PyCFunction)rlock_release,
METH_VARARGS, rlock_release_doc}, METH_VARARGS, rlock_release_doc},

20
Modules/_xxsubinterpretersmodule.c
View File

@ -2768,7 +2768,7 @@ channel__channel_id(PyObject *self, PyObject *args, PyObject *kwds)
static PyMethodDef module_functions[] = { static PyMethodDef module_functions[] = {
{"create", (PyCFunction)interp_create, {"create", (PyCFunction)interp_create,
METH_VARARGS, create_doc}, METH_VARARGS, create_doc},
{"destroy", (PyCFunction)interp_destroy, {"destroy", (PyCFunction)(void(*)(void))interp_destroy,
METH_VARARGS | METH_KEYWORDS, destroy_doc}, METH_VARARGS | METH_KEYWORDS, destroy_doc},
{"list_all", interp_list_all, {"list_all", interp_list_all,
METH_NOARGS, list_all_doc}, METH_NOARGS, list_all_doc},
@ -2776,29 +2776,29 @@ static PyMethodDef module_functions[] = {
METH_NOARGS, get_current_doc}, METH_NOARGS, get_current_doc},
{"get_main", interp_get_main, {"get_main", interp_get_main,
METH_NOARGS, get_main_doc}, 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}, 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}, 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}, METH_VARARGS | METH_KEYWORDS, is_shareable_doc},
{"channel_create", channel_create, {"channel_create", channel_create,
METH_NOARGS, channel_create_doc}, METH_NOARGS, channel_create_doc},
{"channel_destroy", (PyCFunction)channel_destroy, {"channel_destroy", (PyCFunction)(void(*)(void))channel_destroy,
METH_VARARGS | METH_KEYWORDS, channel_destroy_doc}, METH_VARARGS | METH_KEYWORDS, channel_destroy_doc},
{"channel_list_all", channel_list_all, {"channel_list_all", channel_list_all,
METH_NOARGS, channel_list_all_doc}, 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}, 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}, 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}, 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}, 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}, METH_VARARGS | METH_KEYWORDS, NULL},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */

2
Modules/atexitmodule.c
View File

@ -291,7 +291,7 @@ atexit_unregister(PyObject *self, PyObject *func)
} }
static PyMethodDef atexit_methods[] = { 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__}, atexit_register__doc__},
{"_clear", (PyCFunction) atexit_clear, METH_NOARGS, {"_clear", (PyCFunction) atexit_clear, METH_NOARGS,
atexit_clear__doc__}, atexit_clear__doc__},

10
Modules/faulthandler.c
View File

@ -1175,7 +1175,7 @@ PyDoc_STRVAR(module_doc,
static PyMethodDef module_methods[] = { static PyMethodDef module_methods[] = {
{"enable", {"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): " PyDoc_STR("enable(file=sys.stderr, all_threads=True): "
"enable the fault handler")}, "enable the fault handler")},
{"disable", faulthandler_disable_py, METH_NOARGS, {"disable", faulthandler_disable_py, METH_NOARGS,
@ -1183,13 +1183,13 @@ static PyMethodDef module_methods[] = {
{"is_enabled", faulthandler_is_enabled, METH_NOARGS, {"is_enabled", faulthandler_is_enabled, METH_NOARGS,
PyDoc_STR("is_enabled()->bool: check if the handler is enabled")}, PyDoc_STR("is_enabled()->bool: check if the handler is enabled")},
{"dump_traceback", {"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): " PyDoc_STR("dump_traceback(file=sys.stderr, all_threads=True): "
"dump the traceback of the current thread, or of all threads " "dump the traceback of the current thread, or of all threads "
"if all_threads is True, into file")}, "if all_threads is True, into file")},
#ifdef FAULTHANDLER_LATER #ifdef FAULTHANDLER_LATER
{"dump_traceback_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" PyDoc_STR("dump_traceback_later(timeout, repeat=False, file=sys.stderrn, exit=False):\n"
"dump the traceback of all threads in timeout seconds,\n" "dump the traceback of all threads in timeout seconds,\n"
"or each timeout seconds if repeat is True. If exit is True, " "or each timeout seconds if repeat is True. If exit is True, "
@ -1202,13 +1202,13 @@ static PyMethodDef module_methods[] = {
#ifdef FAULTHANDLER_USER #ifdef FAULTHANDLER_USER
{"register", {"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): " PyDoc_STR("register(signum, file=sys.stderr, all_threads=True, chain=False): "
"register a handler for the signal 'signum': dump the " "register a handler for the signal 'signum': dump the "
"traceback of the current thread, or of all threads if " "traceback of the current thread, or of all threads if "
"all_threads is True, into file")}, "all_threads is True, into file")},
{"unregister", {"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 " PyDoc_STR("unregister(signum): unregister the handler of the signal "
"'signum' registered by register()")}, "'signum' registered by register()")},
#endif #endif

6
Modules/nismodule.c
View File

@ -423,13 +423,13 @@ nis_maps (PyObject *self, PyObject *args, PyObject *kwdict)
} }
static PyMethodDef nis_methods[] = { static PyMethodDef nis_methods[] = {
{"match", (PyCFunction)nis_match, {"match", (PyCFunction)(void(*)(void))nis_match,
METH_VARARGS | METH_KEYWORDS, METH_VARARGS | METH_KEYWORDS,
match__doc__}, match__doc__},
{"cat", (PyCFunction)nis_cat, {"cat", (PyCFunction)(void(*)(void))nis_cat,
METH_VARARGS | METH_KEYWORDS, METH_VARARGS | METH_KEYWORDS,
cat__doc__}, cat__doc__},
{"maps", (PyCFunction)nis_maps, {"maps", (PyCFunction)(void(*)(void))nis_maps,
METH_VARARGS | METH_KEYWORDS, METH_VARARGS | METH_KEYWORDS,
maps__doc__}, maps__doc__},
{"get_default_domain", nis_get_default_domain, {"get_default_domain", nis_get_default_domain,

28
Modules/parsermodule.c
View File

@ -206,15 +206,15 @@ static PyObject* parser_st2tuple(PyST_Object *, PyObject *, PyObject *);
#define PUBLIC_METHOD_TYPE (METH_VARARGS|METH_KEYWORDS) #define PUBLIC_METHOD_TYPE (METH_VARARGS|METH_KEYWORDS)
static PyMethodDef parser_methods[] = { 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.")}, 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.")}, 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.")}, 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.")}, 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.")}, PyDoc_STR("Creates a tuple-tree representation of this ST.")},
{"__sizeof__", (PyCFunction)parser_sizeof, METH_NOARGS, {"__sizeof__", (PyCFunction)parser_sizeof, METH_NOARGS,
PyDoc_STR("Returns size in memory, in bytes.")}, PyDoc_STR("Returns size in memory, in bytes.")},
@ -1087,23 +1087,23 @@ parser__pickler(PyObject *self, PyObject *args)
* inheritance. * inheritance.
*/ */
static PyMethodDef parser_functions[] = { 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.")}, 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.")}, 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.")}, 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.")}, 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.")}, 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.")}, 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.")}, 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.")}, 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.")}, PyDoc_STR("Creates an ST object from a tree representation.")},
/* private stuff: support pickle module */ /* private stuff: support pickle module */

2
Modules/posixmodule.c
View File

@ -13175,7 +13175,7 @@ static PyMethodDef posix_methods[] = {
OS_PWRITE_METHODDEF OS_PWRITE_METHODDEF
OS_PWRITEV_METHODDEF OS_PWRITEV_METHODDEF
#ifdef HAVE_SENDFILE #ifdef HAVE_SENDFILE
{"sendfile", (PyCFunction)posix_sendfile, METH_VARARGS | METH_KEYWORDS, {"sendfile", (PyCFunction)(void(*)(void))posix_sendfile, METH_VARARGS | METH_KEYWORDS,
posix_sendfile__doc__}, posix_sendfile__doc__},
#endif #endif
OS_FSTAT_METHODDEF OS_FSTAT_METHODDEF

2
Modules/signalmodule.c
View File

@ -1210,7 +1210,7 @@ static PyMethodDef signal_methods[] = {
SIGNAL_SIGNAL_METHODDEF SIGNAL_SIGNAL_METHODDEF
SIGNAL_STRSIGNAL_METHODDEF SIGNAL_STRSIGNAL_METHODDEF
SIGNAL_GETSIGNAL_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_SIGINTERRUPT_METHODDEF
SIGNAL_PAUSE_METHODDEF SIGNAL_PAUSE_METHODDEF
SIGNAL_PTHREAD_KILL_METHODDEF SIGNAL_PTHREAD_KILL_METHODDEF

8
Modules/socketmodule.c
View File

@ -4810,11 +4810,11 @@ static PyMethodDef sock_methods[] = {
listen_doc}, listen_doc},
{"recv", (PyCFunction)sock_recv, METH_VARARGS, {"recv", (PyCFunction)sock_recv, METH_VARARGS,
recv_doc}, 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}, recv_into_doc},
{"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS, {"recvfrom", (PyCFunction)sock_recvfrom, METH_VARARGS,
recvfrom_doc}, 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}, recvfrom_into_doc},
{"send", (PyCFunction)sock_send, METH_VARARGS, {"send", (PyCFunction)sock_send, METH_VARARGS,
send_doc}, send_doc},
@ -4843,7 +4843,7 @@ static PyMethodDef sock_methods[] = {
sendmsg_doc}, sendmsg_doc},
#endif #endif
#ifdef HAVE_SOCKADDR_ALG #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}, sendmsg_afalg_doc},
#endif #endif
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
@ -6741,7 +6741,7 @@ static PyMethodDef socket_methods[] = {
{"inet_ntop", socket_inet_ntop, {"inet_ntop", socket_inet_ntop,
METH_VARARGS, inet_ntop_doc}, METH_VARARGS, inet_ntop_doc},
#endif #endif
{"getaddrinfo", (PyCFunction)socket_getaddrinfo, {"getaddrinfo", (PyCFunction)(void(*)(void))socket_getaddrinfo,
METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc}, METH_VARARGS | METH_KEYWORDS, getaddrinfo_doc},
{"getnameinfo", socket_getnameinfo, {"getnameinfo", socket_getnameinfo,
METH_VARARGS, getnameinfo_doc}, METH_VARARGS, getnameinfo_doc},

2
Modules/syslogmodule.c
View File

@ -238,7 +238,7 @@ syslog_log_upto(PyObject *self, PyObject *args)
/* List of functions defined in the module */ /* List of functions defined in the module */
static PyMethodDef syslog_methods[] = { 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}, {"closelog", syslog_closelog, METH_NOARGS},
{"syslog", syslog_syslog, METH_VARARGS}, {"syslog", syslog_syslog, METH_VARARGS},
{"setlogmask", syslog_setlogmask, METH_VARARGS}, {"setlogmask", syslog_setlogmask, METH_VARARGS},

4
Modules/xxsubtype.c
View File

@ -70,10 +70,10 @@ static PyMethodDef spamlist_methods[] = {
PyDoc_STR("setstate(state)")}, PyDoc_STR("setstate(state)")},
/* These entries differ only in the flags; they are used by the tests /* These entries differ only in the flags; they are used by the tests
in test.test_descr. */ in test.test_descr. */
{"classmeth", (PyCFunction)spamlist_specialmeth, {"classmeth", (PyCFunction)(void(*)(void))spamlist_specialmeth,
METH_VARARGS | METH_KEYWORDS | METH_CLASS, METH_VARARGS | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("classmeth(*args, **kw)")}, PyDoc_STR("classmeth(*args, **kw)")},
{"staticmeth", (PyCFunction)spamlist_specialmeth, {"staticmeth", (PyCFunction)(void(*)(void))spamlist_specialmeth,
METH_VARARGS | METH_KEYWORDS | METH_STATIC, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
PyDoc_STR("staticmeth(*args, **kw)")}, PyDoc_STR("staticmeth(*args, **kw)")},
{NULL, NULL}, {NULL, NULL},

14
Objects/call.c
View File

@ -514,7 +514,7 @@ _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self,
} }
if (flags & METH_KEYWORDS) { if (flags & METH_KEYWORDS) {
result = (*(PyCFunctionWithKeywords)meth) (self, argstuple, kwargs); result = (*(PyCFunctionWithKeywords)(void(*)(void))meth) (self, argstuple, kwargs);
} }
else { else {
result = (*meth) (self, argstuple); result = (*meth) (self, argstuple);
@ -529,7 +529,7 @@ _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self,
goto no_keyword_error; goto no_keyword_error;
} }
result = (*(_PyCFunctionFast)meth) (self, args, nargs); result = (*(_PyCFunctionFast)(void(*)(void))meth) (self, args, nargs);
break; break;
} }
@ -537,7 +537,7 @@ _PyMethodDef_RawFastCallDict(PyMethodDef *method, PyObject *self,
{ {
PyObject *const *stack; PyObject *const *stack;
PyObject *kwnames; PyObject *kwnames;
_PyCFunctionFastWithKeywords fastmeth = (_PyCFunctionFastWithKeywords)meth; _PyCFunctionFastWithKeywords fastmeth = (_PyCFunctionFastWithKeywords)(void(*)(void))meth;
if (_PyStack_UnpackDict(args, nargs, kwargs, &stack, &kwnames) < 0) { if (_PyStack_UnpackDict(args, nargs, kwargs, &stack, &kwnames) < 0) {
goto exit; goto exit;
@ -650,12 +650,12 @@ _PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self,
if (nkwargs) { if (nkwargs) {
goto no_keyword_error; goto no_keyword_error;
} }
result = ((_PyCFunctionFast)meth) (self, args, nargs); result = ((_PyCFunctionFast)(void(*)(void))meth) (self, args, nargs);
break; break;
case METH_FASTCALL | METH_KEYWORDS: case METH_FASTCALL | METH_KEYWORDS:
/* Fast-path: avoid temporary dict to pass keyword arguments */ /* 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; break;
case METH_VARARGS: case METH_VARARGS:
@ -689,7 +689,7 @@ _PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self,
kwdict = NULL; kwdict = NULL;
} }
result = (*(PyCFunctionWithKeywords)meth) (self, argtuple, kwdict); result = (*(PyCFunctionWithKeywords)(void(*)(void))meth) (self, argtuple, kwdict);
Py_XDECREF(kwdict); Py_XDECREF(kwdict);
} }
else { else {
@ -752,7 +752,7 @@ cfunction_call_varargs(PyObject *func, PyObject *args, PyObject *kwargs)
return NULL; return NULL;
} }
result = (*(PyCFunctionWithKeywords)meth)(self, args, kwargs); result = (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, args, kwargs);
Py_LeaveRecursiveCall(); Py_LeaveRecursiveCall();
} }

18
Objects/dictobject.c
View File

@ -3095,15 +3095,15 @@ PyDoc_STRVAR(values__doc__,
static PyMethodDef mapp_methods[] = { static PyMethodDef mapp_methods[] = {
DICT___CONTAINS___METHODDEF DICT___CONTAINS___METHODDEF
{"__getitem__", (PyCFunction)dict_subscript, METH_O | METH_COEXIST, {"__getitem__", (PyCFunction)(void(*)(void))dict_subscript, METH_O | METH_COEXIST,
getitem__doc__}, getitem__doc__},
{"__sizeof__", (PyCFunction)dict_sizeof, METH_NOARGS, {"__sizeof__", (PyCFunction)(void(*)(void))dict_sizeof, METH_NOARGS,
sizeof__doc__}, sizeof__doc__},
DICT_GET_METHODDEF DICT_GET_METHODDEF
DICT_SETDEFAULT_METHODDEF DICT_SETDEFAULT_METHODDEF
{"pop", (PyCFunction)dict_pop, METH_VARARGS, {"pop", (PyCFunction)dict_pop, METH_VARARGS,
pop__doc__}, pop__doc__},
{"popitem", (PyCFunction)dict_popitem, METH_NOARGS, {"popitem", (PyCFunction)(void(*)(void))dict_popitem, METH_NOARGS,
popitem__doc__}, popitem__doc__},
{"keys", dictkeys_new, METH_NOARGS, {"keys", dictkeys_new, METH_NOARGS,
keys__doc__}, keys__doc__},
@ -3111,7 +3111,7 @@ static PyMethodDef mapp_methods[] = {
items__doc__}, items__doc__},
{"values", dictvalues_new, METH_NOARGS, {"values", dictvalues_new, METH_NOARGS,
values__doc__}, values__doc__},
{"update", (PyCFunction)dict_update, METH_VARARGS | METH_KEYWORDS, {"update", (PyCFunction)(void(*)(void))dict_update, METH_VARARGS | METH_KEYWORDS,
update__doc__}, update__doc__},
DICT_FROMKEYS_METHODDEF DICT_FROMKEYS_METHODDEF
{"clear", (PyCFunction)dict_clear, METH_NOARGS, {"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."); PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
static PyMethodDef dictiter_methods[] = { static PyMethodDef dictiter_methods[] = {
{"__length_hint__", (PyCFunction)dictiter_len, METH_NOARGS, {"__length_hint__", (PyCFunction)(void(*)(void))dictiter_len, METH_NOARGS,
length_hint_doc}, length_hint_doc},
{"__reduce__", (PyCFunction)dictiter_reduce, METH_NOARGS, {"__reduce__", (PyCFunction)(void(*)(void))dictiter_reduce, METH_NOARGS,
reduce_doc}, reduce_doc},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
@ -4209,7 +4209,7 @@ PyDoc_STRVAR(reversed_keys_doc,
static PyMethodDef dictkeys_methods[] = { static PyMethodDef dictkeys_methods[] = {
{"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O, {"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O,
isdisjoint_doc}, isdisjoint_doc},
{"__reversed__", (PyCFunction)dictkeys_reversed, METH_NOARGS, {"__reversed__", (PyCFunction)(void(*)(void))dictkeys_reversed, METH_NOARGS,
reversed_keys_doc}, reversed_keys_doc},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
@ -4315,7 +4315,7 @@ PyDoc_STRVAR(reversed_items_doc,
static PyMethodDef dictitems_methods[] = { static PyMethodDef dictitems_methods[] = {
{"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O, {"isdisjoint", (PyCFunction)dictviews_isdisjoint, METH_O,
isdisjoint_doc}, isdisjoint_doc},
{"__reversed__", (PyCFunction)dictitems_reversed, METH_NOARGS, {"__reversed__", (PyCFunction)(void(*)(void))dictitems_reversed, METH_NOARGS,
reversed_items_doc}, reversed_items_doc},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };
@ -4396,7 +4396,7 @@ PyDoc_STRVAR(reversed_values_doc,
"Return a reverse iterator over the dict values."); "Return a reverse iterator over the dict values.");
static PyMethodDef dictvalues_methods[] = { static PyMethodDef dictvalues_methods[] = {
{"__reversed__", (PyCFunction)dictvalues_reversed, METH_NOARGS, {"__reversed__", (PyCFunction)(void(*)(void))dictvalues_reversed, METH_NOARGS,
reversed_values_doc}, reversed_values_doc},
{NULL, NULL} /* sentinel */ {NULL, NULL} /* sentinel */
}; };

2
Objects/memoryobject.c
View File

@ -3086,7 +3086,7 @@ static PyMethodDef memory_methods[] = {
{"tobytes", (PyCFunction)memory_tobytes, METH_NOARGS, memory_tobytes_doc}, {"tobytes", (PyCFunction)memory_tobytes, METH_NOARGS, memory_tobytes_doc},
{"hex", (PyCFunction)memory_hex, METH_NOARGS, memory_hex_doc}, {"hex", (PyCFunction)memory_hex, METH_NOARGS, memory_hex_doc},
{"tolist", (PyCFunction)memory_tolist, METH_NOARGS, memory_tolist_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}, {"toreadonly", (PyCFunction)memory_toreadonly, METH_NOARGS, memory_toreadonly_doc},
{"__enter__", memory_enter, METH_NOARGS, NULL}, {"__enter__", memory_enter, METH_NOARGS, NULL},
{"__exit__", memory_exit, METH_VARARGS, NULL}, {"__exit__", memory_exit, METH_VARARGS, NULL},

4
Objects/odictobject.c
View File

@ -1311,7 +1311,7 @@ static PyMethodDef odict_methods[] = {
{"__reduce__", (PyCFunction)odict_reduce, METH_NOARGS, {"__reduce__", (PyCFunction)odict_reduce, METH_NOARGS,
odict_reduce__doc__}, odict_reduce__doc__},
ORDEREDDICT_SETDEFAULT_METHODDEF ORDEREDDICT_SETDEFAULT_METHODDEF
{"pop", (PyCFunction)odict_pop, {"pop", (PyCFunction)(void(*)(void))odict_pop,
METH_VARARGS | METH_KEYWORDS, odict_pop__doc__}, METH_VARARGS | METH_KEYWORDS, odict_pop__doc__},
ORDEREDDICT_POPITEM_METHODDEF ORDEREDDICT_POPITEM_METHODDEF
{"keys", odictkeys_new, METH_NOARGS, {"keys", odictkeys_new, METH_NOARGS,
@ -1320,7 +1320,7 @@ static PyMethodDef odict_methods[] = {
odict_values__doc__}, odict_values__doc__},
{"items", odictitems_new, METH_NOARGS, {"items", odictitems_new, METH_NOARGS,
odict_items__doc__}, odict_items__doc__},
{"update", (PyCFunction)odict_update, METH_VARARGS | METH_KEYWORDS, {"update", (PyCFunction)(void(*)(void))odict_update, METH_VARARGS | METH_KEYWORDS,
odict_update__doc__}, odict_update__doc__},
{"clear", (PyCFunction)odict_clear, METH_NOARGS, {"clear", (PyCFunction)odict_clear, METH_NOARGS,
odict_clear__doc__}, odict_clear__doc__},

6
Objects/typeobject.c
View File

@ -3481,7 +3481,7 @@ type___sizeof___impl(PyTypeObject *self)
static PyMethodDef type_methods[] = { static PyMethodDef type_methods[] = {
TYPE_MRO_METHODDEF TYPE_MRO_METHODDEF
TYPE___SUBCLASSES___METHODDEF TYPE___SUBCLASSES___METHODDEF
{"__prepare__", (PyCFunction)type_prepare, {"__prepare__", (PyCFunction)(void(*)(void))type_prepare,
METH_FASTCALL | METH_KEYWORDS | METH_CLASS, METH_FASTCALL | METH_KEYWORDS | METH_CLASS,
PyDoc_STR("__prepare__() -> dict\n" PyDoc_STR("__prepare__() -> dict\n"
"used to create the namespace for the class statement")}, "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[] = { 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" PyDoc_STR("__new__($type, *args, **kwargs)\n--\n\n"
"Create and return a new object. " "Create and return a new object. "
"See help(type) for accurate signature.")}, "See help(type) for accurate signature.")},
@ -7140,7 +7140,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
} }
else if (Py_TYPE(descr) == &PyCFunction_Type && else if (Py_TYPE(descr) == &PyCFunction_Type &&
PyCFunction_GET_FUNCTION(descr) == PyCFunction_GET_FUNCTION(descr) ==
(PyCFunction)tp_new_wrapper && (PyCFunction)(void(*)(void))tp_new_wrapper &&
ptr == (void**)&type->tp_new) ptr == (void**)&type->tp_new)
{ {
/* The __new__ wrapper is not a wrapper descriptor, /* The __new__ wrapper is not a wrapper descriptor,

2
Objects/unicodeobject.c
View File

@ -13948,7 +13948,7 @@ static PyMethodDef unicode_methods[] = {
UNICODE_ISIDENTIFIER_METHODDEF UNICODE_ISIDENTIFIER_METHODDEF
UNICODE_ISPRINTABLE_METHODDEF UNICODE_ISPRINTABLE_METHODDEF
UNICODE_ZFILL_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__}, {"format_map", (PyCFunction) do_string_format_map, METH_O, format_map__doc__},
UNICODE___FORMAT___METHODDEF UNICODE___FORMAT___METHODDEF
UNICODE_MAKETRANS_METHODDEF UNICODE_MAKETRANS_METHODDEF

2
Python/_warnings.c
View File

@ -1150,7 +1150,7 @@ PyDoc_STRVAR(warn_explicit_doc,
static PyMethodDef warnings_functions[] = { static PyMethodDef warnings_functions[] = {
WARNINGS_WARN_METHODDEF WARNINGS_WARN_METHODDEF
{"warn_explicit", (PyCFunction)warnings_warn_explicit, {"warn_explicit", (PyCFunction)(void(*)(void))warnings_warn_explicit,
METH_VARARGS | METH_KEYWORDS, warn_explicit_doc}, METH_VARARGS | METH_KEYWORDS, warn_explicit_doc},
{"_filters_mutated", (PyCFunction)warnings_filters_mutated, METH_NOARGS, {"_filters_mutated", (PyCFunction)warnings_filters_mutated, METH_NOARGS,
NULL}, NULL},

18
Python/bltinmodule.c
View File

@ -2195,7 +2195,7 @@ PyDoc_STRVAR(builtin_sorted__doc__,
"reverse flag can be set to request the result in descending order."); "reverse flag can be set to request the result in descending order.");
#define BUILTIN_SORTED_METHODDEF \ #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 * static PyObject *
builtin_sorted(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) builtin_sorted(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
@ -2691,15 +2691,15 @@ PyTypeObject PyZip_Type = {
static PyMethodDef builtin_methods[] = { 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}, 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_ABS_METHODDEF
BUILTIN_ALL_METHODDEF BUILTIN_ALL_METHODDEF
BUILTIN_ANY_METHODDEF BUILTIN_ANY_METHODDEF
BUILTIN_ASCII_METHODDEF BUILTIN_ASCII_METHODDEF
BUILTIN_BIN_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_CALLABLE_METHODDEF
BUILTIN_CHR_METHODDEF BUILTIN_CHR_METHODDEF
BUILTIN_COMPILE_METHODDEF BUILTIN_COMPILE_METHODDEF
@ -2709,7 +2709,7 @@ static PyMethodDef builtin_methods[] = {
BUILTIN_EVAL_METHODDEF BUILTIN_EVAL_METHODDEF
BUILTIN_EXEC_METHODDEF BUILTIN_EXEC_METHODDEF
BUILTIN_FORMAT_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_GLOBALS_METHODDEF
BUILTIN_HASATTR_METHODDEF BUILTIN_HASATTR_METHODDEF
BUILTIN_HASH_METHODDEF BUILTIN_HASH_METHODDEF
@ -2721,13 +2721,13 @@ static PyMethodDef builtin_methods[] = {
{"iter", builtin_iter, METH_VARARGS, iter_doc}, {"iter", builtin_iter, METH_VARARGS, iter_doc},
BUILTIN_LEN_METHODDEF BUILTIN_LEN_METHODDEF
BUILTIN_LOCALS_METHODDEF BUILTIN_LOCALS_METHODDEF
{"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc}, {"max", (PyCFunction)(void(*)(void))builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc},
{"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc}, {"min", (PyCFunction)(void(*)(void))builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc},
{"next", (PyCFunction)builtin_next, METH_FASTCALL, next_doc}, {"next", (PyCFunction)(void(*)(void))builtin_next, METH_FASTCALL, next_doc},
BUILTIN_OCT_METHODDEF BUILTIN_OCT_METHODDEF
BUILTIN_ORD_METHODDEF BUILTIN_ORD_METHODDEF
BUILTIN_POW_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_REPR_METHODDEF
BUILTIN_ROUND_METHODDEF BUILTIN_ROUND_METHODDEF
BUILTIN_SETATTR_METHODDEF BUILTIN_SETATTR_METHODDEF

2
Python/context.c
View File

@ -648,7 +648,7 @@ static PyMethodDef PyContext_methods[] = {
_CONTEXTVARS_CONTEXT_KEYS_METHODDEF _CONTEXTVARS_CONTEXT_KEYS_METHODDEF
_CONTEXTVARS_CONTEXT_VALUES_METHODDEF _CONTEXTVARS_CONTEXT_VALUES_METHODDEF
_CONTEXTVARS_CONTEXT_COPY_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} {NULL, NULL}
}; };

6
Python/sysmodule.c
View File

@ -1521,7 +1521,7 @@ sys_getandroidapilevel(PyObject *self)
static PyMethodDef sys_methods[] = { static PyMethodDef sys_methods[] = {
/* Might as well keep this in alphabetic order */ /* Might as well keep this in alphabetic order */
{"breakpointhook", (PyCFunction)sys_breakpointhook, {"breakpointhook", (PyCFunction)(void(*)(void))sys_breakpointhook,
METH_FASTCALL | METH_KEYWORDS, breakpointhook_doc}, METH_FASTCALL | METH_KEYWORDS, breakpointhook_doc},
{"callstats", sys_callstats, METH_NOARGS, {"callstats", sys_callstats, METH_NOARGS,
callstats_doc}, callstats_doc},
@ -1560,7 +1560,7 @@ static PyMethodDef sys_methods[] = {
{"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc}, {"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
{"getrecursionlimit", sys_getrecursionlimit, METH_NOARGS, {"getrecursionlimit", sys_getrecursionlimit, METH_NOARGS,
getrecursionlimit_doc}, getrecursionlimit_doc},
{"getsizeof", (PyCFunction)sys_getsizeof, {"getsizeof", (PyCFunction)(void(*)(void))sys_getsizeof,
METH_VARARGS | METH_KEYWORDS, getsizeof_doc}, METH_VARARGS | METH_KEYWORDS, getsizeof_doc},
{"_getframe", sys_getframe, METH_VARARGS, getframe_doc}, {"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
@ -1601,7 +1601,7 @@ static PyMethodDef sys_methods[] = {
set_coroutine_wrapper_doc}, set_coroutine_wrapper_doc},
{"get_coroutine_wrapper", sys_get_coroutine_wrapper, METH_NOARGS, {"get_coroutine_wrapper", sys_get_coroutine_wrapper, METH_NOARGS,
get_coroutine_wrapper_doc}, 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}, METH_VARARGS | METH_KEYWORDS, set_asyncgen_hooks_doc},
{"get_asyncgen_hooks", sys_get_asyncgen_hooks, METH_NOARGS, {"get_asyncgen_hooks", sys_get_asyncgen_hooks, METH_NOARGS,
get_asyncgen_hooks_doc}, get_asyncgen_hooks_doc},