Index: Python/ceval.c =================================================================== --- Python/ceval.c (revision 61796) +++ Python/ceval.c (working copy) @@ -497,7 +497,7 @@ (PyObject **)NULL, 0, (PyObject **)NULL, 0, (PyObject **)NULL, 0, - NULL); + NULL, NULL); } @@ -2397,26 +2397,46 @@ } case MAKE_FUNCTION: + { + int posdefaults = oparg & 0xff; + int kwdefaults = (oparg>>8) & 0xff; + v = POP(); /* code object */ x = PyFunction_New(v, f->f_globals); Py_DECREF(v); /* XXX Maybe this should be a separate opcode? */ - if (x != NULL && oparg > 0) { - v = PyTuple_New(oparg); + if (x != NULL && posdefaults > 0) { + v = PyTuple_New(posdefaults); if (v == NULL) { Py_DECREF(x); x = NULL; break; } - while (--oparg >= 0) { + while (--posdefaults >= 0) { w = POP(); - PyTuple_SET_ITEM(v, oparg, w); + PyTuple_SET_ITEM(v, posdefaults, w); } err = PyFunction_SetDefaults(x, v); Py_DECREF(v); } + if (x != NULL && kwdefaults > 0) { + v = PyDict_New(); + if (v == NULL) { + Py_DECREF(x); + x = NULL; + break; + } + while (--kwdefaults >= 0) { + w = POP(); /* default value */ + u = POP(); /* kw only arg name */ + PyDict_SetItem(v, u, w); + } + err = PyFunction_SetKwDefaults(x, v); + Py_DECREF(v); + } PUSH(x); break; + } case MAKE_CLOSURE: { @@ -2684,7 +2704,7 @@ PyObject * PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals, PyObject **args, int argcount, PyObject **kws, int kwcount, - PyObject **defs, int defcount, PyObject *closure) + PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure) { register PyFrameObject *f; register PyObject *retval = NULL; @@ -2708,6 +2728,7 @@ freevars = f->f_localsplus + co->co_nlocals; if (co->co_argcount > 0 || + co->co_kwonlyargcount > 0 || co->co_flags & (CO_VARARGS | CO_VARKEYWORDS)) { int i; int n = argcount; @@ -2716,7 +2737,7 @@ kwdict = PyDict_New(); if (kwdict == NULL) goto fail; - i = co->co_argcount; + i = co->co_argcount + co->co_kwonlyargcount; if (co->co_flags & CO_VARARGS) i++; SETLOCAL(i, kwdict); @@ -2725,7 +2746,7 @@ if (!(co->co_flags & CO_VARARGS)) { PyErr_Format(PyExc_TypeError, "%.200s() takes %s %d " - "%sargument%s (%d given)", + "%spositional argument%s (%d given)", PyString_AsString(co->co_name), defcount ? "at most" : "exactly", co->co_argcount, @@ -2745,7 +2766,7 @@ u = PyTuple_New(argcount - n); if (u == NULL) goto fail; - SETLOCAL(co->co_argcount, u); + SETLOCAL(co->co_argcount + co->co_kwonlyargcount, u); for (i = n; i < argcount; i++) { x = args[i]; Py_INCREF(x); @@ -2763,7 +2784,9 @@ goto fail; } /* XXX slow -- speed up using dictionary? */ - for (j = 0; j < co->co_argcount; j++) { + for (j = 0; + j < co->co_argcount + co->co_kwonlyargcount; + j++) { PyObject *nm = PyTuple_GET_ITEM( co->co_varnames, j); int cmp = PyObject_RichCompareBool( @@ -2776,7 +2799,7 @@ /* Check errors from Compare */ if (PyErr_Occurred()) goto fail; - if (j >= co->co_argcount) { + if (j >= co->co_argcount + co->co_kwonlyargcount) { if (kwdict == NULL) { PyErr_Format(PyExc_TypeError, "%.200s() got an unexpected " @@ -2801,13 +2824,38 @@ SETLOCAL(j, value); } } + if (co->co_kwonlyargcount > 0) { + for (i = co->co_argcount; + i < co->co_argcount + co->co_kwonlyargcount; + i++) { + PyObject *name, *def; + if (GETLOCAL(i) != NULL) + continue; + name = PyTuple_GET_ITEM(co->co_varnames, i); + def = NULL; + if (kwdefs != NULL) + def = PyDict_GetItem(kwdefs, name); + if (def != NULL) { + Py_INCREF(def); + SETLOCAL(i, def); + continue; + } + PyErr_Format(PyExc_TypeError, + "%.200s() needs " + "keyword-only argument %s", + PyString_AsString(co->co_name), + PyString_AsString(name)); + goto fail; + } + } if (argcount < co->co_argcount) { int m = co->co_argcount - defcount; for (i = argcount; i < m; i++) { if (GETLOCAL(i) == NULL) { PyErr_Format(PyExc_TypeError, "%.200s() takes %s %d " - "%sargument%s (%d given)", + "%spositional argument%s " + "(%d given)", PyString_AsString(co->co_name), ((co->co_flags & CO_VARARGS) || defcount) ? "at least" @@ -2846,7 +2894,7 @@ char *cellname, *argname; PyObject *c; - nargs = co->co_argcount; + nargs = co->co_argcount + co->co_kwonlyargcount; if (co->co_flags & CO_VARARGS) nargs++; if (co->co_flags & CO_VARKEYWORDS) @@ -3697,12 +3745,14 @@ PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *kwdefs = PyFunction_GET_KW_DEFAULTS(func); PyObject **d = NULL; int nd = 0; PCALL(PCALL_FUNCTION); PCALL(PCALL_FAST_FUNCTION); - if (argdefs == NULL && co->co_argcount == n && nk==0 && + if (argdefs == NULL && co->co_argcount == n && + co->co_kwonlyargcount == 0 && nk==0 && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { PyFrameObject *f; PyObject *retval = NULL; @@ -3740,7 +3790,7 @@ } return PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, (*pp_stack)-n, na, - (*pp_stack)-2*nk, nk, d, nd, + (*pp_stack)-2*nk, nk, d, nd, kwdefs, PyFunction_GET_CLOSURE(func)); } Index: Python/graminit.c =================================================================== --- Python/graminit.c (revision 61796) +++ Python/graminit.c (working copy) @@ -156,14 +156,16 @@ {29, 5}, {0, 1}, }; -static arc arcs_8_2[1] = { +static arc arcs_8_2[3] = { {21, 6}, + {29, 7}, + {0, 2}, }; static arc arcs_8_3[1] = { - {21, 7}, + {21, 8}, }; static arc arcs_8_4[1] = { - {28, 8}, + {28, 9}, }; static arc arcs_8_5[4] = { {26, 1}, @@ -172,30 +174,41 @@ {0, 5}, }; static arc arcs_8_6[2] = { - {29, 9}, + {29, 7}, {0, 6}, }; -static arc arcs_8_7[1] = { - {0, 7}, +static arc arcs_8_7[2] = { + {21, 10}, + {31, 3}, }; -static arc arcs_8_8[2] = { - {29, 5}, +static arc arcs_8_8[1] = { {0, 8}, }; -static arc arcs_8_9[1] = { - {31, 3}, +static arc arcs_8_9[2] = { + {29, 5}, + {0, 9}, }; -static state states_8[10] = { +static arc arcs_8_10[3] = { + {29, 7}, + {27, 11}, + {0, 10}, +}; +static arc arcs_8_11[1] = { + {28, 6}, +}; +static state states_8[12] = { {3, arcs_8_0}, {3, arcs_8_1}, - {1, arcs_8_2}, + {3, arcs_8_2}, {1, arcs_8_3}, {1, arcs_8_4}, {4, arcs_8_5}, {2, arcs_8_6}, - {1, arcs_8_7}, - {2, arcs_8_8}, - {1, arcs_8_9}, + {2, arcs_8_7}, + {1, arcs_8_8}, + {2, arcs_8_9}, + {3, arcs_8_10}, + {1, arcs_8_11}, }; static arc arcs_9_0[2] = { {21, 1}, @@ -1807,7 +1820,7 @@ "\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {263, "parameters", 0, 4, states_7, "\000\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, - {264, "varargslist", 0, 10, states_8, + {264, "varargslist", 0, 12, states_8, "\000\040\040\300\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, {265, "fpdef", 0, 4, states_9, "\000\040\040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"}, Index: Python/ast.c =================================================================== --- Python/ast.c (revision 61796) +++ Python/ast.c (working copy) @@ -609,43 +609,138 @@ return result; } +/* returns -1 if failed to handle keyword only arguments + returns new position to keep processing if successful + (',' NAME ['=' test])* + ^^^ + start pointing here + */ +static int +handle_keywordonly_args(struct compiling *c, const node *n, int start, + asdl_seq *kwonlyargs, asdl_seq *kwdefaults) +{ + node *ch; + expr_ty name; + int i = start; + int j = 0; /* index for kwdefaults and kwonlyargs */ + if (kwonlyargs == NULL) { + ast_error(CHILD(n, start), "named arguments must follow bare *"); + return -1; + } + assert(kwdefaults != NULL); + while (i < NCH(n)) { + ch = CHILD(n, i); + switch (TYPE(ch)) { + case NAME: + if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) { + expr_ty expression = ast_for_expr(c, CHILD(n, i + 2)); + if (!expression) { + ast_error(ch, "assignment to None"); + goto error; + } + asdl_seq_SET(kwdefaults, j, expression); + i += 2; /* '=' and test */ + } + else { /* setting NULL if no default value exists */ + asdl_seq_SET(kwdefaults, j, NULL); + } + if (!strcmp(STR(ch), "None")) { + ast_error(ch, "assignment to None"); + goto error; + } + name = Name(NEW_IDENTIFIER(ch), + Param, LINENO(ch), ch->n_col_offset, + c->c_arena); + if (!name) { + ast_error(ch, "expecting name"); + goto error; + } + asdl_seq_SET(kwonlyargs, j++, name); + i += 2; /* the name and the comma */ + break; + case DOUBLESTAR: + return i; + default: + ast_error(ch, "unexpected node"); + goto error; + } + } + return i; + error: + return -1; +} + /* Create AST for argument list. */ static arguments_ty ast_for_arguments(struct compiling *c, const node *n) { /* parameters: '(' [varargslist] ')' - varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] - | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [','] + varargslist: (fpdef ['=' test] ',')* + ('*' [NAME] (',' fpdef ['=' test])* [',' '**' NAME] | '**' NAME) + | fpdef ['=' test] (',' fpdef ['=' test])* [','] */ - int i, j, k, n_args = 0, n_defaults = 0, found_default = 0; - asdl_seq *args, *defaults; + int i, j, k, nposargs = 0, nkwonlyargs = 0; + int nposdefaults = 0, found_default = 0; + asdl_seq *posargs, *posdefaults, *kwonlyargs, *kwdefaults; identifier vararg = NULL, kwarg = NULL; node *ch; if (TYPE(n) == parameters) { if (NCH(n) == 2) /* () as argument list */ - return arguments(NULL, NULL, NULL, NULL, c->c_arena); + return arguments(NULL, NULL, NULL, NULL, NULL, NULL, c->c_arena); n = CHILD(n, 1); } REQ(n, varargslist); - /* first count the number of normal args & defaults */ + /* first count the number of positional args & defaults */ for (i = 0; i < NCH(n); i++) { ch = CHILD(n, i); - if (TYPE(ch) == fpdef) - n_args++; - if (TYPE(ch) == EQUAL) - n_defaults++; + if (TYPE(ch) == STAR) { + if (TYPE(CHILD(n, i+1)) == NAME) { + /* skip NAME of vararg */ + /* so that following can count only keyword only args */ + i += 2; + } else { + i++; + } + break; + } + if (TYPE(ch) == fpdef) nposargs++; + if (TYPE(ch) == EQUAL) nposdefaults++; } - args = (n_args ? asdl_seq_new(n_args, c->c_arena) : NULL); - if (!args && n_args) + /* count the number of keyword only args & + defaults for keyword only args */ + for ( ; i < NCH(n); ++i) { + ch = CHILD(n, i); + if (TYPE(ch) == DOUBLESTAR) break; + if (TYPE(ch) == NAME) nkwonlyargs++; + } + posargs = (nposargs ? asdl_seq_new(nposargs, c->c_arena) : NULL); + if (!posargs && nposargs) return NULL; /* Don't need to goto error; no objects allocated */ - defaults = (n_defaults ? asdl_seq_new(n_defaults, c->c_arena) : NULL); - if (!defaults && n_defaults) + kwonlyargs = (nkwonlyargs ? + asdl_seq_new(nkwonlyargs, c->c_arena) : NULL); + if (!kwonlyargs && nkwonlyargs) return NULL; /* Don't need to goto error; no objects allocated */ + posdefaults = (nposdefaults ? + asdl_seq_new(nposdefaults, c->c_arena) : NULL); + if (!posdefaults && nposdefaults) + return NULL; /* Don't need to goto error; no objects allocated */ + /* The length of kwonlyargs and kwdefaults are same + since we set NULL as default for keyword only argument w/o default + - we have sequence data structure, but no dictionary */ + kwdefaults = (nkwonlyargs ? + asdl_seq_new(nkwonlyargs, c->c_arena) : NULL); + if (!kwdefaults && nkwonlyargs) + return NULL; /* Don't need to goto error; no objects allocated */ + if (nposargs + nkwonlyargs > 255) { + ast_error(n, "more than 255 arguments"); + return NULL; + } + /* fpdef: NAME | '(' fplist ')' fplist: fpdef (',' fpdef)* [','] */ @@ -664,8 +759,8 @@ expr_ty expression = ast_for_expr(c, CHILD(n, i + 2)); if (!expression) goto error; - assert(defaults != NULL); - asdl_seq_SET(defaults, j++, expression); + assert(posdefaults != NULL); + asdl_seq_SET(posdefaults, j++, expression); i += 2; found_default = 1; } @@ -679,8 +774,9 @@ /* def foo((x)): is not complex, special case. */ if (NCH(ch) != 1) { /* We have complex arguments, setup for unpacking. */ - asdl_seq_SET(args, k++, compiler_complex_args(c, ch)); - if (!asdl_seq_GET(args, k-1)) + asdl_seq_SET(posargs, k++, + compiler_complex_args(c, ch)); + if (!asdl_seq_GET(posargs, k-1)) goto error; } else { /* def foo((x)): setup for checking NAME below. */ @@ -702,18 +798,38 @@ c->c_arena); if (!name) goto error; - asdl_seq_SET(args, k++, name); - + asdl_seq_SET(posargs, k++, name); } i += 2; /* the name and the comma */ break; case STAR: + if (i+1 >= NCH(n)) { + ast_error(CHILD(n, i), + "named arguments must follow bare *"); + goto error; + } if (!strcmp(STR(CHILD(n, i+1)), "None")) { ast_error(CHILD(n, i+1), "assignment to None"); goto error; } - vararg = NEW_IDENTIFIER(CHILD(n, i+1)); - i += 3; + if (TYPE(CHILD(n, i+1)) == COMMA) { + int res = 0; + i += 2; /* now follows keyword only arguments */ + res = handle_keywordonly_args(c, n, i, + kwonlyargs, kwdefaults); + if (res == -1) goto error; + i = res; /* res has new position to process */ + } else { + vararg = NEW_IDENTIFIER(CHILD(n, i+1)); + i += 3; + if (i < NCH(n) && TYPE(CHILD(n, i)) == NAME) { + int res = 0; + res = handle_keywordonly_args(c, n, i, + kwonlyargs, kwdefaults); + if (res == -1) goto error; + i = res; /* res has new position to process */ + } + } break; case DOUBLESTAR: if (!strcmp(STR(CHILD(n, i+1)), "None")) { @@ -731,7 +847,8 @@ } } - return arguments(args, vararg, kwarg, defaults, c->c_arena); + return arguments(posargs, vararg, kwonlyargs, kwarg, + posdefaults, kwdefaults, c->c_arena); error: Py_XDECREF(vararg); @@ -895,7 +1012,7 @@ expr_ty expression; if (NCH(n) == 3) { - args = arguments(NULL, NULL, NULL, NULL, c->c_arena); + args = arguments(NULL, NULL, NULL, NULL, NULL, NULL, c->c_arena); if (!args) return NULL; expression = ast_for_expr(c, CHILD(n, 2)); Index: Python/import.c =================================================================== --- Python/import.c (revision 61796) +++ Python/import.c (working copy) @@ -73,9 +73,10 @@ Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp) Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode) Python 2.6a1: 62161 (WITH_CLEANUP optimization) + Python 2.6a1: 62171 (added keyword-only parameters) . */ -#define MAGIC (62161 | ((long)'\r'<<16) | ((long)'\n'<<24)) +#define MAGIC (62171 | ((long)'\r'<<16) | ((long)'\n'<<24)) /* Magic word as global; note that _PyImport_Init() can change the value of this global to accommodate for alterations of how the Index: Python/symtable.c =================================================================== --- Python/symtable.c (revision 61796) +++ Python/symtable.c (working copy) @@ -906,6 +906,17 @@ } \ } +#define VISIT_KWONLYDEFAULTS(ST, KW_DEFAULTS) { \ + int i = 0; \ + asdl_seq *seq = (KW_DEFAULTS); /* avoid variable capture */ \ + for (i = 0; i < asdl_seq_LEN(seq); i++) { \ + expr_ty elt = (expr_ty)asdl_seq_GET(seq, i); \ + if (!elt) continue; /* can be NULL */ \ + if (!symtable_visit_expr((ST), elt)) \ + return 0; \ + } \ +} + static int symtable_new_tmpname(struct symtable *st) { @@ -923,6 +934,8 @@ return 1; } + + static int symtable_visit_stmt(struct symtable *st, stmt_ty s) { @@ -932,6 +945,9 @@ return 0; if (s->v.FunctionDef.args->defaults) VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults); + if (s->v.FunctionDef.args->kw_defaults) + VISIT_KWONLYDEFAULTS(st, + s->v.FunctionDef.args->kw_defaults); if (s->v.FunctionDef.decorator_list) VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list); if (!symtable_enter_block(st, s->v.FunctionDef.name, @@ -1289,6 +1305,8 @@ */ if (a->args && !symtable_visit_params(st, a->args, 1)) return 0; + if (a->kwonlyargs && !symtable_visit_params(st, a->kwonlyargs, 1)) + return 0; if (a->vararg) { if (!symtable_add_def(st, a->vararg, DEF_PARAM)) return 0; Index: Python/marshal.c =================================================================== --- Python/marshal.c (revision 61796) +++ Python/marshal.c (working copy) @@ -356,6 +356,7 @@ PyCodeObject *co = (PyCodeObject *)v; w_byte(TYPE_CODE, p); w_long(co->co_argcount, p); + w_long(co->co_kwonlyargcount, p); w_long(co->co_nlocals, p); w_long(co->co_stacksize, p); w_long(co->co_flags, p); @@ -896,6 +897,7 @@ } else { int argcount; + int kwonlyargcount; int nlocals; int stacksize; int flags; @@ -914,6 +916,7 @@ /* XXX ignore long->int overflows for now */ argcount = (int)r_long(p); + kwonlyargcount = (int)r_long(p); nlocals = (int)r_long(p); stacksize = (int)r_long(p); flags = (int)r_long(p); @@ -947,7 +950,8 @@ goto code_error; v = (PyObject *) PyCode_New( - argcount, nlocals, stacksize, flags, + argcount, kwonlyargcount, + nlocals, stacksize, flags, code, consts, names, varnames, freevars, cellvars, filename, name, firstlineno, lnotab); Index: Python/compile.c =================================================================== --- Python/compile.c (revision 61796) +++ Python/compile.c (working copy) @@ -106,7 +106,8 @@ PyObject *u_private; /* for private name mangling */ - int u_argcount; /* number of arguments for block */ + int u_argcount; /* number of arguments for block */ + int u_kwonlyargcount; /* number of keyword only arguments for block */ /* Pointer to the most recently allocated block. By following b_list members, you can reach all early allocated blocks. */ basicblock *u_blocks; @@ -446,6 +447,7 @@ } memset(u, 0, sizeof(struct compiler_unit)); u->u_argcount = 0; + u->u_kwonlyargcount = 0; u->u_ste = PySymtable_Lookup(c->c_st, key); if (!u->u_ste) { compiler_unit_free(u); @@ -859,9 +861,9 @@ return -NARGS(oparg)-1; case CALL_FUNCTION_VAR_KW: return -NARGS(oparg)-2; + case MAKE_FUNCTION: + return -NARGS(oparg); #undef NARGS - case MAKE_FUNCTION: - return -oparg; case BUILD_SLICE: if (oparg == 3) return -2; @@ -1357,6 +1359,25 @@ } static int +compiler_visit_kwonlydefaults(struct compiler *c, asdl_seq *kwonlyargs, + asdl_seq *kw_defaults) +{ + int i, default_count = 0; + for (i = 0; i < asdl_seq_LEN(kwonlyargs); i++) { + expr_ty arg = asdl_seq_GET(kwonlyargs, i); + expr_ty default_ = asdl_seq_GET(kw_defaults, i); + if (default_) { + ADDOP_O(c, LOAD_CONST, arg->v.Name.id, consts); + if (!compiler_visit_expr(c, default_)) { + return -1; + } + default_count++; + } + } + return default_count; +} + +static int compiler_function(struct compiler *c, stmt_ty s) { PyCodeObject *co; @@ -1364,14 +1385,22 @@ arguments_ty args = s->v.FunctionDef.args; asdl_seq* decos = s->v.FunctionDef.decorator_list; stmt_ty st; - int i, n, docstring; + int i, n, docstring, kw_default_count = 0, arglength; assert(s->kind == FunctionDef_kind); if (!compiler_decorators(c, decos)) return 0; + if (args->kwonlyargs) { + int res = compiler_visit_kwonlydefaults(c, args->kwonlyargs, + args->kw_defaults); + if (res < 0) + return 0; + kw_default_count = res; + } if (args->defaults) VISIT_SEQ(c, expr, args->defaults); + if (!compiler_enter_scope(c, s->v.FunctionDef.name, (void *)s, s->lineno)) return 0; @@ -1389,6 +1418,7 @@ compiler_arguments(c, args); c->u->u_argcount = asdl_seq_LEN(args->args); + c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); n = asdl_seq_LEN(s->v.FunctionDef.body); /* if there was a docstring, we need to skip the first statement */ for (i = docstring; i < n; i++) { @@ -1400,7 +1430,9 @@ if (co == NULL) return 0; - compiler_make_closure(c, co, asdl_seq_LEN(args->defaults)); + arglength = asdl_seq_LEN(args->defaults); + arglength |= kw_default_count << 8; + compiler_make_closure(c, co, arglength); Py_DECREF(co); for (i = 0; i < asdl_seq_LEN(decos); i++) { @@ -1504,6 +1536,7 @@ { PyCodeObject *co; static identifier name; + int kw_default_count = 0, arglength; arguments_ty args = e->v.Lambda.args; assert(e->kind == Lambda_kind); @@ -1513,6 +1546,12 @@ return 0; } + if (args->kwonlyargs) { + int res = compiler_visit_kwonlydefaults(c, args->kwonlyargs, + args->kw_defaults); + if (res < 0) return 0; + kw_default_count = res; + } if (args->defaults) VISIT_SEQ(c, expr, args->defaults); if (!compiler_enter_scope(c, name, (void *)e, e->lineno)) @@ -1522,6 +1561,7 @@ compiler_arguments(c, args); c->u->u_argcount = asdl_seq_LEN(args->args); + c->u->u_kwonlyargcount = asdl_seq_LEN(args->kwonlyargs); VISIT_IN_SCOPE(c, expr, e->v.Lambda.body); ADDOP_IN_SCOPE(c, RETURN_VALUE); co = assemble(c, 1); @@ -1529,7 +1569,9 @@ if (co == NULL) return 0; - compiler_make_closure(c, co, asdl_seq_LEN(args->defaults)); + arglength = asdl_seq_LEN(args->defaults); + arglength |= kw_default_count << 8; + compiler_make_closure(c, co, arglength); Py_DECREF(co); return 1; @@ -3856,7 +3898,8 @@ Py_DECREF(consts); consts = tmp; - co = PyCode_New(c->u->u_argcount, nlocals, stackdepth(c), flags, + co = PyCode_New(c->u->u_argcount, c->u->u_kwonlyargcount, + nlocals, stackdepth(c), flags, bytecode, consts, names, varnames, freevars, cellvars, filename, c->u->u_name, Index: Python/frozen.c =================================================================== --- Python/frozen.c (revision 61796) +++ Python/frozen.c (working copy) @@ -12,13 +12,14 @@ the appropriate bytes from M___main__.c. */ static unsigned char M___hello__[] = { - 99,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0, - 0,115,9,0,0,0,100,0,0,71,72,100,1,0,83,40, - 2,0,0,0,115,14,0,0,0,72,101,108,108,111,32,119, - 111,114,108,100,46,46,46,78,40,0,0,0,0,40,0,0, - 0,0,40,0,0,0,0,40,0,0,0,0,115,8,0,0, - 0,104,101,108,108,111,46,112,121,115,1,0,0,0,63,1, - 0,0,0,115,0,0,0,0, + 99,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0, + 0,64,0,0,0,115,9,0,0,0,100,0,0,71,72,100, + 1,0,83,40,2,0,0,0,115,14,0,0,0,72,101,108, + 108,111,32,119,111,114,108,100,46,46,46,78,40,0,0,0, + 0,40,0,0,0,0,40,0,0,0,0,40,0,0,0,0, + 115,8,0,0,0,104,101,108,108,111,46,112,121,115,8,0, + 0,0,60,109,111,100,117,108,101,62,1,0,0,0,115,0, + 0,0,0, }; #define SIZE (int)sizeof(M___hello__) Index: Python/Python-ast.c =================================================================== --- Python/Python-ast.c (revision 61796) +++ Python/Python-ast.c (working copy) @@ -349,8 +349,10 @@ static char *arguments_fields[]={ "args", "vararg", + "kwonlyargs", "kwarg", "defaults", + "kw_defaults", }; static PyTypeObject *keyword_type; static PyObject* ast2obj_keyword(void*); @@ -726,7 +728,7 @@ excepthandler_type = make_type("excepthandler", AST_type, excepthandler_fields, 5); if (!excepthandler_type) return 0; - arguments_type = make_type("arguments", AST_type, arguments_fields, 4); + arguments_type = make_type("arguments", AST_type, arguments_fields, 6); if (!arguments_type) return 0; keyword_type = make_type("keyword", AST_type, keyword_fields, 2); if (!keyword_type) return 0; @@ -1770,8 +1772,8 @@ } arguments_ty -arguments(asdl_seq * args, identifier vararg, identifier kwarg, asdl_seq * - defaults, PyArena *arena) +arguments(asdl_seq * args, identifier vararg, asdl_seq * kwonlyargs, identifier + kwarg, asdl_seq * defaults, asdl_seq * kw_defaults, PyArena *arena) { arguments_ty p; p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p)); @@ -1779,8 +1781,10 @@ return NULL; p->args = args; p->vararg = vararg; + p->kwonlyargs = kwonlyargs; p->kwarg = kwarg; p->defaults = defaults; + p->kw_defaults = kw_defaults; return p; } @@ -2871,6 +2875,11 @@ if (PyObject_SetAttrString(result, "vararg", value) == -1) goto failed; Py_DECREF(value); + value = ast2obj_list(o->kwonlyargs, ast2obj_expr); + if (!value) goto failed; + if (PyObject_SetAttrString(result, "kwonlyargs", value) == -1) + goto failed; + Py_DECREF(value); value = ast2obj_identifier(o->kwarg); if (!value) goto failed; if (PyObject_SetAttrString(result, "kwarg", value) == -1) @@ -2881,6 +2890,11 @@ if (PyObject_SetAttrString(result, "defaults", value) == -1) goto failed; Py_DECREF(value); + value = ast2obj_list(o->kw_defaults, ast2obj_expr); + if (!value) goto failed; + if (PyObject_SetAttrString(result, "kw_defaults", value) == -1) + goto failed; + Py_DECREF(value); return result; failed: Py_XDECREF(value); Index: Include/code.h =================================================================== --- Include/code.h (revision 61796) +++ Include/code.h (working copy) @@ -10,6 +10,7 @@ typedef struct { PyObject_HEAD int co_argcount; /* #arguments, except *args */ + int co_kwonlyargcount; /* #keyword only arguments */ int co_nlocals; /* #local variables */ int co_stacksize; /* #entries needed for evaluation stack */ int co_flags; /* CO_..., see below */ @@ -66,8 +67,9 @@ /* Public interface */ PyAPI_FUNC(PyCodeObject *) PyCode_New( - int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *, - PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *); + int, int, int, int, int, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, PyObject *, + PyObject *, PyObject *, int, PyObject *); /* same as struct above */ PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int); Index: Include/funcobject.h =================================================================== --- Include/funcobject.h (revision 61796) +++ Include/funcobject.h (working copy) @@ -23,6 +23,7 @@ PyObject *func_code; /* A code object */ PyObject *func_globals; /* A dictionary (other mappings won't do) */ PyObject *func_defaults; /* NULL or a tuple */ + PyObject *func_kwdefaults; /* NULL or a dict */ PyObject *func_closure; /* NULL or a tuple of cell objects */ PyObject *func_doc; /* The __doc__ attribute, can be anything */ PyObject *func_name; /* The __name__ attribute, a string object */ @@ -47,6 +48,8 @@ PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *); PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *); PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *); +PyAPI_FUNC(PyObject *) PyFunction_GetKwDefaults(PyObject *); +PyAPI_FUNC(int) PyFunction_SetKwDefaults(PyObject *, PyObject *); PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *); PyAPI_FUNC(int) PyFunction_SetClosure(PyObject *, PyObject *); @@ -60,6 +63,8 @@ (((PyFunctionObject *)func) -> func_module) #define PyFunction_GET_DEFAULTS(func) \ (((PyFunctionObject *)func) -> func_defaults) +#define PyFunction_GET_KW_DEFAULTS(func) \ + (((PyFunctionObject *)func) -> func_kwdefaults) #define PyFunction_GET_CLOSURE(func) \ (((PyFunctionObject *)func) -> func_closure) Index: Include/Python-ast.h =================================================================== --- Include/Python-ast.h (revision 61796) +++ Include/Python-ast.h (working copy) @@ -335,8 +335,10 @@ struct _arguments { asdl_seq *args; identifier vararg; + asdl_seq *kwonlyargs; identifier kwarg; asdl_seq *defaults; + asdl_seq *kw_defaults; }; struct _keyword { @@ -492,9 +494,10 @@ #define excepthandler(a0, a1, a2, a3, a4, a5) _Py_excepthandler(a0, a1, a2, a3, a4, a5) excepthandler_ty _Py_excepthandler(expr_ty type, expr_ty name, asdl_seq * body, int lineno, int col_offset, PyArena *arena); -#define arguments(a0, a1, a2, a3, a4) _Py_arguments(a0, a1, a2, a3, a4) -arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, identifier - kwarg, asdl_seq * defaults, PyArena *arena); +#define arguments(a0, a1, a2, a3, a4, a5, a6) _Py_arguments(a0, a1, a2, a3, a4, a5, a6) +arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, asdl_seq * + kwonlyargs, identifier kwarg, asdl_seq * defaults, + asdl_seq * kw_defaults, PyArena *arena); #define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2) keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena); #define alias(a0, a1, a2) _Py_alias(a0, a1, a2) Index: Include/eval.h =================================================================== --- Include/eval.h (revision 61796) +++ Include/eval.h (working copy) @@ -15,7 +15,7 @@ PyObject **args, int argc, PyObject **kwds, int kwdc, PyObject **defs, int defc, - PyObject *closure); + PyObject *kwdefs, PyObject *closure); PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args); Index: Grammar/Grammar =================================================================== --- Grammar/Grammar (revision 61796) +++ Grammar/Grammar (working copy) @@ -37,7 +37,7 @@ funcdef: 'def' NAME parameters ':' suite parameters: '(' [varargslist] ')' varargslist: ((fpdef ['=' test] ',')* - ('*' NAME [',' '**' NAME] | '**' NAME) | + ('*' [NAME] (',' NAME ['=' test])* [',' '**' NAME] | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']) fpdef: NAME | '(' fplist ')' fplist: fpdef (',' fpdef)* [','] Index: Objects/codeobject.c =================================================================== --- Objects/codeobject.c (revision 61796) +++ Objects/codeobject.c (working copy) @@ -41,7 +41,8 @@ PyCodeObject * -PyCode_New(int argcount, int nlocals, int stacksize, int flags, +PyCode_New(int argcount, int kwonlyargcount, + int nlocals, int stacksize, int flags, PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames, PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name, int firstlineno, @@ -80,6 +81,7 @@ co = PyObject_NEW(PyCodeObject, &PyCode_Type); if (co != NULL) { co->co_argcount = argcount; + co->co_kwonlyargcount = kwonlyargcount; co->co_nlocals = nlocals; co->co_stacksize = stacksize; co->co_flags = flags; @@ -112,6 +114,7 @@ static PyMemberDef code_memberlist[] = { {"co_argcount", T_INT, OFF(co_argcount), READONLY}, + {"co_kwonlyargcount", T_INT, OFF(co_kwonlyargcount), READONLY}, {"co_nlocals", T_INT, OFF(co_nlocals), READONLY}, {"co_stacksize",T_INT, OFF(co_stacksize), READONLY}, {"co_flags", T_INT, OFF(co_flags), READONLY}, @@ -182,6 +185,7 @@ code_new(PyTypeObject *type, PyObject *args, PyObject *kw) { int argcount; + int kwonlyargcount; int nlocals; int stacksize; int flags; @@ -197,8 +201,9 @@ int firstlineno; PyObject *lnotab; - if (!PyArg_ParseTuple(args, "iiiiSO!O!O!SSiS|O!O!:code", - &argcount, &nlocals, &stacksize, &flags, + if (!PyArg_ParseTuple(args, "iiiiiSO!O!O!SSiS|O!O!:code", + &argcount, &kwonlyargcount, + &nlocals, &stacksize, &flags, &code, &PyTuple_Type, &consts, &PyTuple_Type, &names, @@ -216,6 +221,12 @@ goto cleanup; } + if (kwonlyargcount < 0) { + PyErr_SetString( + PyExc_ValueError, + "code: kwonlyargcount must not be negative"); + goto cleanup; + } if (nlocals < 0) { PyErr_SetString( PyExc_ValueError, @@ -242,7 +253,8 @@ if (ourcellvars == NULL) goto cleanup; - co = (PyObject *)PyCode_New(argcount, nlocals, stacksize, flags, + co = (PyObject *)PyCode_New(argcount, kwonlyargcount, + nlocals, stacksize, flags, code, consts, ournames, ourvarnames, ourfreevars, ourcellvars, filename, name, firstlineno, lnotab); @@ -299,6 +311,8 @@ if (cmp) return cmp; cmp = co->co_argcount - cp->co_argcount; if (cmp) goto normalize; + cmp = co->co_kwonlyargcount - cp->co_kwonlyargcount; + if (cmp) goto normalize; cmp = co->co_nlocals - cp->co_nlocals; if (cmp) goto normalize; cmp = co->co_flags - cp->co_flags; @@ -412,7 +426,8 @@ h6 = PyObject_Hash(co->co_cellvars); if (h6 == -1) return -1; h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^ - co->co_argcount ^ co->co_nlocals ^ co->co_flags; + co->co_argcount ^ co->co_kwonlyargcount ^ + co->co_nlocals ^ co->co_flags; if (h == -1) h = -2; return h; } Index: Objects/funcobject.c =================================================================== --- Objects/funcobject.c (revision 61796) +++ Objects/funcobject.c (working copy) @@ -24,6 +24,7 @@ op->func_name = ((PyCodeObject *)code)->co_name; Py_INCREF(op->func_name); op->func_defaults = NULL; /* No default arguments */ + op->func_kwdefaults = NULL; /* No keyword only defaults */ op->func_closure = NULL; consts = ((PyCodeObject *)code)->co_consts; if (PyTuple_Size(consts) >= 1) { @@ -122,6 +123,38 @@ } PyObject * +PyFunction_GetKwDefaults(PyObject *op) +{ + if (!PyFunction_Check(op)) { + PyErr_BadInternalCall(); + return NULL; + } + return ((PyFunctionObject *) op) -> func_kwdefaults; +} + +int +PyFunction_SetKwDefaults(PyObject *op, PyObject *defaults) +{ + if (!PyFunction_Check(op)) { + PyErr_BadInternalCall(); + return -1; + } + if (defaults == Py_None) + defaults = NULL; + else if (defaults && PyDict_Check(defaults)) { + Py_INCREF(defaults); + } + else { + PyErr_SetString(PyExc_SystemError, + "non-dict keyword only default args"); + return -1; + } + Py_XDECREF(((PyFunctionObject *)op) -> func_kwdefaults); + ((PyFunctionObject *) op) -> func_kwdefaults = defaults; + return 0; +} + +PyObject * PyFunction_GetClosure(PyObject *op) { if (!PyFunction_Check(op)) { @@ -329,6 +362,44 @@ return 0; } +static PyObject * +func_get_kwdefaults(PyFunctionObject *op) +{ + if (restricted()) + return NULL; + if (op->func_kwdefaults == NULL) { + Py_INCREF(Py_None); + return Py_None; + } + Py_INCREF(op->func_kwdefaults); + return op->func_kwdefaults; +} + +static int +func_set_kwdefaults(PyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + + if (restricted()) + return -1; + + if (value == Py_None) + value = NULL; + /* Legal to del f.func_kwdefaults. + * Can only set func_kwdefaults to NULL or a dict. */ + if (value != NULL && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + tmp = op->func_kwdefaults; + Py_XINCREF(value); + op->func_kwdefaults = value; + Py_XDECREF(tmp); + return 0; +} + + static PyGetSetDef func_getsetlist[] = { {"func_code", (getter)func_get_code, (setter)func_set_code}, {"__code__", (getter)func_get_code, (setter)func_set_code}, @@ -336,6 +407,10 @@ (setter)func_set_defaults}, {"__defaults__", (getter)func_get_defaults, (setter)func_set_defaults}, + {"func_kwdefaults", (getter)func_get_kwdefaults, + (setter)func_set_kwdefaults}, + {"__kwdefaults__", (getter)func_get_kwdefaults, + (setter)func_set_kwdefaults}, {"func_dict", (getter)func_get_dict, (setter)func_set_dict}, {"__dict__", (getter)func_get_dict, (setter)func_set_dict}, {"func_name", (getter)func_get_name, (setter)func_set_name}, @@ -456,6 +531,7 @@ Py_XDECREF(op->func_module); Py_DECREF(op->func_name); Py_XDECREF(op->func_defaults); + Py_XDECREF(op->func_kwdefaults); Py_XDECREF(op->func_doc); Py_XDECREF(op->func_dict); Py_XDECREF(op->func_closure); @@ -477,6 +553,7 @@ Py_VISIT(f->func_globals); Py_VISIT(f->func_module); Py_VISIT(f->func_defaults); + Py_VISIT(f->func_kwdefaults); Py_VISIT(f->func_doc); Py_VISIT(f->func_name); Py_VISIT(f->func_dict); @@ -526,6 +603,7 @@ PyFunction_GET_GLOBALS(func), (PyObject *)NULL, &PyTuple_GET_ITEM(arg, 0), PyTuple_Size(arg), k, nk, d, nd, + PyFunction_GET_KW_DEFAULTS(func), PyFunction_GET_CLOSURE(func)); if (k != NULL) Index: Misc/NEWS =================================================================== --- Misc/NEWS (revision 61796) +++ Misc/NEWS (working copy) @@ -60,6 +60,8 @@ - Issue #2143: Fix embedded readline() hang on SSL socket EOF. +- PEP 3102: Added keyword-only arguments. + Library ------- Index: Parser/Python.asdl =================================================================== --- Parser/Python.asdl (revision 61796) +++ Parser/Python.asdl (working copy) @@ -104,8 +104,8 @@ excepthandler = (expr? type, expr? name, stmt* body, int lineno, int col_offset) - arguments = (expr* args, identifier? vararg, - identifier? kwarg, expr* defaults) + arguments = (expr* args, identifier? vararg, expr* kwonlyargs, + identifier? kwarg, expr* defaults, expr* kw_defaults) -- keyword arguments supplied to call keyword = (identifier arg, expr value) Index: Tools/compiler/ast.txt =================================================================== --- Tools/compiler/ast.txt (revision 61796) +++ Tools/compiler/ast.txt (working copy) @@ -12,8 +12,8 @@ Module: doc*, node Stmt: nodes! Decorators: nodes! -Function: decorators&, name*, argnames*, defaults!, flags*, doc*, code -Lambda: argnames*, defaults!, flags*, code +Function: decorators&, name*, argnames*, defaults!, kwonlyargs*, flags*, doc*, code +Lambda: argnames*, defaults!, kwonlyargs*, flags*, code Class: name*, bases!, doc*, code, decorators& = None Pass: Break: Index: Lib/compiler/pycodegen.py =================================================================== --- Lib/compiler/pycodegen.py (revision 61796) +++ Lib/compiler/pycodegen.py (working copy) @@ -382,6 +382,12 @@ walk(node.code, gen) gen.finish() self.set_lineno(node) + for keyword in node.kwonlyargs: + default = keyword.expr + if isinstance(default, ast.EmptyNode): + continue + self.emit('LOAD_CONST', keyword.name) + self.visit(default) for default in node.defaults: self.visit(default) self._makeClosure(gen, len(node.defaults)) @@ -1333,7 +1339,9 @@ name = func.name args, hasTupleArg = generateArgList(func.argnames) + kwonlyargs = generateKwonlyArgList(func.kwonlyargs) self.graph = pyassem.PyFlowGraph(name, func.filename, args, + kwonlyargs=kwonlyargs, optimized=1) self.isLambda = isLambda self.super_init() @@ -1469,6 +1477,13 @@ raise ValueError, "unexpect argument type:", elt return args + extra, count +def generateKwonlyArgList(keywordOnlyArgs): + kwonlyargs = {} + for elt in keywordOnlyArgs: + assert isinstance(elt, ast.Keyword) + kwonlyargs[elt.name] = elt.expr + return kwonlyargs + def findOp(node): """Find the op (DELETE, LOAD, STORE) in an AssTuple tree""" v = OpFinder() Index: Lib/compiler/pyassem.py =================================================================== --- Lib/compiler/pyassem.py (revision 61796) +++ Lib/compiler/pyassem.py (working copy) @@ -313,13 +313,15 @@ class PyFlowGraph(FlowGraph): super_init = FlowGraph.__init__ - def __init__(self, name, filename, args=(), optimized=0, klass=None): + def __init__(self, name, filename, + args=(), kwonlyargs={}, optimized=0, klass=None): self.super_init() self.name = name self.filename = filename self.docstring = None self.args = args # XXX self.argcount = getArgCount(args) + self.kwonlyargs = kwonlyargs self.klass = klass if optimized: self.flags = CO_OPTIMIZED | CO_NEWLOCALS @@ -595,7 +597,9 @@ argcount = self.argcount if self.flags & CO_VARKEYWORDS: argcount = argcount - 1 - return types.CodeType(argcount, nlocals, self.stacksize, self.flags, + kwonlyargcount = len(self.kwonlyargs) + return types.CodeType(argcount, kwonlyargcount, + nlocals, self.stacksize, self.flags, self.lnotab.getCode(), self.getConsts(), tuple(self.names), tuple(self.varnames), self.filename, self.name, self.lnotab.firstline, @@ -803,7 +807,8 @@ def CALL_FUNCTION_VAR_KW(self, argc): return self.CALL_FUNCTION(argc)-2 def MAKE_FUNCTION(self, argc): - return -argc + hi, lo = divmod(argc, 256) + return -(lo + hi * 2) def MAKE_CLOSURE(self, argc): # XXX need to account for free variables too! return -argc Index: Lib/compiler/transformer.py =================================================================== --- Lib/compiler/transformer.py (revision 61796) +++ Lib/compiler/transformer.py (working copy) @@ -261,9 +261,9 @@ args = nodelist[-3][2] if args[0] == symbol.varargslist: - names, defaults, flags = self.com_arglist(args[1:]) + names, defaults, kwonlyargs, flags = self.com_arglist(args[1:]) else: - names = defaults = () + names = defaults = kwonlyargs = () flags = 0 doc = self.get_docstring(nodelist[-1]) @@ -274,21 +274,23 @@ assert isinstance(code, Stmt) assert isinstance(code.nodes[0], Discard) del code.nodes[0] - return Function(decorators, name, names, defaults, flags, doc, code, - lineno=lineno) + return Function(decorators, name, names, defaults, + kwonlyargs, flags, doc, code, lineno=lineno) def lambdef(self, nodelist): # lambdef: 'lambda' [varargslist] ':' test if nodelist[2][0] == symbol.varargslist: - names, defaults, flags = self.com_arglist(nodelist[2][1:]) + names, defaults, kwonlyargs, flags = \ + self.com_arglist(nodelist[2][1:]) else: - names = defaults = () + names = defaults = kwonlyargs = () flags = 0 # code for lambda code = self.com_node(nodelist[-1]) - return Lambda(names, defaults, flags, code, lineno=nodelist[1][2]) + return Lambda(names, defaults, kwonlyargs, + flags, code, lineno=nodelist[1][2]) old_lambdef = lambdef def classdef(self, nodelist): @@ -808,13 +810,36 @@ # ('const', xxxx)) Nodes) return Discard(Const(None)) + def keywordonlyargs(self, nodelist): + # (',' NAME ['=' test])* + # ^^^ + # ------+ + kwonlyargs = [] + i = 0 + while i < len(nodelist): + default = EmptyNode() + node = nodelist[i] + assert node[0] == token.COMMA + if i+1 < len(nodelist) and nodelist[i+1][0] == token.EQUAL: + assert i+2 < len(nodelist) + default = self.com_node(nodelist[i+2]) + i += 2 + if node[0] == token.DOUBLESTAR: + return kwonlyargs, i + elif node[0] == token.NAME: + kwonlyargs.append(Keyword(node[1], default, lineno=node[2])) + i += 2 + return kwonlyargs, i + def com_arglist(self, nodelist): # varargslist: - # (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME) - # | fpdef ['=' test] (',' fpdef ['=' test])* [','] + # (fpdef ['=' test] ',')* + # ('*' [NAME] (',' NAME '=' test)* [',' '**' NAME] | '**' NAME) + # | fpdef ['=' test] (',' fpdef ['=' test])* [','] # fpdef: NAME | '(' fplist ')' # fplist: fpdef (',' fpdef)* [','] names = [] + kwonlyargs = [] defaults = [] flags = 0 @@ -824,10 +849,16 @@ if node[0] == token.STAR or node[0] == token.DOUBLESTAR: if node[0] == token.STAR: node = nodelist[i+1] - if node[0] == token.NAME: + if node[0] == token.NAME: # vararg names.append(node[1]) flags = flags | CO_VARARGS i = i + 3 + else: # no vararg + assert node[0] == token.COMMA + i += 1 + if i < len(nodelist) and nodelist[i][0] == token.NAME: + kwonlyargs, skip = self.keywordonlyargs(nodelist[i:]) + i += skip if i < len(nodelist): # should be DOUBLESTAR @@ -856,7 +887,7 @@ # skip the comma i = i + 1 - return names, defaults, flags + return names, defaults, kwonlyargs, flags def com_fpdef(self, node): # fpdef: NAME | '(' fplist ')' Index: Lib/compiler/ast.py =================================================================== --- Lib/compiler/ast.py (revision 61796) +++ Lib/compiler/ast.py (working copy) @@ -544,11 +544,12 @@ return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level)) class Function(Node): - def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): + def __init__(self, decorators, name, argnames, defaults, kwonlyargs, flags, doc, code, lineno=None): self.decorators = decorators self.name = name self.argnames = argnames self.defaults = defaults + self.kwonlyargs = kwonlyargs self.flags = flags self.doc = doc self.code = code @@ -567,6 +568,7 @@ children.append(self.name) children.append(self.argnames) children.extend(flatten(self.defaults)) + children.append(self.kwonlyargs) children.append(self.flags) children.append(self.doc) children.append(self.code) @@ -581,7 +583,7 @@ return tuple(nodelist) def __repr__(self): - return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code)) + return "Function(%s, %s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.kwonlyargs), repr(self.flags), repr(self.doc), repr(self.code)) class GenExpr(Node): def __init__(self, code, lineno=None): @@ -589,6 +591,7 @@ self.lineno = lineno self.argnames = ['.0'] self.varargs = self.kwargs = None + self.kwonlyargs = () def getChildren(self): return self.code, @@ -771,9 +774,10 @@ return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr)) class Lambda(Node): - def __init__(self, argnames, defaults, flags, code, lineno=None): + def __init__(self, argnames, defaults, kwonlyargs, flags, code, lineno=None): self.argnames = argnames self.defaults = defaults + self.kwonlyargs = kwonlyargs self.flags = flags self.code = code self.lineno = lineno @@ -789,6 +793,7 @@ children = [] children.append(self.argnames) children.extend(flatten(self.defaults)) + children.append(self.kwonlyargs) children.append(self.flags) children.append(self.code) return tuple(children) @@ -800,7 +805,7 @@ return tuple(nodelist) def __repr__(self): - return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code)) + return "Lambda(%s, %s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.kwonlyargs), repr(self.flags), repr(self.code)) class LeftShift(Node): def __init__(self, (left, right), lineno=None): Index: Lib/test/test_extcall.py =================================================================== --- Lib/test/test_extcall.py (revision 61796) +++ Lib/test/test_extcall.py (working copy) @@ -65,17 +65,17 @@ >>> g() Traceback (most recent call last): ... - TypeError: g() takes at least 1 argument (0 given) + TypeError: g() takes at least 1 positional argument (0 given) >>> g(*()) Traceback (most recent call last): ... - TypeError: g() takes at least 1 argument (0 given) + TypeError: g() takes at least 1 positional argument (0 given) >>> g(*(), **{}) Traceback (most recent call last): ... - TypeError: g() takes at least 1 argument (0 given) + TypeError: g() takes at least 1 positional argument (0 given) >>> g(1) 1 () {} Index: Lib/test/test_code.py =================================================================== --- Lib/test/test_code.py (revision 61796) +++ Lib/test/test_code.py (working copy) @@ -9,6 +9,7 @@ >>> dump(f.func_code) name: f argcount: 1 +kwonlyargcount: 0 names: () varnames: ('x', 'g') cellvars: ('x',) @@ -20,6 +21,7 @@ >>> dump(f(4).func_code) name: g argcount: 1 +kwonlyargcount: 0 names: () varnames: ('y',) cellvars: () @@ -34,9 +36,11 @@ ... c = a * b ... return c ... + >>> dump(h.func_code) name: h argcount: 2 +kwonlyargcount: 0 names: () varnames: ('x', 'y', 'a', 'b', 'c') cellvars: () @@ -53,6 +57,7 @@ >>> dump(attrs.func_code) name: attrs argcount: 1 +kwonlyargcount: 0 names: ('attr1', 'attr2', 'attr3') varnames: ('obj',) cellvars: () @@ -70,6 +75,7 @@ >>> dump(optimize_away.func_code) name: optimize_away argcount: 0 +kwonlyargcount: 0 names: () varnames: () cellvars: () @@ -78,6 +84,22 @@ flags: 67 consts: ("'doc string'", 'None') +>>> def keywordonly_args(a,b,*,k1): +... return a,b,k1 +... + +>>> dump(keywordonly_args.func_code) +name: keywordonly_args +argcount: 2 +kwonlyargcount: 1 +names: () +varnames: ('a', 'b', 'k1') +cellvars: () +freevars: () +nlocals: 3 +flags: 67 +consts: ('None',) + """ def consts(t): @@ -91,8 +113,8 @@ def dump(co): """Print out a text representation of a code object.""" - for attr in ["name", "argcount", "names", "varnames", "cellvars", - "freevars", "nlocals", "flags"]: + for attr in ["name", "argcount", "kwonlyargcount", "names", "varnames", + "cellvars", "freevars", "nlocals", "flags"]: print "%s: %s" % (attr, getattr(co, "co_" + attr)) print "consts:", tuple(consts(co.co_consts)) Index: Lib/test/test_new.py =================================================================== --- Lib/test/test_new.py (revision 61796) +++ Lib/test/test_new.py (working copy) @@ -108,6 +108,7 @@ c = f.func_code argcount = c.co_argcount + kwonlyargcount = c.co_kwonlyargcount nlocals = c.co_nlocals stacksize = c.co_stacksize flags = c.co_flags @@ -122,35 +123,41 @@ freevars = c.co_freevars cellvars = c.co_cellvars - d = new.code(argcount, nlocals, stacksize, flags, codestring, + d = new.code(argcount, kwonlyargcount, + nlocals, stacksize, flags, codestring, constants, names, varnames, filename, name, firstlineno, lnotab, freevars, cellvars) # test backwards-compatibility version with no freevars or cellvars - d = new.code(argcount, nlocals, stacksize, flags, codestring, + d = new.code(argcount, kwonlyargcount, + nlocals, stacksize, flags, codestring, constants, names, varnames, filename, name, firstlineno, lnotab) # negative co_argcount used to trigger a SystemError self.assertRaises(ValueError, new.code, - -argcount, nlocals, stacksize, flags, codestring, + -argcount, kwonlyargcount, + nlocals, stacksize, flags, codestring, constants, names, varnames, filename, name, firstlineno, lnotab) # negative co_nlocals used to trigger a SystemError self.assertRaises(ValueError, new.code, - argcount, -nlocals, stacksize, flags, codestring, + argcount, kwonlyargcount, + -nlocals, stacksize, flags, codestring, constants, names, varnames, filename, name, firstlineno, lnotab) # non-string co_name used to trigger a Py_FatalError self.assertRaises(TypeError, new.code, - argcount, nlocals, stacksize, flags, codestring, + argcount, kwonlyargcount, + nlocals, stacksize, flags, codestring, constants, (5,), varnames, filename, name, firstlineno, lnotab) # new.code used to be a way to mutate a tuple... class S(str): pass t = (S("ab"),) - d = new.code(argcount, nlocals, stacksize, flags, codestring, + d = new.code(argcount, kwonlyargcount, + nlocals, stacksize, flags, codestring, constants, t, varnames, filename, name, firstlineno, lnotab) self.assert_(type(t[0]) is S, "eek, tuple changed under us!") Index: Lib/test/test_keywordonlyarg.py =================================================================== --- Lib/test/test_keywordonlyarg.py (revision 0) +++ Lib/test/test_keywordonlyarg.py (revision 0) @@ -0,0 +1,161 @@ +#!/usr/bin/env python + +"""Unit tests for the keyword only argument specified in PEP 3102.""" + +__author__ = "Jiwon Seo" +__email__ = "seojiwon at gmail dot com" + +import unittest +from test.test_support import run_unittest + +def posonly_sum(pos_arg1, *arg, **kwarg): + return pos_arg1 + sum(arg) + sum(kwarg.values()) +def keywordonly_sum(*, k1=0, k2): + return k1 + k2 +def keywordonly_nodefaults_sum(*, k1, k2): + return k1 + k2 +def keywordonly_and_kwarg_sum(*, k1, k2, **kwarg): + return k1 + k2 + sum(kwarg.values()) +def mixedargs_sum(a, b=0, *arg, k1, k2=0): + return a + b + k1 + k2 + sum(arg) +def mixedargs_sum2(a, b=0, *arg, k1, k2=0, **kwargs): + return a + b + k1 + k2 + sum(arg) + sum(kwargs.values()) + +def sortnum(*nums, reverse=False): + return sorted(list(nums), reverse=reverse) + +def sortwords(*words, reverse=False, **kwargs): + return sorted(list(words), reverse=reverse) + +class Foo: + def __init__(self, *, k1, k2=0): + self.k1 = k1 + self.k2 = k2 + def set(self, p1, *, k1, k2): + self.k1 = k1 + self.k2 = k2 + def sum(self): + return self.k1 + self.k2 + +class KeywordOnlyArgTestCase(unittest.TestCase): + def assertRaisesSyntaxError(self, codestr): + def shouldRaiseSyntaxError(s): + compile(s, "", "single") + self.assertRaises(SyntaxError, shouldRaiseSyntaxError, codestr) + + def testSyntaxErrorForFunctionDefinition(self): + self.assertRaisesSyntaxError("def f(p, *):\n pass\n") + self.assertRaisesSyntaxError("def f(p1, *, p1=100):\n pass\n") + self.assertRaisesSyntaxError("def f(p1, *k1, k1=100):\n pass\n") + self.assertRaisesSyntaxError("def f(p1, *, k1, k1=100):\n pass\n") + self.assertRaisesSyntaxError("def f(p1, *, **k1):\n pass\n") + self.assertRaisesSyntaxError("def f(p1, *, k1, **k1):\n pass\n") + self.assertRaisesSyntaxError("def f(p1, *, None, **k1):\n pass\n") + self.assertRaisesSyntaxError("def f(p, *, (k1, k2), **kw):\n pass\n") + + def testSyntaxForManyArguments(self): + fundef = "def f(" + for i in range(255): + fundef += "i%d, "%i + fundef += "*, key=100):\n pass\n" + self.assertRaisesSyntaxError(fundef) + + fundef2 = "def foo(i,*," + for i in range(255): + fundef2 += "i%d, "%i + fundef2 += "lastarg):\n pass\n" + self.assertRaisesSyntaxError(fundef2) + + # exactly 255 arguments, should compile ok + fundef3 = "def f(i,*," + for i in range(253): + fundef3 += "i%d, "%i + fundef3 += "lastarg):\n pass\n" + compile(fundef3, "", "single") + + def testSyntaxErrorForFunctionCall(self): + self.assertRaisesSyntaxError("f(p, k=1, p2)") + self.assertRaisesSyntaxError("f(p, *(1,2), k1=100)") + + def testRaiseErrorFuncallWithUnexpectedKeywordArgument(self): + self.assertRaises(TypeError, keywordonly_sum, ()) + self.assertRaises(TypeError, keywordonly_nodefaults_sum, ()) + self.assertRaises(TypeError, Foo, ()) + try: + keywordonly_sum(k2=100, non_existing_arg=200) + self.fail("should raise TypeError") + except TypeError: + pass + try: + keywordonly_nodefaults_sum(k2=2) + self.fail("should raise TypeError") + except TypeError: + pass + + def testFunctionCall(self): + self.assertEquals(1, posonly_sum(1)) + self.assertEquals(1+2, posonly_sum(1,**{"2":2})) + self.assertEquals(1+2+3, posonly_sum(1,*(2,3))) + self.assertEquals(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) + + self.assertEquals(1, keywordonly_sum(k2=1)) + self.assertEquals(1+2, keywordonly_sum(k1=1, k2=2)) + + self.assertEquals(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) + self.assertEquals(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) + self.assertEquals(1+2+3+4, + keywordonly_and_kwarg_sum(k1=1, k2=2, + **{"a":3,"b":4})) + + self.assertEquals(1+2, mixedargs_sum(1, k1=2)) + self.assertEquals(1+2+3, mixedargs_sum(1, 2, k1=3)) + self.assertEquals(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) + self.assertEquals(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) + + self.assertEquals(1+2, mixedargs_sum2(1, k1=2)) + self.assertEquals(1+2+3, mixedargs_sum2(1, 2, k1=3)) + self.assertEquals(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) + self.assertEquals(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) + self.assertEquals(1+2+3+4+5+6, + mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) + self.assertEquals(1+2+3+4+5+6, + mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) + + self.assertEquals(1, Foo(k1=1).sum()) + self.assertEquals(1+2, Foo(k1=1,k2=2).sum()) + + self.assertEquals([1,2,3], sortnum(3,2,1)) + self.assertEquals([3,2,1], sortnum(1,2,3, reverse=True)) + + self.assertEquals(['a','b','c'], sortwords('a','c','b')) + self.assertEquals(['c','b','a'], sortwords('a','c','b', reverse=True)) + self.assertEquals(['c','b','a'], + sortwords('a','c','b', reverse=True, ignore='ignore')) + + def testKwDefaults(self): + def foo(p1,p2=0, *, k1, k2=0): + return p1 + p2 + k1 + k2 + + self.assertEquals(2, foo.__code__.co_kwonlyargcount) + self.assertEquals({"k2":0}, foo.__kwdefaults__) + foo.__kwdefaults__ = {"k1":0} + try: + foo(1,k1=10) + self.fail("__kwdefaults__ is not properly changed") + except TypeError: + pass + + def test_kwonly_methods(self): + class Example: + def f(self, *, k1=1, k2=2): + return k1, k2 + + self.assertEqual(Example().f(k1=1, k2=2), (1, 2)) + self.assertEqual(Example.f(Example(), k1=1, k2=2), (1, 2)) + self.assertRaises(TypeError, Example.f, k1=1, k2=2) + +def test_main(): + run_unittest(KeywordOnlyArgTestCase) + +if __name__ == "__main__": + test_main() Index: Lib/test/test_scope.py =================================================================== --- Lib/test/test_scope.py (revision 61796) +++ Lib/test/test_scope.py (working copy) @@ -166,6 +166,17 @@ self.assertEqual(t.method_and_var(), "method") self.assertEqual(t.actual_global(), "global") + def testCellIsKwonlyArg(self): + # Issue 1409: Initialisation of a cell value, + # when it comes from a keyword-only parameter + def foo(*, a=17): + def bar(): + return a + 5 + return bar() + 3 + + self.assertEqual(foo(a=42), 50) + self.assertEqual(foo(), 25) + def testRecursion(self): def f(x): Index: Lib/test/test_grammar.py =================================================================== --- Lib/test/test_grammar.py (revision 61796) +++ Lib/test/test_grammar.py (working copy) @@ -139,7 +139,8 @@ def testFuncdef(self): ### 'def' NAME parameters ':' suite ### parameters: '(' [varargslist] ')' - ### varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME] + ### varargslist: (fpdef ['=' test] ',')* + ### ('*' (NAME|',' fpdef ['=' test]) [',' ('**'|'*' '*') NAME] ### | ('**'|'*' '*') NAME) ### | fpdef ['=' test] (',' fpdef ['=' test])* [','] ### fpdef: NAME | '(' fplist ')' @@ -281,6 +282,16 @@ d31v(1) def d32v((x,)): pass d32v((1,)) + #keyword only argument tests + def pos0key1(*, key): return key + pos0key1(key=100) + def pos2key2(p1, p2, *, k1, k2=100): return p1,p2,k1,k2 + pos2key2(1, 2, k1=100) + pos2key2(1, 2, k1=100, k2=200) + pos2key2(1, 2, k2=100, k1=200) + def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg): return p1,p2,k1,k2,kwarg + pos2key2dict(1,2,k2=100,tokwarg1=100,tokwarg2=200) + pos2key2dict(1,2,tokwarg1=100,tokwarg2=200, k2=100) # Check ast errors in *args and *kwargs check_syntax_error(self, "f(*g(1=2))") @@ -299,6 +310,9 @@ self.assertEquals(l5(1, 2), 5) self.assertEquals(l5(1, 2, 3), 6) check_syntax_error(self, "lambda x: x = 2") + l6 = lambda x, y, *, k=20: x+y+k + self.assertEquals(l6(1,2), 1+2+20) + self.assertEquals(l6(1,2,k=10), 1+2+10) ### stmt: simple_stmt | compound_stmt # Tested below Index: Lib/test/test_collections.py =================================================================== --- Lib/test/test_collections.py (revision 61796) +++ Lib/test/test_collections.py (working copy) @@ -108,7 +108,8 @@ self.assertEqual(Dot(1)._replace(d=999), (999,)) self.assertEqual(Dot(1)._fields, ('d',)) - n = 10000 + # Highest possible because of SyntaxError: more than 255 arguments. + n = 254 import string, random names = [''.join([random.choice(string.letters) for j in range(10)]) for i in range(n)] Big = namedtuple('Big', names) Index: Lib/test/test_ast.py =================================================================== --- Lib/test/test_ast.py (revision 61796) +++ Lib/test/test_ast.py (working copy) @@ -155,9 +155,9 @@ #### EVERYTHING BELOW IS GENERATED ##### exec_results = [ -('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, None, []), [('Pass', (1, 9))], [])]), +('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], None, [], []), [('Pass', (1, 9))], [])]), ('Module', [('ClassDef', (1, 0), 'C', [], [('Pass', (1, 8))], [])]), -('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, None, []), [('Return', (1, 8), ('Num', (1, 15), 1))], [])]), +('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, [], None, [], []), [('Return', (1, 8), ('Num', (1, 15), 1))], [])]), ('Module', [('Delete', (1, 0), [('Name', (1, 4), 'v', ('Del',))])]), ('Module', [('Assign', (1, 0), [('Name', (1, 0), 'v', ('Store',))], ('Num', (1, 4), 1))]), ('Module', [('AugAssign', (1, 0), ('Name', (1, 0), 'v', ('Store',)), ('Add',), ('Num', (1, 5), 1))]), @@ -185,7 +185,7 @@ ('Expression', ('BoolOp', (1, 0), ('And',), [('Name', (1, 0), 'a', ('Load',)), ('Name', (1, 6), 'b', ('Load',))])), ('Expression', ('BinOp', (1, 0), ('Name', (1, 0), 'a', ('Load',)), ('Add',), ('Name', (1, 4), 'b', ('Load',)))), ('Expression', ('UnaryOp', (1, 0), ('Not',), ('Name', (1, 4), 'v', ('Load',)))), -('Expression', ('Lambda', (1, 0), ('arguments', [], None, None, []), ('Name', (1, 7), 'None', ('Load',)))), +('Expression', ('Lambda', (1, 0), ('arguments', [], None, [], None, [], []), ('Name', (1, 7), 'None', ('Load',)))), ('Expression', ('Dict', (1, 0), [('Num', (1, 2), 1)], [('Num', (1, 4), 2)])), ('Expression', ('ListComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))])])), ('Expression', ('GeneratorExp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))])])), Index: Modules/_ctypes/callbacks.c =================================================================== --- Modules/_ctypes/callbacks.c (revision 61796) +++ Modules/_ctypes/callbacks.c (working copy) @@ -51,6 +51,7 @@ if (!empty_string) goto bad; py_code = PyCode_New( 0, /*int argcount,*/ + 0, /*int kwonlyargcount,*/ 0, /*int nlocals,*/ 0, /*int stacksize,*/ 0, /*int flags,*/ Index: Modules/pyexpat.c =================================================================== --- Modules/pyexpat.c (revision 61796) +++ Modules/pyexpat.c (working copy) @@ -279,6 +279,7 @@ filename = PyString_FromString(__FILE__); handler_info[slot].tb_code = PyCode_New(0, /* argcount */ + 0, /* kwonlyargcount */ 0, /* nlocals */ 0, /* stacksize */ 0, /* flags */ Index: Modules/parsermodule.c =================================================================== --- Modules/parsermodule.c (revision 61796) +++ Modules/parsermodule.c (working copy) @@ -1119,13 +1119,13 @@ } -/* '*' NAME [',' '**' NAME] | '**' NAME +/* '*' [NAME] (',' NAME ['=' test])* [',' '**' NAME] | '**' NAME */ static int validate_varargslist_trailer(node *tree, int start) { int nch = NCH(tree); - int res = 0; + int res = 0, i; int sym; if (nch <= start) { @@ -1135,15 +1135,40 @@ sym = TYPE(CHILD(tree, start)); if (sym == STAR) { /* - * ('*' NAME [',' '**' NAME] + * '*' [NAME] (',' NAME ['=' test])* [',' '**' NAME] | '**' NAME */ if (nch-start == 2) res = validate_name(CHILD(tree, start+1), NULL); - else if (nch-start == 5) + else if (nch-start == 5 && TYPE(CHILD(tree, start+2)) == COMMA) res = (validate_name(CHILD(tree, start+1), NULL) && validate_comma(CHILD(tree, start+2)) && validate_doublestar(CHILD(tree, start+3)) && validate_name(CHILD(tree, start+4), NULL)); + else { + /* skip over [NAME] (',' NAME ['=' test])* */ + i = start + 1; + if (TYPE(CHILD(tree, i)) == NAME) { /* skip over [NAME] */ + i += 1; + } + while (res && i+1 < nch) { /* validate (',' NAME ['=' test])* */ + res = validate_comma(CHILD(tree, i)); + if (TYPE(CHILD(tree, i+1)) == DOUBLESTAR) + break; + res = res && validate_name(CHILD(tree, i+1), NULL); + if (res && i+2 < nch && TYPE(CHILD(tree, i+2)) == EQUAL) { + res = res && (i+3 < nch) + && validate_test(CHILD(tree, i+3)); + i += 4; + } + else { + i += 2; + } + } + /* [',' '**' NAME] */ + if (res && i+1 < nch && TYPE(CHILD(tree, i+1)) == DOUBLESTAR) { + res = validate_name(CHILD(tree, i+2), NULL); + } + } } else if (sym == DOUBLESTAR) { /* @@ -1162,9 +1187,8 @@ * * varargslist: * (fpdef ['=' test] ',')* - * ('*' NAME [',' '**' NAME] - * | '**' NAME) - * | fpdef ['=' test] (',' fpdef ['=' test])* [','] + * ('*' [NAME] (',' NAME ['=' test])* [',' '**' NAME] | '**' NAME) + * | fpdef ['=' test] (',' fpdef ['=' test])* [','] * */ static int @@ -1183,7 +1207,7 @@ sym = TYPE(CHILD(tree, 0)); if (sym == STAR || sym == DOUBLESTAR) /* whole thing matches: - * '*' NAME [',' '**' NAME] | '**' NAME + * '*' [NAME] (',' NAME ['=' test])* [',' '**' NAME] | '**' NAME */ res = validate_varargslist_trailer(tree, 0); else if (sym == fpdef) { @@ -1215,7 +1239,7 @@ break; } } - /* ... '*' NAME [',' '**' NAME] | '**' NAME + /* .. ('*' [NAME] (',' NAME ['=' test])* [',' '**' NAME] | '**' NAME) * i --^^^ */ if (res)