Skip to content

Commit 9af34c9

Browse files
isidenticalisidentical
authoredJul 16, 2021
bpo-20201: variadic arguments support for AC (GH-18609)
Implement support for `*args` in AC, and port `print()` to use it.
·
v3.14.0a6v3.11.0a1
1 parent 7915c96 commit 9af34c9

File tree

8 files changed

+664
-100
lines changed

8 files changed

+664
-100
lines changed
 

‎Include/modsupport.h

+10-1
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,7 @@ PyAPI_FUNC(PyObject *) Py_BuildValue(const char *, ...);
5050
PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);
5151

5252

53+
#define ANY_VARARGS(n) (n == PY_SSIZE_T_MAX)
5354
#ifndef Py_LIMITED_API
5455
PyAPI_FUNC(int) _PyArg_UnpackStack(
5556
PyObject *const *args,
@@ -73,7 +74,7 @@ PyAPI_FUNC(void) _PyArg_BadArgument(const char *, const char *, const char *, Py
7374
PyAPI_FUNC(int) _PyArg_CheckPositional(const char *, Py_ssize_t,
7475
Py_ssize_t, Py_ssize_t);
7576
#define _PyArg_CheckPositional(funcname, nargs, min, max) \
76-
(((min) <= (nargs) && (nargs) <= (max)) \
77+
((!ANY_VARARGS(max) && (min) <= (nargs) && (nargs) <= (max)) \
7778
|| _PyArg_CheckPositional((funcname), (nargs), (min), (max)))
7879

7980
#endif
@@ -127,6 +128,14 @@ PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywords(
127128
struct _PyArg_Parser *parser,
128129
int minpos, int maxpos, int minkw,
129130
PyObject **buf);
131+
132+
PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywordsWithVararg(
133+
PyObject *const *args, Py_ssize_t nargs,
134+
PyObject *kwargs, PyObject *kwnames,
135+
struct _PyArg_Parser *parser,
136+
int minpos, int maxpos, int minkw,
137+
int vararg, PyObject **buf);
138+
130139
#define _PyArg_UnpackKeywords(args, nargs, kwargs, kwnames, parser, minpos, maxpos, minkw, buf) \
131140
(((minkw) == 0 && (kwargs) == NULL && (kwnames) == NULL && \
132141
(minpos) <= (nargs) && (nargs) <= (maxpos) && args != NULL) ? (args) : \

‎Lib/test/clinic.test

+220
Original file line numberDiff line numberDiff line change
@@ -3304,3 +3304,223 @@ test_preprocessor_guarded_else(PyObject *module, PyObject *Py_UNUSED(ignored))
33043304
#define TEST_PREPROCESSOR_GUARDED_ELSE_METHODDEF
33053305
#endif /* !defined(TEST_PREPROCESSOR_GUARDED_ELSE_METHODDEF) */
33063306
/*[clinic end generated code: output=3804bb18d454038c input=3fc80c9989d2f2e1]*/
3307+
3308+
/*[clinic input]
3309+
test_vararg_and_posonly
3310+
3311+
3312+
a: object
3313+
*args: object
3314+
/
3315+
3316+
[clinic start generated code]*/
3317+
3318+
PyDoc_STRVAR(test_vararg_and_posonly__doc__,
3319+
"test_vararg_and_posonly($module, a, /, *args)\n"
3320+
"--\n"
3321+
"\n");
3322+
3323+
#define TEST_VARARG_AND_POSONLY_METHODDEF \
3324+
{"test_vararg_and_posonly", (PyCFunction)(void(*)(void))test_vararg_and_posonly, METH_FASTCALL, test_vararg_and_posonly__doc__},
3325+
3326+
static PyObject *
3327+
test_vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args);
3328+
3329+
static PyObject *
3330+
test_vararg_and_posonly(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
3331+
{
3332+
PyObject *return_value = NULL;
3333+
PyObject *a;
3334+
PyObject *__clinic_args = NULL;
3335+
3336+
if (!_PyArg_CheckPositional("test_vararg_and_posonly", nargs, 1, PY_SSIZE_T_MAX)) {
3337+
goto exit;
3338+
}
3339+
a = args[0];
3340+
__clinic_args = PyTuple_New(nargs - 1);
3341+
for (Py_ssize_t i = 0; i < nargs - 1; ++i) {
3342+
PyTuple_SET_ITEM(__clinic_args, i, args[1 + i]);
3343+
}
3344+
return_value = test_vararg_and_posonly_impl(module, a, __clinic_args);
3345+
3346+
exit:
3347+
Py_XDECREF(__clinic_args);
3348+
return return_value;
3349+
}
3350+
3351+
static PyObject *
3352+
test_vararg_and_posonly_impl(PyObject *module, PyObject *a, PyObject *args)
3353+
/*[clinic end generated code: output=ada613d2d87c9341 input=08dc2bf7afbf1613]*/
3354+
3355+
/*[clinic input]
3356+
test_vararg
3357+
3358+
3359+
a: object
3360+
*args: object
3361+
3362+
[clinic start generated code]*/
3363+
3364+
PyDoc_STRVAR(test_vararg__doc__,
3365+
"test_vararg($module, /, a, *args)\n"
3366+
"--\n"
3367+
"\n");
3368+
3369+
#define TEST_VARARG_METHODDEF \
3370+
{"test_vararg", (PyCFunction)(void(*)(void))test_vararg, METH_FASTCALL|METH_KEYWORDS, test_vararg__doc__},
3371+
3372+
static PyObject *
3373+
test_vararg_impl(PyObject *module, PyObject *a, PyObject *args);
3374+
3375+
static PyObject *
3376+
test_vararg(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
3377+
{
3378+
PyObject *return_value = NULL;
3379+
static const char * const _keywords[] = {"a", NULL};
3380+
static _PyArg_Parser _parser = {NULL, _keywords, "test_vararg", 0};
3381+
PyObject *argsbuf[2];
3382+
Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
3383+
PyObject *a;
3384+
PyObject *__clinic_args = NULL;
3385+
3386+
args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
3387+
if (!args) {
3388+
goto exit;
3389+
}
3390+
a = args[0];
3391+
__clinic_args = args[1];
3392+
return_value = test_vararg_impl(module, a, __clinic_args);
3393+
3394+
exit:
3395+
Py_XDECREF(__clinic_args);
3396+
return return_value;
3397+
}
3398+
3399+
static PyObject *
3400+
test_vararg_impl(PyObject *module, PyObject *a, PyObject *args)
3401+
/*[clinic end generated code: output=f721025731c3bfe8 input=81d33815ad1bae6e]*/
3402+
3403+
/*[clinic input]
3404+
test_vararg_with_default
3405+
3406+
3407+
a: object
3408+
*args: object
3409+
b: bool = False
3410+
3411+
[clinic start generated code]*/
3412+
3413+
PyDoc_STRVAR(test_vararg_with_default__doc__,
3414+
"test_vararg_with_default($module, /, a, *args, b=False)\n"
3415+
"--\n"
3416+
"\n");
3417+
3418+
#define TEST_VARARG_WITH_DEFAULT_METHODDEF \
3419+
{"test_vararg_with_default", (PyCFunction)(void(*)(void))test_vararg_with_default, METH_FASTCALL|METH_KEYWORDS, test_vararg_with_default__doc__},
3420+
3421+
static PyObject *
3422+
test_vararg_with_default_impl(PyObject *module, PyObject *a, PyObject *args,
3423+
int b);
3424+
3425+
static PyObject *
3426+
test_vararg_with_default(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
3427+
{
3428+
PyObject *return_value = NULL;
3429+
static const char * const _keywords[] = {"a", "b", NULL};
3430+
static _PyArg_Parser _parser = {NULL, _keywords, "test_vararg_with_default", 0};
3431+
PyObject *argsbuf[3];
3432+
Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
3433+
PyObject *a;
3434+
PyObject *__clinic_args = NULL;
3435+
int b = 0;
3436+
3437+
args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, 1, argsbuf);
3438+
if (!args) {
3439+
goto exit;
3440+
}
3441+
a = args[0];
3442+
__clinic_args = args[1];
3443+
if (!noptargs) {
3444+
goto skip_optional_kwonly;
3445+
}
3446+
b = PyObject_IsTrue(args[2]);
3447+
if (b < 0) {
3448+
goto exit;
3449+
}
3450+
skip_optional_kwonly:
3451+
return_value = test_vararg_with_default_impl(module, a, __clinic_args, b);
3452+
3453+
exit:
3454+
Py_XDECREF(__clinic_args);
3455+
return return_value;
3456+
}
3457+
3458+
static PyObject *
3459+
test_vararg_with_default_impl(PyObject *module, PyObject *a, PyObject *args,
3460+
int b)
3461+
/*[clinic end generated code: output=63b34d3241c52fda input=6e110b54acd9b22d]*/
3462+
3463+
/*[clinic input]
3464+
test_vararg_with_only_defaults
3465+
3466+
3467+
*args: object
3468+
b: bool = False
3469+
c: object = ' '
3470+
3471+
[clinic start generated code]*/
3472+
3473+
PyDoc_STRVAR(test_vararg_with_only_defaults__doc__,
3474+
"test_vararg_with_only_defaults($module, /, *args, b=False, c=\' \')\n"
3475+
"--\n"
3476+
"\n");
3477+
3478+
#define TEST_VARARG_WITH_ONLY_DEFAULTS_METHODDEF \
3479+
{"test_vararg_with_only_defaults", (PyCFunction)(void(*)(void))test_vararg_with_only_defaults, METH_FASTCALL|METH_KEYWORDS, test_vararg_with_only_defaults__doc__},
3480+
3481+
static PyObject *
3482+
test_vararg_with_only_defaults_impl(PyObject *module, PyObject *args, int b,
3483+
PyObject *c);
3484+
3485+
static PyObject *
3486+
test_vararg_with_only_defaults(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
3487+
{
3488+
PyObject *return_value = NULL;
3489+
static const char * const _keywords[] = {"b", "c", NULL};
3490+
static _PyArg_Parser _parser = {NULL, _keywords, "test_vararg_with_only_defaults", 0};
3491+
PyObject *argsbuf[3];
3492+
Py_ssize_t noptargs = 0 + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
3493+
PyObject *__clinic_args = NULL;
3494+
int b = 0;
3495+
PyObject *c = " ";
3496+
3497+
args = _PyArg_UnpackKeywordsWithVararg(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, 0, argsbuf);
3498+
if (!args) {
3499+
goto exit;
3500+
}
3501+
__clinic_args = args[0];
3502+
if (!noptargs) {
3503+
goto skip_optional_kwonly;
3504+
}
3505+
if (args[1]) {
3506+
b = PyObject_IsTrue(args[1]);
3507+
if (b < 0) {
3508+
goto exit;
3509+
}
3510+
if (!--noptargs) {
3511+
goto skip_optional_kwonly;
3512+
}
3513+
}
3514+
c = args[2];
3515+
skip_optional_kwonly:
3516+
return_value = test_vararg_with_only_defaults_impl(module, __clinic_args, b, c);
3517+
3518+
exit:
3519+
Py_XDECREF(__clinic_args);
3520+
return return_value;
3521+
}
3522+
3523+
static PyObject *
3524+
test_vararg_with_only_defaults_impl(PyObject *module, PyObject *args, int b,
3525+
PyObject *c)
3526+
/*[clinic end generated code: output=dc29ce6ebc2ec10c input=fa56a709a035666e]*/

‎Lib/test/test_call.py

+1-1
Original file line numberDiff line numberDiff line change
@@ -129,7 +129,7 @@ def test_varargs16_kw(self):
129129
min, 0, default=1, key=2, foo=3)
130130

131131
def test_varargs17_kw(self):
132-
msg = r"^print\(\) takes at most 4 keyword arguments \(5 given\)$"
132+
msg = r"'foo' is an invalid keyword argument for print\(\)$"
133133
self.assertRaisesRegex(TypeError, msg,
134134
print, 0, sep=1, end=2, file=3, flush=4, foo=5)
135135

‎Misc/NEWS.d/next/Tools-Demos/2020-02-25-18-22-09.bpo-20291.AyrDiZ.rst

+1
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
Added support for variadic positional parameters in Argument Clinic.

‎Python/bltinmodule.c

+42-38
Original file line numberDiff line numberDiff line change
@@ -1952,33 +1952,41 @@ builtin_pow_impl(PyObject *module, PyObject *base, PyObject *exp,
19521952
return PyNumber_Power(base, exp, mod);
19531953
}
19541954

1955+
/*[clinic input]
1956+
print as builtin_print
1957+
1958+
*args: object
1959+
sep: object(c_default="Py_None") = ' '
1960+
string inserted between values, default a space.
1961+
end: object(c_default="Py_None") = '\n'
1962+
string appended after the last value, default a newline.
1963+
file: object = None
1964+
a file-like object (stream); defaults to the current sys.stdout.
1965+
flush: bool = False
1966+
whether to forcibly flush the stream.
1967+
1968+
Prints the values to a stream, or to sys.stdout by default.
1969+
1970+
[clinic start generated code]*/
19551971

1956-
/* AC: cannot convert yet, waiting for *args support */
19571972
static PyObject *
1958-
builtin_print(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1973+
builtin_print_impl(PyObject *module, PyObject *args, PyObject *sep,
1974+
PyObject *end, PyObject *file, int flush)
1975+
/*[clinic end generated code: output=3cfc0940f5bc237b input=c143c575d24fe665]*/
19591976
{
1960-
static const char * const _keywords[] = {"sep", "end", "file", "flush", 0};
1961-
static struct _PyArg_Parser _parser = {"|OOOp:print", _keywords, 0};
1962-
PyObject *sep = NULL, *end = NULL, *file = NULL;
1963-
int flush = 0;
19641977
int i, err;
19651978

1966-
if (kwnames != NULL &&
1967-
!_PyArg_ParseStackAndKeywords(args + nargs, 0, kwnames, &_parser,
1968-
&sep, &end, &file, &flush)) {
1969-
return NULL;
1970-
}
1971-
1972-
if (file == NULL || file == Py_None) {
1979+
if (file == Py_None) {
19731980
file = _PySys_GetObjectId(&PyId_stdout);
19741981
if (file == NULL) {
19751982
PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
19761983
return NULL;
19771984
}
19781985

19791986
/* sys.stdout may be None when FILE* stdout isn't connected */
1980-
if (file == Py_None)
1987+
if (file == Py_None) {
19811988
Py_RETURN_NONE;
1989+
}
19821990
}
19831991

19841992
if (sep == Py_None) {
@@ -2000,48 +2008,45 @@ builtin_print(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject
20002008
return NULL;
20012009
}
20022010

2003-
for (i = 0; i < nargs; i++) {
2011+
for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
20042012
if (i > 0) {
2005-
if (sep == NULL)
2013+
if (sep == NULL) {
20062014
err = PyFile_WriteString(" ", file);
2007-
else
2008-
err = PyFile_WriteObject(sep, file,
2009-
Py_PRINT_RAW);
2010-
if (err)
2015+
}
2016+
else {
2017+
err = PyFile_WriteObject(sep, file, Py_PRINT_RAW);
2018+
}
2019+
if (err) {
20112020
return NULL;
2021+
}
20122022
}
2013-
err = PyFile_WriteObject(args[i], file, Py_PRINT_RAW);
2014-
if (err)
2023+
err = PyFile_WriteObject(PyTuple_GET_ITEM(args, i), file, Py_PRINT_RAW);
2024+
if (err) {
20152025
return NULL;
2026+
}
20162027
}
20172028

2018-
if (end == NULL)
2029+
if (end == NULL) {
20192030
err = PyFile_WriteString("\n", file);
2020-
else
2031+
}
2032+
else {
20212033
err = PyFile_WriteObject(end, file, Py_PRINT_RAW);
2022-
if (err)
2034+
}
2035+
if (err) {
20232036
return NULL;
2037+
}
20242038

20252039
if (flush) {
20262040
PyObject *tmp = _PyObject_CallMethodIdNoArgs(file, &PyId_flush);
2027-
if (tmp == NULL)
2041+
if (tmp == NULL) {
20282042
return NULL;
2043+
}
20292044
Py_DECREF(tmp);
20302045
}
20312046

20322047
Py_RETURN_NONE;
20332048
}
20342049

2035-
PyDoc_STRVAR(print_doc,
2036-
"print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n\
2037-
\n\
2038-
Prints the values to a stream, or to sys.stdout by default.\n\
2039-
Optional keyword arguments:\n\
2040-
file: a file-like object (stream); defaults to the current sys.stdout.\n\
2041-
sep: string inserted between values, default a space.\n\
2042-
end: string appended after the last value, default a newline.\n\
2043-
flush: whether to forcibly flush the stream.");
2044-
20452050

20462051
/*[clinic input]
20472052
input as builtin_input
@@ -2644,7 +2649,6 @@ builtin_issubclass_impl(PyObject *module, PyObject *cls,
26442649
return PyBool_FromLong(retval);
26452650
}
26462651

2647-
26482652
typedef struct {
26492653
PyObject_HEAD
26502654
Py_ssize_t tuplesize;
@@ -2955,7 +2959,7 @@ static PyMethodDef builtin_methods[] = {
29552959
BUILTIN_OCT_METHODDEF
29562960
BUILTIN_ORD_METHODDEF
29572961
BUILTIN_POW_METHODDEF
2958-
{"print", (PyCFunction)(void(*)(void))builtin_print, METH_FASTCALL | METH_KEYWORDS, print_doc},
2962+
BUILTIN_PRINT_METHODDEF
29592963
BUILTIN_REPR_METHODDEF
29602964
BUILTIN_ROUND_METHODDEF
29612965
BUILTIN_SETATTR_METHODDEF

‎Python/clinic/bltinmodule.c.h

+75-1
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎Python/getargs.c

+160
Original file line numberDiff line numberDiff line change
@@ -2465,6 +2465,166 @@ _PyArg_UnpackKeywords(PyObject *const *args, Py_ssize_t nargs,
24652465
return buf;
24662466
}
24672467

2468+
PyObject * const *
2469+
_PyArg_UnpackKeywordsWithVararg(PyObject *const *args, Py_ssize_t nargs,
2470+
PyObject *kwargs, PyObject *kwnames,
2471+
struct _PyArg_Parser *parser,
2472+
int minpos, int maxpos, int minkw,
2473+
int vararg, PyObject **buf)
2474+
{
2475+
PyObject *kwtuple;
2476+
PyObject *keyword;
2477+
Py_ssize_t varargssize = 0;
2478+
int i, posonly, minposonly, maxargs;
2479+
int reqlimit = minkw ? maxpos + minkw : minpos;
2480+
Py_ssize_t nkwargs;
2481+
PyObject *current_arg;
2482+
PyObject * const *kwstack = NULL;
2483+
2484+
assert(kwargs == NULL || PyDict_Check(kwargs));
2485+
assert(kwargs == NULL || kwnames == NULL);
2486+
2487+
if (parser == NULL) {
2488+
PyErr_BadInternalCall();
2489+
return NULL;
2490+
}
2491+
2492+
if (kwnames != NULL && !PyTuple_Check(kwnames)) {
2493+
PyErr_BadInternalCall();
2494+
return NULL;
2495+
}
2496+
2497+
if (args == NULL && nargs == 0) {
2498+
args = buf;
2499+
}
2500+
2501+
if (!parser_init(parser)) {
2502+
return NULL;
2503+
}
2504+
2505+
kwtuple = parser->kwtuple;
2506+
posonly = parser->pos;
2507+
minposonly = Py_MIN(posonly, minpos);
2508+
maxargs = posonly + (int)PyTuple_GET_SIZE(kwtuple);
2509+
if (kwargs != NULL) {
2510+
nkwargs = PyDict_GET_SIZE(kwargs);
2511+
}
2512+
else if (kwnames != NULL) {
2513+
nkwargs = PyTuple_GET_SIZE(kwnames);
2514+
kwstack = args + nargs;
2515+
}
2516+
else {
2517+
nkwargs = 0;
2518+
}
2519+
if (nargs < minposonly) {
2520+
PyErr_Format(PyExc_TypeError,
2521+
"%.200s%s takes %s %d positional argument%s"
2522+
" (%zd given)",
2523+
(parser->fname == NULL) ? "function" : parser->fname,
2524+
(parser->fname == NULL) ? "" : "()",
2525+
minposonly < maxpos ? "at least" : "exactly",
2526+
minposonly,
2527+
minposonly == 1 ? "" : "s",
2528+
nargs);
2529+
return NULL;
2530+
}
2531+
2532+
/* create varargs tuple */
2533+
varargssize = nargs - maxpos;
2534+
if (varargssize < 0) {
2535+
varargssize = 0;
2536+
}
2537+
buf[vararg] = PyTuple_New(varargssize);
2538+
if (!buf[vararg]) {
2539+
return NULL;
2540+
}
2541+
2542+
/* copy tuple args */
2543+
for (i = 0; i < nargs; i++) {
2544+
if (i >= vararg) {
2545+
Py_INCREF(args[i]);
2546+
PyTuple_SET_ITEM(buf[vararg], i - vararg, args[i]);
2547+
continue;
2548+
}
2549+
else {
2550+
buf[i] = args[i];
2551+
}
2552+
}
2553+
2554+
/* copy keyword args using kwtuple to drive process */
2555+
for (i = Py_MAX((int)nargs, posonly) - varargssize; i < maxargs; i++) {
2556+
if (nkwargs) {
2557+
keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2558+
if (kwargs != NULL) {
2559+
current_arg = PyDict_GetItemWithError(kwargs, keyword);
2560+
if (!current_arg && PyErr_Occurred()) {
2561+
goto exit;
2562+
}
2563+
}
2564+
else {
2565+
current_arg = find_keyword(kwnames, kwstack, keyword);
2566+
}
2567+
}
2568+
else {
2569+
current_arg = NULL;
2570+
}
2571+
2572+
buf[i + vararg + 1] = current_arg;
2573+
2574+
if (current_arg) {
2575+
--nkwargs;
2576+
}
2577+
else if (i < minpos || (maxpos <= i && i < reqlimit)) {
2578+
/* Less arguments than required */
2579+
keyword = PyTuple_GET_ITEM(kwtuple, i - posonly);
2580+
PyErr_Format(PyExc_TypeError, "%.200s%s missing required "
2581+
"argument '%U' (pos %d)",
2582+
(parser->fname == NULL) ? "function" : parser->fname,
2583+
(parser->fname == NULL) ? "" : "()",
2584+
keyword, i+1);
2585+
goto exit;
2586+
}
2587+
}
2588+
2589+
if (nkwargs > 0) {
2590+
Py_ssize_t j;
2591+
/* make sure there are no extraneous keyword arguments */
2592+
j = 0;
2593+
while (1) {
2594+
int match;
2595+
if (kwargs != NULL) {
2596+
if (!PyDict_Next(kwargs, &j, &keyword, NULL))
2597+
break;
2598+
}
2599+
else {
2600+
if (j >= PyTuple_GET_SIZE(kwnames))
2601+
break;
2602+
keyword = PyTuple_GET_ITEM(kwnames, j);
2603+
j++;
2604+
}
2605+
2606+
match = PySequence_Contains(kwtuple, keyword);
2607+
if (match <= 0) {
2608+
if (!match) {
2609+
PyErr_Format(PyExc_TypeError,
2610+
"'%S' is an invalid keyword "
2611+
"argument for %.200s%s",
2612+
keyword,
2613+
(parser->fname == NULL) ? "this function" : parser->fname,
2614+
(parser->fname == NULL) ? "" : "()");
2615+
}
2616+
goto exit;
2617+
}
2618+
}
2619+
}
2620+
2621+
return buf;
2622+
2623+
exit:
2624+
Py_XDECREF(buf[vararg]);
2625+
return NULL;
2626+
}
2627+
24682628

24692629
static const char *
24702630
skipitem(const char **p_format, va_list *p_va, int flags)

‎Tools/clinic/clinic.py

+155-59
Large diffs are not rendered by default.

0 commit comments

Comments
 (0)
Please sign in to comment.