bpo-42128: Structural Pattern Matching (PEP 634) (GH-22917)
Co-authored-by: Guido van Rossum <guido@python.org>
Co-authored-by: Talin <viridia@gmail.com>
Co-authored-by: Pablo Galindo <pablogsal@gmail.com>
diff --git a/Python/Python-ast.c b/Python/Python-ast.c
index debd3e3..439da8f 100644
--- a/Python/Python-ast.c
+++ b/Python/Python-ast.c
@@ -91,6 +91,9 @@ struct ast_state {
PyObject *Lt_type;
PyObject *MatMult_singleton;
PyObject *MatMult_type;
+ PyObject *MatchAs_type;
+ PyObject *MatchOr_type;
+ PyObject *Match_type;
PyObject *Mod_singleton;
PyObject *Mod_type;
PyObject *Module_type;
@@ -137,6 +140,7 @@ struct ast_state {
PyObject *Yield_type;
PyObject *__dict__;
PyObject *__doc__;
+ PyObject *__match_args__;
PyObject *__module__;
PyObject *_attributes;
PyObject *_fields;
@@ -153,6 +157,7 @@ struct ast_state {
PyObject *bases;
PyObject *body;
PyObject *boolop_type;
+ PyObject *cases;
PyObject *cause;
PyObject *cmpop_type;
PyObject *col_offset;
@@ -175,6 +180,7 @@ struct ast_state {
PyObject *format_spec;
PyObject *func;
PyObject *generators;
+ PyObject *guard;
PyObject *handlers;
PyObject *id;
PyObject *ifs;
@@ -193,6 +199,7 @@ struct ast_state {
PyObject *level;
PyObject *lineno;
PyObject *lower;
+ PyObject *match_case_type;
PyObject *mod_type;
PyObject *module;
PyObject *msg;
@@ -204,6 +211,8 @@ struct ast_state {
PyObject *ops;
PyObject *optional_vars;
PyObject *orelse;
+ PyObject *pattern;
+ PyObject *patterns;
PyObject *posonlyargs;
PyObject *returns;
PyObject *right;
@@ -211,6 +220,7 @@ struct ast_state {
PyObject *slice;
PyObject *step;
PyObject *stmt_type;
+ PyObject *subject;
PyObject *tag;
PyObject *target;
PyObject *targets;
@@ -348,6 +358,9 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->Lt_type);
Py_CLEAR(state->MatMult_singleton);
Py_CLEAR(state->MatMult_type);
+ Py_CLEAR(state->MatchAs_type);
+ Py_CLEAR(state->MatchOr_type);
+ Py_CLEAR(state->Match_type);
Py_CLEAR(state->Mod_singleton);
Py_CLEAR(state->Mod_type);
Py_CLEAR(state->Module_type);
@@ -394,6 +407,7 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->Yield_type);
Py_CLEAR(state->__dict__);
Py_CLEAR(state->__doc__);
+ Py_CLEAR(state->__match_args__);
Py_CLEAR(state->__module__);
Py_CLEAR(state->_attributes);
Py_CLEAR(state->_fields);
@@ -410,6 +424,7 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->bases);
Py_CLEAR(state->body);
Py_CLEAR(state->boolop_type);
+ Py_CLEAR(state->cases);
Py_CLEAR(state->cause);
Py_CLEAR(state->cmpop_type);
Py_CLEAR(state->col_offset);
@@ -432,6 +447,7 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->format_spec);
Py_CLEAR(state->func);
Py_CLEAR(state->generators);
+ Py_CLEAR(state->guard);
Py_CLEAR(state->handlers);
Py_CLEAR(state->id);
Py_CLEAR(state->ifs);
@@ -450,6 +466,7 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->level);
Py_CLEAR(state->lineno);
Py_CLEAR(state->lower);
+ Py_CLEAR(state->match_case_type);
Py_CLEAR(state->mod_type);
Py_CLEAR(state->module);
Py_CLEAR(state->msg);
@@ -461,6 +478,8 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->ops);
Py_CLEAR(state->optional_vars);
Py_CLEAR(state->orelse);
+ Py_CLEAR(state->pattern);
+ Py_CLEAR(state->patterns);
Py_CLEAR(state->posonlyargs);
Py_CLEAR(state->returns);
Py_CLEAR(state->right);
@@ -468,6 +487,7 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->slice);
Py_CLEAR(state->step);
Py_CLEAR(state->stmt_type);
+ Py_CLEAR(state->subject);
Py_CLEAR(state->tag);
Py_CLEAR(state->target);
Py_CLEAR(state->targets);
@@ -494,6 +514,7 @@ static int init_identifiers(struct ast_state *state)
{
if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0;
+ if ((state->__match_args__ = PyUnicode_InternFromString("__match_args__")) == NULL) return 0;
if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0;
if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return 0;
if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return 0;
@@ -506,6 +527,7 @@ static int init_identifiers(struct ast_state *state)
if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return 0;
if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return 0;
if ((state->body = PyUnicode_InternFromString("body")) == NULL) return 0;
+ if ((state->cases = PyUnicode_InternFromString("cases")) == NULL) return 0;
if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0;
if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return 0;
if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return 0;
@@ -523,6 +545,7 @@ static int init_identifiers(struct ast_state *state)
if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return 0;
if ((state->func = PyUnicode_InternFromString("func")) == NULL) return 0;
if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return 0;
+ if ((state->guard = PyUnicode_InternFromString("guard")) == NULL) return 0;
if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return 0;
if ((state->id = PyUnicode_InternFromString("id")) == NULL) return 0;
if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return 0;
@@ -549,12 +572,15 @@ static int init_identifiers(struct ast_state *state)
if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return 0;
if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return 0;
if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return 0;
+ if ((state->pattern = PyUnicode_InternFromString("pattern")) == NULL) return 0;
+ if ((state->patterns = PyUnicode_InternFromString("patterns")) == NULL) return 0;
if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0;
if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return 0;
if ((state->right = PyUnicode_InternFromString("right")) == NULL) return 0;
if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return 0;
if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return 0;
if ((state->step = PyUnicode_InternFromString("step")) == NULL) return 0;
+ if ((state->subject = PyUnicode_InternFromString("subject")) == NULL) return 0;
if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return 0;
if ((state->target = PyUnicode_InternFromString("target")) == NULL) return 0;
if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return 0;
@@ -579,6 +605,7 @@ GENERATE_ASDL_SEQ_CONSTRUCTOR(arg, arg_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(keyword, keyword_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(alias, alias_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(withitem, withitem_ty)
+GENERATE_ASDL_SEQ_CONSTRUCTOR(match_case, match_case_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty)
static PyObject* ast2obj_mod(struct ast_state *state, void*);
@@ -682,6 +709,10 @@ static const char * const AsyncWith_fields[]={
"body",
"type_comment",
};
+static const char * const Match_fields[]={
+ "subject",
+ "cases",
+};
static const char * const Raise_fields[]={
"exc",
"cause",
@@ -832,6 +863,13 @@ static const char * const Slice_fields[]={
"upper",
"step",
};
+static const char * const MatchAs_fields[]={
+ "pattern",
+ "name",
+};
+static const char * const MatchOr_fields[]={
+ "patterns",
+};
static PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty);
static PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty);
static PyObject* ast2obj_operator(struct ast_state *state, operator_ty);
@@ -899,6 +937,12 @@ static const char * const withitem_fields[]={
"context_expr",
"optional_vars",
};
+static PyObject* ast2obj_match_case(struct ast_state *state, void*);
+static const char * const match_case_fields[]={
+ "pattern",
+ "guard",
+ "body",
+};
static PyObject* ast2obj_type_ignore(struct ast_state *state, void*);
static const char * const TypeIgnore_fields[]={
"lineno",
@@ -1089,9 +1133,10 @@ make_type(struct ast_state *state, const char *type, PyObject* base,
}
PyTuple_SET_ITEM(fnames, i, field);
}
- result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOOOs}",
+ result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOOOOOs}",
type, base,
state->_fields, fnames,
+ state->__match_args__, fnames,
state->__module__,
state->ast,
state->__doc__, doc);
@@ -1222,6 +1267,7 @@ static int add_ast_fields(struct ast_state *state)
empty_tuple = PyTuple_New(0);
if (!empty_tuple ||
PyObject_SetAttrString(state->AST_type, "_fields", empty_tuple) < 0 ||
+ PyObject_SetAttrString(state->AST_type, "__match_args__", empty_tuple) < 0 ||
PyObject_SetAttrString(state->AST_type, "_attributes", empty_tuple) < 0) {
Py_XDECREF(empty_tuple);
return -1;
@@ -1291,6 +1337,7 @@ init_types(struct ast_state *state)
" | If(expr test, stmt* body, stmt* orelse)\n"
" | With(withitem* items, stmt* body, string? type_comment)\n"
" | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"
+ " | Match(expr subject, match_case* cases)\n"
" | Raise(expr? exc, expr? cause)\n"
" | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
" | Assert(expr test, expr? msg)\n"
@@ -1393,6 +1440,10 @@ init_types(struct ast_state *state)
if (PyObject_SetAttr(state->AsyncWith_type, state->type_comment, Py_None)
== -1)
return 0;
+ state->Match_type = make_type(state, "Match", state->stmt_type,
+ Match_fields, 2,
+ "Match(expr subject, match_case* cases)");
+ if (!state->Match_type) return 0;
state->Raise_type = make_type(state, "Raise", state->stmt_type,
Raise_fields, 2,
"Raise(expr? exc, expr? cause)");
@@ -1471,7 +1522,9 @@ init_types(struct ast_state *state)
" | Name(identifier id, expr_context ctx)\n"
" | List(expr* elts, expr_context ctx)\n"
" | Tuple(expr* elts, expr_context ctx)\n"
- " | Slice(expr? lower, expr? upper, expr? step)");
+ " | Slice(expr? lower, expr? upper, expr? step)\n"
+ " | MatchAs(expr pattern, identifier name)\n"
+ " | MatchOr(expr* patterns)");
if (!state->expr_type) return 0;
if (!add_attributes(state, state->expr_type, expr_attributes, 4)) return 0;
if (PyObject_SetAttr(state->expr_type, state->end_lineno, Py_None) == -1)
@@ -1604,6 +1657,14 @@ init_types(struct ast_state *state)
return 0;
if (PyObject_SetAttr(state->Slice_type, state->step, Py_None) == -1)
return 0;
+ state->MatchAs_type = make_type(state, "MatchAs", state->expr_type,
+ MatchAs_fields, 2,
+ "MatchAs(expr pattern, identifier name)");
+ if (!state->MatchAs_type) return 0;
+ state->MatchOr_type = make_type(state, "MatchOr", state->expr_type,
+ MatchOr_fields, 1,
+ "MatchOr(expr* patterns)");
+ if (!state->MatchOr_type) return 0;
state->expr_context_type = make_type(state, "expr_context",
state->AST_type, NULL, 0,
"expr_context = Load | Store | Del");
@@ -1910,6 +1971,13 @@ init_types(struct ast_state *state)
if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None)
== -1)
return 0;
+ state->match_case_type = make_type(state, "match_case", state->AST_type,
+ match_case_fields, 3,
+ "match_case(expr pattern, expr? guard, stmt* body)");
+ if (!state->match_case_type) return 0;
+ if (!add_attributes(state, state->match_case_type, NULL, 0)) return 0;
+ if (PyObject_SetAttr(state->match_case_type, state->guard, Py_None) == -1)
+ return 0;
state->type_ignore_type = make_type(state, "type_ignore", state->AST_type,
NULL, 0,
"type_ignore = TypeIgnore(int lineno, string tag)");
@@ -1955,6 +2023,8 @@ static int obj2ast_alias(struct ast_state *state, PyObject* obj, alias_ty* out,
PyArena* arena);
static int obj2ast_withitem(struct ast_state *state, PyObject* obj,
withitem_ty* out, PyArena* arena);
+static int obj2ast_match_case(struct ast_state *state, PyObject* obj,
+ match_case_ty* out, PyArena* arena);
static int obj2ast_type_ignore(struct ast_state *state, PyObject* obj,
type_ignore_ty* out, PyArena* arena);
@@ -2389,6 +2459,29 @@ AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, string type_comment,
}
stmt_ty
+Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, int col_offset,
+ int end_lineno, int end_col_offset, PyArena *arena)
+{
+ stmt_ty p;
+ if (!subject) {
+ PyErr_SetString(PyExc_ValueError,
+ "field 'subject' is required for Match");
+ return NULL;
+ }
+ p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
+ if (!p)
+ return NULL;
+ p->kind = Match_kind;
+ p->v.Match.subject = subject;
+ p->v.Match.cases = cases;
+ p->lineno = lineno;
+ p->col_offset = col_offset;
+ p->end_lineno = end_lineno;
+ p->end_col_offset = end_col_offset;
+ return p;
+}
+
+stmt_ty
Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int end_lineno,
int end_col_offset, PyArena *arena)
{
@@ -3263,6 +3356,51 @@ Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int col_offset,
return p;
}
+expr_ty
+MatchAs(expr_ty pattern, identifier name, int lineno, int col_offset, int
+ end_lineno, int end_col_offset, PyArena *arena)
+{
+ expr_ty p;
+ if (!pattern) {
+ PyErr_SetString(PyExc_ValueError,
+ "field 'pattern' is required for MatchAs");
+ return NULL;
+ }
+ if (!name) {
+ PyErr_SetString(PyExc_ValueError,
+ "field 'name' is required for MatchAs");
+ return NULL;
+ }
+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
+ if (!p)
+ return NULL;
+ p->kind = MatchAs_kind;
+ p->v.MatchAs.pattern = pattern;
+ p->v.MatchAs.name = name;
+ p->lineno = lineno;
+ p->col_offset = col_offset;
+ p->end_lineno = end_lineno;
+ p->end_col_offset = end_col_offset;
+ return p;
+}
+
+expr_ty
+MatchOr(asdl_expr_seq * patterns, int lineno, int col_offset, int end_lineno,
+ int end_col_offset, PyArena *arena)
+{
+ expr_ty p;
+ p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
+ if (!p)
+ return NULL;
+ p->kind = MatchOr_kind;
+ p->v.MatchOr.patterns = patterns;
+ p->lineno = lineno;
+ p->col_offset = col_offset;
+ p->end_lineno = end_lineno;
+ p->end_col_offset = end_col_offset;
+ return p;
+}
+
comprehension_ty
comprehension(expr_ty target, expr_ty iter, asdl_expr_seq * ifs, int is_async,
PyArena *arena)
@@ -3406,6 +3544,24 @@ withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena)
return p;
}
+match_case_ty
+match_case(expr_ty pattern, expr_ty guard, asdl_stmt_seq * body, PyArena *arena)
+{
+ match_case_ty p;
+ if (!pattern) {
+ PyErr_SetString(PyExc_ValueError,
+ "field 'pattern' is required for match_case");
+ return NULL;
+ }
+ p = (match_case_ty)PyArena_Malloc(arena, sizeof(*p));
+ if (!p)
+ return NULL;
+ p->pattern = pattern;
+ p->guard = guard;
+ p->body = body;
+ return p;
+}
+
type_ignore_ty
TypeIgnore(int lineno, string tag, PyArena *arena)
{
@@ -3847,6 +4003,22 @@ ast2obj_stmt(struct ast_state *state, void* _o)
goto failed;
Py_DECREF(value);
break;
+ case Match_kind:
+ tp = (PyTypeObject *)state->Match_type;
+ result = PyType_GenericNew(tp, NULL, NULL);
+ if (!result) goto failed;
+ value = ast2obj_expr(state, o->v.Match.subject);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->subject, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ value = ast2obj_list(state, (asdl_seq*)o->v.Match.cases,
+ ast2obj_match_case);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->cases, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ break;
case Raise_kind:
tp = (PyTypeObject *)state->Raise_type;
result = PyType_GenericNew(tp, NULL, NULL);
@@ -4460,6 +4632,32 @@ ast2obj_expr(struct ast_state *state, void* _o)
goto failed;
Py_DECREF(value);
break;
+ case MatchAs_kind:
+ tp = (PyTypeObject *)state->MatchAs_type;
+ result = PyType_GenericNew(tp, NULL, NULL);
+ if (!result) goto failed;
+ value = ast2obj_expr(state, o->v.MatchAs.pattern);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->pattern, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ value = ast2obj_identifier(state, o->v.MatchAs.name);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->name, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ break;
+ case MatchOr_kind:
+ tp = (PyTypeObject *)state->MatchOr_type;
+ result = PyType_GenericNew(tp, NULL, NULL);
+ if (!result) goto failed;
+ value = ast2obj_list(state, (asdl_seq*)o->v.MatchOr.patterns,
+ ast2obj_expr);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->patterns, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ break;
}
value = ast2obj_int(state, o->lineno);
if (!value) goto failed;
@@ -4928,6 +5126,40 @@ ast2obj_withitem(struct ast_state *state, void* _o)
}
PyObject*
+ast2obj_match_case(struct ast_state *state, void* _o)
+{
+ match_case_ty o = (match_case_ty)_o;
+ PyObject *result = NULL, *value = NULL;
+ PyTypeObject *tp;
+ if (!o) {
+ Py_RETURN_NONE;
+ }
+ tp = (PyTypeObject *)state->match_case_type;
+ result = PyType_GenericNew(tp, NULL, NULL);
+ if (!result) return NULL;
+ value = ast2obj_expr(state, o->pattern);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->pattern, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ value = ast2obj_expr(state, o->guard);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->guard, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ value = ast2obj_list(state, (asdl_seq*)o->body, ast2obj_stmt);
+ if (!value) goto failed;
+ if (PyObject_SetAttr(result, state->body, value) == -1)
+ goto failed;
+ Py_DECREF(value);
+ return result;
+failed:
+ Py_XDECREF(value);
+ Py_XDECREF(result);
+ return NULL;
+}
+
+PyObject*
ast2obj_type_ignore(struct ast_state *state, void* _o)
{
type_ignore_ty o = (type_ignore_ty)_o;
@@ -6581,6 +6813,66 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (*out == NULL) goto failed;
return 0;
}
+ tp = state->Match_type;
+ isinstance = PyObject_IsInstance(obj, tp);
+ if (isinstance == -1) {
+ return 1;
+ }
+ if (isinstance) {
+ expr_ty subject;
+ asdl_match_case_seq* cases;
+
+ if (_PyObject_LookupAttr(obj, state->subject, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"subject\" missing from Match");
+ return 1;
+ }
+ else {
+ int res;
+ res = obj2ast_expr(state, tmp, &subject, arena);
+ if (res != 0) goto failed;
+ Py_CLEAR(tmp);
+ }
+ if (_PyObject_LookupAttr(obj, state->cases, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"cases\" missing from Match");
+ return 1;
+ }
+ else {
+ int res;
+ Py_ssize_t len;
+ Py_ssize_t i;
+ if (!PyList_Check(tmp)) {
+ PyErr_Format(PyExc_TypeError, "Match field \"cases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+ goto failed;
+ }
+ len = PyList_GET_SIZE(tmp);
+ cases = _Py_asdl_match_case_seq_new(len, arena);
+ if (cases == NULL) goto failed;
+ for (i = 0; i < len; i++) {
+ match_case_ty val;
+ PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
+ Py_INCREF(tmp2);
+ res = obj2ast_match_case(state, tmp2, &val, arena);
+ Py_DECREF(tmp2);
+ if (res != 0) goto failed;
+ if (len != PyList_GET_SIZE(tmp)) {
+ PyErr_SetString(PyExc_RuntimeError, "Match field \"cases\" changed size during iteration");
+ goto failed;
+ }
+ asdl_seq_SET(cases, i, val);
+ }
+ Py_CLEAR(tmp);
+ }
+ *out = Match(subject, cases, lineno, col_offset, end_lineno,
+ end_col_offset, arena);
+ if (*out == NULL) goto failed;
+ return 0;
+ }
tp = state->Raise_type;
isinstance = PyObject_IsInstance(obj, tp);
if (isinstance == -1) {
@@ -8591,6 +8883,92 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena*
if (*out == NULL) goto failed;
return 0;
}
+ tp = state->MatchAs_type;
+ isinstance = PyObject_IsInstance(obj, tp);
+ if (isinstance == -1) {
+ return 1;
+ }
+ if (isinstance) {
+ expr_ty pattern;
+ identifier name;
+
+ if (_PyObject_LookupAttr(obj, state->pattern, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"pattern\" missing from MatchAs");
+ return 1;
+ }
+ else {
+ int res;
+ res = obj2ast_expr(state, tmp, &pattern, arena);
+ if (res != 0) goto failed;
+ Py_CLEAR(tmp);
+ }
+ if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"name\" missing from MatchAs");
+ return 1;
+ }
+ else {
+ int res;
+ res = obj2ast_identifier(state, tmp, &name, arena);
+ if (res != 0) goto failed;
+ Py_CLEAR(tmp);
+ }
+ *out = MatchAs(pattern, name, lineno, col_offset, end_lineno,
+ end_col_offset, arena);
+ if (*out == NULL) goto failed;
+ return 0;
+ }
+ tp = state->MatchOr_type;
+ isinstance = PyObject_IsInstance(obj, tp);
+ if (isinstance == -1) {
+ return 1;
+ }
+ if (isinstance) {
+ asdl_expr_seq* patterns;
+
+ if (_PyObject_LookupAttr(obj, state->patterns, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"patterns\" missing from MatchOr");
+ return 1;
+ }
+ else {
+ int res;
+ Py_ssize_t len;
+ Py_ssize_t i;
+ if (!PyList_Check(tmp)) {
+ PyErr_Format(PyExc_TypeError, "MatchOr field \"patterns\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+ goto failed;
+ }
+ len = PyList_GET_SIZE(tmp);
+ patterns = _Py_asdl_expr_seq_new(len, arena);
+ if (patterns == NULL) goto failed;
+ for (i = 0; i < len; i++) {
+ expr_ty val;
+ PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
+ Py_INCREF(tmp2);
+ res = obj2ast_expr(state, tmp2, &val, arena);
+ Py_DECREF(tmp2);
+ if (res != 0) goto failed;
+ if (len != PyList_GET_SIZE(tmp)) {
+ PyErr_SetString(PyExc_RuntimeError, "MatchOr field \"patterns\" changed size during iteration");
+ goto failed;
+ }
+ asdl_seq_SET(patterns, i, val);
+ }
+ Py_CLEAR(tmp);
+ }
+ *out = MatchOr(patterns, lineno, col_offset, end_lineno,
+ end_col_offset, arena);
+ if (*out == NULL) goto failed;
+ return 0;
+ }
PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj);
failed:
@@ -9652,6 +10030,81 @@ obj2ast_withitem(struct ast_state *state, PyObject* obj, withitem_ty* out,
}
int
+obj2ast_match_case(struct ast_state *state, PyObject* obj, match_case_ty* out,
+ PyArena* arena)
+{
+ PyObject* tmp = NULL;
+ expr_ty pattern;
+ expr_ty guard;
+ asdl_stmt_seq* body;
+
+ if (_PyObject_LookupAttr(obj, state->pattern, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"pattern\" missing from match_case");
+ return 1;
+ }
+ else {
+ int res;
+ res = obj2ast_expr(state, tmp, &pattern, arena);
+ if (res != 0) goto failed;
+ Py_CLEAR(tmp);
+ }
+ if (_PyObject_LookupAttr(obj, state->guard, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL || tmp == Py_None) {
+ Py_CLEAR(tmp);
+ guard = NULL;
+ }
+ else {
+ int res;
+ res = obj2ast_expr(state, tmp, &guard, arena);
+ if (res != 0) goto failed;
+ Py_CLEAR(tmp);
+ }
+ if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+ return 1;
+ }
+ if (tmp == NULL) {
+ PyErr_SetString(PyExc_TypeError, "required field \"body\" missing from match_case");
+ return 1;
+ }
+ else {
+ int res;
+ Py_ssize_t len;
+ Py_ssize_t i;
+ if (!PyList_Check(tmp)) {
+ PyErr_Format(PyExc_TypeError, "match_case field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+ goto failed;
+ }
+ len = PyList_GET_SIZE(tmp);
+ body = _Py_asdl_stmt_seq_new(len, arena);
+ if (body == NULL) goto failed;
+ for (i = 0; i < len; i++) {
+ stmt_ty val;
+ PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
+ Py_INCREF(tmp2);
+ res = obj2ast_stmt(state, tmp2, &val, arena);
+ Py_DECREF(tmp2);
+ if (res != 0) goto failed;
+ if (len != PyList_GET_SIZE(tmp)) {
+ PyErr_SetString(PyExc_RuntimeError, "match_case field \"body\" changed size during iteration");
+ goto failed;
+ }
+ asdl_seq_SET(body, i, val);
+ }
+ Py_CLEAR(tmp);
+ }
+ *out = match_case(pattern, guard, body, arena);
+ return 0;
+failed:
+ Py_XDECREF(tmp);
+ return 1;
+}
+
+int
obj2ast_type_ignore(struct ast_state *state, PyObject* obj, type_ignore_ty*
out, PyArena* arena)
{
@@ -9792,6 +10245,9 @@ astmodule_exec(PyObject *m)
if (PyModule_AddObjectRef(m, "AsyncWith", state->AsyncWith_type) < 0) {
return -1;
}
+ if (PyModule_AddObjectRef(m, "Match", state->Match_type) < 0) {
+ return -1;
+ }
if (PyModule_AddObjectRef(m, "Raise", state->Raise_type) < 0) {
return -1;
}
@@ -9911,6 +10367,12 @@ astmodule_exec(PyObject *m)
if (PyModule_AddObjectRef(m, "Slice", state->Slice_type) < 0) {
return -1;
}
+ if (PyModule_AddObjectRef(m, "MatchAs", state->MatchAs_type) < 0) {
+ return -1;
+ }
+ if (PyModule_AddObjectRef(m, "MatchOr", state->MatchOr_type) < 0) {
+ return -1;
+ }
if (PyModule_AddObjectRef(m, "expr_context", state->expr_context_type) < 0)
{
return -1;
@@ -10050,6 +10512,9 @@ astmodule_exec(PyObject *m)
if (PyModule_AddObjectRef(m, "withitem", state->withitem_type) < 0) {
return -1;
}
+ if (PyModule_AddObjectRef(m, "match_case", state->match_case_type) < 0) {
+ return -1;
+ }
if (PyModule_AddObjectRef(m, "type_ignore", state->type_ignore_type) < 0) {
return -1;
}
diff --git a/Python/ast.c b/Python/ast.c
index 5e74f65..c58b4a6 100644
--- a/Python/ast.c
+++ b/Python/ast.c
@@ -309,6 +309,14 @@ validate_expr(expr_ty exp, expr_context_ty ctx)
return validate_exprs(exp->v.Tuple.elts, ctx, 0);
case NamedExpr_kind:
return validate_expr(exp->v.NamedExpr.value, Load);
+ case MatchAs_kind:
+ PyErr_SetString(PyExc_ValueError,
+ "MatchAs is only valid in match_case patterns");
+ return 0;
+ case MatchOr_kind:
+ PyErr_SetString(PyExc_ValueError,
+ "MatchOr is only valid in match_case patterns");
+ return 0;
/* This last case doesn't have any checking. */
case Name_kind:
return 1;
@@ -318,6 +326,13 @@ validate_expr(expr_ty exp, expr_context_ty ctx)
}
static int
+validate_pattern(expr_ty p)
+{
+ // Coming soon (thanks Batuhan)!
+ return 1;
+}
+
+static int
_validate_nonempty_seq(asdl_seq *seq, const char *what, const char *owner)
{
if (asdl_seq_LEN(seq))
@@ -415,6 +430,20 @@ validate_stmt(stmt_ty stmt)
return 0;
}
return validate_body(stmt->v.AsyncWith.body, "AsyncWith");
+ case Match_kind:
+ if (!validate_expr(stmt->v.Match.subject, Load)
+ || !validate_nonempty_seq(stmt->v.Match.cases, "cases", "Match")) {
+ return 0;
+ }
+ for (i = 0; i < asdl_seq_LEN(stmt->v.Match.cases); i++) {
+ match_case_ty m = asdl_seq_GET(stmt->v.Match.cases, i);
+ if (!validate_pattern(m->pattern)
+ || (m->guard && !validate_expr(m->guard, Load))
+ || !validate_body(m->body, "match_case")) {
+ return 0;
+ }
+ }
+ return 1;
case Raise_kind:
if (stmt->v.Raise.exc) {
return validate_expr(stmt->v.Raise.exc, Load) &&
diff --git a/Python/ast_opt.c b/Python/ast_opt.c
index 8c958ca..6ad00dc 100644
--- a/Python/ast_opt.c
+++ b/Python/ast_opt.c
@@ -408,6 +408,9 @@ static int astfold_comprehension(comprehension_ty node_, PyArena *ctx_, _PyASTOp
static int astfold_keyword(keyword_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_withitem(withitem_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_excepthandler(excepthandler_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
+static int astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
+static int astfold_pattern(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
+
#define CALL(FUNC, TYPE, ARG) \
if (!FUNC((ARG), ctx_, state)) \
return 0;
@@ -590,6 +593,10 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
case Constant_kind:
// Already a constant, nothing further to do
break;
+ case MatchAs_kind:
+ case MatchOr_kind:
+ // These can't occur outside of patterns.
+ Py_UNREACHABLE();
// No default case, so the compiler will emit a warning if new expression
// kinds are added without being handled here
}
@@ -709,6 +716,10 @@ astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
case Expr_kind:
CALL(astfold_expr, expr_ty, node_->v.Expr.value);
break;
+ case Match_kind:
+ CALL(astfold_expr, expr_ty, node_->v.Match.subject);
+ CALL_SEQ(astfold_match_case, match_case, node_->v.Match.cases);
+ break;
// The following statements don't contain any subexpressions to be folded
case Import_kind:
case ImportFrom_kind:
@@ -746,6 +757,125 @@ astfold_withitem(withitem_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
return 1;
}
+static int
+astfold_pattern_negative(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
+{
+ assert(node_->kind == UnaryOp_kind);
+ assert(node_->v.UnaryOp.op == USub);
+ assert(node_->v.UnaryOp.operand->kind == Constant_kind);
+ PyObject *value = node_->v.UnaryOp.operand->v.Constant.value;
+ assert(PyComplex_CheckExact(value) ||
+ PyFloat_CheckExact(value) ||
+ PyLong_CheckExact(value));
+ PyObject *negated = PyNumber_Negative(value);
+ if (negated == NULL) {
+ return 0;
+ }
+ assert(PyComplex_CheckExact(negated) ||
+ PyFloat_CheckExact(negated) ||
+ PyLong_CheckExact(negated));
+ return make_const(node_, negated, ctx_);
+}
+
+static int
+astfold_pattern_complex(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
+{
+ expr_ty left = node_->v.BinOp.left;
+ expr_ty right = node_->v.BinOp.right;
+ if (left->kind == UnaryOp_kind) {
+ CALL(astfold_pattern_negative, expr_ty, left);
+ }
+ assert(left->kind = Constant_kind);
+ assert(right->kind = Constant_kind);
+ // LHS must be real, RHS must be imaginary:
+ if (!(PyFloat_CheckExact(left->v.Constant.value) ||
+ PyLong_CheckExact(left->v.Constant.value)) ||
+ !PyComplex_CheckExact(right->v.Constant.value))
+ {
+ // Not actually valid, but it's the compiler's job to complain:
+ return 1;
+ }
+ PyObject *new;
+ if (node_->v.BinOp.op == Add) {
+ new = PyNumber_Add(left->v.Constant.value, right->v.Constant.value);
+ }
+ else {
+ assert(node_->v.BinOp.op == Sub);
+ new = PyNumber_Subtract(left->v.Constant.value, right->v.Constant.value);
+ }
+ if (new == NULL) {
+ return 0;
+ }
+ assert(PyComplex_CheckExact(new));
+ return make_const(node_, new, ctx_);
+}
+
+static int
+astfold_pattern_keyword(keyword_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
+{
+ CALL(astfold_pattern, expr_ty, node_->value);
+ return 1;
+}
+
+static int
+astfold_pattern(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
+{
+ // Don't blindly optimize the pattern as an expr; it plays by its own rules!
+ // Currently, this is only used to form complex/negative numeric constants.
+ switch (node_->kind) {
+ case Attribute_kind:
+ break;
+ case BinOp_kind:
+ CALL(astfold_pattern_complex, expr_ty, node_);
+ break;
+ case Call_kind:
+ CALL_SEQ(astfold_pattern, expr, node_->v.Call.args);
+ CALL_SEQ(astfold_pattern_keyword, keyword, node_->v.Call.keywords);
+ break;
+ case Constant_kind:
+ break;
+ case Dict_kind:
+ CALL_SEQ(astfold_pattern, expr, node_->v.Dict.keys);
+ CALL_SEQ(astfold_pattern, expr, node_->v.Dict.values);
+ break;
+ // Not actually valid, but it's the compiler's job to complain:
+ case JoinedStr_kind:
+ break;
+ case List_kind:
+ CALL_SEQ(astfold_pattern, expr, node_->v.List.elts);
+ break;
+ case MatchAs_kind:
+ CALL(astfold_pattern, expr_ty, node_->v.MatchAs.pattern);
+ break;
+ case MatchOr_kind:
+ CALL_SEQ(astfold_pattern, expr, node_->v.MatchOr.patterns);
+ break;
+ case Name_kind:
+ break;
+ case Starred_kind:
+ CALL(astfold_pattern, expr_ty, node_->v.Starred.value);
+ break;
+ case Tuple_kind:
+ CALL_SEQ(astfold_pattern, expr, node_->v.Tuple.elts);
+ break;
+ case UnaryOp_kind:
+ CALL(astfold_pattern_negative, expr_ty, node_);
+ break;
+ default:
+ Py_UNREACHABLE();
+ }
+ return 1;
+}
+
+static int
+astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
+{
+ CALL(astfold_pattern, expr_ty, node_->pattern);
+ CALL_OPT(astfold_expr, expr_ty, node_->guard);
+ CALL_SEQ(astfold_stmt, stmt, node_->body);
+ return 1;
+}
+
#undef CALL
#undef CALL_OPT
#undef CALL_SEQ
diff --git a/Python/ceval.c b/Python/ceval.c
index e1a8f15..7862643 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -880,6 +880,230 @@ _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
return 0;
}
+
+// PEP 634: Structural Pattern Matching
+
+
+// Return a tuple of values corresponding to keys, with error checks for
+// duplicate/missing keys.
+static PyObject*
+match_keys(PyThreadState *tstate, PyObject *map, PyObject *keys)
+{
+ assert(PyTuple_CheckExact(keys));
+ Py_ssize_t nkeys = PyTuple_GET_SIZE(keys);
+ if (!nkeys) {
+ // No keys means no items.
+ return PyTuple_New(0);
+ }
+ PyObject *seen = NULL;
+ PyObject *dummy = NULL;
+ PyObject *values = NULL;
+ // We use the two argument form of map.get(key, default) for two reasons:
+ // - Atomically check for a key and get its value without error handling.
+ // - Don't cause key creation or resizing in dict subclasses like
+ // collections.defaultdict that define __missing__ (or similar).
+ _Py_IDENTIFIER(get);
+ PyObject *get = _PyObject_GetAttrId(map, &PyId_get);
+ if (get == NULL) {
+ goto fail;
+ }
+ seen = PySet_New(NULL);
+ if (seen == NULL) {
+ goto fail;
+ }
+ // dummy = object()
+ dummy = _PyObject_CallNoArg((PyObject *)&PyBaseObject_Type);
+ if (dummy == NULL) {
+ goto fail;
+ }
+ values = PyList_New(0);
+ if (values == NULL) {
+ goto fail;
+ }
+ for (Py_ssize_t i = 0; i < nkeys; i++) {
+ PyObject *key = PyTuple_GET_ITEM(keys, i);
+ if (PySet_Contains(seen, key) || PySet_Add(seen, key)) {
+ if (!_PyErr_Occurred(tstate)) {
+ // Seen it before!
+ _PyErr_Format(tstate, PyExc_ValueError,
+ "mapping pattern checks duplicate key (%R)", key);
+ }
+ goto fail;
+ }
+ PyObject *value = PyObject_CallFunctionObjArgs(get, key, dummy, NULL);
+ if (value == NULL) {
+ goto fail;
+ }
+ if (value == dummy) {
+ // key not in map!
+ Py_DECREF(value);
+ Py_DECREF(values);
+ // Return None:
+ Py_INCREF(Py_None);
+ values = Py_None;
+ goto done;
+ }
+ PyList_Append(values, value);
+ Py_DECREF(value);
+ }
+ Py_SETREF(values, PyList_AsTuple(values));
+ // Success:
+done:
+ Py_DECREF(get);
+ Py_DECREF(seen);
+ Py_DECREF(dummy);
+ return values;
+fail:
+ Py_XDECREF(get);
+ Py_XDECREF(seen);
+ Py_XDECREF(dummy);
+ Py_XDECREF(values);
+ return NULL;
+}
+
+// Extract a named attribute from the subject, with additional bookkeeping to
+// raise TypeErrors for repeated lookups. On failure, return NULL (with no
+// error set). Use _PyErr_Occurred(tstate) to disambiguate.
+static PyObject*
+match_class_attr(PyThreadState *tstate, PyObject *subject, PyObject *type,
+ PyObject *name, PyObject *seen)
+{
+ assert(PyUnicode_CheckExact(name));
+ assert(PySet_CheckExact(seen));
+ if (PySet_Contains(seen, name) || PySet_Add(seen, name)) {
+ if (!_PyErr_Occurred(tstate)) {
+ // Seen it before!
+ _PyErr_Format(tstate, PyExc_TypeError,
+ "%s() got multiple sub-patterns for attribute %R",
+ ((PyTypeObject*)type)->tp_name, name);
+ }
+ return NULL;
+ }
+ PyObject *attr = PyObject_GetAttr(subject, name);
+ if (attr == NULL && _PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
+ _PyErr_Clear(tstate);
+ }
+ return attr;
+}
+
+// On success (match), return a tuple of extracted attributes. On failure (no
+// match), return NULL. Use _PyErr_Occurred(tstate) to disambiguate.
+static PyObject*
+match_class(PyThreadState *tstate, PyObject *subject, PyObject *type,
+ Py_ssize_t nargs, PyObject *kwargs)
+{
+ if (!PyType_Check(type)) {
+ const char *e = "called match pattern must be a type";
+ _PyErr_Format(tstate, PyExc_TypeError, e);
+ return NULL;
+ }
+ assert(PyTuple_CheckExact(kwargs));
+ // First, an isinstance check:
+ if (PyObject_IsInstance(subject, type) <= 0) {
+ return NULL;
+ }
+ // So far so good:
+ PyObject *seen = PySet_New(NULL);
+ if (seen == NULL) {
+ return NULL;
+ }
+ PyObject *attrs = PyList_New(0);
+ if (attrs == NULL) {
+ Py_DECREF(seen);
+ return NULL;
+ }
+ // NOTE: From this point on, goto fail on failure:
+ PyObject *match_args = NULL;
+ // First, the positional subpatterns:
+ if (nargs) {
+ int match_self = 0;
+ match_args = PyObject_GetAttrString(type, "__match_args__");
+ if (match_args) {
+ if (PyList_CheckExact(match_args)) {
+ Py_SETREF(match_args, PyList_AsTuple(match_args));
+ }
+ if (match_args == NULL) {
+ goto fail;
+ }
+ if (!PyTuple_CheckExact(match_args)) {
+ const char *e = "%s.__match_args__ must be a list or tuple "
+ "(got %s)";
+ _PyErr_Format(tstate, PyExc_TypeError, e,
+ ((PyTypeObject *)type)->tp_name,
+ Py_TYPE(match_args)->tp_name);
+ goto fail;
+ }
+ }
+ else if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
+ _PyErr_Clear(tstate);
+ // _Py_TPFLAGS_MATCH_SELF is only acknowledged if the type does not
+ // define __match_args__. This is natural behavior for subclasses:
+ // it's as if __match_args__ is some "magic" value that is lost as
+ // soon as they redefine it.
+ match_args = PyTuple_New(0);
+ match_self = PyType_HasFeature((PyTypeObject*)type,
+ _Py_TPFLAGS_MATCH_SELF);
+ }
+ else {
+ goto fail;
+ }
+ assert(PyTuple_CheckExact(match_args));
+ Py_ssize_t allowed = match_self ? 1 : PyTuple_GET_SIZE(match_args);
+ if (allowed < nargs) {
+ const char *plural = (allowed == 1) ? "" : "s";
+ _PyErr_Format(tstate, PyExc_TypeError,
+ "%s() accepts %d positional sub-pattern%s (%d given)",
+ ((PyTypeObject*)type)->tp_name,
+ allowed, plural, nargs);
+ goto fail;
+ }
+ if (match_self) {
+ // Easy. Copy the subject itself, and move on to kwargs.
+ PyList_Append(attrs, subject);
+ }
+ else {
+ for (Py_ssize_t i = 0; i < nargs; i++) {
+ PyObject *name = PyTuple_GET_ITEM(match_args, i);
+ if (!PyUnicode_CheckExact(name)) {
+ _PyErr_Format(tstate, PyExc_TypeError,
+ "__match_args__ elements must be strings "
+ "(got %s)", Py_TYPE(name)->tp_name);
+ goto fail;
+ }
+ PyObject *attr = match_class_attr(tstate, subject, type, name,
+ seen);
+ if (attr == NULL) {
+ goto fail;
+ }
+ PyList_Append(attrs, attr);
+ Py_DECREF(attr);
+ }
+ }
+ Py_CLEAR(match_args);
+ }
+ // Finally, the keyword subpatterns:
+ for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(kwargs); i++) {
+ PyObject *name = PyTuple_GET_ITEM(kwargs, i);
+ PyObject *attr = match_class_attr(tstate, subject, type, name, seen);
+ if (attr == NULL) {
+ goto fail;
+ }
+ PyList_Append(attrs, attr);
+ Py_DECREF(attr);
+ }
+ Py_SETREF(attrs, PyList_AsTuple(attrs));
+ Py_DECREF(seen);
+ return attrs;
+fail:
+ // We really don't care whether an error was raised or not... that's our
+ // caller's problem. All we know is that the match failed.
+ Py_XDECREF(match_args);
+ Py_DECREF(seen);
+ Py_DECREF(attrs);
+ return NULL;
+}
+
+
static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause);
static int unpack_iterable(PyThreadState *, PyObject *, int, int, PyObject **);
@@ -3618,6 +3842,164 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
#endif
}
+ case TARGET(GET_LEN): {
+ // PUSH(len(TOS))
+ Py_ssize_t len_i = PyObject_Length(TOP());
+ if (len_i < 0) {
+ goto error;
+ }
+ PyObject *len_o = PyLong_FromSsize_t(len_i);
+ if (len_o == NULL) {
+ goto error;
+ }
+ PUSH(len_o);
+ DISPATCH();
+ }
+
+ case TARGET(MATCH_CLASS): {
+ // Pop TOS. On success, set TOS to True and TOS1 to a tuple of
+ // attributes. On failure, set TOS to False.
+ PyObject *names = POP();
+ PyObject *type = TOP();
+ PyObject *subject = SECOND();
+ assert(PyTuple_CheckExact(names));
+ PyObject *attrs = match_class(tstate, subject, type, oparg, names);
+ Py_DECREF(names);
+ if (attrs) {
+ // Success!
+ assert(PyTuple_CheckExact(attrs));
+ Py_DECREF(subject);
+ SET_SECOND(attrs);
+ }
+ else if (_PyErr_Occurred(tstate)) {
+ goto error;
+ }
+ Py_DECREF(type);
+ SET_TOP(PyBool_FromLong(!!attrs));
+ DISPATCH();
+ }
+
+ case TARGET(MATCH_MAPPING): {
+ // PUSH(isinstance(TOS, _collections_abc.Mapping))
+ PyObject *subject = TOP();
+ // Fast path for dicts:
+ if (PyDict_Check(subject)) {
+ Py_INCREF(Py_True);
+ PUSH(Py_True);
+ DISPATCH();
+ }
+ // Lazily import _collections_abc.Mapping, and keep it handy on the
+ // PyInterpreterState struct (it gets cleaned up at exit):
+ PyInterpreterState *interp = PyInterpreterState_Get();
+ if (interp->map_abc == NULL) {
+ PyObject *abc = PyImport_ImportModule("_collections_abc");
+ if (abc == NULL) {
+ goto error;
+ }
+ interp->map_abc = PyObject_GetAttrString(abc, "Mapping");
+ if (interp->map_abc == NULL) {
+ goto error;
+ }
+ }
+ int match = PyObject_IsInstance(subject, interp->map_abc);
+ if (match < 0) {
+ goto error;
+ }
+ PUSH(PyBool_FromLong(match));
+ DISPATCH();
+ }
+
+ case TARGET(MATCH_SEQUENCE): {
+ // PUSH(not isinstance(TOS, (bytearray, bytes, str))
+ // and isinstance(TOS, _collections_abc.Sequence))
+ PyObject *subject = TOP();
+ // Fast path for lists and tuples:
+ if (PyType_FastSubclass(Py_TYPE(subject),
+ Py_TPFLAGS_LIST_SUBCLASS |
+ Py_TPFLAGS_TUPLE_SUBCLASS))
+ {
+ Py_INCREF(Py_True);
+ PUSH(Py_True);
+ DISPATCH();
+ }
+ // Bail on some possible Sequences that we intentionally exclude:
+ if (PyType_FastSubclass(Py_TYPE(subject),
+ Py_TPFLAGS_BYTES_SUBCLASS |
+ Py_TPFLAGS_UNICODE_SUBCLASS) ||
+ PyByteArray_Check(subject))
+ {
+ Py_INCREF(Py_False);
+ PUSH(Py_False);
+ DISPATCH();
+ }
+ // Lazily import _collections_abc.Sequence, and keep it handy on the
+ // PyInterpreterState struct (it gets cleaned up at exit):
+ PyInterpreterState *interp = PyInterpreterState_Get();
+ if (interp->seq_abc == NULL) {
+ PyObject *abc = PyImport_ImportModule("_collections_abc");
+ if (abc == NULL) {
+ goto error;
+ }
+ interp->seq_abc = PyObject_GetAttrString(abc, "Sequence");
+ if (interp->seq_abc == NULL) {
+ goto error;
+ }
+ }
+ int match = PyObject_IsInstance(subject, interp->seq_abc);
+ if (match < 0) {
+ goto error;
+ }
+ PUSH(PyBool_FromLong(match));
+ DISPATCH();
+ }
+
+ case TARGET(MATCH_KEYS): {
+ // On successful match for all keys, PUSH(values) and PUSH(True).
+ // Otherwise, PUSH(None) and PUSH(False).
+ PyObject *keys = TOP();
+ PyObject *subject = SECOND();
+ PyObject *values_or_none = match_keys(tstate, subject, keys);
+ if (values_or_none == NULL) {
+ goto error;
+ }
+ PUSH(values_or_none);
+ if (values_or_none == Py_None) {
+ Py_INCREF(Py_False);
+ PUSH(Py_False);
+ DISPATCH();
+ }
+ assert(PyTuple_CheckExact(values_or_none));
+ Py_INCREF(Py_True);
+ PUSH(Py_True);
+ DISPATCH();
+ }
+
+ case TARGET(COPY_DICT_WITHOUT_KEYS): {
+ // rest = dict(TOS1)
+ // for key in TOS:
+ // del rest[key]
+ // SET_TOP(rest)
+ PyObject *keys = TOP();
+ PyObject *subject = SECOND();
+ PyObject *rest = PyDict_New();
+ if (rest == NULL || PyDict_Update(rest, subject)) {
+ Py_XDECREF(rest);
+ goto error;
+ }
+ // This may seem a bit inefficient, but keys is rarely big enough to
+ // actually impact runtime.
+ assert(PyTuple_CheckExact(keys));
+ for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(keys); i++) {
+ if (PyDict_DelItem(rest, PyTuple_GET_ITEM(keys, i))) {
+ Py_DECREF(rest);
+ goto error;
+ }
+ }
+ Py_DECREF(keys);
+ SET_TOP(rest);
+ DISPATCH();
+ }
+
case TARGET(GET_ITER): {
/* before: [obj]; after [getiter(obj)] */
PyObject *iterable = TOP();
diff --git a/Python/compile.c b/Python/compile.c
index 386c552..454005e 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -202,6 +202,11 @@ struct compiler {
PyArena *c_arena; /* pointer to memory allocation arena */
};
+typedef struct {
+ PyObject *stores;
+ int allow_irrefutable;
+} pattern_context;
+
static int compiler_enter_scope(struct compiler *, identifier, int, void *, int);
static void compiler_free(struct compiler *);
static basicblock *compiler_new_block(struct compiler *);
@@ -210,7 +215,7 @@ static int compiler_addop(struct compiler *, int);
static int compiler_addop_i(struct compiler *, int, Py_ssize_t);
static int compiler_addop_j(struct compiler *, int, basicblock *);
static int compiler_addop_j_noline(struct compiler *, int, basicblock *);
-static int compiler_error(struct compiler *, const char *);
+static int compiler_error(struct compiler *, const char *, ...);
static int compiler_warn(struct compiler *, const char *, ...);
static int compiler_nameop(struct compiler *, identifier, expr_context_ty);
@@ -248,6 +253,11 @@ static int compiler_async_comprehension_generator(
int depth,
expr_ty elt, expr_ty val, int type);
+static int compiler_pattern(struct compiler *, expr_ty, pattern_context *);
+static int compiler_match(struct compiler *, stmt_ty);
+static int compiler_pattern_subpattern(struct compiler *, expr_ty,
+ pattern_context *);
+
static PyCodeObject *assemble(struct compiler *, int addNone);
static PyObject *__doc__, *__annotations__;
@@ -1150,6 +1160,16 @@ stack_effect(int opcode, int oparg, int jump)
case DICT_MERGE:
case DICT_UPDATE:
return -1;
+ case COPY_DICT_WITHOUT_KEYS:
+ return 0;
+ case MATCH_CLASS:
+ return -1;
+ case GET_LEN:
+ case MATCH_MAPPING:
+ case MATCH_SEQUENCE:
+ return 1;
+ case MATCH_KEYS:
+ return 2;
default:
return PY_INVALID_STACK_EFFECT;
}
@@ -1580,6 +1600,11 @@ compiler_addop_j_noline(struct compiler *c, int opcode, basicblock *b)
} \
}
+#define RETURN_IF_FALSE(X) \
+ if (!(X)) { \
+ return 0; \
+ }
+
/* Search if variable annotations are present statically in a block. */
static int
@@ -3414,6 +3439,8 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s)
return compiler_while(c, s);
case If_kind:
return compiler_if(c, s);
+ case Match_kind:
+ return compiler_match(c, s);
case Raise_kind:
n = 0;
if (s->v.Raise.exc) {
@@ -3758,12 +3785,11 @@ starunpack_helper(struct compiler *c, asdl_expr_seq *elts, int pushed,
}
static int
-assignment_helper(struct compiler *c, asdl_expr_seq *elts)
+unpack_helper(struct compiler *c, asdl_expr_seq *elts)
{
Py_ssize_t n = asdl_seq_LEN(elts);
- Py_ssize_t i;
int seen_star = 0;
- for (i = 0; i < n; i++) {
+ for (Py_ssize_t i = 0; i < n; i++) {
expr_ty elt = asdl_seq_GET(elts, i);
if (elt->kind == Starred_kind && !seen_star) {
if ((i >= (1 << 8)) ||
@@ -3782,7 +3808,15 @@ assignment_helper(struct compiler *c, asdl_expr_seq *elts)
if (!seen_star) {
ADDOP_I(c, UNPACK_SEQUENCE, n);
}
- for (i = 0; i < n; i++) {
+ return 1;
+}
+
+static int
+assignment_helper(struct compiler *c, asdl_expr_seq *elts)
+{
+ Py_ssize_t n = asdl_seq_LEN(elts);
+ RETURN_IF_FALSE(unpack_helper(c, elts));
+ for (Py_ssize_t i = 0; i < n; i++) {
expr_ty elt = asdl_seq_GET(elts, i);
VISIT(c, expr, elt->kind != Starred_kind ? elt : elt->v.Starred.value);
}
@@ -4132,13 +4166,8 @@ validate_keywords(struct compiler *c, asdl_keyword_seq *keywords)
for (Py_ssize_t j = i + 1; j < nkeywords; j++) {
keyword_ty other = ((keyword_ty)asdl_seq_GET(keywords, j));
if (other->arg && !PyUnicode_Compare(key->arg, other->arg)) {
- PyObject *msg = PyUnicode_FromFormat("keyword argument repeated: %U", key->arg);
- if (msg == NULL) {
- return -1;
- }
c->u->u_col_offset = other->col_offset;
- compiler_error(c, PyUnicode_AsUTF8(msg));
- Py_DECREF(msg);
+ compiler_error(c, "keyword argument repeated: %U", key->arg);
return -1;
}
}
@@ -5119,6 +5148,10 @@ compiler_visit_expr1(struct compiler *c, expr_ty e)
return compiler_list(c, e);
case Tuple_kind:
return compiler_tuple(c, e);
+ case MatchAs_kind:
+ case MatchOr_kind:
+ // Can only occur in patterns, which are handled elsewhere.
+ Py_UNREACHABLE();
}
return 1;
}
@@ -5305,28 +5338,34 @@ compiler_annassign(struct compiler *c, stmt_ty s)
*/
static int
-compiler_error(struct compiler *c, const char *errstr)
+compiler_error(struct compiler *c, const char *format, ...)
{
- PyObject *loc;
- PyObject *u = NULL, *v = NULL;
-
- loc = PyErr_ProgramTextObject(c->c_filename, c->u->u_lineno);
- if (!loc) {
+ va_list vargs;
+#ifdef HAVE_STDARG_PROTOTYPES
+ va_start(vargs, format);
+#else
+ va_start(vargs);
+#endif
+ PyObject *msg = PyUnicode_FromFormatV(format, vargs);
+ va_end(vargs);
+ if (msg == NULL) {
+ return 0;
+ }
+ PyObject *loc = PyErr_ProgramTextObject(c->c_filename, c->u->u_lineno);
+ if (loc == NULL) {
Py_INCREF(Py_None);
loc = Py_None;
}
- u = Py_BuildValue("(OiiO)", c->c_filename, c->u->u_lineno,
- c->u->u_col_offset + 1, loc);
- if (!u)
+ PyObject *args = Py_BuildValue("O(OiiO)", msg, c->c_filename,
+ c->u->u_lineno, c->u->u_col_offset + 1, loc);
+ Py_DECREF(msg);
+ if (args == NULL) {
goto exit;
- v = Py_BuildValue("(zO)", errstr, u);
- if (!v)
- goto exit;
- PyErr_SetObject(PyExc_SyntaxError, v);
+ }
+ PyErr_SetObject(PyExc_SyntaxError, args);
exit:
Py_DECREF(loc);
- Py_XDECREF(u);
- Py_XDECREF(v);
+ Py_XDECREF(args);
return 0;
}
@@ -5421,6 +5460,654 @@ compiler_slice(struct compiler *c, expr_ty s)
return 1;
}
+
+// PEP 634: Structural Pattern Matching
+
+// To keep things simple, all compiler_pattern_* routines follow the convention
+// of replacing TOS (the subject for the given pattern) with either True (match)
+// or False (no match). We do this even for irrefutable patterns; the idea is
+// that it's much easier to smooth out any redundant pushing, popping, and
+// jumping in the peephole optimizer than to detect or predict it here.
+
+
+#define WILDCARD_CHECK(N) \
+ ((N)->kind == Name_kind && \
+ _PyUnicode_EqualToASCIIString((N)->v.Name.id, "_"))
+
+
+static int
+pattern_helper_store_name(struct compiler *c, identifier n, pattern_context *pc)
+{
+ assert(!_PyUnicode_EqualToASCIIString(n, "_"));
+ // Can't assign to the same name twice:
+ if (pc->stores == NULL) {
+ RETURN_IF_FALSE(pc->stores = PySet_New(NULL));
+ }
+ else {
+ int duplicate = PySet_Contains(pc->stores, n);
+ if (duplicate < 0) {
+ return 0;
+ }
+ if (duplicate) {
+ const char *e = "multiple assignments to name %R in pattern";
+ return compiler_error(c, e, n);
+ }
+ }
+ RETURN_IF_FALSE(!PySet_Add(pc->stores, n));
+ RETURN_IF_FALSE(compiler_nameop(c, n, Store));
+ return 1;
+}
+
+
+static int
+pattern_helper_sequence_unpack(struct compiler *c, asdl_expr_seq *values,
+ Py_ssize_t star, pattern_context *pc)
+{
+ RETURN_IF_FALSE(unpack_helper(c, values));
+ // We've now got a bunch of new subjects on the stack. If any of them fail
+ // to match, we need to pop everything else off, then finally push False.
+ // fails is an array of blocks that correspond to the necessary amount of
+ // popping for each element:
+ basicblock **fails;
+ Py_ssize_t size = asdl_seq_LEN(values);
+ fails = (basicblock **)PyObject_Malloc(sizeof(basicblock*) * size);
+ if (fails == NULL) {
+ PyErr_NoMemory();
+ return 0;
+ }
+ // NOTE: Can't use our nice returning macros anymore: they'll leak memory!
+ // goto error on error.
+ for (Py_ssize_t i = 0; i < size; i++) {
+ fails[i] = compiler_new_block(c);
+ if (fails[i] == NULL) {
+ goto error;
+ }
+ }
+ for (Py_ssize_t i = 0; i < size; i++) {
+ expr_ty value = asdl_seq_GET(values, i);
+ if (i == star) {
+ assert(value->kind == Starred_kind);
+ value = value->v.Starred.value;
+ }
+ if (!compiler_pattern_subpattern(c, value, pc) ||
+ !compiler_addop_j(c, POP_JUMP_IF_FALSE, fails[i]) ||
+ compiler_next_block(c) == NULL)
+ {
+ goto error;
+ }
+ }
+ // Success!
+ basicblock *end = compiler_new_block(c);
+ if (end == NULL ||
+ !compiler_addop_load_const(c, Py_True) ||
+ !compiler_addop_j(c, JUMP_FORWARD, end))
+ {
+ goto error;
+ }
+ // This is where we handle failed sub-patterns. For a sequence pattern like
+ // [a, b, c, d], this will look like:
+ // fails[0]: POP_TOP
+ // fails[1]: POP_TOP
+ // fails[2]: POP_TOP
+ // fails[3]: LOAD_CONST False
+ for (Py_ssize_t i = 0; i < size - 1; i++) {
+ compiler_use_next_block(c, fails[i]);
+ if (!compiler_addop(c, POP_TOP)) {
+ goto error;
+ }
+ }
+ compiler_use_next_block(c, fails[size - 1]);
+ if (!compiler_addop_load_const(c, Py_False)) {
+ goto error;
+ }
+ compiler_use_next_block(c, end);
+ PyObject_Free(fails);
+ return 1;
+error:
+ PyObject_Free(fails);
+ return 0;
+}
+
+// Like pattern_helper_sequence_unpack, but uses BINARY_SUBSCR instead of
+// UNPACK_SEQUENCE / UNPACK_EX. This is more efficient for patterns with a
+// starred wildcard like [first, *_] / [first, *_, last] / [*_, last] / etc.
+static int
+pattern_helper_sequence_subscr(struct compiler *c, asdl_expr_seq *values,
+ Py_ssize_t star, pattern_context *pc)
+{
+ basicblock *end, *fail_pop_1;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ RETURN_IF_FALSE(fail_pop_1 = compiler_new_block(c));
+ Py_ssize_t size = asdl_seq_LEN(values);
+ for (Py_ssize_t i = 0; i < size; i++) {
+ expr_ty value = asdl_seq_GET(values, i);
+ if (WILDCARD_CHECK(value)) {
+ continue;
+ }
+ if (i == star) {
+ assert(value->kind == Starred_kind);
+ assert(WILDCARD_CHECK(value->v.Starred.value));
+ continue;
+ }
+ ADDOP(c, DUP_TOP);
+ if (i < star) {
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(i));
+ }
+ else {
+ // The subject may not support negative indexing! Compute a
+ // nonnegative index:
+ ADDOP(c, GET_LEN);
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size - i));
+ ADDOP(c, BINARY_SUBTRACT);
+ }
+ ADDOP(c, BINARY_SUBSCR);
+ RETURN_IF_FALSE(compiler_pattern_subpattern(c, value, pc));
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ }
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, fail_pop_1);
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_False);
+ compiler_use_next_block(c, end);
+ return 1;
+}
+
+
+// Like compiler_pattern, but turn off checks for irrefutability.
+static int
+compiler_pattern_subpattern(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ int allow_irrefutable = pc->allow_irrefutable;
+ pc->allow_irrefutable = 1;
+ RETURN_IF_FALSE(compiler_pattern(c, p, pc));
+ pc->allow_irrefutable = allow_irrefutable;
+ return 1;
+}
+
+
+static int
+compiler_pattern_as(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == MatchAs_kind);
+ basicblock *end, *fail_pop_1;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ RETURN_IF_FALSE(fail_pop_1 = compiler_new_block(c));
+ // Need to make a copy for (possibly) storing later:
+ ADDOP(c, DUP_TOP);
+ RETURN_IF_FALSE(compiler_pattern(c, p->v.MatchAs.pattern, pc));
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ RETURN_IF_FALSE(pattern_helper_store_name(c, p->v.MatchAs.name, pc));
+ ADDOP_LOAD_CONST(c, Py_True);
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, fail_pop_1);
+ // Need to pop that unused copy from before:
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_False);
+ compiler_use_next_block(c, end);
+ return 1;
+}
+
+
+static int
+compiler_pattern_capture(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == Name_kind);
+ assert(p->v.Name.ctx == Store);
+ assert(!WILDCARD_CHECK(p));
+ if (!pc->allow_irrefutable) {
+ // Whoops, can't have a name capture here!
+ const char *e = "name capture %R makes remaining patterns unreachable";
+ return compiler_error(c, e, p->v.Name.id);
+ }
+ RETURN_IF_FALSE(pattern_helper_store_name(c, p->v.Name.id, pc));
+ ADDOP_LOAD_CONST(c, Py_True);
+ return 1;
+}
+
+
+static int
+compiler_pattern_class(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ asdl_expr_seq *args = p->v.Call.args;
+ asdl_keyword_seq *kwargs = p->v.Call.keywords;
+ Py_ssize_t nargs = asdl_seq_LEN(args);
+ Py_ssize_t nkwargs = asdl_seq_LEN(kwargs);
+ if (INT_MAX < nargs || INT_MAX < nargs + nkwargs - 1) {
+ const char *e = "too many sub-patterns in class pattern %R";
+ return compiler_error(c, e, p->v.Call.func);
+ }
+ RETURN_IF_FALSE(!validate_keywords(c, kwargs));
+ basicblock *end, *fail_pop_1;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ RETURN_IF_FALSE(fail_pop_1 = compiler_new_block(c));
+ VISIT(c, expr, p->v.Call.func);
+ PyObject *kwnames;
+ RETURN_IF_FALSE(kwnames = PyTuple_New(nkwargs));
+ Py_ssize_t i;
+ for (i = 0; i < nkwargs; i++) {
+ PyObject *name = ((keyword_ty) asdl_seq_GET(kwargs, i))->arg;
+ Py_INCREF(name);
+ PyTuple_SET_ITEM(kwnames, i, name);
+ }
+ ADDOP_LOAD_CONST_NEW(c, kwnames);
+ ADDOP_I(c, MATCH_CLASS, nargs);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ // TOS is now a tuple of (nargs + nkwargs) attributes.
+ for (i = 0; i < nargs + nkwargs; i++) {
+ expr_ty arg;
+ if (i < nargs) {
+ // Positional:
+ arg = asdl_seq_GET(args, i);
+ }
+ else {
+ // Keyword:
+ arg = ((keyword_ty) asdl_seq_GET(kwargs, i - nargs))->value;
+ }
+ if (WILDCARD_CHECK(arg)) {
+ continue;
+ }
+ // Get the i-th attribute, and match it against the i-th pattern:
+ ADDOP(c, DUP_TOP);
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(i));
+ ADDOP(c, BINARY_SUBSCR);
+ RETURN_IF_FALSE(compiler_pattern_subpattern(c, arg, pc));
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ }
+ // Success! Pop the tuple of attributes:
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, fail_pop_1);
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_False);
+ compiler_use_next_block(c, end);
+ return 1;
+}
+
+
+static int
+compiler_pattern_literal(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == Constant_kind);
+ PyObject *v = p->v.Constant.value;
+ ADDOP_LOAD_CONST(c, v);
+ // Literal True, False, and None are compared by identity. All others use
+ // equality:
+ ADDOP_COMPARE(c, (v == Py_None || PyBool_Check(v)) ? Is : Eq);
+ return 1;
+}
+
+
+static int
+compiler_pattern_mapping(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ basicblock *end, *fail_pop_1, *fail_pop_3;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ RETURN_IF_FALSE(fail_pop_1 = compiler_new_block(c));
+ RETURN_IF_FALSE(fail_pop_3 = compiler_new_block(c));
+ asdl_expr_seq *keys = p->v.Dict.keys;
+ asdl_expr_seq *values = p->v.Dict.values;
+ Py_ssize_t size = asdl_seq_LEN(values);
+ // A starred pattern will be a keyless value. It is guranteed to be last:
+ int star = size ? !asdl_seq_GET(keys, size - 1) : 0;
+ ADDOP(c, MATCH_MAPPING);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ if (!size) {
+ // If the pattern is just "{}", we're done!
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, fail_pop_1);
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_False);
+ compiler_use_next_block(c, end);
+ return 1;
+ }
+ if (size - star) {
+ // If the pattern has any keys in it, perform a length check:
+ ADDOP(c, GET_LEN);
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size - star));
+ ADDOP_COMPARE(c, GtE);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ }
+ if (INT_MAX < size - star - 1) {
+ return compiler_error(c, "too many sub-patterns in mapping pattern");
+ }
+ // Collect all of the keys into a tuple for MATCH_KEYS and
+ // COPY_DICT_WITHOUT_KEYS. They can either be dotted names or literals:
+ for (Py_ssize_t i = 0; i < size - star; i++) {
+ expr_ty key = asdl_seq_GET(keys, i);
+ if (key == NULL) {
+ const char *e = "can't use starred name here "
+ "(consider moving to end)";
+ return compiler_error(c, e);
+ }
+ VISIT(c, expr, key);
+ }
+ ADDOP_I(c, BUILD_TUPLE, size - star);
+ ADDOP(c, MATCH_KEYS);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_3);
+ NEXT_BLOCK(c);
+ // So far so good. There's now a tuple of values on the stack to match
+ // sub-patterns against:
+ for (Py_ssize_t i = 0; i < size - star; i++) {
+ expr_ty value = asdl_seq_GET(values, i);
+ if (WILDCARD_CHECK(value)) {
+ continue;
+ }
+ ADDOP(c, DUP_TOP);
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(i));
+ ADDOP(c, BINARY_SUBSCR);
+ RETURN_IF_FALSE(compiler_pattern_subpattern(c, value, pc));
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_3);
+ NEXT_BLOCK(c);
+ }
+ // If we get this far, it's a match! We're done with that tuple of values.
+ ADDOP(c, POP_TOP);
+ if (star) {
+ // If we had a starred name, bind a dict of remaining items to it:
+ ADDOP(c, COPY_DICT_WITHOUT_KEYS);
+ PyObject *id = asdl_seq_GET(values, size - 1)->v.Name.id;
+ RETURN_IF_FALSE(pattern_helper_store_name(c, id, pc));
+ }
+ else {
+ // Otherwise, we don't care about this tuple of keys anymore:
+ ADDOP(c, POP_TOP);
+ }
+ // Pop the subject:
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ // The top two items are a tuple of values or None, followed by a tuple of
+ // keys. Pop them both:
+ compiler_use_next_block(c, fail_pop_3);
+ ADDOP(c, POP_TOP);
+ ADDOP(c, POP_TOP);
+ compiler_use_next_block(c, fail_pop_1);
+ // Pop the subject:
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_False);
+ compiler_use_next_block(c, end);
+ return 1;
+}
+
+
+static int
+compiler_pattern_or(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == MatchOr_kind);
+ // control is the set of names bound by the first alternative. If all of the
+ // others bind the same names (they should), then this becomes pc->stores.
+ PyObject *control = NULL;
+ basicblock *end, *pass_pop_1;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ RETURN_IF_FALSE(pass_pop_1 = compiler_new_block(c));
+ Py_ssize_t size = asdl_seq_LEN(p->v.MatchOr.patterns);
+ assert(size > 1);
+ // We're going to be messing with pc. Keep the original info handy:
+ PyObject *stores_init = pc->stores;
+ int allow_irrefutable = pc->allow_irrefutable;
+ for (Py_ssize_t i = 0; i < size; i++) {
+ // NOTE: Can't use our nice returning macros in here: they'll leak sets!
+ expr_ty alt = asdl_seq_GET(p->v.MatchOr.patterns, i);
+ pc->stores = PySet_New(stores_init);
+ // An irrefutable sub-pattern must be last, if it is allowed at all:
+ int is_last = i == size - 1;
+ pc->allow_irrefutable = allow_irrefutable && is_last;
+ SET_LOC(c, alt);
+ if (pc->stores == NULL ||
+ // Only copy the subject if we're *not* on the last alternative:
+ (!is_last && !compiler_addop(c, DUP_TOP)) ||
+ !compiler_pattern(c, alt, pc) ||
+ // Only jump if we're *not* on the last alternative:
+ (!is_last && !compiler_addop_j(c, POP_JUMP_IF_TRUE, pass_pop_1)) ||
+ !compiler_next_block(c))
+ {
+ goto fail;
+ }
+ if (!i) {
+ // If this is the first alternative, save its stores as a "control"
+ // for the others (they can't bind a different set of names):
+ control = pc->stores;
+ continue;
+ }
+ if (PySet_GET_SIZE(pc->stores) || PySet_GET_SIZE(control)) {
+ // Otherwise, check to see if we differ from the control set:
+ PyObject *diff = PyNumber_InPlaceXor(pc->stores, control);
+ if (diff == NULL) {
+ goto fail;
+ }
+ if (PySet_GET_SIZE(diff)) {
+ // The names differ! Raise.
+ Py_DECREF(diff);
+ compiler_error(c, "alternative patterns bind different names");
+ goto fail;
+ }
+ Py_DECREF(diff);
+ }
+ Py_DECREF(pc->stores);
+ }
+ Py_XDECREF(stores_init);
+ // Update pc->stores and restore pc->allow_irrefutable:
+ pc->stores = control;
+ pc->allow_irrefutable = allow_irrefutable;
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, pass_pop_1);
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ compiler_use_next_block(c, end);
+ return 1;
+fail:
+ Py_XDECREF(stores_init);
+ Py_XDECREF(control);
+ return 0;
+}
+
+
+static int
+compiler_pattern_sequence(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == List_kind || p->kind == Tuple_kind);
+ asdl_expr_seq *values = (p->kind == Tuple_kind) ? p->v.Tuple.elts
+ : p->v.List.elts;
+ Py_ssize_t size = asdl_seq_LEN(values);
+ Py_ssize_t star = -1;
+ int only_wildcard = 1;
+ int star_wildcard = 0;
+ // Find a starred name, if it exists. There may be at most one:
+ for (Py_ssize_t i = 0; i < size; i++) {
+ expr_ty value = asdl_seq_GET(values, i);
+ if (value->kind == Starred_kind) {
+ value = value->v.Starred.value;
+ if (star >= 0) {
+ const char *e = "multiple starred names in sequence pattern";
+ return compiler_error(c, e);
+ }
+ star_wildcard = WILDCARD_CHECK(value);
+ star = i;
+ }
+ only_wildcard &= WILDCARD_CHECK(value);
+ }
+ basicblock *end, *fail_pop_1;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ RETURN_IF_FALSE(fail_pop_1 = compiler_new_block(c));
+ ADDOP(c, MATCH_SEQUENCE);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ if (star < 0) {
+ // No star: len(subject) == size
+ ADDOP(c, GET_LEN);
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size));
+ ADDOP_COMPARE(c, Eq);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ }
+ else if (size > 1) {
+ // Star: len(subject) >= size - 1
+ ADDOP(c, GET_LEN);
+ ADDOP_LOAD_CONST_NEW(c, PyLong_FromSsize_t(size - 1));
+ ADDOP_COMPARE(c, GtE);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, fail_pop_1);
+ NEXT_BLOCK(c);
+ }
+ if (only_wildcard) {
+ // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ }
+ else if (star_wildcard) {
+ RETURN_IF_FALSE(pattern_helper_sequence_subscr(c, values, star, pc));
+ }
+ else {
+ RETURN_IF_FALSE(pattern_helper_sequence_unpack(c, values, star, pc));
+ }
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, fail_pop_1);
+ ADDOP(c, POP_TOP)
+ ADDOP_LOAD_CONST(c, Py_False);
+ compiler_use_next_block(c, end);
+ return 1;
+}
+
+
+static int
+compiler_pattern_value(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == Attribute_kind);
+ assert(p->v.Attribute.ctx == Load);
+ VISIT(c, expr, p);
+ ADDOP_COMPARE(c, Eq);
+ return 1;
+}
+
+
+static int
+compiler_pattern_wildcard(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ assert(p->kind == Name_kind);
+ assert(p->v.Name.ctx == Store);
+ assert(WILDCARD_CHECK(p));
+ if (!pc->allow_irrefutable) {
+ // Whoops, can't have a wildcard here!
+ const char *e = "wildcard makes remaining patterns unreachable";
+ return compiler_error(c, e);
+ }
+ ADDOP(c, POP_TOP);
+ ADDOP_LOAD_CONST(c, Py_True);
+ return 1;
+}
+
+
+static int
+compiler_pattern(struct compiler *c, expr_ty p, pattern_context *pc)
+{
+ SET_LOC(c, p);
+ switch (p->kind) {
+ case Attribute_kind:
+ return compiler_pattern_value(c, p, pc);
+ case BinOp_kind:
+ // Because we allow "2+2j", things like "2+2" make it this far:
+ return compiler_error(c, "patterns cannot include operators");
+ case Call_kind:
+ return compiler_pattern_class(c, p, pc);
+ case Constant_kind:
+ return compiler_pattern_literal(c, p, pc);
+ case Dict_kind:
+ return compiler_pattern_mapping(c, p, pc);
+ case JoinedStr_kind:
+ // Because we allow strings, f-strings make it this far:
+ return compiler_error(c, "patterns cannot include f-strings");
+ case List_kind:
+ case Tuple_kind:
+ return compiler_pattern_sequence(c, p, pc);
+ case MatchAs_kind:
+ return compiler_pattern_as(c, p, pc);
+ case MatchOr_kind:
+ return compiler_pattern_or(c, p, pc);
+ case Name_kind:
+ if (WILDCARD_CHECK(p)) {
+ return compiler_pattern_wildcard(c, p, pc);
+ }
+ return compiler_pattern_capture(c, p, pc);
+ default:
+ Py_UNREACHABLE();
+ }
+}
+
+
+static int
+compiler_match(struct compiler *c, stmt_ty s)
+{
+ VISIT(c, expr, s->v.Match.subject);
+ basicblock *next, *end;
+ RETURN_IF_FALSE(end = compiler_new_block(c));
+ Py_ssize_t cases = asdl_seq_LEN(s->v.Match.cases);
+ assert(cases);
+ pattern_context pc;
+ // We use pc.stores to track:
+ // - Repeated name assignments in the same pattern.
+ // - Different name assignments in alternatives.
+ // It's a set of names, but we don't create it until it's needed:
+ pc.stores = NULL;
+ match_case_ty m = asdl_seq_GET(s->v.Match.cases, cases - 1);
+ int has_default = WILDCARD_CHECK(m->pattern) && 1 < cases;
+ for (Py_ssize_t i = 0; i < cases - has_default; i++) {
+ m = asdl_seq_GET(s->v.Match.cases, i);
+ SET_LOC(c, m->pattern);
+ RETURN_IF_FALSE(next = compiler_new_block(c));
+ // If pc.allow_irrefutable is 0, any name captures against our subject
+ // will raise. Irrefutable cases must be either guarded, last, or both:
+ pc.allow_irrefutable = m->guard != NULL || i == cases - 1;
+ // Only copy the subject if we're *not* on the last case:
+ if (i != cases - has_default - 1) {
+ ADDOP(c, DUP_TOP);
+ }
+ int result = compiler_pattern(c, m->pattern, &pc);
+ Py_CLEAR(pc.stores);
+ RETURN_IF_FALSE(result);
+ ADDOP_JUMP(c, POP_JUMP_IF_FALSE, next);
+ NEXT_BLOCK(c);
+ if (m->guard) {
+ RETURN_IF_FALSE(compiler_jump_if(c, m->guard, next, 0));
+ }
+ // Success! Pop the subject off, we're done with it:
+ if (i != cases - has_default - 1) {
+ ADDOP(c, POP_TOP);
+ }
+ VISIT_SEQ(c, stmt, m->body);
+ ADDOP_JUMP(c, JUMP_FORWARD, end);
+ compiler_use_next_block(c, next);
+ }
+ if (has_default) {
+ if (cases == 1) {
+ // No matches. Done with the subject:
+ ADDOP(c, POP_TOP);
+ }
+ // A trailing "case _" is common, and lets us save a bit of redundant
+ // pushing and popping in the loop above:
+ m = asdl_seq_GET(s->v.Match.cases, cases - 1);
+ SET_LOC(c, m->pattern);
+ if (m->guard) {
+ RETURN_IF_FALSE(compiler_jump_if(c, m->guard, end, 0));
+ }
+ VISIT_SEQ(c, stmt, m->body);
+ }
+ compiler_use_next_block(c, end);
+ return 1;
+}
+
+
+#undef WILDCARD_CHECK
+
+
/* End of the compiler section, beginning of the assembler section */
/* do depth-first search of basic block graph, starting with block.
diff --git a/Python/importlib_external.h b/Python/importlib_external.h
index 32ed87d..6b4cd39 100644
--- a/Python/importlib_external.h
+++ b/Python/importlib_external.h
@@ -315,7 +315,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,115,38,0,0,0,16,5,6,1,22,1,4,255,
2,2,14,3,24,1,16,128,18,1,12,1,2,1,12,1,
2,3,12,254,2,1,2,1,2,254,2,253,255,128,114,84,
- 0,0,0,105,105,13,0,0,114,45,0,0,0,114,33,0,
+ 0,0,0,105,106,13,0,0,114,45,0,0,0,114,33,0,
0,0,115,2,0,0,0,13,10,90,11,95,95,112,121,99,
97,99,104,101,95,95,122,4,111,112,116,45,122,3,46,112,
121,122,4,46,112,121,119,122,4,46,112,121,99,41,1,218,
@@ -429,7 +429,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
90,15,97,108,109,111,115,116,95,102,105,108,101,110,97,109,
101,218,8,102,105,108,101,110,97,109,101,114,7,0,0,0,
114,7,0,0,0,114,8,0,0,0,218,17,99,97,99,104,
- 101,95,102,114,111,109,95,115,111,117,114,99,101,85,1,0,
+ 101,95,102,114,111,109,95,115,111,117,114,99,101,86,1,0,
0,115,74,0,0,0,8,18,6,1,2,1,4,255,8,2,
4,1,8,1,12,1,10,1,12,1,16,1,8,1,8,1,
8,1,24,1,8,1,12,1,6,1,8,2,8,1,8,1,
@@ -510,7 +510,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,90,9,111,112,116,95,108,101,118,101,108,90,13,98,
97,115,101,95,102,105,108,101,110,97,109,101,114,7,0,0,
0,114,7,0,0,0,114,8,0,0,0,218,17,115,111,117,
- 114,99,101,95,102,114,111,109,95,99,97,99,104,101,156,1,
+ 114,99,101,95,102,114,111,109,95,99,97,99,104,101,157,1,
0,0,115,62,0,0,0,12,9,8,1,10,1,12,1,4,
1,10,1,12,1,14,1,16,1,4,1,4,1,12,1,8,
1,8,1,2,1,8,255,10,2,8,1,14,1,10,1,16,
@@ -546,7 +546,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
120,116,101,110,115,105,111,110,218,11,115,111,117,114,99,101,
95,112,97,116,104,114,7,0,0,0,114,7,0,0,0,114,
8,0,0,0,218,15,95,103,101,116,95,115,111,117,114,99,
- 101,102,105,108,101,196,1,0,0,115,24,0,0,0,12,7,
+ 101,102,105,108,101,197,1,0,0,115,24,0,0,0,12,7,
4,1,16,1,24,1,4,1,2,1,12,1,16,1,14,1,
16,1,2,254,255,128,114,120,0,0,0,99,1,0,0,0,
0,0,0,0,0,0,0,0,1,0,0,0,8,0,0,0,
@@ -559,7 +559,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
112,108,101,114,113,0,0,0,114,109,0,0,0,114,95,0,
0,0,114,101,0,0,0,41,1,114,108,0,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,218,11,95,
- 103,101,116,95,99,97,99,104,101,100,215,1,0,0,115,20,
+ 103,101,116,95,99,97,99,104,101,100,216,1,0,0,115,20,
0,0,0,14,1,2,1,10,1,12,1,6,1,14,1,4,
1,4,2,2,251,255,128,114,124,0,0,0,99,1,0,0,
0,0,0,0,0,0,0,0,0,2,0,0,0,8,0,0,
@@ -574,7 +574,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,114,65,0,0,0,114,64,0,0,0,41,2,114,
58,0,0,0,114,66,0,0,0,114,7,0,0,0,114,7,
0,0,0,114,8,0,0,0,218,10,95,99,97,108,99,95,
- 109,111,100,101,227,1,0,0,115,16,0,0,0,2,2,14,
+ 109,111,100,101,228,1,0,0,115,16,0,0,0,2,2,14,
1,12,1,6,1,8,3,4,1,2,251,255,128,114,126,0,
0,0,99,1,0,0,0,0,0,0,0,0,0,0,0,3,
0,0,0,4,0,0,0,3,0,0,0,115,52,0,0,0,
@@ -611,7 +611,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
108,102,114,128,0,0,0,218,4,97,114,103,115,218,6,107,
119,97,114,103,115,169,1,218,6,109,101,116,104,111,100,114,
7,0,0,0,114,8,0,0,0,218,19,95,99,104,101,99,
- 107,95,110,97,109,101,95,119,114,97,112,112,101,114,247,1,
+ 107,95,110,97,109,101,95,119,114,97,112,112,101,114,248,1,
0,0,115,20,0,0,0,8,1,8,1,10,1,4,1,8,
1,2,255,2,1,6,255,24,2,255,128,122,40,95,99,104,
101,99,107,95,110,97,109,101,46,60,108,111,99,97,108,115,
@@ -630,14 +630,14 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
99,116,95,95,218,6,117,112,100,97,116,101,41,3,90,3,
110,101,119,90,3,111,108,100,114,82,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,218,5,95,119,
- 114,97,112,4,2,0,0,115,12,0,0,0,8,1,10,1,
+ 114,97,112,5,2,0,0,115,12,0,0,0,8,1,10,1,
18,1,2,128,18,1,255,128,122,26,95,99,104,101,99,107,
95,110,97,109,101,46,60,108,111,99,97,108,115,62,46,95,
119,114,97,112,41,1,78,41,2,218,10,95,98,111,111,116,
115,116,114,97,112,114,145,0,0,0,41,3,114,134,0,0,
0,114,135,0,0,0,114,145,0,0,0,114,7,0,0,0,
114,133,0,0,0,114,8,0,0,0,218,11,95,99,104,101,
- 99,107,95,110,97,109,101,239,1,0,0,115,14,0,0,0,
+ 99,107,95,110,97,109,101,240,1,0,0,115,14,0,0,0,
14,8,8,10,8,1,8,2,10,6,4,1,255,128,114,147,
0,0,0,99,2,0,0,0,0,0,0,0,0,0,0,0,
5,0,0,0,6,0,0,0,67,0,0,0,115,60,0,0,
@@ -665,7 +665,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
97,109,101,218,6,108,111,97,100,101,114,218,8,112,111,114,
116,105,111,110,115,218,3,109,115,103,114,7,0,0,0,114,
7,0,0,0,114,8,0,0,0,218,17,95,102,105,110,100,
- 95,109,111,100,117,108,101,95,115,104,105,109,14,2,0,0,
+ 95,109,111,100,117,108,101,95,115,104,105,109,15,2,0,0,
115,12,0,0,0,14,10,16,1,4,1,22,1,4,1,255,
128,114,154,0,0,0,99,3,0,0,0,0,0,0,0,0,
0,0,0,6,0,0,0,4,0,0,0,67,0,0,0,115,
@@ -733,7 +733,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
115,90,5,109,97,103,105,99,114,105,0,0,0,114,17,0,
0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,0,
0,218,13,95,99,108,97,115,115,105,102,121,95,112,121,99,
- 31,2,0,0,115,30,0,0,0,12,16,8,1,16,1,12,
+ 32,2,0,0,115,30,0,0,0,12,16,8,1,16,1,12,
1,16,1,12,1,10,1,12,1,8,1,16,1,8,2,16,
1,16,1,4,1,255,128,114,163,0,0,0,99,5,0,0,
0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,
@@ -788,7 +788,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,114,162,0,0,0,114,105,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,218,23,95,118,
97,108,105,100,97,116,101,95,116,105,109,101,115,116,97,109,
- 112,95,112,121,99,64,2,0,0,115,20,0,0,0,24,19,
+ 112,95,112,121,99,65,2,0,0,115,20,0,0,0,24,19,
10,1,12,1,16,1,8,1,22,1,2,255,22,2,8,254,
255,128,114,167,0,0,0,99,4,0,0,0,0,0,0,0,
0,0,0,0,4,0,0,0,4,0,0,0,67,0,0,0,
@@ -834,7 +834,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,218,11,115,111,117,114,99,101,95,104,97,115,104,114,
128,0,0,0,114,162,0,0,0,114,7,0,0,0,114,7,
0,0,0,114,8,0,0,0,218,18,95,118,97,108,105,100,
- 97,116,101,95,104,97,115,104,95,112,121,99,92,2,0,0,
+ 97,116,101,95,104,97,115,104,95,112,121,99,93,2,0,0,
115,16,0,0,0,16,17,2,1,8,1,4,255,2,2,6,
254,4,255,255,128,114,169,0,0,0,99,4,0,0,0,0,
0,0,0,0,0,0,0,5,0,0,0,5,0,0,0,67,
@@ -858,7 +858,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,42,0,0,0,114,128,0,0,0,114,118,0,0,0,114,
119,0,0,0,218,4,99,111,100,101,114,7,0,0,0,114,
7,0,0,0,114,8,0,0,0,218,17,95,99,111,109,112,
- 105,108,101,95,98,121,116,101,99,111,100,101,116,2,0,0,
+ 105,108,101,95,98,121,116,101,99,111,100,101,117,2,0,0,
115,20,0,0,0,10,2,10,1,12,1,8,1,12,1,4,
1,10,2,4,1,6,255,255,128,114,176,0,0,0,99,3,
0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,5,
@@ -877,7 +877,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,166,0,0,0,114,42,0,0,0,114,7,0,0,0,114,
7,0,0,0,114,8,0,0,0,218,22,95,99,111,100,101,
95,116,111,95,116,105,109,101,115,116,97,109,112,95,112,121,
- 99,129,2,0,0,115,14,0,0,0,8,2,14,1,14,1,
+ 99,130,2,0,0,115,14,0,0,0,8,2,14,1,14,1,
14,1,16,1,4,1,255,128,114,181,0,0,0,84,99,3,
0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,5,
0,0,0,67,0,0,0,115,80,0,0,0,116,0,116,1,
@@ -895,7 +895,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,90,7,99,104,101,99,107,101,100,114,42,0,0,0,
114,17,0,0,0,114,7,0,0,0,114,7,0,0,0,114,
8,0,0,0,218,17,95,99,111,100,101,95,116,111,95,104,
- 97,115,104,95,112,121,99,139,2,0,0,115,16,0,0,0,
+ 97,115,104,95,112,121,99,140,2,0,0,115,16,0,0,0,
8,2,12,1,14,1,16,1,10,1,16,1,4,1,255,128,
114,182,0,0,0,99,1,0,0,0,0,0,0,0,0,0,
0,0,5,0,0,0,6,0,0,0,67,0,0,0,115,62,
@@ -923,7 +923,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
105,110,103,90,15,110,101,119,108,105,110,101,95,100,101,99,
111,100,101,114,114,7,0,0,0,114,7,0,0,0,114,8,
0,0,0,218,13,100,101,99,111,100,101,95,115,111,117,114,
- 99,101,150,2,0,0,115,12,0,0,0,8,5,12,1,10,
+ 99,101,151,2,0,0,115,12,0,0,0,8,5,12,1,10,
1,12,1,20,1,255,128,114,187,0,0,0,169,2,114,151,
0,0,0,218,26,115,117,98,109,111,100,117,108,101,95,115,
101,97,114,99,104,95,108,111,99,97,116,105,111,110,115,99,
@@ -984,7 +984,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
8,115,117,102,102,105,120,101,115,114,193,0,0,0,90,7,
100,105,114,110,97,109,101,114,7,0,0,0,114,7,0,0,
0,114,8,0,0,0,218,23,115,112,101,99,95,102,114,111,
- 109,95,102,105,108,101,95,108,111,99,97,116,105,111,110,167,
+ 109,95,102,105,108,101,95,108,111,99,97,116,105,111,110,168,
2,0,0,115,74,0,0,0,8,12,4,4,10,1,2,2,
14,1,14,1,4,1,2,251,10,7,16,8,6,1,8,3,
14,1,14,1,10,1,6,1,4,1,2,253,4,5,8,3,
@@ -1023,7 +1023,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
72,75,69,89,95,76,79,67,65,76,95,77,65,67,72,73,
78,69,114,20,0,0,0,114,7,0,0,0,114,7,0,0,
0,114,8,0,0,0,218,14,95,111,112,101,110,95,114,101,
- 103,105,115,116,114,121,247,2,0,0,115,12,0,0,0,2,
+ 103,105,115,116,114,121,248,2,0,0,115,12,0,0,0,2,
2,16,1,12,1,18,1,2,255,255,128,122,36,87,105,110,
100,111,119,115,82,101,103,105,115,116,114,121,70,105,110,100,
101,114,46,95,111,112,101,110,95,114,101,103,105,115,116,114,
@@ -1050,7 +1050,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
116,114,121,95,107,101,121,114,21,0,0,0,90,4,104,107,
101,121,218,8,102,105,108,101,112,97,116,104,114,7,0,0,
0,114,7,0,0,0,114,8,0,0,0,218,16,95,115,101,
- 97,114,99,104,95,114,101,103,105,115,116,114,121,254,2,0,
+ 97,114,99,104,95,114,101,103,105,115,116,114,121,255,2,0,
0,115,30,0,0,0,6,2,8,1,6,2,6,1,16,1,
6,255,2,2,12,1,26,1,18,128,4,3,12,254,6,1,
2,255,255,128,122,38,87,105,110,100,111,119,115,82,101,103,
@@ -1073,7 +1073,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,218,6,116,97,114,103,101,116,114,210,0,0,0,
114,151,0,0,0,114,200,0,0,0,114,198,0,0,0,114,
7,0,0,0,114,7,0,0,0,114,8,0,0,0,218,9,
- 102,105,110,100,95,115,112,101,99,13,3,0,0,115,36,0,
+ 102,105,110,100,95,115,112,101,99,14,3,0,0,115,36,0,
0,0,10,2,8,1,4,1,2,1,12,1,12,1,6,1,
14,1,14,1,6,1,8,1,2,1,6,254,8,3,2,252,
4,255,2,254,255,128,122,31,87,105,110,100,111,119,115,82,
@@ -1093,7 +1093,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
169,4,114,209,0,0,0,114,150,0,0,0,114,58,0,0,
0,114,198,0,0,0,114,7,0,0,0,114,7,0,0,0,
114,8,0,0,0,218,11,102,105,110,100,95,109,111,100,117,
- 108,101,29,3,0,0,115,10,0,0,0,12,7,8,1,6,
+ 108,101,30,3,0,0,115,10,0,0,0,12,7,8,1,6,
1,4,2,255,128,122,33,87,105,110,100,111,119,115,82,101,
103,105,115,116,114,121,70,105,110,100,101,114,46,102,105,110,
100,95,109,111,100,117,108,101,41,2,78,78,41,1,78,41,
@@ -1105,7 +1105,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
104,111,100,114,204,0,0,0,218,11,99,108,97,115,115,109,
101,116,104,111,100,114,211,0,0,0,114,214,0,0,0,114,
217,0,0,0,114,7,0,0,0,114,7,0,0,0,114,7,
- 0,0,0,114,8,0,0,0,114,202,0,0,0,235,2,0,
+ 0,0,0,114,8,0,0,0,114,202,0,0,0,236,2,0,
0,115,32,0,0,0,8,0,4,2,2,3,2,255,2,4,
2,255,12,3,2,2,10,1,2,6,10,1,2,14,12,1,
2,15,16,1,255,128,114,202,0,0,0,99,0,0,0,0,
@@ -1142,7 +1142,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
108,0,0,0,90,13,102,105,108,101,110,97,109,101,95,98,
97,115,101,90,9,116,97,105,108,95,110,97,109,101,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,193,0,
- 0,0,48,3,0,0,115,10,0,0,0,18,3,16,1,14,
+ 0,0,49,3,0,0,115,10,0,0,0,18,3,16,1,14,
1,16,1,255,128,122,24,95,76,111,97,100,101,114,66,97,
115,105,99,115,46,105,115,95,112,97,99,107,97,103,101,99,
2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,
@@ -1152,7 +1152,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
101,32,99,114,101,97,116,105,111,110,46,78,114,7,0,0,
0,169,2,114,130,0,0,0,114,198,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,218,13,99,114,
- 101,97,116,101,95,109,111,100,117,108,101,56,3,0,0,243,
+ 101,97,116,101,95,109,111,100,117,108,101,57,3,0,0,243,
4,0,0,0,4,0,255,128,122,27,95,76,111,97,100,101,
114,66,97,115,105,99,115,46,99,114,101,97,116,101,95,109,
111,100,117,108,101,99,2,0,0,0,0,0,0,0,0,0,
@@ -1172,7 +1172,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
111,118,101,100,218,4,101,120,101,99,114,143,0,0,0,41,
3,114,130,0,0,0,218,6,109,111,100,117,108,101,114,175,
0,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,218,11,101,120,101,99,95,109,111,100,117,108,101,59,
+ 0,0,218,11,101,120,101,99,95,109,111,100,117,108,101,60,
3,0,0,115,14,0,0,0,12,2,8,1,6,1,4,1,
6,255,20,2,255,128,122,25,95,76,111,97,100,101,114,66,
97,115,105,99,115,46,101,120,101,99,95,109,111,100,117,108,
@@ -1184,14 +1184,14 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,218,17,95,108,111,97,100,95,109,111,100,117,108,101,95,
115,104,105,109,169,2,114,130,0,0,0,114,150,0,0,0,
114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,218,
- 11,108,111,97,100,95,109,111,100,117,108,101,67,3,0,0,
+ 11,108,111,97,100,95,109,111,100,117,108,101,68,3,0,0,
115,4,0,0,0,12,3,255,128,122,25,95,76,111,97,100,
101,114,66,97,115,105,99,115,46,108,111,97,100,95,109,111,
100,117,108,101,78,41,8,114,137,0,0,0,114,136,0,0,
0,114,138,0,0,0,114,139,0,0,0,114,193,0,0,0,
114,226,0,0,0,114,232,0,0,0,114,235,0,0,0,114,
7,0,0,0,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,222,0,0,0,43,3,0,0,115,14,0,0,
+ 0,0,0,114,222,0,0,0,44,3,0,0,115,14,0,0,
0,8,0,4,2,8,3,8,8,8,3,12,8,255,128,114,
222,0,0,0,99,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,3,0,0,0,64,0,0,0,115,74,0,
@@ -1216,7 +1216,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
32,32,32,32,32,32,32,78,41,1,114,64,0,0,0,169,
2,114,130,0,0,0,114,58,0,0,0,114,7,0,0,0,
114,7,0,0,0,114,8,0,0,0,218,10,112,97,116,104,
- 95,109,116,105,109,101,75,3,0,0,115,4,0,0,0,4,
+ 95,109,116,105,109,101,76,3,0,0,115,4,0,0,0,4,
6,255,128,122,23,83,111,117,114,99,101,76,111,97,100,101,
114,46,112,97,116,104,95,109,116,105,109,101,99,2,0,0,
0,0,0,0,0,0,0,0,0,2,0,0,0,4,0,0,
@@ -1250,7 +1250,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
108,101,100,46,10,32,32,32,32,32,32,32,32,114,180,0,
0,0,78,41,1,114,238,0,0,0,114,237,0,0,0,114,
7,0,0,0,114,7,0,0,0,114,8,0,0,0,218,10,
- 112,97,116,104,95,115,116,97,116,115,83,3,0,0,115,4,
+ 112,97,116,104,95,115,116,97,116,115,84,3,0,0,115,4,
0,0,0,14,12,255,128,122,23,83,111,117,114,99,101,76,
111,97,100,101,114,46,112,97,116,104,95,115,116,97,116,115,
99,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,
@@ -1274,7 +1274,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
4,114,130,0,0,0,114,119,0,0,0,90,10,99,97,99,
104,101,95,112,97,116,104,114,42,0,0,0,114,7,0,0,
0,114,7,0,0,0,114,8,0,0,0,218,15,95,99,97,
- 99,104,101,95,98,121,116,101,99,111,100,101,97,3,0,0,
+ 99,104,101,95,98,121,116,101,99,111,100,101,98,3,0,0,
115,4,0,0,0,12,8,255,128,122,28,83,111,117,114,99,
101,76,111,97,100,101,114,46,95,99,97,99,104,101,95,98,
121,116,101,99,111,100,101,99,3,0,0,0,0,0,0,0,
@@ -1291,7 +1291,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
102,105,108,101,115,46,10,32,32,32,32,32,32,32,32,78,
114,7,0,0,0,41,3,114,130,0,0,0,114,58,0,0,
0,114,42,0,0,0,114,7,0,0,0,114,7,0,0,0,
- 114,8,0,0,0,114,240,0,0,0,107,3,0,0,114,227,
+ 114,8,0,0,0,114,240,0,0,0,108,3,0,0,114,227,
0,0,0,122,21,83,111,117,114,99,101,76,111,97,100,101,
114,46,115,101,116,95,100,97,116,97,99,2,0,0,0,0,
0,0,0,0,0,0,0,5,0,0,0,10,0,0,0,67,
@@ -1311,7 +1311,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,187,0,0,0,41,5,114,130,0,0,0,114,150,0,0,
0,114,58,0,0,0,114,185,0,0,0,218,3,101,120,99,
114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,218,
- 10,103,101,116,95,115,111,117,114,99,101,114,3,0,0,115,
+ 10,103,101,116,95,115,111,117,114,99,101,115,3,0,0,115,
26,0,0,0,10,2,2,1,12,1,8,4,14,253,4,1,
2,1,4,255,2,1,2,255,8,128,2,255,255,128,122,23,
83,111,117,114,99,101,76,111,97,100,101,114,46,103,101,116,
@@ -1334,7 +1334,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
112,105,108,101,41,4,114,130,0,0,0,114,42,0,0,0,
114,58,0,0,0,114,245,0,0,0,114,7,0,0,0,114,
7,0,0,0,114,8,0,0,0,218,14,115,111,117,114,99,
- 101,95,116,111,95,99,111,100,101,124,3,0,0,115,8,0,
+ 101,95,116,111,95,99,111,100,101,125,3,0,0,115,8,0,
0,0,12,5,4,1,6,255,255,128,122,27,83,111,117,114,
99,101,76,111,97,100,101,114,46,115,111,117,114,99,101,95,
116,111,95,99,111,100,101,99,2,0,0,0,0,0,0,0,
@@ -1412,7 +1412,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,114,17,0,0,0,90,10,98,121,116,101,115,95,100,97,
116,97,90,11,99,111,100,101,95,111,98,106,101,99,116,114,
7,0,0,0,114,7,0,0,0,114,8,0,0,0,114,228,
- 0,0,0,132,3,0,0,115,170,0,0,0,10,7,4,1,
+ 0,0,0,133,3,0,0,115,170,0,0,0,10,7,4,1,
4,1,4,1,4,1,4,1,2,1,12,1,14,1,10,1,
2,2,14,1,14,1,6,1,12,2,2,1,14,1,14,1,
4,1,2,3,2,1,6,254,2,4,12,1,16,1,12,1,
@@ -1429,7 +1429,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
238,0,0,0,114,239,0,0,0,114,241,0,0,0,114,240,
0,0,0,114,244,0,0,0,114,248,0,0,0,114,228,0,
0,0,114,7,0,0,0,114,7,0,0,0,114,7,0,0,
- 0,114,8,0,0,0,114,236,0,0,0,73,3,0,0,115,
+ 0,114,8,0,0,0,114,236,0,0,0,74,3,0,0,115,
18,0,0,0,8,0,8,2,8,8,8,14,8,10,8,7,
14,10,12,8,255,128,114,236,0,0,0,99,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,
@@ -1457,7 +1457,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
32,32,102,105,110,100,101,114,46,78,114,170,0,0,0,41,
3,114,130,0,0,0,114,150,0,0,0,114,58,0,0,0,
114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,114,
- 223,0,0,0,222,3,0,0,115,6,0,0,0,6,3,10,
+ 223,0,0,0,223,3,0,0,115,6,0,0,0,6,3,10,
1,255,128,122,19,70,105,108,101,76,111,97,100,101,114,46,
95,95,105,110,105,116,95,95,99,2,0,0,0,0,0,0,
0,0,0,0,0,2,0,0,0,2,0,0,0,67,0,0,
@@ -1466,7 +1466,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,169,2,218,9,95,95,99,108,97,115,115,95,95,
114,143,0,0,0,169,2,114,130,0,0,0,90,5,111,116,
104,101,114,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,218,6,95,95,101,113,95,95,228,3,0,0,243,8,
+ 0,0,218,6,95,95,101,113,95,95,229,3,0,0,243,8,
0,0,0,12,1,10,1,2,255,255,128,122,17,70,105,108,
101,76,111,97,100,101,114,46,95,95,101,113,95,95,99,1,
0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,3,
@@ -1475,7 +1475,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,121,0,0,0,169,3,218,4,104,97,115,104,114,128,0,
0,0,114,58,0,0,0,169,1,114,130,0,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,218,8,95,
- 95,104,97,115,104,95,95,232,3,0,0,243,4,0,0,0,
+ 95,104,97,115,104,95,95,233,3,0,0,243,4,0,0,0,
20,1,255,128,122,19,70,105,108,101,76,111,97,100,101,114,
46,95,95,104,97,115,104,95,95,99,2,0,0,0,0,0,
0,0,0,0,0,0,2,0,0,0,3,0,0,0,3,0,
@@ -1489,7 +1489,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
116,101,97,100,46,10,10,32,32,32,32,32,32,32,32,78,
41,3,218,5,115,117,112,101,114,114,254,0,0,0,114,235,
0,0,0,114,234,0,0,0,169,1,114,1,1,0,0,114,
- 7,0,0,0,114,8,0,0,0,114,235,0,0,0,235,3,
+ 7,0,0,0,114,8,0,0,0,114,235,0,0,0,236,3,
0,0,115,4,0,0,0,16,10,255,128,122,22,70,105,108,
101,76,111,97,100,101,114,46,108,111,97,100,95,109,111,100,
117,108,101,99,2,0,0,0,0,0,0,0,0,0,0,0,
@@ -1500,7 +1500,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
32,102,111,117,110,100,32,98,121,32,116,104,101,32,102,105,
110,100,101,114,46,78,114,62,0,0,0,114,234,0,0,0,
114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,114,
- 190,0,0,0,247,3,0,0,243,4,0,0,0,6,3,255,
+ 190,0,0,0,248,3,0,0,243,4,0,0,0,6,3,255,
128,122,23,70,105,108,101,76,111,97,100,101,114,46,103,101,
116,95,102,105,108,101,110,97,109,101,99,2,0,0,0,0,
0,0,0,0,0,0,0,3,0,0,0,8,0,0,0,67,
@@ -1521,7 +1521,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
112,101,110,95,99,111,100,101,114,97,0,0,0,90,4,114,
101,97,100,114,80,0,0,0,41,3,114,130,0,0,0,114,
58,0,0,0,114,83,0,0,0,114,7,0,0,0,114,7,
- 0,0,0,114,8,0,0,0,114,242,0,0,0,252,3,0,
+ 0,0,0,114,8,0,0,0,114,242,0,0,0,253,3,0,
0,115,16,0,0,0,14,2,16,1,22,1,20,128,14,2,
22,1,20,128,255,128,122,19,70,105,108,101,76,111,97,100,
101,114,46,103,101,116,95,100,97,116,97,99,2,0,0,0,
@@ -1534,7 +1534,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
130,0,0,0,114,231,0,0,0,114,18,1,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,218,19,103,
101,116,95,114,101,115,111,117,114,99,101,95,114,101,97,100,
- 101,114,5,4,0,0,115,6,0,0,0,12,2,8,1,255,
+ 101,114,6,4,0,0,115,6,0,0,0,12,2,8,1,255,
128,122,30,70,105,108,101,76,111,97,100,101,114,46,103,101,
116,95,114,101,115,111,117,114,99,101,95,114,101,97,100,101,
114,41,13,114,137,0,0,0,114,136,0,0,0,114,138,0,
@@ -1543,7 +1543,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,190,0,0,0,114,242,0,0,0,114,19,1,0,0,90,
13,95,95,99,108,97,115,115,99,101,108,108,95,95,114,7,
0,0,0,114,7,0,0,0,114,12,1,0,0,114,8,0,
- 0,0,114,254,0,0,0,217,3,0,0,115,26,0,0,0,
+ 0,0,114,254,0,0,0,218,3,0,0,115,26,0,0,0,
8,0,4,2,8,3,8,6,8,4,2,3,14,1,2,11,
10,1,8,4,2,9,18,1,255,128,114,254,0,0,0,99,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -1566,7 +1566,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
95,109,116,105,109,101,90,7,115,116,95,115,105,122,101,41,
3,114,130,0,0,0,114,58,0,0,0,114,253,0,0,0,
114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,114,
- 239,0,0,0,15,4,0,0,115,6,0,0,0,8,2,14,
+ 239,0,0,0,16,4,0,0,115,6,0,0,0,8,2,14,
1,255,128,122,27,83,111,117,114,99,101,70,105,108,101,76,
111,97,100,101,114,46,112,97,116,104,95,115,116,97,116,115,
99,4,0,0,0,0,0,0,0,0,0,0,0,5,0,0,
@@ -1576,7 +1576,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
100,101,41,2,114,126,0,0,0,114,240,0,0,0,41,5,
114,130,0,0,0,114,119,0,0,0,114,118,0,0,0,114,
42,0,0,0,114,66,0,0,0,114,7,0,0,0,114,7,
- 0,0,0,114,8,0,0,0,114,241,0,0,0,20,4,0,
+ 0,0,0,114,8,0,0,0,114,241,0,0,0,21,4,0,
0,115,6,0,0,0,8,2,16,1,255,128,122,32,83,111,
117,114,99,101,70,105,108,101,76,111,97,100,101,114,46,95,
99,97,99,104,101,95,98,121,116,101,99,111,100,101,114,75,
@@ -1612,7 +1612,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,218,6,112,97,114,101,110,116,114,108,0,0,0,114,53,
0,0,0,114,49,0,0,0,114,243,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,114,240,0,0,
- 0,25,4,0,0,115,58,0,0,0,12,2,4,1,12,2,
+ 0,26,4,0,0,115,58,0,0,0,12,2,4,1,12,2,
12,1,10,1,12,254,12,4,10,1,2,1,14,1,12,1,
4,2,14,1,6,3,4,1,4,255,16,2,8,128,2,1,
12,1,18,1,14,1,8,2,2,1,18,255,8,128,2,254,
@@ -1621,7 +1621,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
41,7,114,137,0,0,0,114,136,0,0,0,114,138,0,0,
0,114,139,0,0,0,114,239,0,0,0,114,241,0,0,0,
114,240,0,0,0,114,7,0,0,0,114,7,0,0,0,114,
- 7,0,0,0,114,8,0,0,0,114,20,1,0,0,11,4,
+ 7,0,0,0,114,8,0,0,0,114,20,1,0,0,12,4,
0,0,115,12,0,0,0,8,0,4,2,8,2,8,5,18,
5,255,128,114,20,1,0,0,99,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,2,0,0,0,64,0,0,
@@ -1644,7 +1644,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,41,5,114,130,0,0,0,114,150,0,0,0,114,
58,0,0,0,114,42,0,0,0,114,162,0,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,228,0,
- 0,0,60,4,0,0,115,24,0,0,0,10,1,10,1,2,
+ 0,0,61,4,0,0,115,24,0,0,0,10,1,10,1,2,
4,2,1,6,254,12,4,2,1,14,1,2,1,2,1,6,
253,255,128,122,29,83,111,117,114,99,101,108,101,115,115,70,
105,108,101,76,111,97,100,101,114,46,103,101,116,95,99,111,
@@ -1654,13 +1654,13 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
97,115,32,116,104,101,114,101,32,105,115,32,110,111,32,115,
111,117,114,99,101,32,99,111,100,101,46,78,114,7,0,0,
0,114,234,0,0,0,114,7,0,0,0,114,7,0,0,0,
- 114,8,0,0,0,114,244,0,0,0,76,4,0,0,114,25,
+ 114,8,0,0,0,114,244,0,0,0,77,4,0,0,114,25,
0,0,0,122,31,83,111,117,114,99,101,108,101,115,115,70,
105,108,101,76,111,97,100,101,114,46,103,101,116,95,115,111,
117,114,99,101,78,41,6,114,137,0,0,0,114,136,0,0,
0,114,138,0,0,0,114,139,0,0,0,114,228,0,0,0,
114,244,0,0,0,114,7,0,0,0,114,7,0,0,0,114,
- 7,0,0,0,114,8,0,0,0,114,26,1,0,0,56,4,
+ 7,0,0,0,114,8,0,0,0,114,26,1,0,0,57,4,
0,0,115,10,0,0,0,8,0,4,2,8,2,12,16,255,
128,114,26,1,0,0,99,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,3,0,0,0,64,0,0,0,115,
@@ -1682,20 +1682,20 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
100,0,83,0,114,121,0,0,0,114,170,0,0,0,41,3,
114,130,0,0,0,114,128,0,0,0,114,58,0,0,0,114,
7,0,0,0,114,7,0,0,0,114,8,0,0,0,114,223,
- 0,0,0,89,4,0,0,115,6,0,0,0,6,1,10,1,
+ 0,0,0,90,4,0,0,115,6,0,0,0,6,1,10,1,
255,128,122,28,69,120,116,101,110,115,105,111,110,70,105,108,
101,76,111,97,100,101,114,46,95,95,105,110,105,116,95,95,
99,2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,
0,2,0,0,0,67,0,0,0,114,255,0,0,0,114,121,
0,0,0,114,0,1,0,0,114,2,1,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,114,3,1,0,
- 0,93,4,0,0,114,4,1,0,0,122,26,69,120,116,101,
+ 0,94,4,0,0,114,4,1,0,0,122,26,69,120,116,101,
110,115,105,111,110,70,105,108,101,76,111,97,100,101,114,46,
95,95,101,113,95,95,99,1,0,0,0,0,0,0,0,0,
0,0,0,1,0,0,0,3,0,0,0,67,0,0,0,114,
5,1,0,0,114,121,0,0,0,114,6,1,0,0,114,8,
1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,114,9,1,0,0,97,4,0,0,114,10,1,0,0,
+ 0,0,114,9,1,0,0,98,4,0,0,114,10,1,0,0,
122,28,69,120,116,101,110,115,105,111,110,70,105,108,101,76,
111,97,100,101,114,46,95,95,104,97,115,104,95,95,99,2,
0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,5,
@@ -1712,7 +1712,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
97,109,105,99,114,160,0,0,0,114,128,0,0,0,114,58,
0,0,0,41,3,114,130,0,0,0,114,198,0,0,0,114,
231,0,0,0,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,226,0,0,0,100,4,0,0,115,16,0,0,
+ 0,0,0,114,226,0,0,0,101,4,0,0,115,16,0,0,
0,4,2,6,1,4,255,6,2,8,1,4,255,4,2,255,
128,122,33,69,120,116,101,110,115,105,111,110,70,105,108,101,
76,111,97,100,101,114,46,99,114,101,97,116,101,95,109,111,
@@ -1730,7 +1730,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
105,99,114,160,0,0,0,114,128,0,0,0,114,58,0,0,
0,169,2,114,130,0,0,0,114,231,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,114,232,0,0,
- 0,108,4,0,0,115,10,0,0,0,14,2,6,1,8,1,
+ 0,109,4,0,0,115,10,0,0,0,14,2,6,1,8,1,
8,255,255,128,122,31,69,120,116,101,110,115,105,111,110,70,
105,108,101,76,111,97,100,101,114,46,101,120,101,99,95,109,
111,100,117,108,101,99,2,0,0,0,0,0,0,0,0,0,
@@ -1748,14 +1748,14 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
78,114,7,0,0,0,169,2,114,5,0,0,0,218,6,115,
117,102,102,105,120,169,1,90,9,102,105,108,101,95,110,97,
109,101,114,7,0,0,0,114,8,0,0,0,114,9,0,0,
- 0,117,4,0,0,115,8,0,0,0,4,0,2,1,20,255,
+ 0,118,4,0,0,115,8,0,0,0,4,0,2,1,20,255,
255,128,122,49,69,120,116,101,110,115,105,111,110,70,105,108,
101,76,111,97,100,101,114,46,105,115,95,112,97,99,107,97,
103,101,46,60,108,111,99,97,108,115,62,46,60,103,101,110,
101,120,112,114,62,78,41,4,114,61,0,0,0,114,58,0,
0,0,218,3,97,110,121,114,219,0,0,0,114,234,0,0,
0,114,7,0,0,0,114,30,1,0,0,114,8,0,0,0,
- 114,193,0,0,0,114,4,0,0,115,10,0,0,0,14,2,
+ 114,193,0,0,0,115,4,0,0,115,10,0,0,0,14,2,
12,1,2,1,8,255,255,128,122,30,69,120,116,101,110,115,
105,111,110,70,105,108,101,76,111,97,100,101,114,46,105,115,
95,112,97,99,107,97,103,101,99,2,0,0,0,0,0,0,
@@ -1766,7 +1766,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
110,111,116,32,99,114,101,97,116,101,32,97,32,99,111,100,
101,32,111,98,106,101,99,116,46,78,114,7,0,0,0,114,
234,0,0,0,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,228,0,0,0,120,4,0,0,114,25,0,0,
+ 0,0,0,114,228,0,0,0,121,4,0,0,114,25,0,0,
0,122,28,69,120,116,101,110,115,105,111,110,70,105,108,101,
76,111,97,100,101,114,46,103,101,116,95,99,111,100,101,99,
2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,
@@ -1776,13 +1776,13 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
115,32,104,97,118,101,32,110,111,32,115,111,117,114,99,101,
32,99,111,100,101,46,78,114,7,0,0,0,114,234,0,0,
0,114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,
- 114,244,0,0,0,124,4,0,0,114,25,0,0,0,122,30,
+ 114,244,0,0,0,125,4,0,0,114,25,0,0,0,122,30,
69,120,116,101,110,115,105,111,110,70,105,108,101,76,111,97,
100,101,114,46,103,101,116,95,115,111,117,114,99,101,99,2,
0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,1,
0,0,0,67,0,0,0,114,13,1,0,0,114,14,1,0,
0,114,62,0,0,0,114,234,0,0,0,114,7,0,0,0,
- 114,7,0,0,0,114,8,0,0,0,114,190,0,0,0,128,
+ 114,7,0,0,0,114,8,0,0,0,114,190,0,0,0,129,
4,0,0,114,15,1,0,0,122,32,69,120,116,101,110,115,
105,111,110,70,105,108,101,76,111,97,100,101,114,46,103,101,
116,95,102,105,108,101,110,97,109,101,78,41,14,114,137,0,
@@ -1791,7 +1791,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,226,0,0,0,114,232,0,0,0,114,193,0,0,0,114,
228,0,0,0,114,244,0,0,0,114,147,0,0,0,114,190,
0,0,0,114,7,0,0,0,114,7,0,0,0,114,7,0,
- 0,0,114,8,0,0,0,114,17,1,0,0,81,4,0,0,
+ 0,0,114,8,0,0,0,114,17,1,0,0,82,4,0,0,
115,26,0,0,0,8,0,4,2,8,6,8,4,8,4,8,
3,8,8,8,6,8,6,8,4,2,4,14,1,255,128,114,
17,1,0,0,99,0,0,0,0,0,0,0,0,0,0,0,
@@ -1834,7 +1834,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
102,105,110,100,101,114,169,4,114,130,0,0,0,114,128,0,
0,0,114,58,0,0,0,90,11,112,97,116,104,95,102,105,
110,100,101,114,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,223,0,0,0,141,4,0,0,115,10,0,0,
+ 0,0,0,114,223,0,0,0,142,4,0,0,115,10,0,0,
0,6,1,6,1,14,1,10,1,255,128,122,23,95,78,97,
109,101,115,112,97,99,101,80,97,116,104,46,95,95,105,110,
105,116,95,95,99,1,0,0,0,0,0,0,0,0,0,0,
@@ -1852,7 +1852,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
1,0,0,218,3,100,111,116,90,2,109,101,114,7,0,0,
0,114,7,0,0,0,114,8,0,0,0,218,23,95,102,105,
110,100,95,112,97,114,101,110,116,95,112,97,116,104,95,110,
- 97,109,101,115,147,4,0,0,115,10,0,0,0,18,2,8,
+ 97,109,101,115,148,4,0,0,115,10,0,0,0,18,2,8,
1,4,2,8,3,255,128,122,38,95,78,97,109,101,115,112,
97,99,101,80,97,116,104,46,95,102,105,110,100,95,112,97,
114,101,110,116,95,112,97,116,104,95,110,97,109,101,115,99,
@@ -1865,7 +1865,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
18,112,97,114,101,110,116,95,109,111,100,117,108,101,95,110,
97,109,101,90,14,112,97,116,104,95,97,116,116,114,95,110,
97,109,101,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,114,35,1,0,0,157,4,0,0,115,6,0,0,0,
+ 0,0,114,35,1,0,0,158,4,0,0,115,6,0,0,0,
12,1,16,1,255,128,122,31,95,78,97,109,101,115,112,97,
99,101,80,97,116,104,46,95,103,101,116,95,112,97,114,101,
110,116,95,112,97,116,104,99,1,0,0,0,0,0,0,0,
@@ -1881,7 +1881,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
34,1,0,0,41,3,114,130,0,0,0,90,11,112,97,114,
101,110,116,95,112,97,116,104,114,198,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,218,12,95,114,
- 101,99,97,108,99,117,108,97,116,101,161,4,0,0,115,18,
+ 101,99,97,108,99,117,108,97,116,101,162,4,0,0,115,18,
0,0,0,12,2,10,1,14,1,18,3,6,1,8,1,6,
1,6,1,255,128,122,27,95,78,97,109,101,115,112,97,99,
101,80,97,116,104,46,95,114,101,99,97,108,99,117,108,97,
@@ -1890,7 +1890,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
116,0,124,0,160,1,161,0,131,1,83,0,114,121,0,0,
0,41,2,218,4,105,116,101,114,114,42,1,0,0,114,8,
1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,218,8,95,95,105,116,101,114,95,95,174,4,0,0,
+ 0,0,218,8,95,95,105,116,101,114,95,95,175,4,0,0,
243,4,0,0,0,12,1,255,128,122,23,95,78,97,109,101,
115,112,97,99,101,80,97,116,104,46,95,95,105,116,101,114,
95,95,99,2,0,0,0,0,0,0,0,0,0,0,0,2,
@@ -1899,7 +1899,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,169,1,114,42,1,0,0,41,2,114,130,0,0,0,218,
5,105,110,100,101,120,114,7,0,0,0,114,7,0,0,0,
114,8,0,0,0,218,11,95,95,103,101,116,105,116,101,109,
- 95,95,177,4,0,0,114,46,1,0,0,122,26,95,78,97,
+ 95,95,178,4,0,0,114,46,1,0,0,122,26,95,78,97,
109,101,115,112,97,99,101,80,97,116,104,46,95,95,103,101,
116,105,116,101,109,95,95,99,3,0,0,0,0,0,0,0,
0,0,0,0,3,0,0,0,3,0,0,0,67,0,0,0,
@@ -1907,7 +1907,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,83,0,114,121,0,0,0,41,1,114,34,1,0,0,41,
3,114,130,0,0,0,114,48,1,0,0,114,58,0,0,0,
114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,218,
- 11,95,95,115,101,116,105,116,101,109,95,95,180,4,0,0,
+ 11,95,95,115,101,116,105,116,101,109,95,95,181,4,0,0,
115,4,0,0,0,14,1,255,128,122,26,95,78,97,109,101,
115,112,97,99,101,80,97,116,104,46,95,95,115,101,116,105,
116,101,109,95,95,99,1,0,0,0,0,0,0,0,0,0,
@@ -1915,7 +1915,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
1,0,0,114,121,0,0,0,41,2,114,4,0,0,0,114,
42,1,0,0,114,8,1,0,0,114,7,0,0,0,114,7,
0,0,0,114,8,0,0,0,218,7,95,95,108,101,110,95,
- 95,183,4,0,0,114,46,1,0,0,122,22,95,78,97,109,
+ 95,184,4,0,0,114,46,1,0,0,122,22,95,78,97,109,
101,115,112,97,99,101,80,97,116,104,46,95,95,108,101,110,
95,95,99,1,0,0,0,0,0,0,0,0,0,0,0,1,
0,0,0,3,0,0,0,67,0,0,0,243,12,0,0,0,
@@ -1923,7 +1923,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
20,95,78,97,109,101,115,112,97,99,101,80,97,116,104,40,
123,33,114,125,41,41,2,114,77,0,0,0,114,34,1,0,
0,114,8,1,0,0,114,7,0,0,0,114,7,0,0,0,
- 114,8,0,0,0,218,8,95,95,114,101,112,114,95,95,186,
+ 114,8,0,0,0,218,8,95,95,114,101,112,114,95,95,187,
4,0,0,114,46,1,0,0,122,23,95,78,97,109,101,115,
112,97,99,101,80,97,116,104,46,95,95,114,101,112,114,95,
95,99,2,0,0,0,0,0,0,0,0,0,0,0,2,0,
@@ -1931,7 +1931,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
1,124,0,160,0,161,0,118,0,83,0,114,121,0,0,0,
114,47,1,0,0,169,2,114,130,0,0,0,218,4,105,116,
101,109,114,7,0,0,0,114,7,0,0,0,114,8,0,0,
- 0,218,12,95,95,99,111,110,116,97,105,110,115,95,95,189,
+ 0,218,12,95,95,99,111,110,116,97,105,110,115,95,95,190,
4,0,0,114,46,1,0,0,122,27,95,78,97,109,101,115,
112,97,99,101,80,97,116,104,46,95,95,99,111,110,116,97,
105,110,115,95,95,99,2,0,0,0,0,0,0,0,0,0,
@@ -1939,7 +1939,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,0,124,0,106,0,160,1,124,1,161,1,1,0,100,
0,83,0,114,121,0,0,0,41,2,114,34,1,0,0,114,
197,0,0,0,114,54,1,0,0,114,7,0,0,0,114,7,
- 0,0,0,114,8,0,0,0,114,197,0,0,0,192,4,0,
+ 0,0,0,114,8,0,0,0,114,197,0,0,0,193,4,0,
0,243,4,0,0,0,16,1,255,128,122,21,95,78,97,109,
101,115,112,97,99,101,80,97,116,104,46,97,112,112,101,110,
100,78,41,15,114,137,0,0,0,114,136,0,0,0,114,138,
@@ -1948,7 +1948,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,114,49,1,0,0,114,50,1,0,0,114,51,1,0,0,
114,53,1,0,0,114,56,1,0,0,114,197,0,0,0,114,
7,0,0,0,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,32,1,0,0,134,4,0,0,115,28,0,0,
+ 0,0,0,114,32,1,0,0,135,4,0,0,115,28,0,0,
0,8,0,4,1,8,6,8,6,8,10,8,4,8,13,8,
3,8,3,8,3,8,3,8,3,12,3,255,128,114,32,1,
0,0,99,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -1964,7 +1964,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,116,0,124,1,124,2,124,3,131,3,124,0,95,1,
100,0,83,0,114,121,0,0,0,41,2,114,32,1,0,0,
114,34,1,0,0,114,38,1,0,0,114,7,0,0,0,114,
- 7,0,0,0,114,8,0,0,0,114,223,0,0,0,198,4,
+ 7,0,0,0,114,8,0,0,0,114,223,0,0,0,199,4,
0,0,115,4,0,0,0,18,1,255,128,122,25,95,78,97,
109,101,115,112,97,99,101,76,111,97,100,101,114,46,95,95,
105,110,105,116,95,95,99,1,0,0,0,0,0,0,0,0,
@@ -1981,20 +1981,20 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
112,97,99,101,41,62,78,41,2,114,77,0,0,0,114,137,
0,0,0,41,1,114,231,0,0,0,114,7,0,0,0,114,
7,0,0,0,114,8,0,0,0,218,11,109,111,100,117,108,
- 101,95,114,101,112,114,201,4,0,0,115,4,0,0,0,12,
+ 101,95,114,101,112,114,202,4,0,0,115,4,0,0,0,12,
7,255,128,122,28,95,78,97,109,101,115,112,97,99,101,76,
111,97,100,101,114,46,109,111,100,117,108,101,95,114,101,112,
114,99,2,0,0,0,0,0,0,0,0,0,0,0,2,0,
0,0,1,0,0,0,67,0,0,0,114,24,0,0,0,41,
2,78,84,114,7,0,0,0,114,234,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,114,193,0,0,
- 0,210,4,0,0,243,4,0,0,0,4,1,255,128,122,27,
+ 0,211,4,0,0,243,4,0,0,0,4,1,255,128,122,27,
95,78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,
46,105,115,95,112,97,99,107,97,103,101,99,2,0,0,0,
0,0,0,0,0,0,0,0,2,0,0,0,1,0,0,0,
67,0,0,0,114,24,0,0,0,41,2,78,114,10,0,0,
0,114,7,0,0,0,114,234,0,0,0,114,7,0,0,0,
- 114,7,0,0,0,114,8,0,0,0,114,244,0,0,0,213,
+ 114,7,0,0,0,114,8,0,0,0,114,244,0,0,0,214,
4,0,0,114,60,1,0,0,122,27,95,78,97,109,101,115,
112,97,99,101,76,111,97,100,101,114,46,103,101,116,95,115,
111,117,114,99,101,99,2,0,0,0,0,0,0,0,0,0,
@@ -2004,20 +2004,20 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,105,110,103,62,114,230,0,0,0,84,41,1,114,246,0,
0,0,41,1,114,247,0,0,0,114,234,0,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,228,0,
- 0,0,216,4,0,0,114,57,1,0,0,122,25,95,78,97,
+ 0,0,217,4,0,0,114,57,1,0,0,122,25,95,78,97,
109,101,115,112,97,99,101,76,111,97,100,101,114,46,103,101,
116,95,99,111,100,101,99,2,0,0,0,0,0,0,0,0,
0,0,0,2,0,0,0,1,0,0,0,67,0,0,0,114,
24,0,0,0,114,224,0,0,0,114,7,0,0,0,114,225,
0,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,114,226,0,0,0,219,4,0,0,114,227,0,0,0,
+ 0,0,114,226,0,0,0,220,4,0,0,114,227,0,0,0,
122,30,95,78,97,109,101,115,112,97,99,101,76,111,97,100,
101,114,46,99,114,101,97,116,101,95,109,111,100,117,108,101,
99,2,0,0,0,0,0,0,0,0,0,0,0,2,0,0,
0,1,0,0,0,67,0,0,0,115,4,0,0,0,100,0,
83,0,114,121,0,0,0,114,7,0,0,0,114,27,1,0,
0,114,7,0,0,0,114,7,0,0,0,114,8,0,0,0,
- 114,232,0,0,0,222,4,0,0,114,60,1,0,0,122,28,
+ 114,232,0,0,0,223,4,0,0,114,60,1,0,0,122,28,
95,78,97,109,101,115,112,97,99,101,76,111,97,100,101,114,
46,101,120,101,99,95,109,111,100,117,108,101,99,2,0,0,
0,0,0,0,0,0,0,0,0,2,0,0,0,4,0,0,
@@ -2035,7 +2035,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,125,78,41,4,114,146,0,0,0,114,160,0,0,0,114,
34,1,0,0,114,233,0,0,0,114,234,0,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,235,0,
- 0,0,225,4,0,0,115,10,0,0,0,6,7,4,1,4,
+ 0,0,226,4,0,0,115,10,0,0,0,6,7,4,1,4,
255,12,3,255,128,122,28,95,78,97,109,101,115,112,97,99,
101,76,111,97,100,101,114,46,108,111,97,100,95,109,111,100,
117,108,101,78,41,12,114,137,0,0,0,114,136,0,0,0,
@@ -2043,7 +2043,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
59,1,0,0,114,193,0,0,0,114,244,0,0,0,114,228,
0,0,0,114,226,0,0,0,114,232,0,0,0,114,235,0,
0,0,114,7,0,0,0,114,7,0,0,0,114,7,0,0,
- 0,114,8,0,0,0,114,58,1,0,0,197,4,0,0,115,
+ 0,114,8,0,0,0,114,58,1,0,0,198,4,0,0,115,
22,0,0,0,8,0,8,1,2,3,10,1,8,8,8,3,
8,3,8,3,8,3,12,3,255,128,114,58,1,0,0,99,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -2080,7 +2080,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
95,99,97,99,104,101,218,5,105,116,101,109,115,114,140,0,
0,0,114,62,1,0,0,41,2,114,128,0,0,0,218,6,
102,105,110,100,101,114,114,7,0,0,0,114,7,0,0,0,
- 114,8,0,0,0,114,62,1,0,0,244,4,0,0,115,16,
+ 114,8,0,0,0,114,62,1,0,0,245,4,0,0,115,16,
0,0,0,22,4,8,1,10,1,10,1,8,1,2,128,4,
252,255,128,122,28,80,97,116,104,70,105,110,100,101,114,46,
105,110,118,97,108,105,100,97,116,101,95,99,97,99,104,101,
@@ -2100,7 +2100,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
89,0,0,0,114,149,0,0,0,114,129,0,0,0,41,2,
114,58,0,0,0,90,4,104,111,111,107,114,7,0,0,0,
114,7,0,0,0,114,8,0,0,0,218,11,95,112,97,116,
- 104,95,104,111,111,107,115,254,4,0,0,115,20,0,0,0,
+ 104,95,104,111,111,107,115,255,4,0,0,115,20,0,0,0,
16,3,12,1,10,1,2,1,14,1,12,1,4,1,4,2,
2,253,255,128,122,22,80,97,116,104,70,105,110,100,101,114,
46,95,112,97,116,104,95,104,111,111,107,115,99,2,0,0,
@@ -2132,7 +2132,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,41,3,114,209,0,0,0,114,58,0,0,0,114,66,
1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
0,0,218,20,95,112,97,116,104,95,105,109,112,111,114,116,
- 101,114,95,99,97,99,104,101,11,5,0,0,115,30,0,0,
+ 101,114,95,99,97,99,104,101,12,5,0,0,115,30,0,0,
0,8,8,2,1,12,1,12,1,6,3,2,1,12,1,4,
4,12,253,10,1,12,1,4,1,2,253,2,250,255,128,122,
31,80,97,116,104,70,105,110,100,101,114,46,95,112,97,116,
@@ -2150,7 +2150,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
209,0,0,0,114,150,0,0,0,114,66,1,0,0,114,151,
0,0,0,114,152,0,0,0,114,198,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,218,16,95,108,
- 101,103,97,99,121,95,103,101,116,95,115,112,101,99,33,5,
+ 101,103,97,99,121,95,103,101,116,95,115,112,101,99,34,5,
0,0,115,20,0,0,0,10,4,16,1,10,2,4,1,8,
1,12,1,12,1,6,1,4,1,255,128,122,27,80,97,116,
104,70,105,110,100,101,114,46,95,108,101,103,97,99,121,95,
@@ -2182,7 +2182,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
101,95,112,97,116,104,90,5,101,110,116,114,121,114,66,1,
0,0,114,198,0,0,0,114,152,0,0,0,114,7,0,0,
0,114,7,0,0,0,114,8,0,0,0,218,9,95,103,101,
- 116,95,115,112,101,99,48,5,0,0,115,44,0,0,0,4,
+ 116,95,115,112,101,99,49,5,0,0,115,44,0,0,0,4,
5,8,1,14,1,2,1,10,1,8,1,10,1,14,1,12,
2,8,1,2,1,10,1,8,1,6,1,8,1,8,1,10,
5,2,128,12,2,6,1,4,1,255,128,122,20,80,97,116,
@@ -2209,7 +2209,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
32,1,0,0,41,6,114,209,0,0,0,114,150,0,0,0,
114,58,0,0,0,114,213,0,0,0,114,198,0,0,0,114,
74,1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,214,0,0,0,80,5,0,0,115,28,0,0,
+ 0,0,0,114,214,0,0,0,81,5,0,0,115,28,0,0,
0,8,6,6,1,14,1,8,1,4,1,10,1,6,1,4,
1,6,3,16,1,4,1,4,2,4,2,255,128,122,20,80,
97,116,104,70,105,110,100,101,114,46,102,105,110,100,95,115,
@@ -2229,7 +2229,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
105,110,100,95,115,112,101,99,40,41,32,105,110,115,116,101,
97,100,46,10,10,32,32,32,32,32,32,32,32,78,114,215,
0,0,0,114,216,0,0,0,114,7,0,0,0,114,7,0,
- 0,0,114,8,0,0,0,114,217,0,0,0,104,5,0,0,
+ 0,0,114,8,0,0,0,114,217,0,0,0,105,5,0,0,
115,10,0,0,0,12,8,8,1,4,1,6,1,255,128,122,
22,80,97,116,104,70,105,110,100,101,114,46,102,105,110,100,
95,109,111,100,117,108,101,99,0,0,0,0,0,0,0,0,
@@ -2261,7 +2261,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
18,102,105,110,100,95,100,105,115,116,114,105,98,117,116,105,
111,110,115,41,3,114,131,0,0,0,114,132,0,0,0,114,
76,1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,114,77,1,0,0,117,5,0,0,115,6,0,0,
+ 0,0,0,114,77,1,0,0,118,5,0,0,115,6,0,0,
0,12,10,16,1,255,128,122,29,80,97,116,104,70,105,110,
100,101,114,46,102,105,110,100,95,100,105,115,116,114,105,98,
117,116,105,111,110,115,41,1,78,41,2,78,78,41,1,78,
@@ -2271,7 +2271,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
72,1,0,0,114,75,1,0,0,114,214,0,0,0,114,217,
0,0,0,114,77,1,0,0,114,7,0,0,0,114,7,0,
0,0,114,7,0,0,0,114,8,0,0,0,114,61,1,0,
- 0,240,4,0,0,115,38,0,0,0,8,0,4,2,2,2,
+ 0,241,4,0,0,115,38,0,0,0,8,0,4,2,2,2,
10,1,2,9,10,1,2,12,10,1,2,21,10,1,2,14,
12,1,2,31,12,1,2,23,12,1,2,12,14,1,255,128,
114,61,1,0,0,99,0,0,0,0,0,0,0,0,0,0,
@@ -2316,7 +2316,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,102,2,86,0,1,0,113,2,100,0,83,0,114,121,0,
0,0,114,7,0,0,0,114,28,1,0,0,169,1,114,151,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,9,0,
- 0,0,146,5,0,0,114,14,0,0,0,122,38,70,105,108,
+ 0,0,147,5,0,0,114,14,0,0,0,122,38,70,105,108,
101,70,105,110,100,101,114,46,95,95,105,110,105,116,95,95,
46,60,108,111,99,97,108,115,62,46,60,103,101,110,101,120,
112,114,62,114,86,0,0,0,114,116,0,0,0,78,41,7,
@@ -2328,7 +2328,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
58,0,0,0,218,14,108,111,97,100,101,114,95,100,101,116,
97,105,108,115,90,7,108,111,97,100,101,114,115,114,200,0,
0,0,114,7,0,0,0,114,79,1,0,0,114,8,0,0,
- 0,114,223,0,0,0,140,5,0,0,115,18,0,0,0,4,
+ 0,114,223,0,0,0,141,5,0,0,115,18,0,0,0,4,
4,12,1,26,1,6,1,10,2,6,1,8,1,12,1,255,
128,122,19,70,105,108,101,70,105,110,100,101,114,46,95,95,
105,110,105,116,95,95,99,1,0,0,0,0,0,0,0,0,
@@ -2338,7 +2338,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
32,100,105,114,101,99,116,111,114,121,32,109,116,105,109,101,
46,114,116,0,0,0,78,41,1,114,81,1,0,0,114,8,
1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,114,62,1,0,0,154,5,0,0,114,69,0,0,0,
+ 0,0,114,62,1,0,0,155,5,0,0,114,69,0,0,0,
122,28,70,105,108,101,70,105,110,100,101,114,46,105,110,118,
97,108,105,100,97,116,101,95,99,97,99,104,101,115,99,2,
0,0,0,0,0,0,0,0,0,0,0,3,0,0,0,3,
@@ -2361,7 +2361,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
41,3,114,214,0,0,0,114,151,0,0,0,114,189,0,0,
0,41,3,114,130,0,0,0,114,150,0,0,0,114,198,0,
0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,0,
- 0,114,148,0,0,0,160,5,0,0,115,10,0,0,0,10,
+ 0,114,148,0,0,0,161,5,0,0,115,10,0,0,0,10,
7,8,1,8,1,16,1,255,128,122,22,70,105,108,101,70,
105,110,100,101,114,46,102,105,110,100,95,108,111,97,100,101,
114,99,6,0,0,0,0,0,0,0,0,0,0,0,7,0,
@@ -2372,7 +2372,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
199,0,0,0,114,150,0,0,0,114,58,0,0,0,90,4,
115,109,115,108,114,213,0,0,0,114,151,0,0,0,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,75,1,
- 0,0,172,5,0,0,115,10,0,0,0,10,1,8,1,2,
+ 0,0,173,5,0,0,115,10,0,0,0,10,1,8,1,2,
1,6,255,255,128,122,20,70,105,108,101,70,105,110,100,101,
114,46,95,103,101,116,95,115,112,101,99,78,99,3,0,0,
0,0,0,0,0,0,0,0,0,14,0,0,0,8,0,0,
@@ -2427,7 +2427,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
110,105,116,95,102,105,108,101,110,97,109,101,90,9,102,117,
108,108,95,112,97,116,104,114,198,0,0,0,114,7,0,0,
0,114,7,0,0,0,114,8,0,0,0,114,214,0,0,0,
- 177,5,0,0,115,80,0,0,0,4,5,14,1,2,1,24,
+ 178,5,0,0,115,80,0,0,0,4,5,14,1,2,1,24,
1,14,1,6,1,10,1,8,1,6,1,6,2,6,1,10,
1,6,2,4,1,8,2,12,1,14,1,8,1,10,1,8,
1,24,1,2,255,8,5,14,2,16,1,16,1,14,1,10,
@@ -2458,7 +2458,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
104,0,124,0,93,12,125,1,124,1,160,0,161,0,146,2,
113,4,83,0,114,7,0,0,0,41,1,114,117,0,0,0,
41,2,114,5,0,0,0,90,2,102,110,114,7,0,0,0,
- 114,7,0,0,0,114,8,0,0,0,114,13,0,0,0,254,
+ 114,7,0,0,0,114,8,0,0,0,114,13,0,0,0,255,
5,0,0,115,4,0,0,0,20,0,255,128,122,41,70,105,
108,101,70,105,110,100,101,114,46,95,102,105,108,108,95,99,
97,99,104,101,46,60,108,111,99,97,108,115,62,46,60,115,
@@ -2476,7 +2476,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,55,1,0,0,114,128,0,0,0,114,39,1,0,0,114,
29,1,0,0,90,8,110,101,119,95,110,97,109,101,114,7,
0,0,0,114,7,0,0,0,114,8,0,0,0,114,86,1,
- 0,0,225,5,0,0,115,40,0,0,0,6,2,2,1,22,
+ 0,0,226,5,0,0,115,40,0,0,0,6,2,2,1,22,
1,18,1,6,3,12,3,12,1,6,7,8,1,16,1,4,
1,18,1,4,2,12,1,6,1,12,1,20,1,4,255,2,
233,255,128,122,22,70,105,108,101,70,105,110,100,101,114,46,
@@ -2515,14 +2515,14 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
169,2,114,209,0,0,0,114,85,1,0,0,114,7,0,0,
0,114,8,0,0,0,218,24,112,97,116,104,95,104,111,111,
107,95,102,111,114,95,70,105,108,101,70,105,110,100,101,114,
- 10,6,0,0,115,8,0,0,0,8,2,12,1,16,1,255,
+ 11,6,0,0,115,8,0,0,0,8,2,12,1,16,1,255,
128,122,54,70,105,108,101,70,105,110,100,101,114,46,112,97,
116,104,95,104,111,111,107,46,60,108,111,99,97,108,115,62,
46,112,97,116,104,95,104,111,111,107,95,102,111,114,95,70,
105,108,101,70,105,110,100,101,114,78,114,7,0,0,0,41,
3,114,209,0,0,0,114,85,1,0,0,114,91,1,0,0,
114,7,0,0,0,114,90,1,0,0,114,8,0,0,0,218,
- 9,112,97,116,104,95,104,111,111,107,0,6,0,0,115,6,
+ 9,112,97,116,104,95,104,111,111,107,1,6,0,0,115,6,
0,0,0,14,10,4,6,255,128,122,20,70,105,108,101,70,
105,110,100,101,114,46,112,97,116,104,95,104,111,111,107,99,
1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,
@@ -2530,7 +2530,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
122,16,70,105,108,101,70,105,110,100,101,114,40,123,33,114,
125,41,41,2,114,77,0,0,0,114,58,0,0,0,114,8,
1,0,0,114,7,0,0,0,114,7,0,0,0,114,8,0,
- 0,0,114,53,1,0,0,18,6,0,0,114,46,1,0,0,
+ 0,0,114,53,1,0,0,19,6,0,0,114,46,1,0,0,
122,19,70,105,108,101,70,105,110,100,101,114,46,95,95,114,
101,112,114,95,95,41,1,78,41,15,114,137,0,0,0,114,
136,0,0,0,114,138,0,0,0,114,139,0,0,0,114,223,
@@ -2538,7 +2538,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,114,148,0,0,0,114,75,1,0,0,114,214,0,0,
0,114,86,1,0,0,114,221,0,0,0,114,92,1,0,0,
114,53,1,0,0,114,7,0,0,0,114,7,0,0,0,114,
- 7,0,0,0,114,8,0,0,0,114,78,1,0,0,131,5,
+ 7,0,0,0,114,8,0,0,0,114,78,1,0,0,132,5,
0,0,115,26,0,0,0,8,0,4,2,8,7,8,14,4,
4,8,2,8,12,10,5,8,48,2,31,10,1,12,17,255,
128,114,78,1,0,0,99,4,0,0,0,0,0,0,0,0,
@@ -2562,7 +2562,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
97,109,101,90,9,99,112,97,116,104,110,97,109,101,114,151,
0,0,0,114,198,0,0,0,114,7,0,0,0,114,7,0,
0,0,114,8,0,0,0,218,14,95,102,105,120,95,117,112,
- 95,109,111,100,117,108,101,24,6,0,0,115,38,0,0,0,
+ 95,109,111,100,117,108,101,25,6,0,0,115,38,0,0,0,
10,2,10,1,4,1,4,1,8,1,8,1,12,1,10,2,
4,1,14,1,2,1,8,1,8,1,8,1,14,1,12,1,
6,2,2,254,255,128,114,97,1,0,0,99,0,0,0,0,
@@ -2582,7 +2582,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
0,0,114,101,0,0,0,41,3,90,10,101,120,116,101,110,
115,105,111,110,115,90,6,115,111,117,114,99,101,90,8,98,
121,116,101,99,111,100,101,114,7,0,0,0,114,7,0,0,
- 0,114,8,0,0,0,114,195,0,0,0,47,6,0,0,115,
+ 0,114,8,0,0,0,114,195,0,0,0,48,6,0,0,115,
10,0,0,0,12,5,8,1,8,1,10,1,255,128,114,195,
0,0,0,99,1,0,0,0,0,0,0,0,0,0,0,0,
1,0,0,0,1,0,0,0,67,0,0,0,115,8,0,0,
@@ -2591,7 +2591,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,97,112,95,109,111,100,117,108,101,114,7,0,0,0,114,
7,0,0,0,114,8,0,0,0,218,21,95,115,101,116,95,
98,111,111,116,115,116,114,97,112,95,109,111,100,117,108,101,
- 58,6,0,0,115,4,0,0,0,8,2,255,128,114,100,1,
+ 59,6,0,0,115,4,0,0,0,8,2,255,128,114,100,1,
0,0,99,1,0,0,0,0,0,0,0,0,0,0,0,2,
0,0,0,4,0,0,0,67,0,0,0,115,50,0,0,0,
116,0,124,0,131,1,1,0,116,1,131,0,125,1,116,2,
@@ -2606,7 +2606,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
114,197,0,0,0,114,61,1,0,0,41,2,114,99,1,0,
0,90,17,115,117,112,112,111,114,116,101,100,95,108,111,97,
100,101,114,115,114,7,0,0,0,114,7,0,0,0,114,8,
- 0,0,0,218,8,95,105,110,115,116,97,108,108,63,6,0,
+ 0,0,0,218,8,95,105,110,115,116,97,108,108,64,6,0,
0,115,10,0,0,0,8,2,6,1,20,1,16,1,255,128,
114,102,1,0,0,41,1,114,75,0,0,0,41,1,78,41,
3,78,78,78,41,2,114,0,0,0,0,114,0,0,0,0,
@@ -2649,7 +2649,7 @@ const unsigned char _Py_M__importlib_bootstrap_external[] = {
2,4,3,10,1,6,2,22,2,8,1,10,1,14,1,4,
4,4,1,2,1,2,1,4,255,8,4,6,16,8,3,8,
5,8,5,8,6,8,6,8,12,8,10,8,9,8,5,8,
- 7,10,9,10,22,0,127,16,24,12,1,4,2,4,1,6,
+ 7,10,9,10,22,0,127,16,25,12,1,4,2,4,1,6,
2,6,1,10,1,8,2,6,2,8,2,16,2,8,71,8,
40,8,19,8,12,8,12,8,31,8,17,8,33,8,28,10,
24,10,13,10,10,8,11,6,14,4,3,2,1,12,255,14,
diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h
index 8495871..692442a 100644
--- a/Python/opcode_targets.h
+++ b/Python/opcode_targets.h
@@ -29,11 +29,11 @@
&&TARGET_BINARY_TRUE_DIVIDE,
&&TARGET_INPLACE_FLOOR_DIVIDE,
&&TARGET_INPLACE_TRUE_DIVIDE,
- &&_unknown_opcode,
- &&_unknown_opcode,
- &&_unknown_opcode,
- &&_unknown_opcode,
- &&_unknown_opcode,
+ &&TARGET_GET_LEN,
+ &&TARGET_MATCH_MAPPING,
+ &&TARGET_MATCH_SEQUENCE,
+ &&TARGET_MATCH_KEYS,
+ &&TARGET_COPY_DICT_WITHOUT_KEYS,
&&_unknown_opcode,
&&_unknown_opcode,
&&_unknown_opcode,
@@ -151,7 +151,7 @@
&&_unknown_opcode,
&&_unknown_opcode,
&&_unknown_opcode,
- &&_unknown_opcode,
+ &&TARGET_MATCH_CLASS,
&&_unknown_opcode,
&&TARGET_SETUP_ASYNC_WITH,
&&TARGET_FORMAT_VALUE,
diff --git a/Python/pystate.c b/Python/pystate.c
index 1623bab..e7c085d 100644
--- a/Python/pystate.c
+++ b/Python/pystate.c
@@ -308,6 +308,8 @@ interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate)
Py_CLEAR(interp->importlib);
Py_CLEAR(interp->import_func);
Py_CLEAR(interp->dict);
+ Py_CLEAR(interp->map_abc);
+ Py_CLEAR(interp->seq_abc);
#ifdef HAVE_FORK
Py_CLEAR(interp->before_forkers);
Py_CLEAR(interp->after_forkers_parent);
diff --git a/Python/symtable.c b/Python/symtable.c
index cce1b1b..10a47d1 100644
--- a/Python/symtable.c
+++ b/Python/symtable.c
@@ -207,6 +207,7 @@ static int symtable_visit_argannotations(struct symtable *st, asdl_arg_seq *args
static int symtable_implicit_arg(struct symtable *st, int pos);
static int symtable_visit_annotations(struct symtable *st, arguments_ty, expr_ty);
static int symtable_visit_withitem(struct symtable *st, withitem_ty item);
+static int symtable_visit_match_case(struct symtable *st, match_case_ty m);
static identifier top = NULL, lambda = NULL, genexpr = NULL,
@@ -239,6 +240,7 @@ symtable_new(void)
goto fail;
st->st_cur = NULL;
st->st_private = NULL;
+ st->in_pattern = 0;
return st;
fail:
PySymtable_Free(st);
@@ -1294,6 +1296,10 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
if (s->v.If.orelse)
VISIT_SEQ(st, stmt, s->v.If.orelse);
break;
+ case Match_kind:
+ VISIT(st, expr, s->v.Match.subject);
+ VISIT_SEQ(st, match_case, s->v.Match.cases);
+ break;
case Raise_kind:
if (s->v.Raise.exc) {
VISIT(st, expr, s->v.Raise.exc);
@@ -1648,6 +1654,13 @@ symtable_visit_expr(struct symtable *st, expr_ty e)
VISIT(st, expr, e->v.Slice.step)
break;
case Name_kind:
+ // Don't make "_" a local when used in a pattern:
+ if (st->in_pattern &&
+ e->v.Name.ctx == Store &&
+ _PyUnicode_EqualToASCIIString(e->v.Name.id, "_"))
+ {
+ break;
+ }
if (!symtable_add_def(st, e->v.Name.id,
e->v.Name.ctx == Load ? USE : DEF_LOCAL))
VISIT_QUIT(st, 0);
@@ -1667,6 +1680,13 @@ symtable_visit_expr(struct symtable *st, expr_ty e)
case Tuple_kind:
VISIT_SEQ(st, expr, e->v.Tuple.elts);
break;
+ case MatchAs_kind:
+ VISIT(st, expr, e->v.MatchAs.pattern);
+ symtable_add_def(st, e->v.MatchAs.name, DEF_LOCAL);
+ break;
+ case MatchOr_kind:
+ VISIT_SEQ(st, expr, e->v.MatchOr.patterns);
+ break;
}
VISIT_QUIT(st, 1);
}
@@ -1785,6 +1805,20 @@ symtable_visit_withitem(struct symtable *st, withitem_ty item)
return 1;
}
+static int
+symtable_visit_match_case(struct symtable *st, match_case_ty m)
+{
+ assert(!st->in_pattern);
+ st->in_pattern = 1;
+ VISIT(st, expr, m->pattern);
+ assert(st->in_pattern);
+ st->in_pattern = 0;
+ if (m->guard) {
+ VISIT(st, expr, m->guard);
+ }
+ VISIT_SEQ(st, stmt, m->body);
+ return 1;
+}
static int
symtable_visit_alias(struct symtable *st, alias_ty a)