diff --git a/.python-version b/.python-version new file mode 100644 index 000000000000000..02534efbc613028 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.15-dev diff --git a/Doc/library/token-list.inc b/Doc/library/token-list.inc index 655758c4a400ccd..a7acb3d65fa76ed 100644 --- a/Doc/library/token-list.inc +++ b/Doc/library/token-list.inc @@ -102,3 +102,5 @@ - ``":="`` * - .. data:: EXCLAMATION - ``"!"`` + * - .. data:: LFBRACE + - ``"f{"`` diff --git a/Grammar/Tokens b/Grammar/Tokens index 0547e6ed08f79ae..7ae3d332a51a54f 100644 --- a/Grammar/Tokens +++ b/Grammar/Tokens @@ -59,6 +59,7 @@ RARROW '->' ELLIPSIS '...' COLONEQUAL ':=' EXCLAMATION '!' +LFBRACE 'f{' OP TYPE_IGNORE diff --git a/Grammar/python.gram b/Grammar/python.gram index a8adeb566aaf5d1..537fd42f2a61769 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -902,6 +902,7 @@ atom[expr_ty]: | &'(' (genexp | tuple | group) | &'[' (listcomp | list) | &'{' (dictcomp | setcomp | dict | set) + | &'f{' (frozendictcomp | frozensetcomp | frozendict | frozenset) | '...' { _PyAST_Constant(Py_Ellipsis, NULL, EXTRA) } group[expr_ty]: @@ -1023,6 +1024,8 @@ tuple[expr_ty]: set[expr_ty]: '{' a=star_named_expressions_sequence '}' { _PyAST_Set(a, EXTRA) } +frozenset[expr_ty]: 'f{' a=star_named_expressions_sequence '}' { _PyAST_FrozenSet(a, EXTRA) } + # Dicts # ----- @@ -1034,6 +1037,14 @@ dict[expr_ty]: EXTRA) } | '{' invalid_double_starred_kvpairs '}' +frozendict[expr_ty]: + | 'f{' a=[double_starred_kvpairs] '}' { + _PyAST_FrozenDict( + CHECK(asdl_expr_seq*, _PyPegen_get_keys(p, a)), + CHECK(asdl_expr_seq*, _PyPegen_get_values(p, a)), + EXTRA) } + | 'f{' invalid_double_starred_kvpairs '}' + double_starred_kvpairs[asdl_seq*]: a=','.double_starred_kvpair+ [','] { a } double_starred_kvpair[KeyValuePair*]: @@ -1064,6 +1075,10 @@ setcomp[expr_ty]: | '{' a=star_named_expression b=for_if_clauses '}' { _PyAST_SetComp(a, b, EXTRA) } | invalid_comprehension +frozensetcomp[expr_ty]: + | 'f{' a=star_named_expression b=for_if_clauses '}' { _PyAST_FrozenSetComp(a, b, EXTRA) } + | invalid_comprehension + genexp[expr_ty]: | '(' a=( assignment_expression | expression !':=' | starred_expression ) b=for_if_clauses ')' { _PyAST_GeneratorExp(a, b, EXTRA) } | invalid_comprehension @@ -1072,6 +1087,10 @@ dictcomp[expr_ty]: | '{' a=kvpair b=for_if_clauses '}' { _PyAST_DictComp(a->key, a->value, b, EXTRA) } | '{' '**' a=expression b=for_if_clauses '}' { _PyAST_DictComp(a, NULL, b, EXTRA) } +frozendictcomp[expr_ty]: + | 'f{' a=kvpair b=for_if_clauses '}' { _PyAST_FrozenDictComp(a->key, a->value, b, EXTRA) } + | 'f{' '**' a=expression b=for_if_clauses '}' { _PyAST_FrozenDictComp(a, NULL, b, EXTRA) } + # FUNCTION CALL ARGUMENTS # ======================= @@ -1353,10 +1372,10 @@ invalid_comprehension: RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in list comprehension") } | '(' a='**' b=expression for_if_clauses { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in generator expression") } - | ('[' | '{') a=star_named_expression ',' b=star_named_expressions for_if_clauses { + | ('[' | '{' | 'f{') a=star_named_expression ',' b=star_named_expressions for_if_clauses { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, PyPegen_last_item(b, expr_ty), "did you forget parentheses around the comprehension target?") } - | ('[' | '{') a=star_named_expression b=',' for_if_clauses { + | ('[' | '{' | 'f{') a=star_named_expression b=',' for_if_clauses { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "did you forget parentheses around the comprehension target?") } invalid_parameters: | a="/" ',' { diff --git a/Include/internal/pycore_ast.h b/Include/internal/pycore_ast.h index b47398669bbe513..35b237cbd86470d 100644 --- a/Include/internal/pycore_ast.h +++ b/Include/internal/pycore_ast.h @@ -359,14 +359,15 @@ struct _stmt { }; enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, - Lambda_kind=5, IfExp_kind=6, Dict_kind=7, Set_kind=8, - ListComp_kind=9, SetComp_kind=10, DictComp_kind=11, - GeneratorExp_kind=12, Await_kind=13, Yield_kind=14, - YieldFrom_kind=15, Compare_kind=16, Call_kind=17, - FormattedValue_kind=18, Interpolation_kind=19, - JoinedStr_kind=20, TemplateStr_kind=21, Constant_kind=22, - Attribute_kind=23, Subscript_kind=24, Starred_kind=25, - Name_kind=26, List_kind=27, Tuple_kind=28, Slice_kind=29}; + Lambda_kind=5, IfExp_kind=6, Dict_kind=7, FrozenDict_kind=8, + Set_kind=9, FrozenSet_kind=10, ListComp_kind=11, + SetComp_kind=12, FrozenSetComp_kind=13, DictComp_kind=14, + FrozenDictComp_kind=15, GeneratorExp_kind=16, Await_kind=17, + Yield_kind=18, YieldFrom_kind=19, Compare_kind=20, + Call_kind=21, FormattedValue_kind=22, Interpolation_kind=23, + JoinedStr_kind=24, TemplateStr_kind=25, Constant_kind=26, + Attribute_kind=27, Subscript_kind=28, Starred_kind=29, + Name_kind=30, List_kind=31, Tuple_kind=32, Slice_kind=33}; struct _expr { enum _expr_kind kind; union { @@ -407,10 +408,19 @@ struct _expr { asdl_expr_seq *values; } Dict; + struct { + asdl_expr_seq *keys; + asdl_expr_seq *values; + } FrozenDict; + struct { asdl_expr_seq *elts; } Set; + struct { + asdl_expr_seq *elts; + } FrozenSet; + struct { expr_ty elt; asdl_comprehension_seq *generators; @@ -421,12 +431,23 @@ struct _expr { asdl_comprehension_seq *generators; } SetComp; + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } FrozenSetComp; + struct { expr_ty key; expr_ty value; asdl_comprehension_seq *generators; } DictComp; + struct { + expr_ty key; + expr_ty value; + asdl_comprehension_seq *generators; + } FrozenDictComp; + struct { expr_ty elt; asdl_comprehension_seq *generators; @@ -806,17 +827,29 @@ expr_ty _PyAST_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, expr_ty _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_FrozenDict(asdl_expr_seq * keys, asdl_expr_seq * values, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); expr_ty _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_FrozenSet(asdl_expr_seq * elts, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_FrozenSetComp(expr_ty elt, asdl_comprehension_seq * generators, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); expr_ty _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_FrozenDictComp(expr_ty key, expr_ty value, + asdl_comprehension_seq * generators, int lineno, + int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); expr_ty _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); diff --git a/Include/internal/pycore_ast_state.h b/Include/internal/pycore_ast_state.h index 32c12fb5875e8ea..290e51fec427389 100644 --- a/Include/internal/pycore_ast_state.h +++ b/Include/internal/pycore_ast_state.h @@ -60,6 +60,10 @@ struct ast_state { PyObject *FloorDiv_type; PyObject *For_type; PyObject *FormattedValue_type; + PyObject *FrozenDictComp_type; + PyObject *FrozenDict_type; + PyObject *FrozenSetComp_type; + PyObject *FrozenSet_type; PyObject *FunctionDef_type; PyObject *FunctionType_type; PyObject *GeneratorExp_type; diff --git a/Include/internal/pycore_ceval.h b/Include/internal/pycore_ceval.h index 19b5473271fffb5..90a3d8f9e4ea45b 100644 --- a/Include/internal/pycore_ceval.h +++ b/Include/internal/pycore_ceval.h @@ -472,6 +472,12 @@ _Py_BuildMap_StackRefSteal( _PyStackRef *arguments, int half_args); +PyAPI_FUNC(int) +_Py_BuildSet_StackRefSteal( + PyObject *set_o, + _PyStackRef *values, + int oparg); + PyAPI_FUNC(void) _Py_assert_within_stack_bounds( _PyInterpreterFrame *frame, _PyStackRef *stack_pointer, diff --git a/Include/internal/pycore_global_objects_fini_generated.h b/Include/internal/pycore_global_objects_fini_generated.h index 7d952a1e52561a6..04217db0c152ceb 100644 --- a/Include/internal/pycore_global_objects_fini_generated.h +++ b/Include/internal/pycore_global_objects_fini_generated.h @@ -1311,6 +1311,8 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[254]); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_SINGLETON(bytes_characters)[255]); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_dictcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_frozendictcomp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_frozensetcomp)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_genexpr)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_lambda)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(anon_listcomp)); diff --git a/Include/internal/pycore_global_strings.h b/Include/internal/pycore_global_strings.h index 8a8bbc3b6d05bf7..215862a9f12b2d8 100644 --- a/Include/internal/pycore_global_strings.h +++ b/Include/internal/pycore_global_strings.h @@ -31,6 +31,8 @@ extern "C" { struct _Py_global_strings { struct { STRUCT_FOR_STR(anon_dictcomp, "") + STRUCT_FOR_STR(anon_frozendictcomp, "") + STRUCT_FOR_STR(anon_frozensetcomp, "") STRUCT_FOR_STR(anon_genexpr, "") STRUCT_FOR_STR(anon_lambda, "") STRUCT_FOR_STR(anon_listcomp, "") diff --git a/Include/internal/pycore_magic_number.h b/Include/internal/pycore_magic_number.h index 74703dcdbcdd6fa..97a1555be5db2b5 100644 --- a/Include/internal/pycore_magic_number.h +++ b/Include/internal/pycore_magic_number.h @@ -301,6 +301,7 @@ Known values: Python 3.16a0 3701 (Add CONSTANT_EMPTY_TUPLE to LOAD_COMMON_CONSTANT) Python 3.16a1 3702 (Replace DELETE_NAME with PUSH_NULL; STORE_NAME) Python 3.16a1 3703 (Replace DELETE_GLOBAL with PUSH_NULL; STORE_GLOBAL) + Python 3.16a1 3704 (Add BUILD_FROZENSET and BUILD_FROZENDICT) Python 3.17 will start with 3750 @@ -314,7 +315,7 @@ PC/launcher.c must also be updated. */ -#define PYC_MAGIC_NUMBER 3703 +#define PYC_MAGIC_NUMBER 3704 /* This is equivalent to converting PYC_MAGIC_NUMBER to 2 bytes (little-endian) and then appending b'\r\n'. */ #define PYC_MAGIC_NUMBER_TOKEN \ diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 04d39f72a27621c..9384850747cbc50 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -74,6 +74,10 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return 2; case BINARY_SLICE: return 3; + case BUILD_FROZENDICT: + return 1; + case BUILD_FROZENSET: + return oparg; case BUILD_INTERPOLATION: return 2 + (oparg & 1); case BUILD_LIST: @@ -571,6 +575,10 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 1; case BINARY_SLICE: return 1; + case BUILD_FROZENDICT: + return 1; + case BUILD_FROZENSET: + return 1; case BUILD_INTERPOLATION: return 1; case BUILD_LIST: @@ -1122,6 +1130,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[267] = { [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG }, [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_FROZENDICT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_FROZENSET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_INTERPOLATION] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1378,6 +1388,8 @@ _PyOpcode_macro_expansion[256] = { [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 5, .uops = { { _GUARD_TOS_FLOAT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_FLOAT, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, OPARG_SIMPLE, 5 }, { _POP_TOP_FLOAT, OPARG_SIMPLE, 5 }, { _POP_TOP_FLOAT, OPARG_SIMPLE, 5 } } }, [BINARY_OP_SUBTRACT_INT] = { .nuops = 5, .uops = { { _GUARD_TOS_INT, OPARG_SIMPLE, 0 }, { _GUARD_NOS_INT, OPARG_SIMPLE, 0 }, { _BINARY_OP_SUBTRACT_INT, OPARG_SIMPLE, 5 }, { _POP_TOP_INT, OPARG_SIMPLE, 5 }, { _POP_TOP_INT, OPARG_SIMPLE, 5 } } }, [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE, OPARG_SIMPLE, 0 } } }, + [BUILD_FROZENDICT] = { .nuops = 1, .uops = { { _BUILD_FROZENDICT, OPARG_SIMPLE, 0 } } }, + [BUILD_FROZENSET] = { .nuops = 1, .uops = { { _BUILD_FROZENSET, OPARG_SIMPLE, 0 } } }, [BUILD_INTERPOLATION] = { .nuops = 1, .uops = { { _BUILD_INTERPOLATION, OPARG_SIMPLE, 0 } } }, [BUILD_LIST] = { .nuops = 1, .uops = { { _BUILD_LIST, OPARG_SIMPLE, 0 } } }, [BUILD_MAP] = { .nuops = 1, .uops = { { _BUILD_MAP, OPARG_SIMPLE, 0 } } }, @@ -1576,6 +1588,8 @@ const char *_PyOpcode_OpName[267] = { [BINARY_OP_SUBTRACT_FLOAT] = "BINARY_OP_SUBTRACT_FLOAT", [BINARY_OP_SUBTRACT_INT] = "BINARY_OP_SUBTRACT_INT", [BINARY_SLICE] = "BINARY_SLICE", + [BUILD_FROZENDICT] = "BUILD_FROZENDICT", + [BUILD_FROZENSET] = "BUILD_FROZENSET", [BUILD_INTERPOLATION] = "BUILD_INTERPOLATION", [BUILD_LIST] = "BUILD_LIST", [BUILD_MAP] = "BUILD_MAP", @@ -1834,8 +1848,6 @@ const uint8_t _PyOpcode_Caches[256] = { PyAPI_DATA(const uint8_t) _PyOpcode_Deopt[256]; #ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Deopt[256] = { - [118] = 118, - [119] = 119, [120] = 120, [121] = 121, [122] = 122, @@ -1876,6 +1888,8 @@ const uint8_t _PyOpcode_Deopt[256] = { [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, [BINARY_OP_SUBTRACT_INT] = BINARY_OP, [BINARY_SLICE] = BINARY_SLICE, + [BUILD_FROZENDICT] = BUILD_FROZENDICT, + [BUILD_FROZENSET] = BUILD_FROZENSET, [BUILD_INTERPOLATION] = BUILD_INTERPOLATION, [BUILD_LIST] = BUILD_LIST, [BUILD_MAP] = BUILD_MAP, @@ -2095,8 +2109,6 @@ const uint8_t _PyOpcode_Deopt[256] = { #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ - case 118: \ - case 119: \ case 120: \ case 121: \ case 122: \ diff --git a/Include/internal/pycore_runtime_init_generated.h b/Include/internal/pycore_runtime_init_generated.h index 366d2d300fb4780..536876d8787f5aa 100644 --- a/Include/internal/pycore_runtime_init_generated.h +++ b/Include/internal/pycore_runtime_init_generated.h @@ -1306,6 +1306,8 @@ extern "C" { #define _Py_str_literals_INIT { \ INIT_STR(anon_dictcomp, ""), \ + INIT_STR(anon_frozendictcomp, ""), \ + INIT_STR(anon_frozensetcomp, ""), \ INIT_STR(anon_genexpr, ""), \ INIT_STR(anon_lambda, ""), \ INIT_STR(anon_listcomp, ""), \ diff --git a/Include/internal/pycore_symtable.h b/Include/internal/pycore_symtable.h index c650a94a1eab2e1..95882fc94f5278b 100644 --- a/Include/internal/pycore_symtable.h +++ b/Include/internal/pycore_symtable.h @@ -40,7 +40,10 @@ typedef enum _comprehension_type { ListComprehension = 1, DictComprehension = 2, SetComprehension = 3, - GeneratorExpression = 4 } _Py_comprehension_ty; + GeneratorExpression = 4, + FrozenDictComprehension = 5, + FrozenSetComprehension = 6, +} _Py_comprehension_ty; /* source location information */ typedef struct { diff --git a/Include/internal/pycore_token.h b/Include/internal/pycore_token.h index 5de1f719a2f1a28..26eeec147d15b48 100644 --- a/Include/internal/pycore_token.h +++ b/Include/internal/pycore_token.h @@ -68,20 +68,21 @@ extern "C" { #define ELLIPSIS 52 #define COLONEQUAL 53 #define EXCLAMATION 54 -#define OP 55 -#define TYPE_IGNORE 56 -#define TYPE_COMMENT 57 -#define SOFT_KEYWORD 58 -#define FSTRING_START 59 -#define FSTRING_MIDDLE 60 -#define FSTRING_END 61 -#define TSTRING_START 62 -#define TSTRING_MIDDLE 63 -#define TSTRING_END 64 -#define COMMENT 65 -#define NL 66 -#define ERRORTOKEN 67 -#define N_TOKENS 69 +#define LFBRACE 55 +#define OP 56 +#define TYPE_IGNORE 57 +#define TYPE_COMMENT 58 +#define SOFT_KEYWORD 59 +#define FSTRING_START 60 +#define FSTRING_MIDDLE 61 +#define FSTRING_END 62 +#define TSTRING_START 63 +#define TSTRING_MIDDLE 64 +#define TSTRING_END 65 +#define COMMENT 66 +#define NL 67 +#define ERRORTOKEN 68 +#define N_TOKENS 70 #define NT_OFFSET 256 /* Special definitions for cooperation with parser */ diff --git a/Include/internal/pycore_unicodeobject_generated.h b/Include/internal/pycore_unicodeobject_generated.h index 00d6297432b5fca..20e32f5908098cb 100644 --- a/Include/internal/pycore_unicodeobject_generated.h +++ b/Include/internal/pycore_unicodeobject_generated.h @@ -3428,6 +3428,14 @@ _PyUnicode_InitStaticStrings(PyInterpreterState *interp) { _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_frozendictcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_STR(anon_frozensetcomp); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); string = &_Py_STR(anon_genexpr); _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 617b56cc286bd48..e60c0c63eb980df 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -47,6 +47,8 @@ extern "C" { #define _BINARY_OP_TRUEDIV_FLOAT_INPLACE 335 #define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT 336 #define _BINARY_SLICE 337 +#define _BUILD_FROZENDICT BUILD_FROZENDICT +#define _BUILD_FROZENSET BUILD_FROZENSET #define _BUILD_INTERPOLATION BUILD_INTERPOLATION #define _BUILD_LIST BUILD_LIST #define _BUILD_MAP BUILD_MAP @@ -521,926 +523,928 @@ extern "C" { #define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13 735 #define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23 736 #define _BINARY_SLICE_r31 737 -#define _BUILD_INTERPOLATION_r01 738 -#define _BUILD_LIST_r01 739 -#define _BUILD_MAP_r01 740 -#define _BUILD_SET_r01 741 -#define _BUILD_SLICE_r01 742 -#define _BUILD_STRING_r01 743 -#define _BUILD_TEMPLATE_r21 744 -#define _BUILD_TUPLE_r01 745 -#define _CALL_BUILTIN_CLASS_r00 746 -#define _CALL_BUILTIN_FAST_r00 747 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 748 -#define _CALL_BUILTIN_O_r03 749 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 750 -#define _CALL_INTRINSIC_1_r12 751 -#define _CALL_INTRINSIC_2_r23 752 -#define _CALL_ISINSTANCE_r31 753 -#define _CALL_KW_NON_PY_r11 754 -#define _CALL_LEN_r33 755 -#define _CALL_LIST_APPEND_r03 756 -#define _CALL_LIST_APPEND_r13 757 -#define _CALL_LIST_APPEND_r23 758 -#define _CALL_LIST_APPEND_r33 759 -#define _CALL_METHOD_DESCRIPTOR_FAST_r00 760 -#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 761 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 762 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 763 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 764 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 765 -#define _CALL_METHOD_DESCRIPTOR_O_r03 766 -#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 767 -#define _CALL_NON_PY_GENERAL_r01 768 -#define _CALL_STR_1_r32 769 -#define _CALL_TUPLE_1_r32 770 -#define _CALL_TYPE_1_r02 771 -#define _CALL_TYPE_1_r12 772 -#define _CALL_TYPE_1_r22 773 -#define _CALL_TYPE_1_r32 774 -#define _CHECK_ATTR_CLASS_r01 775 -#define _CHECK_ATTR_CLASS_r11 776 -#define _CHECK_ATTR_CLASS_r22 777 -#define _CHECK_ATTR_CLASS_r33 778 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 779 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 780 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 781 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 782 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 783 -#define _CHECK_EG_MATCH_r22 784 -#define _CHECK_EXC_MATCH_r22 785 -#define _CHECK_FUNCTION_EXACT_ARGS_r00 786 -#define _CHECK_FUNCTION_VERSION_r00 787 -#define _CHECK_FUNCTION_VERSION_INLINE_r00 788 -#define _CHECK_FUNCTION_VERSION_INLINE_r11 789 -#define _CHECK_FUNCTION_VERSION_INLINE_r22 790 -#define _CHECK_FUNCTION_VERSION_INLINE_r33 791 -#define _CHECK_FUNCTION_VERSION_KW_r11 792 -#define _CHECK_IS_NOT_PY_CALLABLE_r00 793 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 794 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 795 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 796 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 797 -#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 798 -#define _CHECK_IS_PY_CALLABLE_EX_r03 799 -#define _CHECK_IS_PY_CALLABLE_EX_r13 800 -#define _CHECK_IS_PY_CALLABLE_EX_r23 801 -#define _CHECK_IS_PY_CALLABLE_EX_r33 802 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 803 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 804 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 805 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 806 -#define _CHECK_METHOD_VERSION_r00 807 -#define _CHECK_METHOD_VERSION_KW_r11 808 -#define _CHECK_OBJECT_r00 809 -#define _CHECK_PEP_523_r00 810 -#define _CHECK_PEP_523_r11 811 -#define _CHECK_PEP_523_r22 812 -#define _CHECK_PEP_523_r33 813 -#define _CHECK_PERIODIC_r00 814 -#define _CHECK_PERIODIC_AT_END_r00 815 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 816 -#define _CHECK_RECURSION_LIMIT_r00 817 -#define _CHECK_RECURSION_LIMIT_r11 818 -#define _CHECK_RECURSION_LIMIT_r22 819 -#define _CHECK_RECURSION_LIMIT_r33 820 -#define _CHECK_RECURSION_REMAINING_r00 821 -#define _CHECK_RECURSION_REMAINING_r11 822 -#define _CHECK_RECURSION_REMAINING_r22 823 -#define _CHECK_RECURSION_REMAINING_r33 824 -#define _CHECK_STACK_SPACE_r00 825 -#define _CHECK_STACK_SPACE_OPERAND_r00 826 -#define _CHECK_STACK_SPACE_OPERAND_r11 827 -#define _CHECK_STACK_SPACE_OPERAND_r22 828 -#define _CHECK_STACK_SPACE_OPERAND_r33 829 -#define _CHECK_VALIDITY_r00 830 -#define _CHECK_VALIDITY_r11 831 -#define _CHECK_VALIDITY_r22 832 -#define _CHECK_VALIDITY_r33 833 -#define _COLD_DYNAMIC_EXIT_r00 834 -#define _COLD_EXIT_r00 835 -#define _COMPARE_OP_r21 836 -#define _COMPARE_OP_FLOAT_r03 837 -#define _COMPARE_OP_FLOAT_r13 838 -#define _COMPARE_OP_FLOAT_r23 839 -#define _COMPARE_OP_INT_r23 840 -#define _COMPARE_OP_STR_r23 841 -#define _CONTAINS_OP_r23 842 -#define _CONTAINS_OP_DICT_r23 843 -#define _CONTAINS_OP_SET_r23 844 -#define _CONVERT_VALUE_r11 845 -#define _COPY_r01 846 -#define _COPY_1_r02 847 -#define _COPY_1_r12 848 -#define _COPY_1_r23 849 -#define _COPY_2_r03 850 -#define _COPY_2_r13 851 -#define _COPY_2_r23 852 -#define _COPY_3_r03 853 -#define _COPY_3_r13 854 -#define _COPY_3_r23 855 -#define _COPY_3_r33 856 -#define _COPY_FREE_VARS_r00 857 -#define _COPY_FREE_VARS_r11 858 -#define _COPY_FREE_VARS_r22 859 -#define _COPY_FREE_VARS_r33 860 -#define _CREATE_INIT_FRAME_r01 861 -#define _DELETE_ATTR_r10 862 -#define _DELETE_DEREF_r00 863 -#define _DELETE_FAST_r00 864 -#define _DELETE_SUBSCR_r20 865 -#define _DEOPT_r00 866 -#define _DEOPT_r10 867 -#define _DEOPT_r20 868 -#define _DEOPT_r30 869 -#define _DICT_MERGE_r11 870 -#define _DICT_UPDATE_r11 871 -#define _DO_CALL_r01 872 -#define _DO_CALL_FUNCTION_EX_r31 873 -#define _DO_CALL_KW_r11 874 -#define _DYNAMIC_EXIT_r00 875 -#define _DYNAMIC_EXIT_r10 876 -#define _DYNAMIC_EXIT_r20 877 -#define _DYNAMIC_EXIT_r30 878 -#define _END_FOR_r10 879 -#define _END_SEND_r31 880 -#define _ERROR_POP_N_r00 881 -#define _EXIT_INIT_CHECK_r10 882 -#define _EXIT_TRACE_r00 883 -#define _EXIT_TRACE_r10 884 -#define _EXIT_TRACE_r20 885 -#define _EXIT_TRACE_r30 886 -#define _EXPAND_METHOD_r00 887 -#define _EXPAND_METHOD_KW_r11 888 -#define _FATAL_ERROR_r00 889 -#define _FATAL_ERROR_r11 890 -#define _FATAL_ERROR_r22 891 -#define _FATAL_ERROR_r33 892 -#define _FORMAT_SIMPLE_r11 893 -#define _FORMAT_WITH_SPEC_r21 894 -#define _FOR_ITER_r23 895 -#define _FOR_ITER_GEN_FRAME_r03 896 -#define _FOR_ITER_GEN_FRAME_r13 897 -#define _FOR_ITER_GEN_FRAME_r23 898 -#define _FOR_ITER_TIER_TWO_r23 899 -#define _FOR_ITER_VIRTUAL_r23 900 -#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 901 -#define _GET_AITER_r11 902 -#define _GET_ANEXT_r12 903 -#define _GET_AWAITABLE_r11 904 -#define _GET_ITER_r12 905 -#define _GET_ITER_TRAD_r12 906 -#define _GET_LEN_r12 907 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r03 908 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r13 909 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r23 910 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r33 911 -#define _GUARD_BINARY_OP_EXTEND_r22 912 -#define _GUARD_BINARY_OP_EXTEND_LHS_r02 913 -#define _GUARD_BINARY_OP_EXTEND_LHS_r12 914 -#define _GUARD_BINARY_OP_EXTEND_LHS_r22 915 -#define _GUARD_BINARY_OP_EXTEND_LHS_r33 916 -#define _GUARD_BINARY_OP_EXTEND_RHS_r02 917 -#define _GUARD_BINARY_OP_EXTEND_RHS_r12 918 -#define _GUARD_BINARY_OP_EXTEND_RHS_r22 919 -#define _GUARD_BINARY_OP_EXTEND_RHS_r33 920 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 921 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 922 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 923 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 924 -#define _GUARD_BIT_IS_SET_POP_r00 925 -#define _GUARD_BIT_IS_SET_POP_r10 926 -#define _GUARD_BIT_IS_SET_POP_r21 927 -#define _GUARD_BIT_IS_SET_POP_r32 928 -#define _GUARD_BIT_IS_SET_POP_4_r00 929 -#define _GUARD_BIT_IS_SET_POP_4_r10 930 -#define _GUARD_BIT_IS_SET_POP_4_r21 931 -#define _GUARD_BIT_IS_SET_POP_4_r32 932 -#define _GUARD_BIT_IS_SET_POP_5_r00 933 -#define _GUARD_BIT_IS_SET_POP_5_r10 934 -#define _GUARD_BIT_IS_SET_POP_5_r21 935 -#define _GUARD_BIT_IS_SET_POP_5_r32 936 -#define _GUARD_BIT_IS_SET_POP_6_r00 937 -#define _GUARD_BIT_IS_SET_POP_6_r10 938 -#define _GUARD_BIT_IS_SET_POP_6_r21 939 -#define _GUARD_BIT_IS_SET_POP_6_r32 940 -#define _GUARD_BIT_IS_SET_POP_7_r00 941 -#define _GUARD_BIT_IS_SET_POP_7_r10 942 -#define _GUARD_BIT_IS_SET_POP_7_r21 943 -#define _GUARD_BIT_IS_SET_POP_7_r32 944 -#define _GUARD_BIT_IS_UNSET_POP_r00 945 -#define _GUARD_BIT_IS_UNSET_POP_r10 946 -#define _GUARD_BIT_IS_UNSET_POP_r21 947 -#define _GUARD_BIT_IS_UNSET_POP_r32 948 -#define _GUARD_BIT_IS_UNSET_POP_4_r00 949 -#define _GUARD_BIT_IS_UNSET_POP_4_r10 950 -#define _GUARD_BIT_IS_UNSET_POP_4_r21 951 -#define _GUARD_BIT_IS_UNSET_POP_4_r32 952 -#define _GUARD_BIT_IS_UNSET_POP_5_r00 953 -#define _GUARD_BIT_IS_UNSET_POP_5_r10 954 -#define _GUARD_BIT_IS_UNSET_POP_5_r21 955 -#define _GUARD_BIT_IS_UNSET_POP_5_r32 956 -#define _GUARD_BIT_IS_UNSET_POP_6_r00 957 -#define _GUARD_BIT_IS_UNSET_POP_6_r10 958 -#define _GUARD_BIT_IS_UNSET_POP_6_r21 959 -#define _GUARD_BIT_IS_UNSET_POP_6_r32 960 -#define _GUARD_BIT_IS_UNSET_POP_7_r00 961 -#define _GUARD_BIT_IS_UNSET_POP_7_r10 962 -#define _GUARD_BIT_IS_UNSET_POP_7_r21 963 -#define _GUARD_BIT_IS_UNSET_POP_7_r32 964 -#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 965 -#define _GUARD_CALLABLE_BUILTIN_FAST_r00 966 -#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 967 -#define _GUARD_CALLABLE_BUILTIN_O_r00 968 -#define _GUARD_CALLABLE_ISINSTANCE_r03 969 -#define _GUARD_CALLABLE_ISINSTANCE_r13 970 -#define _GUARD_CALLABLE_ISINSTANCE_r23 971 -#define _GUARD_CALLABLE_ISINSTANCE_r33 972 -#define _GUARD_CALLABLE_LEN_r03 973 -#define _GUARD_CALLABLE_LEN_r13 974 -#define _GUARD_CALLABLE_LEN_r23 975 -#define _GUARD_CALLABLE_LEN_r33 976 -#define _GUARD_CALLABLE_LIST_APPEND_r03 977 -#define _GUARD_CALLABLE_LIST_APPEND_r13 978 -#define _GUARD_CALLABLE_LIST_APPEND_r23 979 -#define _GUARD_CALLABLE_LIST_APPEND_r33 980 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 981 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 982 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 983 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 984 -#define _GUARD_CALLABLE_STR_1_r03 985 -#define _GUARD_CALLABLE_STR_1_r13 986 -#define _GUARD_CALLABLE_STR_1_r23 987 -#define _GUARD_CALLABLE_STR_1_r33 988 -#define _GUARD_CALLABLE_TUPLE_1_r03 989 -#define _GUARD_CALLABLE_TUPLE_1_r13 990 -#define _GUARD_CALLABLE_TUPLE_1_r23 991 -#define _GUARD_CALLABLE_TUPLE_1_r33 992 -#define _GUARD_CALLABLE_TYPE_1_r03 993 -#define _GUARD_CALLABLE_TYPE_1_r13 994 -#define _GUARD_CALLABLE_TYPE_1_r23 995 -#define _GUARD_CALLABLE_TYPE_1_r33 996 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 997 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 998 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 999 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 1000 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 1001 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 1002 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 1003 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 1004 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 1005 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 1006 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 1007 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 1008 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 1009 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 1010 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1011 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1012 -#define _GUARD_DORV_NO_DICT_r01 1013 -#define _GUARD_DORV_NO_DICT_r11 1014 -#define _GUARD_DORV_NO_DICT_r22 1015 -#define _GUARD_DORV_NO_DICT_r33 1016 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 1017 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 1018 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 1019 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 1020 -#define _GUARD_GLOBALS_VERSION_r00 1021 -#define _GUARD_GLOBALS_VERSION_r11 1022 -#define _GUARD_GLOBALS_VERSION_r22 1023 -#define _GUARD_GLOBALS_VERSION_r33 1024 -#define _GUARD_IP_RETURN_GENERATOR_r00 1025 -#define _GUARD_IP_RETURN_GENERATOR_r11 1026 -#define _GUARD_IP_RETURN_GENERATOR_r22 1027 -#define _GUARD_IP_RETURN_GENERATOR_r33 1028 -#define _GUARD_IP_RETURN_VALUE_r00 1029 -#define _GUARD_IP_RETURN_VALUE_r11 1030 -#define _GUARD_IP_RETURN_VALUE_r22 1031 -#define _GUARD_IP_RETURN_VALUE_r33 1032 -#define _GUARD_IP_YIELD_VALUE_r00 1033 -#define _GUARD_IP_YIELD_VALUE_r11 1034 -#define _GUARD_IP_YIELD_VALUE_r22 1035 -#define _GUARD_IP_YIELD_VALUE_r33 1036 -#define _GUARD_IP__PUSH_FRAME_r00 1037 -#define _GUARD_IP__PUSH_FRAME_r11 1038 -#define _GUARD_IP__PUSH_FRAME_r22 1039 -#define _GUARD_IP__PUSH_FRAME_r33 1040 -#define _GUARD_IS_FALSE_POP_r00 1041 -#define _GUARD_IS_FALSE_POP_r10 1042 -#define _GUARD_IS_FALSE_POP_r21 1043 -#define _GUARD_IS_FALSE_POP_r32 1044 -#define _GUARD_IS_NONE_POP_r00 1045 -#define _GUARD_IS_NONE_POP_r10 1046 -#define _GUARD_IS_NONE_POP_r21 1047 -#define _GUARD_IS_NONE_POP_r32 1048 -#define _GUARD_IS_NOT_NONE_POP_r10 1049 -#define _GUARD_IS_TRUE_POP_r00 1050 -#define _GUARD_IS_TRUE_POP_r10 1051 -#define _GUARD_IS_TRUE_POP_r21 1052 -#define _GUARD_IS_TRUE_POP_r32 1053 -#define _GUARD_ITERATOR_r01 1054 -#define _GUARD_ITERATOR_r11 1055 -#define _GUARD_ITERATOR_r22 1056 -#define _GUARD_ITERATOR_r33 1057 -#define _GUARD_ITER_VIRTUAL_r01 1058 -#define _GUARD_ITER_VIRTUAL_r11 1059 -#define _GUARD_ITER_VIRTUAL_r22 1060 -#define _GUARD_ITER_VIRTUAL_r33 1061 -#define _GUARD_KEYS_VERSION_r01 1062 -#define _GUARD_KEYS_VERSION_r11 1063 -#define _GUARD_KEYS_VERSION_r22 1064 -#define _GUARD_KEYS_VERSION_r33 1065 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1066 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1067 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1068 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1069 -#define _GUARD_NOS_COMPACT_ASCII_r02 1070 -#define _GUARD_NOS_COMPACT_ASCII_r12 1071 -#define _GUARD_NOS_COMPACT_ASCII_r22 1072 -#define _GUARD_NOS_COMPACT_ASCII_r33 1073 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r03 1074 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r13 1075 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r23 1076 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r33 1077 -#define _GUARD_NOS_DICT_SUBSCRIPT_r02 1078 -#define _GUARD_NOS_DICT_SUBSCRIPT_r12 1079 -#define _GUARD_NOS_DICT_SUBSCRIPT_r22 1080 -#define _GUARD_NOS_DICT_SUBSCRIPT_r33 1081 -#define _GUARD_NOS_FLOAT_r02 1082 -#define _GUARD_NOS_FLOAT_r12 1083 -#define _GUARD_NOS_FLOAT_r22 1084 -#define _GUARD_NOS_FLOAT_r33 1085 -#define _GUARD_NOS_INT_r02 1086 -#define _GUARD_NOS_INT_r12 1087 -#define _GUARD_NOS_INT_r22 1088 -#define _GUARD_NOS_INT_r33 1089 -#define _GUARD_NOS_ITER_VIRTUAL_r02 1090 -#define _GUARD_NOS_ITER_VIRTUAL_r12 1091 -#define _GUARD_NOS_ITER_VIRTUAL_r22 1092 -#define _GUARD_NOS_ITER_VIRTUAL_r33 1093 -#define _GUARD_NOS_LIST_r02 1094 -#define _GUARD_NOS_LIST_r12 1095 -#define _GUARD_NOS_LIST_r22 1096 -#define _GUARD_NOS_LIST_r33 1097 -#define _GUARD_NOS_NOT_NULL_r02 1098 -#define _GUARD_NOS_NOT_NULL_r12 1099 -#define _GUARD_NOS_NOT_NULL_r22 1100 -#define _GUARD_NOS_NOT_NULL_r33 1101 -#define _GUARD_NOS_NULL_r02 1102 -#define _GUARD_NOS_NULL_r12 1103 -#define _GUARD_NOS_NULL_r22 1104 -#define _GUARD_NOS_NULL_r33 1105 -#define _GUARD_NOS_OVERFLOWED_r02 1106 -#define _GUARD_NOS_OVERFLOWED_r12 1107 -#define _GUARD_NOS_OVERFLOWED_r22 1108 -#define _GUARD_NOS_OVERFLOWED_r33 1109 -#define _GUARD_NOS_TUPLE_r02 1110 -#define _GUARD_NOS_TUPLE_r12 1111 -#define _GUARD_NOS_TUPLE_r22 1112 -#define _GUARD_NOS_TUPLE_r33 1113 -#define _GUARD_NOS_TYPE_VERSION_r02 1114 -#define _GUARD_NOS_TYPE_VERSION_r12 1115 -#define _GUARD_NOS_TYPE_VERSION_r22 1116 -#define _GUARD_NOS_TYPE_VERSION_r33 1117 -#define _GUARD_NOS_UNICODE_r02 1118 -#define _GUARD_NOS_UNICODE_r12 1119 -#define _GUARD_NOS_UNICODE_r22 1120 -#define _GUARD_NOS_UNICODE_r33 1121 -#define _GUARD_NOT_EXHAUSTED_LIST_r02 1122 -#define _GUARD_NOT_EXHAUSTED_LIST_r12 1123 -#define _GUARD_NOT_EXHAUSTED_LIST_r22 1124 -#define _GUARD_NOT_EXHAUSTED_LIST_r33 1125 -#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1126 -#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1127 -#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1128 -#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1129 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1130 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1131 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1132 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1133 -#define _GUARD_THIRD_NULL_r03 1134 -#define _GUARD_THIRD_NULL_r13 1135 -#define _GUARD_THIRD_NULL_r23 1136 -#define _GUARD_THIRD_NULL_r33 1137 -#define _GUARD_TOS_ANY_DICT_r01 1138 -#define _GUARD_TOS_ANY_DICT_r11 1139 -#define _GUARD_TOS_ANY_DICT_r22 1140 -#define _GUARD_TOS_ANY_DICT_r33 1141 -#define _GUARD_TOS_ANY_SET_r01 1142 -#define _GUARD_TOS_ANY_SET_r11 1143 -#define _GUARD_TOS_ANY_SET_r22 1144 -#define _GUARD_TOS_ANY_SET_r33 1145 -#define _GUARD_TOS_DICT_r01 1146 -#define _GUARD_TOS_DICT_r11 1147 -#define _GUARD_TOS_DICT_r22 1148 -#define _GUARD_TOS_DICT_r33 1149 -#define _GUARD_TOS_FLOAT_r01 1150 -#define _GUARD_TOS_FLOAT_r11 1151 -#define _GUARD_TOS_FLOAT_r22 1152 -#define _GUARD_TOS_FLOAT_r33 1153 -#define _GUARD_TOS_FROZENDICT_r01 1154 -#define _GUARD_TOS_FROZENDICT_r11 1155 -#define _GUARD_TOS_FROZENDICT_r22 1156 -#define _GUARD_TOS_FROZENDICT_r33 1157 -#define _GUARD_TOS_FROZENSET_r01 1158 -#define _GUARD_TOS_FROZENSET_r11 1159 -#define _GUARD_TOS_FROZENSET_r22 1160 -#define _GUARD_TOS_FROZENSET_r33 1161 -#define _GUARD_TOS_INT_r01 1162 -#define _GUARD_TOS_INT_r11 1163 -#define _GUARD_TOS_INT_r22 1164 -#define _GUARD_TOS_INT_r33 1165 -#define _GUARD_TOS_IS_NONE_r01 1166 -#define _GUARD_TOS_IS_NONE_r11 1167 -#define _GUARD_TOS_IS_NONE_r22 1168 -#define _GUARD_TOS_IS_NONE_r33 1169 -#define _GUARD_TOS_LIST_r01 1170 -#define _GUARD_TOS_LIST_r11 1171 -#define _GUARD_TOS_LIST_r22 1172 -#define _GUARD_TOS_LIST_r33 1173 -#define _GUARD_TOS_NOT_NULL_r01 1174 -#define _GUARD_TOS_NOT_NULL_r11 1175 -#define _GUARD_TOS_NOT_NULL_r22 1176 -#define _GUARD_TOS_NOT_NULL_r33 1177 -#define _GUARD_TOS_OVERFLOWED_r01 1178 -#define _GUARD_TOS_OVERFLOWED_r11 1179 -#define _GUARD_TOS_OVERFLOWED_r22 1180 -#define _GUARD_TOS_OVERFLOWED_r33 1181 -#define _GUARD_TOS_SET_r01 1182 -#define _GUARD_TOS_SET_r11 1183 -#define _GUARD_TOS_SET_r22 1184 -#define _GUARD_TOS_SET_r33 1185 -#define _GUARD_TOS_SLICE_r01 1186 -#define _GUARD_TOS_SLICE_r11 1187 -#define _GUARD_TOS_SLICE_r22 1188 -#define _GUARD_TOS_SLICE_r33 1189 -#define _GUARD_TOS_TUPLE_r01 1190 -#define _GUARD_TOS_TUPLE_r11 1191 -#define _GUARD_TOS_TUPLE_r22 1192 -#define _GUARD_TOS_TUPLE_r33 1193 -#define _GUARD_TOS_UNICODE_r01 1194 -#define _GUARD_TOS_UNICODE_r11 1195 -#define _GUARD_TOS_UNICODE_r22 1196 -#define _GUARD_TOS_UNICODE_r33 1197 -#define _GUARD_TYPE_r01 1198 -#define _GUARD_TYPE_r11 1199 -#define _GUARD_TYPE_r22 1200 -#define _GUARD_TYPE_r33 1201 -#define _GUARD_TYPE_ITER_r02 1202 -#define _GUARD_TYPE_ITER_r12 1203 -#define _GUARD_TYPE_ITER_r22 1204 -#define _GUARD_TYPE_ITER_r33 1205 -#define _GUARD_TYPE_VERSION_r01 1206 -#define _GUARD_TYPE_VERSION_r11 1207 -#define _GUARD_TYPE_VERSION_r22 1208 -#define _GUARD_TYPE_VERSION_r33 1209 -#define _GUARD_TYPE_VERSION_LOCKED_r01 1210 -#define _GUARD_TYPE_VERSION_LOCKED_r11 1211 -#define _GUARD_TYPE_VERSION_LOCKED_r22 1212 -#define _GUARD_TYPE_VERSION_LOCKED_r33 1213 -#define _HANDLE_PENDING_AND_DEOPT_r00 1214 -#define _HANDLE_PENDING_AND_DEOPT_r10 1215 -#define _HANDLE_PENDING_AND_DEOPT_r20 1216 -#define _HANDLE_PENDING_AND_DEOPT_r30 1217 -#define _IMPORT_FROM_r12 1218 -#define _IMPORT_NAME_r21 1219 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1220 -#define _INIT_CALL_PY_EXACT_ARGS_r01 1221 -#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1222 -#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1223 -#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1224 -#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1225 -#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1226 -#define _INSERT_NULL_r10 1227 -#define _INSTRUMENTED_FOR_ITER_r23 1228 -#define _INSTRUMENTED_INSTRUCTION_r00 1229 -#define _INSTRUMENTED_JUMP_FORWARD_r00 1230 -#define _INSTRUMENTED_JUMP_FORWARD_r11 1231 -#define _INSTRUMENTED_JUMP_FORWARD_r22 1232 -#define _INSTRUMENTED_JUMP_FORWARD_r33 1233 -#define _INSTRUMENTED_LINE_r00 1234 -#define _INSTRUMENTED_NOT_TAKEN_r00 1235 -#define _INSTRUMENTED_NOT_TAKEN_r11 1236 -#define _INSTRUMENTED_NOT_TAKEN_r22 1237 -#define _INSTRUMENTED_NOT_TAKEN_r33 1238 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1239 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1240 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1241 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1242 -#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1243 -#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1244 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1245 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1246 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1247 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1248 -#define _IS_NONE_r11 1249 -#define _IS_OP_r03 1250 -#define _IS_OP_r13 1251 -#define _IS_OP_r23 1252 -#define _ITER_CHECK_LIST_r02 1253 -#define _ITER_CHECK_LIST_r12 1254 -#define _ITER_CHECK_LIST_r22 1255 -#define _ITER_CHECK_LIST_r33 1256 -#define _ITER_CHECK_RANGE_r02 1257 -#define _ITER_CHECK_RANGE_r12 1258 -#define _ITER_CHECK_RANGE_r22 1259 -#define _ITER_CHECK_RANGE_r33 1260 -#define _ITER_CHECK_TUPLE_r02 1261 -#define _ITER_CHECK_TUPLE_r12 1262 -#define _ITER_CHECK_TUPLE_r22 1263 -#define _ITER_CHECK_TUPLE_r33 1264 -#define _ITER_JUMP_LIST_r02 1265 -#define _ITER_JUMP_LIST_r12 1266 -#define _ITER_JUMP_LIST_r22 1267 -#define _ITER_JUMP_LIST_r33 1268 -#define _ITER_JUMP_RANGE_r02 1269 -#define _ITER_JUMP_RANGE_r12 1270 -#define _ITER_JUMP_RANGE_r22 1271 -#define _ITER_JUMP_RANGE_r33 1272 -#define _ITER_JUMP_TUPLE_r02 1273 -#define _ITER_JUMP_TUPLE_r12 1274 -#define _ITER_JUMP_TUPLE_r22 1275 -#define _ITER_JUMP_TUPLE_r33 1276 -#define _ITER_NEXT_INLINE_r23 1277 -#define _ITER_NEXT_LIST_r23 1278 -#define _ITER_NEXT_LIST_TIER_TWO_r23 1279 -#define _ITER_NEXT_RANGE_r03 1280 -#define _ITER_NEXT_RANGE_r13 1281 -#define _ITER_NEXT_RANGE_r23 1282 -#define _ITER_NEXT_TUPLE_r03 1283 -#define _ITER_NEXT_TUPLE_r13 1284 -#define _ITER_NEXT_TUPLE_r23 1285 -#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1286 -#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1287 -#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1288 -#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1289 -#define _JUMP_TO_TOP_r00 1290 -#define _LIST_APPEND_r10 1291 -#define _LIST_EXTEND_r11 1292 -#define _LOAD_ATTR_r10 1293 -#define _LOAD_ATTR_CLASS_r11 1294 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1295 -#define _LOAD_ATTR_INSTANCE_VALUE_r02 1296 -#define _LOAD_ATTR_INSTANCE_VALUE_r12 1297 -#define _LOAD_ATTR_INSTANCE_VALUE_r23 1298 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1299 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1300 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1301 -#define _LOAD_ATTR_METHOD_NO_DICT_r02 1302 -#define _LOAD_ATTR_METHOD_NO_DICT_r12 1303 -#define _LOAD_ATTR_METHOD_NO_DICT_r23 1304 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1305 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1306 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1307 -#define _LOAD_ATTR_MODULE_r12 1308 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1309 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1310 -#define _LOAD_ATTR_PROPERTY_FRAME_r01 1311 -#define _LOAD_ATTR_PROPERTY_FRAME_r11 1312 -#define _LOAD_ATTR_PROPERTY_FRAME_r22 1313 -#define _LOAD_ATTR_PROPERTY_FRAME_r33 1314 -#define _LOAD_ATTR_SLOT_r02 1315 -#define _LOAD_ATTR_SLOT_r12 1316 -#define _LOAD_ATTR_SLOT_r23 1317 -#define _LOAD_ATTR_WITH_HINT_r12 1318 -#define _LOAD_BUILD_CLASS_r01 1319 -#define _LOAD_BYTECODE_r00 1320 -#define _LOAD_COMMON_CONSTANT_r01 1321 -#define _LOAD_COMMON_CONSTANT_r12 1322 -#define _LOAD_COMMON_CONSTANT_r23 1323 -#define _LOAD_CONST_r01 1324 -#define _LOAD_CONST_r12 1325 -#define _LOAD_CONST_r23 1326 -#define _LOAD_CONST_INLINE_r01 1327 -#define _LOAD_CONST_INLINE_r12 1328 -#define _LOAD_CONST_INLINE_r23 1329 -#define _LOAD_CONST_INLINE_BORROW_r01 1330 -#define _LOAD_CONST_INLINE_BORROW_r12 1331 -#define _LOAD_CONST_INLINE_BORROW_r23 1332 -#define _LOAD_DEREF_r01 1333 -#define _LOAD_FAST_r01 1334 -#define _LOAD_FAST_r12 1335 -#define _LOAD_FAST_r23 1336 -#define _LOAD_FAST_0_r01 1337 -#define _LOAD_FAST_0_r12 1338 -#define _LOAD_FAST_0_r23 1339 -#define _LOAD_FAST_1_r01 1340 -#define _LOAD_FAST_1_r12 1341 -#define _LOAD_FAST_1_r23 1342 -#define _LOAD_FAST_2_r01 1343 -#define _LOAD_FAST_2_r12 1344 -#define _LOAD_FAST_2_r23 1345 -#define _LOAD_FAST_3_r01 1346 -#define _LOAD_FAST_3_r12 1347 -#define _LOAD_FAST_3_r23 1348 -#define _LOAD_FAST_4_r01 1349 -#define _LOAD_FAST_4_r12 1350 -#define _LOAD_FAST_4_r23 1351 -#define _LOAD_FAST_5_r01 1352 -#define _LOAD_FAST_5_r12 1353 -#define _LOAD_FAST_5_r23 1354 -#define _LOAD_FAST_6_r01 1355 -#define _LOAD_FAST_6_r12 1356 -#define _LOAD_FAST_6_r23 1357 -#define _LOAD_FAST_7_r01 1358 -#define _LOAD_FAST_7_r12 1359 -#define _LOAD_FAST_7_r23 1360 -#define _LOAD_FAST_AND_CLEAR_r01 1361 -#define _LOAD_FAST_AND_CLEAR_r12 1362 -#define _LOAD_FAST_AND_CLEAR_r23 1363 -#define _LOAD_FAST_BORROW_r01 1364 -#define _LOAD_FAST_BORROW_r12 1365 -#define _LOAD_FAST_BORROW_r23 1366 -#define _LOAD_FAST_BORROW_0_r01 1367 -#define _LOAD_FAST_BORROW_0_r12 1368 -#define _LOAD_FAST_BORROW_0_r23 1369 -#define _LOAD_FAST_BORROW_1_r01 1370 -#define _LOAD_FAST_BORROW_1_r12 1371 -#define _LOAD_FAST_BORROW_1_r23 1372 -#define _LOAD_FAST_BORROW_2_r01 1373 -#define _LOAD_FAST_BORROW_2_r12 1374 -#define _LOAD_FAST_BORROW_2_r23 1375 -#define _LOAD_FAST_BORROW_3_r01 1376 -#define _LOAD_FAST_BORROW_3_r12 1377 -#define _LOAD_FAST_BORROW_3_r23 1378 -#define _LOAD_FAST_BORROW_4_r01 1379 -#define _LOAD_FAST_BORROW_4_r12 1380 -#define _LOAD_FAST_BORROW_4_r23 1381 -#define _LOAD_FAST_BORROW_5_r01 1382 -#define _LOAD_FAST_BORROW_5_r12 1383 -#define _LOAD_FAST_BORROW_5_r23 1384 -#define _LOAD_FAST_BORROW_6_r01 1385 -#define _LOAD_FAST_BORROW_6_r12 1386 -#define _LOAD_FAST_BORROW_6_r23 1387 -#define _LOAD_FAST_BORROW_7_r01 1388 -#define _LOAD_FAST_BORROW_7_r12 1389 -#define _LOAD_FAST_BORROW_7_r23 1390 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1391 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1392 -#define _LOAD_FAST_CHECK_r01 1393 -#define _LOAD_FAST_CHECK_r12 1394 -#define _LOAD_FAST_CHECK_r23 1395 -#define _LOAD_FAST_LOAD_FAST_r02 1396 -#define _LOAD_FAST_LOAD_FAST_r13 1397 -#define _LOAD_FROM_DICT_OR_DEREF_r11 1398 -#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1399 -#define _LOAD_GLOBAL_r00 1400 -#define _LOAD_GLOBAL_BUILTINS_r01 1401 -#define _LOAD_GLOBAL_MODULE_r01 1402 -#define _LOAD_LOCALS_r01 1403 -#define _LOAD_LOCALS_r12 1404 -#define _LOAD_LOCALS_r23 1405 -#define _LOAD_NAME_r01 1406 -#define _LOAD_SMALL_INT_r01 1407 -#define _LOAD_SMALL_INT_r12 1408 -#define _LOAD_SMALL_INT_r23 1409 -#define _LOAD_SMALL_INT_0_r01 1410 -#define _LOAD_SMALL_INT_0_r12 1411 -#define _LOAD_SMALL_INT_0_r23 1412 -#define _LOAD_SMALL_INT_1_r01 1413 -#define _LOAD_SMALL_INT_1_r12 1414 -#define _LOAD_SMALL_INT_1_r23 1415 -#define _LOAD_SMALL_INT_2_r01 1416 -#define _LOAD_SMALL_INT_2_r12 1417 -#define _LOAD_SMALL_INT_2_r23 1418 -#define _LOAD_SMALL_INT_3_r01 1419 -#define _LOAD_SMALL_INT_3_r12 1420 -#define _LOAD_SMALL_INT_3_r23 1421 -#define _LOAD_SPECIAL_r00 1422 -#define _LOAD_SUPER_ATTR_ATTR_r31 1423 -#define _LOAD_SUPER_ATTR_METHOD_r32 1424 -#define _LOCK_OBJECT_r01 1425 -#define _LOCK_OBJECT_r11 1426 -#define _LOCK_OBJECT_r22 1427 -#define _LOCK_OBJECT_r33 1428 -#define _MAKE_CALLARGS_A_TUPLE_r33 1429 -#define _MAKE_CELL_r00 1430 -#define _MAKE_FUNCTION_r12 1431 -#define _MAKE_HEAP_SAFE_r01 1432 -#define _MAKE_HEAP_SAFE_r11 1433 -#define _MAKE_HEAP_SAFE_r22 1434 -#define _MAKE_HEAP_SAFE_r33 1435 -#define _MAKE_WARM_r00 1436 -#define _MAKE_WARM_r11 1437 -#define _MAKE_WARM_r22 1438 -#define _MAKE_WARM_r33 1439 -#define _MAP_ADD_r20 1440 -#define _MATCH_CLASS_r33 1441 -#define _MATCH_KEYS_r23 1442 -#define _MATCH_MAPPING_r02 1443 -#define _MATCH_MAPPING_r12 1444 -#define _MATCH_MAPPING_r23 1445 -#define _MATCH_SEQUENCE_r02 1446 -#define _MATCH_SEQUENCE_r12 1447 -#define _MATCH_SEQUENCE_r23 1448 -#define _MAYBE_EXPAND_METHOD_r00 1449 -#define _MAYBE_EXPAND_METHOD_KW_r11 1450 -#define _MONITOR_CALL_r00 1451 -#define _MONITOR_CALL_KW_r11 1452 -#define _MONITOR_JUMP_BACKWARD_r00 1453 -#define _MONITOR_JUMP_BACKWARD_r11 1454 -#define _MONITOR_JUMP_BACKWARD_r22 1455 -#define _MONITOR_JUMP_BACKWARD_r33 1456 -#define _MONITOR_RESUME_r00 1457 -#define _NOP_r00 1458 -#define _NOP_r11 1459 -#define _NOP_r22 1460 -#define _NOP_r33 1461 -#define _POP_EXCEPT_r10 1462 -#define _POP_ITER_r20 1463 -#define _POP_JUMP_IF_FALSE_r00 1464 -#define _POP_JUMP_IF_FALSE_r10 1465 -#define _POP_JUMP_IF_FALSE_r21 1466 -#define _POP_JUMP_IF_FALSE_r32 1467 -#define _POP_JUMP_IF_TRUE_r00 1468 -#define _POP_JUMP_IF_TRUE_r10 1469 -#define _POP_JUMP_IF_TRUE_r21 1470 -#define _POP_JUMP_IF_TRUE_r32 1471 -#define _POP_TOP_r10 1472 -#define _POP_TOP_FLOAT_r00 1473 -#define _POP_TOP_FLOAT_r10 1474 -#define _POP_TOP_FLOAT_r21 1475 -#define _POP_TOP_FLOAT_r32 1476 -#define _POP_TOP_INT_r00 1477 -#define _POP_TOP_INT_r10 1478 -#define _POP_TOP_INT_r21 1479 -#define _POP_TOP_INT_r32 1480 -#define _POP_TOP_NOP_r00 1481 -#define _POP_TOP_NOP_r10 1482 -#define _POP_TOP_NOP_r21 1483 -#define _POP_TOP_NOP_r32 1484 -#define _POP_TOP_OPARG_r00 1485 -#define _POP_TOP_UNICODE_r00 1486 -#define _POP_TOP_UNICODE_r10 1487 -#define _POP_TOP_UNICODE_r21 1488 -#define _POP_TOP_UNICODE_r32 1489 -#define _PUSH_EXC_INFO_r02 1490 -#define _PUSH_EXC_INFO_r12 1491 -#define _PUSH_EXC_INFO_r23 1492 -#define _PUSH_FRAME_r10 1493 -#define _PUSH_NULL_r01 1494 -#define _PUSH_NULL_r12 1495 -#define _PUSH_NULL_r23 1496 -#define _PUSH_NULL_CONDITIONAL_r00 1497 -#define _PUSH_TAGGED_ZERO_r01 1498 -#define _PUSH_TAGGED_ZERO_r12 1499 -#define _PUSH_TAGGED_ZERO_r23 1500 -#define _PY_FRAME_EX_r31 1501 -#define _PY_FRAME_GENERAL_r01 1502 -#define _PY_FRAME_KW_r11 1503 -#define _REPLACE_WITH_TRUE_r02 1504 -#define _REPLACE_WITH_TRUE_r12 1505 -#define _REPLACE_WITH_TRUE_r23 1506 -#define _RESUME_CHECK_r00 1507 -#define _RESUME_CHECK_r11 1508 -#define _RESUME_CHECK_r22 1509 -#define _RESUME_CHECK_r33 1510 -#define _RETURN_GENERATOR_r01 1511 -#define _RETURN_VALUE_r11 1512 -#define _RROT_3_r03 1513 -#define _RROT_3_r13 1514 -#define _RROT_3_r23 1515 -#define _RROT_3_r33 1516 -#define _SAVE_RETURN_OFFSET_r00 1517 -#define _SAVE_RETURN_OFFSET_r11 1518 -#define _SAVE_RETURN_OFFSET_r22 1519 -#define _SAVE_RETURN_OFFSET_r33 1520 -#define _SEND_ASYNC_GEN_r33 1521 -#define _SEND_ASYNC_GEN_TIER_TWO_r33 1522 -#define _SEND_GEN_FRAME_r33 1523 -#define _SEND_VIRTUAL_r33 1524 -#define _SEND_VIRTUAL_TIER_TWO_r03 1525 -#define _SEND_VIRTUAL_TIER_TWO_r13 1526 -#define _SEND_VIRTUAL_TIER_TWO_r23 1527 -#define _SEND_VIRTUAL_TIER_TWO_r33 1528 -#define _SETUP_ANNOTATIONS_r00 1529 -#define _SET_ADD_r10 1530 -#define _SET_FUNCTION_ATTRIBUTE_r01 1531 -#define _SET_FUNCTION_ATTRIBUTE_r11 1532 -#define _SET_FUNCTION_ATTRIBUTE_r21 1533 -#define _SET_FUNCTION_ATTRIBUTE_r32 1534 -#define _SET_IP_r00 1535 -#define _SET_IP_r11 1536 -#define _SET_IP_r22 1537 -#define _SET_IP_r33 1538 -#define _SET_UPDATE_r11 1539 -#define _SPILL_OR_RELOAD_r01 1540 -#define _SPILL_OR_RELOAD_r02 1541 -#define _SPILL_OR_RELOAD_r03 1542 -#define _SPILL_OR_RELOAD_r10 1543 -#define _SPILL_OR_RELOAD_r12 1544 -#define _SPILL_OR_RELOAD_r13 1545 -#define _SPILL_OR_RELOAD_r20 1546 -#define _SPILL_OR_RELOAD_r21 1547 -#define _SPILL_OR_RELOAD_r23 1548 -#define _SPILL_OR_RELOAD_r30 1549 -#define _SPILL_OR_RELOAD_r31 1550 -#define _SPILL_OR_RELOAD_r32 1551 -#define _START_EXECUTOR_r00 1552 -#define _STORE_ATTR_r20 1553 -#define _STORE_ATTR_INSTANCE_VALUE_r21 1554 -#define _STORE_ATTR_SLOT_r21 1555 -#define _STORE_ATTR_WITH_HINT_r21 1556 -#define _STORE_DEREF_r10 1557 -#define _STORE_FAST_LOAD_FAST_r11 1558 -#define _STORE_FAST_STORE_FAST_r20 1559 -#define _STORE_GLOBAL_r10 1560 -#define _STORE_NAME_r10 1561 -#define _STORE_SLICE_r30 1562 -#define _STORE_SUBSCR_r30 1563 -#define _STORE_SUBSCR_DICT_r31 1564 -#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1565 -#define _STORE_SUBSCR_LIST_INT_r32 1566 -#define _SWAP_r11 1567 -#define _SWAP_2_r02 1568 -#define _SWAP_2_r12 1569 -#define _SWAP_2_r22 1570 -#define _SWAP_2_r33 1571 -#define _SWAP_3_r03 1572 -#define _SWAP_3_r13 1573 -#define _SWAP_3_r23 1574 -#define _SWAP_3_r33 1575 -#define _SWAP_FAST_r01 1576 -#define _SWAP_FAST_r11 1577 -#define _SWAP_FAST_r22 1578 -#define _SWAP_FAST_r33 1579 -#define _SWAP_FAST_0_r01 1580 -#define _SWAP_FAST_0_r11 1581 -#define _SWAP_FAST_0_r22 1582 -#define _SWAP_FAST_0_r33 1583 -#define _SWAP_FAST_1_r01 1584 -#define _SWAP_FAST_1_r11 1585 -#define _SWAP_FAST_1_r22 1586 -#define _SWAP_FAST_1_r33 1587 -#define _SWAP_FAST_2_r01 1588 -#define _SWAP_FAST_2_r11 1589 -#define _SWAP_FAST_2_r22 1590 -#define _SWAP_FAST_2_r33 1591 -#define _SWAP_FAST_3_r01 1592 -#define _SWAP_FAST_3_r11 1593 -#define _SWAP_FAST_3_r22 1594 -#define _SWAP_FAST_3_r33 1595 -#define _SWAP_FAST_4_r01 1596 -#define _SWAP_FAST_4_r11 1597 -#define _SWAP_FAST_4_r22 1598 -#define _SWAP_FAST_4_r33 1599 -#define _SWAP_FAST_5_r01 1600 -#define _SWAP_FAST_5_r11 1601 -#define _SWAP_FAST_5_r22 1602 -#define _SWAP_FAST_5_r33 1603 -#define _SWAP_FAST_6_r01 1604 -#define _SWAP_FAST_6_r11 1605 -#define _SWAP_FAST_6_r22 1606 -#define _SWAP_FAST_6_r33 1607 -#define _SWAP_FAST_7_r01 1608 -#define _SWAP_FAST_7_r11 1609 -#define _SWAP_FAST_7_r22 1610 -#define _SWAP_FAST_7_r33 1611 -#define _TIER2_RESUME_CHECK_r00 1612 -#define _TIER2_RESUME_CHECK_r11 1613 -#define _TIER2_RESUME_CHECK_r22 1614 -#define _TIER2_RESUME_CHECK_r33 1615 -#define _TO_BOOL_r11 1616 -#define _TO_BOOL_BOOL_r01 1617 -#define _TO_BOOL_BOOL_r11 1618 -#define _TO_BOOL_BOOL_r22 1619 -#define _TO_BOOL_BOOL_r33 1620 -#define _TO_BOOL_INT_r02 1621 -#define _TO_BOOL_INT_r12 1622 -#define _TO_BOOL_INT_r23 1623 -#define _TO_BOOL_LIST_r02 1624 -#define _TO_BOOL_LIST_r12 1625 -#define _TO_BOOL_LIST_r23 1626 -#define _TO_BOOL_NONE_r01 1627 -#define _TO_BOOL_NONE_r11 1628 -#define _TO_BOOL_NONE_r22 1629 -#define _TO_BOOL_NONE_r33 1630 -#define _TO_BOOL_STR_r02 1631 -#define _TO_BOOL_STR_r12 1632 -#define _TO_BOOL_STR_r23 1633 -#define _TRACE_RECORD_r00 1634 -#define _UNARY_INVERT_r12 1635 -#define _UNARY_NEGATIVE_r12 1636 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1637 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1638 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1639 -#define _UNARY_NOT_r01 1640 -#define _UNARY_NOT_r11 1641 -#define _UNARY_NOT_r22 1642 -#define _UNARY_NOT_r33 1643 -#define _UNPACK_EX_r10 1644 -#define _UNPACK_SEQUENCE_r10 1645 -#define _UNPACK_SEQUENCE_LIST_r10 1646 -#define _UNPACK_SEQUENCE_TUPLE_r10 1647 -#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1648 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1649 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1650 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1651 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1652 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1653 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1654 -#define _WITH_EXCEPT_START_r33 1655 -#define _YIELD_VALUE_r11 1656 -#define MAX_UOP_REGS_ID 1656 +#define _BUILD_FROZENDICT_r11 738 +#define _BUILD_FROZENSET_r01 739 +#define _BUILD_INTERPOLATION_r01 740 +#define _BUILD_LIST_r01 741 +#define _BUILD_MAP_r01 742 +#define _BUILD_SET_r01 743 +#define _BUILD_SLICE_r01 744 +#define _BUILD_STRING_r01 745 +#define _BUILD_TEMPLATE_r21 746 +#define _BUILD_TUPLE_r01 747 +#define _CALL_BUILTIN_CLASS_r00 748 +#define _CALL_BUILTIN_FAST_r00 749 +#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 750 +#define _CALL_BUILTIN_O_r03 751 +#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 752 +#define _CALL_INTRINSIC_1_r12 753 +#define _CALL_INTRINSIC_2_r23 754 +#define _CALL_ISINSTANCE_r31 755 +#define _CALL_KW_NON_PY_r11 756 +#define _CALL_LEN_r33 757 +#define _CALL_LIST_APPEND_r03 758 +#define _CALL_LIST_APPEND_r13 759 +#define _CALL_LIST_APPEND_r23 760 +#define _CALL_LIST_APPEND_r33 761 +#define _CALL_METHOD_DESCRIPTOR_FAST_r00 762 +#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 763 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 764 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 765 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 766 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 767 +#define _CALL_METHOD_DESCRIPTOR_O_r03 768 +#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 769 +#define _CALL_NON_PY_GENERAL_r01 770 +#define _CALL_STR_1_r32 771 +#define _CALL_TUPLE_1_r32 772 +#define _CALL_TYPE_1_r02 773 +#define _CALL_TYPE_1_r12 774 +#define _CALL_TYPE_1_r22 775 +#define _CALL_TYPE_1_r32 776 +#define _CHECK_ATTR_CLASS_r01 777 +#define _CHECK_ATTR_CLASS_r11 778 +#define _CHECK_ATTR_CLASS_r22 779 +#define _CHECK_ATTR_CLASS_r33 780 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 781 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 782 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 783 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 784 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 785 +#define _CHECK_EG_MATCH_r22 786 +#define _CHECK_EXC_MATCH_r22 787 +#define _CHECK_FUNCTION_EXACT_ARGS_r00 788 +#define _CHECK_FUNCTION_VERSION_r00 789 +#define _CHECK_FUNCTION_VERSION_INLINE_r00 790 +#define _CHECK_FUNCTION_VERSION_INLINE_r11 791 +#define _CHECK_FUNCTION_VERSION_INLINE_r22 792 +#define _CHECK_FUNCTION_VERSION_INLINE_r33 793 +#define _CHECK_FUNCTION_VERSION_KW_r11 794 +#define _CHECK_IS_NOT_PY_CALLABLE_r00 795 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 796 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 797 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 798 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 799 +#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 800 +#define _CHECK_IS_PY_CALLABLE_EX_r03 801 +#define _CHECK_IS_PY_CALLABLE_EX_r13 802 +#define _CHECK_IS_PY_CALLABLE_EX_r23 803 +#define _CHECK_IS_PY_CALLABLE_EX_r33 804 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 805 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 806 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 807 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 808 +#define _CHECK_METHOD_VERSION_r00 809 +#define _CHECK_METHOD_VERSION_KW_r11 810 +#define _CHECK_OBJECT_r00 811 +#define _CHECK_PEP_523_r00 812 +#define _CHECK_PEP_523_r11 813 +#define _CHECK_PEP_523_r22 814 +#define _CHECK_PEP_523_r33 815 +#define _CHECK_PERIODIC_r00 816 +#define _CHECK_PERIODIC_AT_END_r00 817 +#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 818 +#define _CHECK_RECURSION_LIMIT_r00 819 +#define _CHECK_RECURSION_LIMIT_r11 820 +#define _CHECK_RECURSION_LIMIT_r22 821 +#define _CHECK_RECURSION_LIMIT_r33 822 +#define _CHECK_RECURSION_REMAINING_r00 823 +#define _CHECK_RECURSION_REMAINING_r11 824 +#define _CHECK_RECURSION_REMAINING_r22 825 +#define _CHECK_RECURSION_REMAINING_r33 826 +#define _CHECK_STACK_SPACE_r00 827 +#define _CHECK_STACK_SPACE_OPERAND_r00 828 +#define _CHECK_STACK_SPACE_OPERAND_r11 829 +#define _CHECK_STACK_SPACE_OPERAND_r22 830 +#define _CHECK_STACK_SPACE_OPERAND_r33 831 +#define _CHECK_VALIDITY_r00 832 +#define _CHECK_VALIDITY_r11 833 +#define _CHECK_VALIDITY_r22 834 +#define _CHECK_VALIDITY_r33 835 +#define _COLD_DYNAMIC_EXIT_r00 836 +#define _COLD_EXIT_r00 837 +#define _COMPARE_OP_r21 838 +#define _COMPARE_OP_FLOAT_r03 839 +#define _COMPARE_OP_FLOAT_r13 840 +#define _COMPARE_OP_FLOAT_r23 841 +#define _COMPARE_OP_INT_r23 842 +#define _COMPARE_OP_STR_r23 843 +#define _CONTAINS_OP_r23 844 +#define _CONTAINS_OP_DICT_r23 845 +#define _CONTAINS_OP_SET_r23 846 +#define _CONVERT_VALUE_r11 847 +#define _COPY_r01 848 +#define _COPY_1_r02 849 +#define _COPY_1_r12 850 +#define _COPY_1_r23 851 +#define _COPY_2_r03 852 +#define _COPY_2_r13 853 +#define _COPY_2_r23 854 +#define _COPY_3_r03 855 +#define _COPY_3_r13 856 +#define _COPY_3_r23 857 +#define _COPY_3_r33 858 +#define _COPY_FREE_VARS_r00 859 +#define _COPY_FREE_VARS_r11 860 +#define _COPY_FREE_VARS_r22 861 +#define _COPY_FREE_VARS_r33 862 +#define _CREATE_INIT_FRAME_r01 863 +#define _DELETE_ATTR_r10 864 +#define _DELETE_DEREF_r00 865 +#define _DELETE_FAST_r00 866 +#define _DELETE_SUBSCR_r20 867 +#define _DEOPT_r00 868 +#define _DEOPT_r10 869 +#define _DEOPT_r20 870 +#define _DEOPT_r30 871 +#define _DICT_MERGE_r11 872 +#define _DICT_UPDATE_r11 873 +#define _DO_CALL_r01 874 +#define _DO_CALL_FUNCTION_EX_r31 875 +#define _DO_CALL_KW_r11 876 +#define _DYNAMIC_EXIT_r00 877 +#define _DYNAMIC_EXIT_r10 878 +#define _DYNAMIC_EXIT_r20 879 +#define _DYNAMIC_EXIT_r30 880 +#define _END_FOR_r10 881 +#define _END_SEND_r31 882 +#define _ERROR_POP_N_r00 883 +#define _EXIT_INIT_CHECK_r10 884 +#define _EXIT_TRACE_r00 885 +#define _EXIT_TRACE_r10 886 +#define _EXIT_TRACE_r20 887 +#define _EXIT_TRACE_r30 888 +#define _EXPAND_METHOD_r00 889 +#define _EXPAND_METHOD_KW_r11 890 +#define _FATAL_ERROR_r00 891 +#define _FATAL_ERROR_r11 892 +#define _FATAL_ERROR_r22 893 +#define _FATAL_ERROR_r33 894 +#define _FORMAT_SIMPLE_r11 895 +#define _FORMAT_WITH_SPEC_r21 896 +#define _FOR_ITER_r23 897 +#define _FOR_ITER_GEN_FRAME_r03 898 +#define _FOR_ITER_GEN_FRAME_r13 899 +#define _FOR_ITER_GEN_FRAME_r23 900 +#define _FOR_ITER_TIER_TWO_r23 901 +#define _FOR_ITER_VIRTUAL_r23 902 +#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 903 +#define _GET_AITER_r11 904 +#define _GET_ANEXT_r12 905 +#define _GET_AWAITABLE_r11 906 +#define _GET_ITER_r12 907 +#define _GET_ITER_TRAD_r12 908 +#define _GET_LEN_r12 909 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r03 910 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r13 911 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r23 912 +#define _GUARD_3OS_ASYNC_GEN_ASEND_r33 913 +#define _GUARD_BINARY_OP_EXTEND_r22 914 +#define _GUARD_BINARY_OP_EXTEND_LHS_r02 915 +#define _GUARD_BINARY_OP_EXTEND_LHS_r12 916 +#define _GUARD_BINARY_OP_EXTEND_LHS_r22 917 +#define _GUARD_BINARY_OP_EXTEND_LHS_r33 918 +#define _GUARD_BINARY_OP_EXTEND_RHS_r02 919 +#define _GUARD_BINARY_OP_EXTEND_RHS_r12 920 +#define _GUARD_BINARY_OP_EXTEND_RHS_r22 921 +#define _GUARD_BINARY_OP_EXTEND_RHS_r33 922 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 923 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 924 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 925 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 926 +#define _GUARD_BIT_IS_SET_POP_r00 927 +#define _GUARD_BIT_IS_SET_POP_r10 928 +#define _GUARD_BIT_IS_SET_POP_r21 929 +#define _GUARD_BIT_IS_SET_POP_r32 930 +#define _GUARD_BIT_IS_SET_POP_4_r00 931 +#define _GUARD_BIT_IS_SET_POP_4_r10 932 +#define _GUARD_BIT_IS_SET_POP_4_r21 933 +#define _GUARD_BIT_IS_SET_POP_4_r32 934 +#define _GUARD_BIT_IS_SET_POP_5_r00 935 +#define _GUARD_BIT_IS_SET_POP_5_r10 936 +#define _GUARD_BIT_IS_SET_POP_5_r21 937 +#define _GUARD_BIT_IS_SET_POP_5_r32 938 +#define _GUARD_BIT_IS_SET_POP_6_r00 939 +#define _GUARD_BIT_IS_SET_POP_6_r10 940 +#define _GUARD_BIT_IS_SET_POP_6_r21 941 +#define _GUARD_BIT_IS_SET_POP_6_r32 942 +#define _GUARD_BIT_IS_SET_POP_7_r00 943 +#define _GUARD_BIT_IS_SET_POP_7_r10 944 +#define _GUARD_BIT_IS_SET_POP_7_r21 945 +#define _GUARD_BIT_IS_SET_POP_7_r32 946 +#define _GUARD_BIT_IS_UNSET_POP_r00 947 +#define _GUARD_BIT_IS_UNSET_POP_r10 948 +#define _GUARD_BIT_IS_UNSET_POP_r21 949 +#define _GUARD_BIT_IS_UNSET_POP_r32 950 +#define _GUARD_BIT_IS_UNSET_POP_4_r00 951 +#define _GUARD_BIT_IS_UNSET_POP_4_r10 952 +#define _GUARD_BIT_IS_UNSET_POP_4_r21 953 +#define _GUARD_BIT_IS_UNSET_POP_4_r32 954 +#define _GUARD_BIT_IS_UNSET_POP_5_r00 955 +#define _GUARD_BIT_IS_UNSET_POP_5_r10 956 +#define _GUARD_BIT_IS_UNSET_POP_5_r21 957 +#define _GUARD_BIT_IS_UNSET_POP_5_r32 958 +#define _GUARD_BIT_IS_UNSET_POP_6_r00 959 +#define _GUARD_BIT_IS_UNSET_POP_6_r10 960 +#define _GUARD_BIT_IS_UNSET_POP_6_r21 961 +#define _GUARD_BIT_IS_UNSET_POP_6_r32 962 +#define _GUARD_BIT_IS_UNSET_POP_7_r00 963 +#define _GUARD_BIT_IS_UNSET_POP_7_r10 964 +#define _GUARD_BIT_IS_UNSET_POP_7_r21 965 +#define _GUARD_BIT_IS_UNSET_POP_7_r32 966 +#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 967 +#define _GUARD_CALLABLE_BUILTIN_FAST_r00 968 +#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 969 +#define _GUARD_CALLABLE_BUILTIN_O_r00 970 +#define _GUARD_CALLABLE_ISINSTANCE_r03 971 +#define _GUARD_CALLABLE_ISINSTANCE_r13 972 +#define _GUARD_CALLABLE_ISINSTANCE_r23 973 +#define _GUARD_CALLABLE_ISINSTANCE_r33 974 +#define _GUARD_CALLABLE_LEN_r03 975 +#define _GUARD_CALLABLE_LEN_r13 976 +#define _GUARD_CALLABLE_LEN_r23 977 +#define _GUARD_CALLABLE_LEN_r33 978 +#define _GUARD_CALLABLE_LIST_APPEND_r03 979 +#define _GUARD_CALLABLE_LIST_APPEND_r13 980 +#define _GUARD_CALLABLE_LIST_APPEND_r23 981 +#define _GUARD_CALLABLE_LIST_APPEND_r33 982 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 983 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 984 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 985 +#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 986 +#define _GUARD_CALLABLE_STR_1_r03 987 +#define _GUARD_CALLABLE_STR_1_r13 988 +#define _GUARD_CALLABLE_STR_1_r23 989 +#define _GUARD_CALLABLE_STR_1_r33 990 +#define _GUARD_CALLABLE_TUPLE_1_r03 991 +#define _GUARD_CALLABLE_TUPLE_1_r13 992 +#define _GUARD_CALLABLE_TUPLE_1_r23 993 +#define _GUARD_CALLABLE_TUPLE_1_r33 994 +#define _GUARD_CALLABLE_TYPE_1_r03 995 +#define _GUARD_CALLABLE_TYPE_1_r13 996 +#define _GUARD_CALLABLE_TYPE_1_r23 997 +#define _GUARD_CALLABLE_TYPE_1_r33 998 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 999 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 1000 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 1001 +#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 1002 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 1003 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 1004 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 1005 +#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 1006 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 1007 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 1008 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 1009 +#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 1010 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 1011 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 1012 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1013 +#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1014 +#define _GUARD_DORV_NO_DICT_r01 1015 +#define _GUARD_DORV_NO_DICT_r11 1016 +#define _GUARD_DORV_NO_DICT_r22 1017 +#define _GUARD_DORV_NO_DICT_r33 1018 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 1019 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 1020 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 1021 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 1022 +#define _GUARD_GLOBALS_VERSION_r00 1023 +#define _GUARD_GLOBALS_VERSION_r11 1024 +#define _GUARD_GLOBALS_VERSION_r22 1025 +#define _GUARD_GLOBALS_VERSION_r33 1026 +#define _GUARD_IP_RETURN_GENERATOR_r00 1027 +#define _GUARD_IP_RETURN_GENERATOR_r11 1028 +#define _GUARD_IP_RETURN_GENERATOR_r22 1029 +#define _GUARD_IP_RETURN_GENERATOR_r33 1030 +#define _GUARD_IP_RETURN_VALUE_r00 1031 +#define _GUARD_IP_RETURN_VALUE_r11 1032 +#define _GUARD_IP_RETURN_VALUE_r22 1033 +#define _GUARD_IP_RETURN_VALUE_r33 1034 +#define _GUARD_IP_YIELD_VALUE_r00 1035 +#define _GUARD_IP_YIELD_VALUE_r11 1036 +#define _GUARD_IP_YIELD_VALUE_r22 1037 +#define _GUARD_IP_YIELD_VALUE_r33 1038 +#define _GUARD_IP__PUSH_FRAME_r00 1039 +#define _GUARD_IP__PUSH_FRAME_r11 1040 +#define _GUARD_IP__PUSH_FRAME_r22 1041 +#define _GUARD_IP__PUSH_FRAME_r33 1042 +#define _GUARD_IS_FALSE_POP_r00 1043 +#define _GUARD_IS_FALSE_POP_r10 1044 +#define _GUARD_IS_FALSE_POP_r21 1045 +#define _GUARD_IS_FALSE_POP_r32 1046 +#define _GUARD_IS_NONE_POP_r00 1047 +#define _GUARD_IS_NONE_POP_r10 1048 +#define _GUARD_IS_NONE_POP_r21 1049 +#define _GUARD_IS_NONE_POP_r32 1050 +#define _GUARD_IS_NOT_NONE_POP_r10 1051 +#define _GUARD_IS_TRUE_POP_r00 1052 +#define _GUARD_IS_TRUE_POP_r10 1053 +#define _GUARD_IS_TRUE_POP_r21 1054 +#define _GUARD_IS_TRUE_POP_r32 1055 +#define _GUARD_ITERATOR_r01 1056 +#define _GUARD_ITERATOR_r11 1057 +#define _GUARD_ITERATOR_r22 1058 +#define _GUARD_ITERATOR_r33 1059 +#define _GUARD_ITER_VIRTUAL_r01 1060 +#define _GUARD_ITER_VIRTUAL_r11 1061 +#define _GUARD_ITER_VIRTUAL_r22 1062 +#define _GUARD_ITER_VIRTUAL_r33 1063 +#define _GUARD_KEYS_VERSION_r01 1064 +#define _GUARD_KEYS_VERSION_r11 1065 +#define _GUARD_KEYS_VERSION_r22 1066 +#define _GUARD_KEYS_VERSION_r33 1067 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1068 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1069 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1070 +#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1071 +#define _GUARD_NOS_COMPACT_ASCII_r02 1072 +#define _GUARD_NOS_COMPACT_ASCII_r12 1073 +#define _GUARD_NOS_COMPACT_ASCII_r22 1074 +#define _GUARD_NOS_COMPACT_ASCII_r33 1075 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r03 1076 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r13 1077 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r23 1078 +#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r33 1079 +#define _GUARD_NOS_DICT_SUBSCRIPT_r02 1080 +#define _GUARD_NOS_DICT_SUBSCRIPT_r12 1081 +#define _GUARD_NOS_DICT_SUBSCRIPT_r22 1082 +#define _GUARD_NOS_DICT_SUBSCRIPT_r33 1083 +#define _GUARD_NOS_FLOAT_r02 1084 +#define _GUARD_NOS_FLOAT_r12 1085 +#define _GUARD_NOS_FLOAT_r22 1086 +#define _GUARD_NOS_FLOAT_r33 1087 +#define _GUARD_NOS_INT_r02 1088 +#define _GUARD_NOS_INT_r12 1089 +#define _GUARD_NOS_INT_r22 1090 +#define _GUARD_NOS_INT_r33 1091 +#define _GUARD_NOS_ITER_VIRTUAL_r02 1092 +#define _GUARD_NOS_ITER_VIRTUAL_r12 1093 +#define _GUARD_NOS_ITER_VIRTUAL_r22 1094 +#define _GUARD_NOS_ITER_VIRTUAL_r33 1095 +#define _GUARD_NOS_LIST_r02 1096 +#define _GUARD_NOS_LIST_r12 1097 +#define _GUARD_NOS_LIST_r22 1098 +#define _GUARD_NOS_LIST_r33 1099 +#define _GUARD_NOS_NOT_NULL_r02 1100 +#define _GUARD_NOS_NOT_NULL_r12 1101 +#define _GUARD_NOS_NOT_NULL_r22 1102 +#define _GUARD_NOS_NOT_NULL_r33 1103 +#define _GUARD_NOS_NULL_r02 1104 +#define _GUARD_NOS_NULL_r12 1105 +#define _GUARD_NOS_NULL_r22 1106 +#define _GUARD_NOS_NULL_r33 1107 +#define _GUARD_NOS_OVERFLOWED_r02 1108 +#define _GUARD_NOS_OVERFLOWED_r12 1109 +#define _GUARD_NOS_OVERFLOWED_r22 1110 +#define _GUARD_NOS_OVERFLOWED_r33 1111 +#define _GUARD_NOS_TUPLE_r02 1112 +#define _GUARD_NOS_TUPLE_r12 1113 +#define _GUARD_NOS_TUPLE_r22 1114 +#define _GUARD_NOS_TUPLE_r33 1115 +#define _GUARD_NOS_TYPE_VERSION_r02 1116 +#define _GUARD_NOS_TYPE_VERSION_r12 1117 +#define _GUARD_NOS_TYPE_VERSION_r22 1118 +#define _GUARD_NOS_TYPE_VERSION_r33 1119 +#define _GUARD_NOS_UNICODE_r02 1120 +#define _GUARD_NOS_UNICODE_r12 1121 +#define _GUARD_NOS_UNICODE_r22 1122 +#define _GUARD_NOS_UNICODE_r33 1123 +#define _GUARD_NOT_EXHAUSTED_LIST_r02 1124 +#define _GUARD_NOT_EXHAUSTED_LIST_r12 1125 +#define _GUARD_NOT_EXHAUSTED_LIST_r22 1126 +#define _GUARD_NOT_EXHAUSTED_LIST_r33 1127 +#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1128 +#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1129 +#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1130 +#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1131 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1132 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1133 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1134 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1135 +#define _GUARD_THIRD_NULL_r03 1136 +#define _GUARD_THIRD_NULL_r13 1137 +#define _GUARD_THIRD_NULL_r23 1138 +#define _GUARD_THIRD_NULL_r33 1139 +#define _GUARD_TOS_ANY_DICT_r01 1140 +#define _GUARD_TOS_ANY_DICT_r11 1141 +#define _GUARD_TOS_ANY_DICT_r22 1142 +#define _GUARD_TOS_ANY_DICT_r33 1143 +#define _GUARD_TOS_ANY_SET_r01 1144 +#define _GUARD_TOS_ANY_SET_r11 1145 +#define _GUARD_TOS_ANY_SET_r22 1146 +#define _GUARD_TOS_ANY_SET_r33 1147 +#define _GUARD_TOS_DICT_r01 1148 +#define _GUARD_TOS_DICT_r11 1149 +#define _GUARD_TOS_DICT_r22 1150 +#define _GUARD_TOS_DICT_r33 1151 +#define _GUARD_TOS_FLOAT_r01 1152 +#define _GUARD_TOS_FLOAT_r11 1153 +#define _GUARD_TOS_FLOAT_r22 1154 +#define _GUARD_TOS_FLOAT_r33 1155 +#define _GUARD_TOS_FROZENDICT_r01 1156 +#define _GUARD_TOS_FROZENDICT_r11 1157 +#define _GUARD_TOS_FROZENDICT_r22 1158 +#define _GUARD_TOS_FROZENDICT_r33 1159 +#define _GUARD_TOS_FROZENSET_r01 1160 +#define _GUARD_TOS_FROZENSET_r11 1161 +#define _GUARD_TOS_FROZENSET_r22 1162 +#define _GUARD_TOS_FROZENSET_r33 1163 +#define _GUARD_TOS_INT_r01 1164 +#define _GUARD_TOS_INT_r11 1165 +#define _GUARD_TOS_INT_r22 1166 +#define _GUARD_TOS_INT_r33 1167 +#define _GUARD_TOS_IS_NONE_r01 1168 +#define _GUARD_TOS_IS_NONE_r11 1169 +#define _GUARD_TOS_IS_NONE_r22 1170 +#define _GUARD_TOS_IS_NONE_r33 1171 +#define _GUARD_TOS_LIST_r01 1172 +#define _GUARD_TOS_LIST_r11 1173 +#define _GUARD_TOS_LIST_r22 1174 +#define _GUARD_TOS_LIST_r33 1175 +#define _GUARD_TOS_NOT_NULL_r01 1176 +#define _GUARD_TOS_NOT_NULL_r11 1177 +#define _GUARD_TOS_NOT_NULL_r22 1178 +#define _GUARD_TOS_NOT_NULL_r33 1179 +#define _GUARD_TOS_OVERFLOWED_r01 1180 +#define _GUARD_TOS_OVERFLOWED_r11 1181 +#define _GUARD_TOS_OVERFLOWED_r22 1182 +#define _GUARD_TOS_OVERFLOWED_r33 1183 +#define _GUARD_TOS_SET_r01 1184 +#define _GUARD_TOS_SET_r11 1185 +#define _GUARD_TOS_SET_r22 1186 +#define _GUARD_TOS_SET_r33 1187 +#define _GUARD_TOS_SLICE_r01 1188 +#define _GUARD_TOS_SLICE_r11 1189 +#define _GUARD_TOS_SLICE_r22 1190 +#define _GUARD_TOS_SLICE_r33 1191 +#define _GUARD_TOS_TUPLE_r01 1192 +#define _GUARD_TOS_TUPLE_r11 1193 +#define _GUARD_TOS_TUPLE_r22 1194 +#define _GUARD_TOS_TUPLE_r33 1195 +#define _GUARD_TOS_UNICODE_r01 1196 +#define _GUARD_TOS_UNICODE_r11 1197 +#define _GUARD_TOS_UNICODE_r22 1198 +#define _GUARD_TOS_UNICODE_r33 1199 +#define _GUARD_TYPE_r01 1200 +#define _GUARD_TYPE_r11 1201 +#define _GUARD_TYPE_r22 1202 +#define _GUARD_TYPE_r33 1203 +#define _GUARD_TYPE_ITER_r02 1204 +#define _GUARD_TYPE_ITER_r12 1205 +#define _GUARD_TYPE_ITER_r22 1206 +#define _GUARD_TYPE_ITER_r33 1207 +#define _GUARD_TYPE_VERSION_r01 1208 +#define _GUARD_TYPE_VERSION_r11 1209 +#define _GUARD_TYPE_VERSION_r22 1210 +#define _GUARD_TYPE_VERSION_r33 1211 +#define _GUARD_TYPE_VERSION_LOCKED_r01 1212 +#define _GUARD_TYPE_VERSION_LOCKED_r11 1213 +#define _GUARD_TYPE_VERSION_LOCKED_r22 1214 +#define _GUARD_TYPE_VERSION_LOCKED_r33 1215 +#define _HANDLE_PENDING_AND_DEOPT_r00 1216 +#define _HANDLE_PENDING_AND_DEOPT_r10 1217 +#define _HANDLE_PENDING_AND_DEOPT_r20 1218 +#define _HANDLE_PENDING_AND_DEOPT_r30 1219 +#define _IMPORT_FROM_r12 1220 +#define _IMPORT_NAME_r21 1221 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1222 +#define _INIT_CALL_PY_EXACT_ARGS_r01 1223 +#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1224 +#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1225 +#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1226 +#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1227 +#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1228 +#define _INSERT_NULL_r10 1229 +#define _INSTRUMENTED_FOR_ITER_r23 1230 +#define _INSTRUMENTED_INSTRUCTION_r00 1231 +#define _INSTRUMENTED_JUMP_FORWARD_r00 1232 +#define _INSTRUMENTED_JUMP_FORWARD_r11 1233 +#define _INSTRUMENTED_JUMP_FORWARD_r22 1234 +#define _INSTRUMENTED_JUMP_FORWARD_r33 1235 +#define _INSTRUMENTED_LINE_r00 1236 +#define _INSTRUMENTED_NOT_TAKEN_r00 1237 +#define _INSTRUMENTED_NOT_TAKEN_r11 1238 +#define _INSTRUMENTED_NOT_TAKEN_r22 1239 +#define _INSTRUMENTED_NOT_TAKEN_r33 1240 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1241 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1242 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1243 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1244 +#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1245 +#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1246 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1247 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1248 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1249 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1250 +#define _IS_NONE_r11 1251 +#define _IS_OP_r03 1252 +#define _IS_OP_r13 1253 +#define _IS_OP_r23 1254 +#define _ITER_CHECK_LIST_r02 1255 +#define _ITER_CHECK_LIST_r12 1256 +#define _ITER_CHECK_LIST_r22 1257 +#define _ITER_CHECK_LIST_r33 1258 +#define _ITER_CHECK_RANGE_r02 1259 +#define _ITER_CHECK_RANGE_r12 1260 +#define _ITER_CHECK_RANGE_r22 1261 +#define _ITER_CHECK_RANGE_r33 1262 +#define _ITER_CHECK_TUPLE_r02 1263 +#define _ITER_CHECK_TUPLE_r12 1264 +#define _ITER_CHECK_TUPLE_r22 1265 +#define _ITER_CHECK_TUPLE_r33 1266 +#define _ITER_JUMP_LIST_r02 1267 +#define _ITER_JUMP_LIST_r12 1268 +#define _ITER_JUMP_LIST_r22 1269 +#define _ITER_JUMP_LIST_r33 1270 +#define _ITER_JUMP_RANGE_r02 1271 +#define _ITER_JUMP_RANGE_r12 1272 +#define _ITER_JUMP_RANGE_r22 1273 +#define _ITER_JUMP_RANGE_r33 1274 +#define _ITER_JUMP_TUPLE_r02 1275 +#define _ITER_JUMP_TUPLE_r12 1276 +#define _ITER_JUMP_TUPLE_r22 1277 +#define _ITER_JUMP_TUPLE_r33 1278 +#define _ITER_NEXT_INLINE_r23 1279 +#define _ITER_NEXT_LIST_r23 1280 +#define _ITER_NEXT_LIST_TIER_TWO_r23 1281 +#define _ITER_NEXT_RANGE_r03 1282 +#define _ITER_NEXT_RANGE_r13 1283 +#define _ITER_NEXT_RANGE_r23 1284 +#define _ITER_NEXT_TUPLE_r03 1285 +#define _ITER_NEXT_TUPLE_r13 1286 +#define _ITER_NEXT_TUPLE_r23 1287 +#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1288 +#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1289 +#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1290 +#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1291 +#define _JUMP_TO_TOP_r00 1292 +#define _LIST_APPEND_r10 1293 +#define _LIST_EXTEND_r11 1294 +#define _LOAD_ATTR_r10 1295 +#define _LOAD_ATTR_CLASS_r11 1296 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1297 +#define _LOAD_ATTR_INSTANCE_VALUE_r02 1298 +#define _LOAD_ATTR_INSTANCE_VALUE_r12 1299 +#define _LOAD_ATTR_INSTANCE_VALUE_r23 1300 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1301 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1302 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1303 +#define _LOAD_ATTR_METHOD_NO_DICT_r02 1304 +#define _LOAD_ATTR_METHOD_NO_DICT_r12 1305 +#define _LOAD_ATTR_METHOD_NO_DICT_r23 1306 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1307 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1308 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1309 +#define _LOAD_ATTR_MODULE_r12 1310 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1311 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1312 +#define _LOAD_ATTR_PROPERTY_FRAME_r01 1313 +#define _LOAD_ATTR_PROPERTY_FRAME_r11 1314 +#define _LOAD_ATTR_PROPERTY_FRAME_r22 1315 +#define _LOAD_ATTR_PROPERTY_FRAME_r33 1316 +#define _LOAD_ATTR_SLOT_r02 1317 +#define _LOAD_ATTR_SLOT_r12 1318 +#define _LOAD_ATTR_SLOT_r23 1319 +#define _LOAD_ATTR_WITH_HINT_r12 1320 +#define _LOAD_BUILD_CLASS_r01 1321 +#define _LOAD_BYTECODE_r00 1322 +#define _LOAD_COMMON_CONSTANT_r01 1323 +#define _LOAD_COMMON_CONSTANT_r12 1324 +#define _LOAD_COMMON_CONSTANT_r23 1325 +#define _LOAD_CONST_r01 1326 +#define _LOAD_CONST_r12 1327 +#define _LOAD_CONST_r23 1328 +#define _LOAD_CONST_INLINE_r01 1329 +#define _LOAD_CONST_INLINE_r12 1330 +#define _LOAD_CONST_INLINE_r23 1331 +#define _LOAD_CONST_INLINE_BORROW_r01 1332 +#define _LOAD_CONST_INLINE_BORROW_r12 1333 +#define _LOAD_CONST_INLINE_BORROW_r23 1334 +#define _LOAD_DEREF_r01 1335 +#define _LOAD_FAST_r01 1336 +#define _LOAD_FAST_r12 1337 +#define _LOAD_FAST_r23 1338 +#define _LOAD_FAST_0_r01 1339 +#define _LOAD_FAST_0_r12 1340 +#define _LOAD_FAST_0_r23 1341 +#define _LOAD_FAST_1_r01 1342 +#define _LOAD_FAST_1_r12 1343 +#define _LOAD_FAST_1_r23 1344 +#define _LOAD_FAST_2_r01 1345 +#define _LOAD_FAST_2_r12 1346 +#define _LOAD_FAST_2_r23 1347 +#define _LOAD_FAST_3_r01 1348 +#define _LOAD_FAST_3_r12 1349 +#define _LOAD_FAST_3_r23 1350 +#define _LOAD_FAST_4_r01 1351 +#define _LOAD_FAST_4_r12 1352 +#define _LOAD_FAST_4_r23 1353 +#define _LOAD_FAST_5_r01 1354 +#define _LOAD_FAST_5_r12 1355 +#define _LOAD_FAST_5_r23 1356 +#define _LOAD_FAST_6_r01 1357 +#define _LOAD_FAST_6_r12 1358 +#define _LOAD_FAST_6_r23 1359 +#define _LOAD_FAST_7_r01 1360 +#define _LOAD_FAST_7_r12 1361 +#define _LOAD_FAST_7_r23 1362 +#define _LOAD_FAST_AND_CLEAR_r01 1363 +#define _LOAD_FAST_AND_CLEAR_r12 1364 +#define _LOAD_FAST_AND_CLEAR_r23 1365 +#define _LOAD_FAST_BORROW_r01 1366 +#define _LOAD_FAST_BORROW_r12 1367 +#define _LOAD_FAST_BORROW_r23 1368 +#define _LOAD_FAST_BORROW_0_r01 1369 +#define _LOAD_FAST_BORROW_0_r12 1370 +#define _LOAD_FAST_BORROW_0_r23 1371 +#define _LOAD_FAST_BORROW_1_r01 1372 +#define _LOAD_FAST_BORROW_1_r12 1373 +#define _LOAD_FAST_BORROW_1_r23 1374 +#define _LOAD_FAST_BORROW_2_r01 1375 +#define _LOAD_FAST_BORROW_2_r12 1376 +#define _LOAD_FAST_BORROW_2_r23 1377 +#define _LOAD_FAST_BORROW_3_r01 1378 +#define _LOAD_FAST_BORROW_3_r12 1379 +#define _LOAD_FAST_BORROW_3_r23 1380 +#define _LOAD_FAST_BORROW_4_r01 1381 +#define _LOAD_FAST_BORROW_4_r12 1382 +#define _LOAD_FAST_BORROW_4_r23 1383 +#define _LOAD_FAST_BORROW_5_r01 1384 +#define _LOAD_FAST_BORROW_5_r12 1385 +#define _LOAD_FAST_BORROW_5_r23 1386 +#define _LOAD_FAST_BORROW_6_r01 1387 +#define _LOAD_FAST_BORROW_6_r12 1388 +#define _LOAD_FAST_BORROW_6_r23 1389 +#define _LOAD_FAST_BORROW_7_r01 1390 +#define _LOAD_FAST_BORROW_7_r12 1391 +#define _LOAD_FAST_BORROW_7_r23 1392 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1393 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1394 +#define _LOAD_FAST_CHECK_r01 1395 +#define _LOAD_FAST_CHECK_r12 1396 +#define _LOAD_FAST_CHECK_r23 1397 +#define _LOAD_FAST_LOAD_FAST_r02 1398 +#define _LOAD_FAST_LOAD_FAST_r13 1399 +#define _LOAD_FROM_DICT_OR_DEREF_r11 1400 +#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1401 +#define _LOAD_GLOBAL_r00 1402 +#define _LOAD_GLOBAL_BUILTINS_r01 1403 +#define _LOAD_GLOBAL_MODULE_r01 1404 +#define _LOAD_LOCALS_r01 1405 +#define _LOAD_LOCALS_r12 1406 +#define _LOAD_LOCALS_r23 1407 +#define _LOAD_NAME_r01 1408 +#define _LOAD_SMALL_INT_r01 1409 +#define _LOAD_SMALL_INT_r12 1410 +#define _LOAD_SMALL_INT_r23 1411 +#define _LOAD_SMALL_INT_0_r01 1412 +#define _LOAD_SMALL_INT_0_r12 1413 +#define _LOAD_SMALL_INT_0_r23 1414 +#define _LOAD_SMALL_INT_1_r01 1415 +#define _LOAD_SMALL_INT_1_r12 1416 +#define _LOAD_SMALL_INT_1_r23 1417 +#define _LOAD_SMALL_INT_2_r01 1418 +#define _LOAD_SMALL_INT_2_r12 1419 +#define _LOAD_SMALL_INT_2_r23 1420 +#define _LOAD_SMALL_INT_3_r01 1421 +#define _LOAD_SMALL_INT_3_r12 1422 +#define _LOAD_SMALL_INT_3_r23 1423 +#define _LOAD_SPECIAL_r00 1424 +#define _LOAD_SUPER_ATTR_ATTR_r31 1425 +#define _LOAD_SUPER_ATTR_METHOD_r32 1426 +#define _LOCK_OBJECT_r01 1427 +#define _LOCK_OBJECT_r11 1428 +#define _LOCK_OBJECT_r22 1429 +#define _LOCK_OBJECT_r33 1430 +#define _MAKE_CALLARGS_A_TUPLE_r33 1431 +#define _MAKE_CELL_r00 1432 +#define _MAKE_FUNCTION_r12 1433 +#define _MAKE_HEAP_SAFE_r01 1434 +#define _MAKE_HEAP_SAFE_r11 1435 +#define _MAKE_HEAP_SAFE_r22 1436 +#define _MAKE_HEAP_SAFE_r33 1437 +#define _MAKE_WARM_r00 1438 +#define _MAKE_WARM_r11 1439 +#define _MAKE_WARM_r22 1440 +#define _MAKE_WARM_r33 1441 +#define _MAP_ADD_r20 1442 +#define _MATCH_CLASS_r33 1443 +#define _MATCH_KEYS_r23 1444 +#define _MATCH_MAPPING_r02 1445 +#define _MATCH_MAPPING_r12 1446 +#define _MATCH_MAPPING_r23 1447 +#define _MATCH_SEQUENCE_r02 1448 +#define _MATCH_SEQUENCE_r12 1449 +#define _MATCH_SEQUENCE_r23 1450 +#define _MAYBE_EXPAND_METHOD_r00 1451 +#define _MAYBE_EXPAND_METHOD_KW_r11 1452 +#define _MONITOR_CALL_r00 1453 +#define _MONITOR_CALL_KW_r11 1454 +#define _MONITOR_JUMP_BACKWARD_r00 1455 +#define _MONITOR_JUMP_BACKWARD_r11 1456 +#define _MONITOR_JUMP_BACKWARD_r22 1457 +#define _MONITOR_JUMP_BACKWARD_r33 1458 +#define _MONITOR_RESUME_r00 1459 +#define _NOP_r00 1460 +#define _NOP_r11 1461 +#define _NOP_r22 1462 +#define _NOP_r33 1463 +#define _POP_EXCEPT_r10 1464 +#define _POP_ITER_r20 1465 +#define _POP_JUMP_IF_FALSE_r00 1466 +#define _POP_JUMP_IF_FALSE_r10 1467 +#define _POP_JUMP_IF_FALSE_r21 1468 +#define _POP_JUMP_IF_FALSE_r32 1469 +#define _POP_JUMP_IF_TRUE_r00 1470 +#define _POP_JUMP_IF_TRUE_r10 1471 +#define _POP_JUMP_IF_TRUE_r21 1472 +#define _POP_JUMP_IF_TRUE_r32 1473 +#define _POP_TOP_r10 1474 +#define _POP_TOP_FLOAT_r00 1475 +#define _POP_TOP_FLOAT_r10 1476 +#define _POP_TOP_FLOAT_r21 1477 +#define _POP_TOP_FLOAT_r32 1478 +#define _POP_TOP_INT_r00 1479 +#define _POP_TOP_INT_r10 1480 +#define _POP_TOP_INT_r21 1481 +#define _POP_TOP_INT_r32 1482 +#define _POP_TOP_NOP_r00 1483 +#define _POP_TOP_NOP_r10 1484 +#define _POP_TOP_NOP_r21 1485 +#define _POP_TOP_NOP_r32 1486 +#define _POP_TOP_OPARG_r00 1487 +#define _POP_TOP_UNICODE_r00 1488 +#define _POP_TOP_UNICODE_r10 1489 +#define _POP_TOP_UNICODE_r21 1490 +#define _POP_TOP_UNICODE_r32 1491 +#define _PUSH_EXC_INFO_r02 1492 +#define _PUSH_EXC_INFO_r12 1493 +#define _PUSH_EXC_INFO_r23 1494 +#define _PUSH_FRAME_r10 1495 +#define _PUSH_NULL_r01 1496 +#define _PUSH_NULL_r12 1497 +#define _PUSH_NULL_r23 1498 +#define _PUSH_NULL_CONDITIONAL_r00 1499 +#define _PUSH_TAGGED_ZERO_r01 1500 +#define _PUSH_TAGGED_ZERO_r12 1501 +#define _PUSH_TAGGED_ZERO_r23 1502 +#define _PY_FRAME_EX_r31 1503 +#define _PY_FRAME_GENERAL_r01 1504 +#define _PY_FRAME_KW_r11 1505 +#define _REPLACE_WITH_TRUE_r02 1506 +#define _REPLACE_WITH_TRUE_r12 1507 +#define _REPLACE_WITH_TRUE_r23 1508 +#define _RESUME_CHECK_r00 1509 +#define _RESUME_CHECK_r11 1510 +#define _RESUME_CHECK_r22 1511 +#define _RESUME_CHECK_r33 1512 +#define _RETURN_GENERATOR_r01 1513 +#define _RETURN_VALUE_r11 1514 +#define _RROT_3_r03 1515 +#define _RROT_3_r13 1516 +#define _RROT_3_r23 1517 +#define _RROT_3_r33 1518 +#define _SAVE_RETURN_OFFSET_r00 1519 +#define _SAVE_RETURN_OFFSET_r11 1520 +#define _SAVE_RETURN_OFFSET_r22 1521 +#define _SAVE_RETURN_OFFSET_r33 1522 +#define _SEND_ASYNC_GEN_r33 1523 +#define _SEND_ASYNC_GEN_TIER_TWO_r33 1524 +#define _SEND_GEN_FRAME_r33 1525 +#define _SEND_VIRTUAL_r33 1526 +#define _SEND_VIRTUAL_TIER_TWO_r03 1527 +#define _SEND_VIRTUAL_TIER_TWO_r13 1528 +#define _SEND_VIRTUAL_TIER_TWO_r23 1529 +#define _SEND_VIRTUAL_TIER_TWO_r33 1530 +#define _SETUP_ANNOTATIONS_r00 1531 +#define _SET_ADD_r10 1532 +#define _SET_FUNCTION_ATTRIBUTE_r01 1533 +#define _SET_FUNCTION_ATTRIBUTE_r11 1534 +#define _SET_FUNCTION_ATTRIBUTE_r21 1535 +#define _SET_FUNCTION_ATTRIBUTE_r32 1536 +#define _SET_IP_r00 1537 +#define _SET_IP_r11 1538 +#define _SET_IP_r22 1539 +#define _SET_IP_r33 1540 +#define _SET_UPDATE_r11 1541 +#define _SPILL_OR_RELOAD_r01 1542 +#define _SPILL_OR_RELOAD_r02 1543 +#define _SPILL_OR_RELOAD_r03 1544 +#define _SPILL_OR_RELOAD_r10 1545 +#define _SPILL_OR_RELOAD_r12 1546 +#define _SPILL_OR_RELOAD_r13 1547 +#define _SPILL_OR_RELOAD_r20 1548 +#define _SPILL_OR_RELOAD_r21 1549 +#define _SPILL_OR_RELOAD_r23 1550 +#define _SPILL_OR_RELOAD_r30 1551 +#define _SPILL_OR_RELOAD_r31 1552 +#define _SPILL_OR_RELOAD_r32 1553 +#define _START_EXECUTOR_r00 1554 +#define _STORE_ATTR_r20 1555 +#define _STORE_ATTR_INSTANCE_VALUE_r21 1556 +#define _STORE_ATTR_SLOT_r21 1557 +#define _STORE_ATTR_WITH_HINT_r21 1558 +#define _STORE_DEREF_r10 1559 +#define _STORE_FAST_LOAD_FAST_r11 1560 +#define _STORE_FAST_STORE_FAST_r20 1561 +#define _STORE_GLOBAL_r10 1562 +#define _STORE_NAME_r10 1563 +#define _STORE_SLICE_r30 1564 +#define _STORE_SUBSCR_r30 1565 +#define _STORE_SUBSCR_DICT_r31 1566 +#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1567 +#define _STORE_SUBSCR_LIST_INT_r32 1568 +#define _SWAP_r11 1569 +#define _SWAP_2_r02 1570 +#define _SWAP_2_r12 1571 +#define _SWAP_2_r22 1572 +#define _SWAP_2_r33 1573 +#define _SWAP_3_r03 1574 +#define _SWAP_3_r13 1575 +#define _SWAP_3_r23 1576 +#define _SWAP_3_r33 1577 +#define _SWAP_FAST_r01 1578 +#define _SWAP_FAST_r11 1579 +#define _SWAP_FAST_r22 1580 +#define _SWAP_FAST_r33 1581 +#define _SWAP_FAST_0_r01 1582 +#define _SWAP_FAST_0_r11 1583 +#define _SWAP_FAST_0_r22 1584 +#define _SWAP_FAST_0_r33 1585 +#define _SWAP_FAST_1_r01 1586 +#define _SWAP_FAST_1_r11 1587 +#define _SWAP_FAST_1_r22 1588 +#define _SWAP_FAST_1_r33 1589 +#define _SWAP_FAST_2_r01 1590 +#define _SWAP_FAST_2_r11 1591 +#define _SWAP_FAST_2_r22 1592 +#define _SWAP_FAST_2_r33 1593 +#define _SWAP_FAST_3_r01 1594 +#define _SWAP_FAST_3_r11 1595 +#define _SWAP_FAST_3_r22 1596 +#define _SWAP_FAST_3_r33 1597 +#define _SWAP_FAST_4_r01 1598 +#define _SWAP_FAST_4_r11 1599 +#define _SWAP_FAST_4_r22 1600 +#define _SWAP_FAST_4_r33 1601 +#define _SWAP_FAST_5_r01 1602 +#define _SWAP_FAST_5_r11 1603 +#define _SWAP_FAST_5_r22 1604 +#define _SWAP_FAST_5_r33 1605 +#define _SWAP_FAST_6_r01 1606 +#define _SWAP_FAST_6_r11 1607 +#define _SWAP_FAST_6_r22 1608 +#define _SWAP_FAST_6_r33 1609 +#define _SWAP_FAST_7_r01 1610 +#define _SWAP_FAST_7_r11 1611 +#define _SWAP_FAST_7_r22 1612 +#define _SWAP_FAST_7_r33 1613 +#define _TIER2_RESUME_CHECK_r00 1614 +#define _TIER2_RESUME_CHECK_r11 1615 +#define _TIER2_RESUME_CHECK_r22 1616 +#define _TIER2_RESUME_CHECK_r33 1617 +#define _TO_BOOL_r11 1618 +#define _TO_BOOL_BOOL_r01 1619 +#define _TO_BOOL_BOOL_r11 1620 +#define _TO_BOOL_BOOL_r22 1621 +#define _TO_BOOL_BOOL_r33 1622 +#define _TO_BOOL_INT_r02 1623 +#define _TO_BOOL_INT_r12 1624 +#define _TO_BOOL_INT_r23 1625 +#define _TO_BOOL_LIST_r02 1626 +#define _TO_BOOL_LIST_r12 1627 +#define _TO_BOOL_LIST_r23 1628 +#define _TO_BOOL_NONE_r01 1629 +#define _TO_BOOL_NONE_r11 1630 +#define _TO_BOOL_NONE_r22 1631 +#define _TO_BOOL_NONE_r33 1632 +#define _TO_BOOL_STR_r02 1633 +#define _TO_BOOL_STR_r12 1634 +#define _TO_BOOL_STR_r23 1635 +#define _TRACE_RECORD_r00 1636 +#define _UNARY_INVERT_r12 1637 +#define _UNARY_NEGATIVE_r12 1638 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1639 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1640 +#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1641 +#define _UNARY_NOT_r01 1642 +#define _UNARY_NOT_r11 1643 +#define _UNARY_NOT_r22 1644 +#define _UNARY_NOT_r33 1645 +#define _UNPACK_EX_r10 1646 +#define _UNPACK_SEQUENCE_r10 1647 +#define _UNPACK_SEQUENCE_LIST_r10 1648 +#define _UNPACK_SEQUENCE_TUPLE_r10 1649 +#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1650 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1651 +#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1652 +#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1653 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1654 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1655 +#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1656 +#define _WITH_EXCEPT_START_r33 1657 +#define _YIELD_VALUE_r11 1658 +#define MAX_UOP_REGS_ID 1658 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 7bd144ccc4af2e4..e615a574f754e11 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -211,7 +211,9 @@ const uint32_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_SET_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SET] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_FROZENSET] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_MAP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_FROZENDICT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SETUP_ANNOTATIONS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DICT_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_DICT_MERGE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, @@ -2031,6 +2033,15 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { -1, -1, -1 }, }, }, + [_BUILD_FROZENSET] = { + .best = { 0, 0, 0, 0 }, + .entries = { + { 1, 0, _BUILD_FROZENSET_r01 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + }, + }, [_BUILD_MAP] = { .best = { 0, 0, 0, 0 }, .entries = { @@ -2040,6 +2051,15 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { -1, -1, -1 }, }, }, + [_BUILD_FROZENDICT] = { + .best = { 1, 1, 1, 1 }, + .entries = { + { -1, -1, -1 }, + { 1, 1, _BUILD_FROZENDICT_r11 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + }, + }, [_SETUP_ANNOTATIONS] = { .best = { 0, 0, 0, 0 }, .entries = { @@ -4350,7 +4370,9 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_LIST_EXTEND_r11] = _LIST_EXTEND, [_SET_UPDATE_r11] = _SET_UPDATE, [_BUILD_SET_r01] = _BUILD_SET, + [_BUILD_FROZENSET_r01] = _BUILD_FROZENSET, [_BUILD_MAP_r01] = _BUILD_MAP, + [_BUILD_FROZENDICT_r11] = _BUILD_FROZENDICT, [_SETUP_ANNOTATIONS_r00] = _SETUP_ANNOTATIONS, [_DICT_UPDATE_r11] = _DICT_UPDATE, [_DICT_MERGE_r11] = _DICT_MERGE, @@ -4984,6 +5006,10 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23] = "_BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23", [_BINARY_SLICE] = "_BINARY_SLICE", [_BINARY_SLICE_r31] = "_BINARY_SLICE_r31", + [_BUILD_FROZENDICT] = "_BUILD_FROZENDICT", + [_BUILD_FROZENDICT_r11] = "_BUILD_FROZENDICT_r11", + [_BUILD_FROZENSET] = "_BUILD_FROZENSET", + [_BUILD_FROZENSET_r01] = "_BUILD_FROZENSET_r01", [_BUILD_INTERPOLATION] = "_BUILD_INTERPOLATION", [_BUILD_INTERPOLATION_r01] = "_BUILD_INTERPOLATION_r01", [_BUILD_LIST] = "_BUILD_LIST", @@ -6550,8 +6576,12 @@ int _PyUop_num_popped(int opcode, int oparg) return 1; case _BUILD_SET: return oparg; + case _BUILD_FROZENSET: + return oparg; case _BUILD_MAP: return oparg*2; + case _BUILD_FROZENDICT: + return 1; case _SETUP_ANNOTATIONS: return 0; case _DICT_UPDATE: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index ccc5c820d80ea57..212dc15807e4988 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -12,122 +12,124 @@ extern "C" { /* Instruction opcodes for compiled code */ #define CACHE 0 #define BINARY_SLICE 1 -#define BUILD_TEMPLATE 2 +#define BUILD_FROZENDICT 2 #define BINARY_OP_INPLACE_ADD_UNICODE 3 -#define CALL_FUNCTION_EX 4 -#define CHECK_EG_MATCH 5 -#define CHECK_EXC_MATCH 6 -#define CLEANUP_THROW 7 -#define DELETE_SUBSCR 8 -#define END_FOR 9 -#define END_SEND 10 -#define EXIT_INIT_CHECK 11 -#define FORMAT_SIMPLE 12 -#define FORMAT_WITH_SPEC 13 -#define GET_AITER 14 -#define GET_ANEXT 15 -#define GET_LEN 16 +#define BUILD_TEMPLATE 4 +#define CALL_FUNCTION_EX 5 +#define CHECK_EG_MATCH 6 +#define CHECK_EXC_MATCH 7 +#define CLEANUP_THROW 8 +#define DELETE_SUBSCR 9 +#define END_FOR 10 +#define END_SEND 11 +#define EXIT_INIT_CHECK 12 +#define FORMAT_SIMPLE 13 +#define FORMAT_WITH_SPEC 14 +#define GET_AITER 15 +#define GET_ANEXT 16 #define RESERVED 17 -#define INTERPRETER_EXIT 18 -#define LOAD_BUILD_CLASS 19 -#define LOAD_LOCALS 20 -#define MAKE_FUNCTION 21 -#define MATCH_KEYS 22 -#define MATCH_MAPPING 23 -#define MATCH_SEQUENCE 24 -#define NOP 25 -#define NOT_TAKEN 26 -#define POP_EXCEPT 27 -#define POP_ITER 28 -#define POP_TOP 29 -#define PUSH_EXC_INFO 30 -#define PUSH_NULL 31 -#define RETURN_GENERATOR 32 -#define RETURN_VALUE 33 -#define SETUP_ANNOTATIONS 34 -#define STORE_SLICE 35 -#define STORE_SUBSCR 36 -#define TO_BOOL 37 -#define UNARY_INVERT 38 -#define UNARY_NEGATIVE 39 -#define UNARY_NOT 40 -#define WITH_EXCEPT_START 41 -#define BINARY_OP 42 -#define BUILD_INTERPOLATION 43 -#define BUILD_LIST 44 -#define BUILD_MAP 45 -#define BUILD_SET 46 -#define BUILD_SLICE 47 -#define BUILD_STRING 48 -#define BUILD_TUPLE 49 -#define CALL 50 -#define CALL_INTRINSIC_1 51 -#define CALL_INTRINSIC_2 52 -#define CALL_KW 53 -#define COMPARE_OP 54 -#define CONTAINS_OP 55 -#define CONVERT_VALUE 56 -#define COPY 57 -#define COPY_FREE_VARS 58 -#define DELETE_ATTR 59 -#define DELETE_DEREF 60 -#define DELETE_FAST 61 -#define DICT_MERGE 62 -#define DICT_UPDATE 63 -#define END_ASYNC_FOR 64 -#define EXTENDED_ARG 65 -#define FOR_ITER 66 -#define GET_AWAITABLE 67 -#define GET_ITER 68 -#define IMPORT_FROM 69 -#define IMPORT_NAME 70 -#define IS_OP 71 -#define JUMP_BACKWARD 72 -#define JUMP_BACKWARD_NO_INTERRUPT 73 -#define JUMP_FORWARD 74 -#define LIST_APPEND 75 -#define LIST_EXTEND 76 -#define LOAD_ATTR 77 -#define LOAD_COMMON_CONSTANT 78 -#define LOAD_CONST 79 -#define LOAD_DEREF 80 -#define LOAD_FAST 81 -#define LOAD_FAST_AND_CLEAR 82 -#define LOAD_FAST_BORROW 83 -#define LOAD_FAST_BORROW_LOAD_FAST_BORROW 84 -#define LOAD_FAST_CHECK 85 -#define LOAD_FAST_LOAD_FAST 86 -#define LOAD_FROM_DICT_OR_DEREF 87 -#define LOAD_FROM_DICT_OR_GLOBALS 88 -#define LOAD_GLOBAL 89 -#define LOAD_NAME 90 -#define LOAD_SMALL_INT 91 -#define LOAD_SPECIAL 92 -#define LOAD_SUPER_ATTR 93 -#define MAKE_CELL 94 -#define MAP_ADD 95 -#define MATCH_CLASS 96 -#define POP_JUMP_IF_FALSE 97 -#define POP_JUMP_IF_NONE 98 -#define POP_JUMP_IF_NOT_NONE 99 -#define POP_JUMP_IF_TRUE 100 -#define RAISE_VARARGS 101 -#define RERAISE 102 -#define SEND 103 -#define SET_ADD 104 -#define SET_FUNCTION_ATTRIBUTE 105 -#define SET_UPDATE 106 -#define STORE_ATTR 107 -#define STORE_DEREF 108 -#define STORE_FAST 109 -#define STORE_FAST_LOAD_FAST 110 -#define STORE_FAST_STORE_FAST 111 -#define STORE_GLOBAL 112 -#define STORE_NAME 113 -#define SWAP 114 -#define UNPACK_EX 115 -#define UNPACK_SEQUENCE 116 -#define YIELD_VALUE 117 +#define GET_LEN 18 +#define INTERPRETER_EXIT 19 +#define LOAD_BUILD_CLASS 20 +#define LOAD_LOCALS 21 +#define MAKE_FUNCTION 22 +#define MATCH_KEYS 23 +#define MATCH_MAPPING 24 +#define MATCH_SEQUENCE 25 +#define NOP 26 +#define NOT_TAKEN 27 +#define POP_EXCEPT 28 +#define POP_ITER 29 +#define POP_TOP 30 +#define PUSH_EXC_INFO 31 +#define PUSH_NULL 32 +#define RETURN_GENERATOR 33 +#define RETURN_VALUE 34 +#define SETUP_ANNOTATIONS 35 +#define STORE_SLICE 36 +#define STORE_SUBSCR 37 +#define TO_BOOL 38 +#define UNARY_INVERT 39 +#define UNARY_NEGATIVE 40 +#define UNARY_NOT 41 +#define WITH_EXCEPT_START 42 +#define BINARY_OP 43 +#define BUILD_FROZENSET 44 +#define BUILD_INTERPOLATION 45 +#define BUILD_LIST 46 +#define BUILD_MAP 47 +#define BUILD_SET 48 +#define BUILD_SLICE 49 +#define BUILD_STRING 50 +#define BUILD_TUPLE 51 +#define CALL 52 +#define CALL_INTRINSIC_1 53 +#define CALL_INTRINSIC_2 54 +#define CALL_KW 55 +#define COMPARE_OP 56 +#define CONTAINS_OP 57 +#define CONVERT_VALUE 58 +#define COPY 59 +#define COPY_FREE_VARS 60 +#define DELETE_ATTR 61 +#define DELETE_DEREF 62 +#define DELETE_FAST 63 +#define DICT_MERGE 64 +#define DICT_UPDATE 65 +#define END_ASYNC_FOR 66 +#define EXTENDED_ARG 67 +#define FOR_ITER 68 +#define GET_AWAITABLE 69 +#define GET_ITER 70 +#define IMPORT_FROM 71 +#define IMPORT_NAME 72 +#define IS_OP 73 +#define JUMP_BACKWARD 74 +#define JUMP_BACKWARD_NO_INTERRUPT 75 +#define JUMP_FORWARD 76 +#define LIST_APPEND 77 +#define LIST_EXTEND 78 +#define LOAD_ATTR 79 +#define LOAD_COMMON_CONSTANT 80 +#define LOAD_CONST 81 +#define LOAD_DEREF 82 +#define LOAD_FAST 83 +#define LOAD_FAST_AND_CLEAR 84 +#define LOAD_FAST_BORROW 85 +#define LOAD_FAST_BORROW_LOAD_FAST_BORROW 86 +#define LOAD_FAST_CHECK 87 +#define LOAD_FAST_LOAD_FAST 88 +#define LOAD_FROM_DICT_OR_DEREF 89 +#define LOAD_FROM_DICT_OR_GLOBALS 90 +#define LOAD_GLOBAL 91 +#define LOAD_NAME 92 +#define LOAD_SMALL_INT 93 +#define LOAD_SPECIAL 94 +#define LOAD_SUPER_ATTR 95 +#define MAKE_CELL 96 +#define MAP_ADD 97 +#define MATCH_CLASS 98 +#define POP_JUMP_IF_FALSE 99 +#define POP_JUMP_IF_NONE 100 +#define POP_JUMP_IF_NOT_NONE 101 +#define POP_JUMP_IF_TRUE 102 +#define RAISE_VARARGS 103 +#define RERAISE 104 +#define SEND 105 +#define SET_ADD 106 +#define SET_FUNCTION_ATTRIBUTE 107 +#define SET_UPDATE 108 +#define STORE_ATTR 109 +#define STORE_DEREF 110 +#define STORE_FAST 111 +#define STORE_FAST_LOAD_FAST 112 +#define STORE_FAST_STORE_FAST 113 +#define STORE_GLOBAL 114 +#define STORE_NAME 115 +#define SWAP 116 +#define UNPACK_EX 117 +#define UNPACK_SEQUENCE 118 +#define YIELD_VALUE 119 #define RESUME 128 #define BINARY_OP_ADD_FLOAT 129 #define BINARY_OP_ADD_INT 130 @@ -254,7 +256,7 @@ extern "C" { #define SETUP_WITH 265 #define STORE_FAST_MAYBE_NULL 266 -#define HAVE_ARGUMENT 41 +#define HAVE_ARGUMENT 42 #define MIN_SPECIALIZED_OPCODE 129 #define MIN_INSTRUMENTED_OPCODE 233 diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py index 916bb25d74dee9b..32d821b16fb7298 100644 --- a/Lib/_ast_unparse.py +++ b/Lib/_ast_unparse.py @@ -730,23 +730,37 @@ def visit_GeneratorExp(self, node): for gen in node.generators: self.traverse(gen) + def _set_comp(self, node): + self.traverse(node.elt) + for gen in node.generators: + self.traverse(gen) + def visit_SetComp(self, node): with self.delimit("{", "}"): - self.traverse(node.elt) - for gen in node.generators: - self.traverse(gen) + self._set_comp(node) + + def visit_FrozenSetComp(self, node): + with self.delimit("f{", "}"): + self._set_comp(node) + + def _dict_comp(self, node): + if node.value: + self.traverse(node.key) + self.write(": ") + self.traverse(node.value) + else: + self.write("**") + self.traverse(node.key) + for gen in node.generators: + self.traverse(gen) def visit_DictComp(self, node): with self.delimit("{", "}"): - if node.value: - self.traverse(node.key) - self.write(": ") - self.traverse(node.value) - else: - self.write("**") - self.traverse(node.key) - for gen in node.generators: - self.traverse(gen) + self._dict_comp(node) + + def visit_FrozenDictComp(self, node): + with self.delimit("f{", "}"): + self._dict_comp(node) def visit_comprehension(self, node): if node.is_async: @@ -772,16 +786,22 @@ def visit_IfExp(self, node): self.set_precedence(_Precedence.TEST, node.orelse) self.traverse(node.orelse) - def visit_Set(self, node): + def _set_like(self, node, delimit_start): if node.elts: - with self.delimit("{", "}"): + with self.delimit(delimit_start, "}"): self.interleave(lambda: self.write(", "), self.traverse, node.elts) else: # `{}` would be interpreted as a dictionary literal, and # `set` might be shadowed. Thus: - self.write('{*()}') + self.write(delimit_start + "*()}") - def visit_Dict(self, node): + def visit_Set(self, node): + self._set_like(node, "{") + + def visit_FrozenSet(self, node): + self._set_like(node, "f{") + + def _dict_like(self, node, delimit_start): def write_key_value_pair(k, v): self.traverse(k) self.write(": ") @@ -798,11 +818,17 @@ def write_item(item): else: write_key_value_pair(k, v) - with self.delimit("{", "}"): + with self.delimit(delimit_start, "}"): self.interleave( lambda: self.write(", "), write_item, zip(node.keys, node.values) ) + def visit_Dict(self, node): + self._dict_like(node, "{") + + def visit_FrozenDict(self, node): + self._dict_like(node, "f{") + def visit_Tuple(self, node): with self.delimit_if( "(", diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 52fa52bbf57e768..9b5f155327d3abd 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -234,120 +234,122 @@ ENTER_EXECUTOR=254, TRACE_RECORD=255, BINARY_SLICE=1, - BUILD_TEMPLATE=2, - CALL_FUNCTION_EX=4, - CHECK_EG_MATCH=5, - CHECK_EXC_MATCH=6, - CLEANUP_THROW=7, - DELETE_SUBSCR=8, - END_FOR=9, - END_SEND=10, - EXIT_INIT_CHECK=11, - FORMAT_SIMPLE=12, - FORMAT_WITH_SPEC=13, - GET_AITER=14, - GET_ANEXT=15, - GET_LEN=16, - INTERPRETER_EXIT=18, - LOAD_BUILD_CLASS=19, - LOAD_LOCALS=20, - MAKE_FUNCTION=21, - MATCH_KEYS=22, - MATCH_MAPPING=23, - MATCH_SEQUENCE=24, - NOP=25, - NOT_TAKEN=26, - POP_EXCEPT=27, - POP_ITER=28, - POP_TOP=29, - PUSH_EXC_INFO=30, - PUSH_NULL=31, - RETURN_GENERATOR=32, - RETURN_VALUE=33, - SETUP_ANNOTATIONS=34, - STORE_SLICE=35, - STORE_SUBSCR=36, - TO_BOOL=37, - UNARY_INVERT=38, - UNARY_NEGATIVE=39, - UNARY_NOT=40, - WITH_EXCEPT_START=41, - BINARY_OP=42, - BUILD_INTERPOLATION=43, - BUILD_LIST=44, - BUILD_MAP=45, - BUILD_SET=46, - BUILD_SLICE=47, - BUILD_STRING=48, - BUILD_TUPLE=49, - CALL=50, - CALL_INTRINSIC_1=51, - CALL_INTRINSIC_2=52, - CALL_KW=53, - COMPARE_OP=54, - CONTAINS_OP=55, - CONVERT_VALUE=56, - COPY=57, - COPY_FREE_VARS=58, - DELETE_ATTR=59, - DELETE_DEREF=60, - DELETE_FAST=61, - DICT_MERGE=62, - DICT_UPDATE=63, - END_ASYNC_FOR=64, - EXTENDED_ARG=65, - FOR_ITER=66, - GET_AWAITABLE=67, - GET_ITER=68, - IMPORT_FROM=69, - IMPORT_NAME=70, - IS_OP=71, - JUMP_BACKWARD=72, - JUMP_BACKWARD_NO_INTERRUPT=73, - JUMP_FORWARD=74, - LIST_APPEND=75, - LIST_EXTEND=76, - LOAD_ATTR=77, - LOAD_COMMON_CONSTANT=78, - LOAD_CONST=79, - LOAD_DEREF=80, - LOAD_FAST=81, - LOAD_FAST_AND_CLEAR=82, - LOAD_FAST_BORROW=83, - LOAD_FAST_BORROW_LOAD_FAST_BORROW=84, - LOAD_FAST_CHECK=85, - LOAD_FAST_LOAD_FAST=86, - LOAD_FROM_DICT_OR_DEREF=87, - LOAD_FROM_DICT_OR_GLOBALS=88, - LOAD_GLOBAL=89, - LOAD_NAME=90, - LOAD_SMALL_INT=91, - LOAD_SPECIAL=92, - LOAD_SUPER_ATTR=93, - MAKE_CELL=94, - MAP_ADD=95, - MATCH_CLASS=96, - POP_JUMP_IF_FALSE=97, - POP_JUMP_IF_NONE=98, - POP_JUMP_IF_NOT_NONE=99, - POP_JUMP_IF_TRUE=100, - RAISE_VARARGS=101, - RERAISE=102, - SEND=103, - SET_ADD=104, - SET_FUNCTION_ATTRIBUTE=105, - SET_UPDATE=106, - STORE_ATTR=107, - STORE_DEREF=108, - STORE_FAST=109, - STORE_FAST_LOAD_FAST=110, - STORE_FAST_STORE_FAST=111, - STORE_GLOBAL=112, - STORE_NAME=113, - SWAP=114, - UNPACK_EX=115, - UNPACK_SEQUENCE=116, - YIELD_VALUE=117, + BUILD_FROZENDICT=2, + BUILD_TEMPLATE=4, + CALL_FUNCTION_EX=5, + CHECK_EG_MATCH=6, + CHECK_EXC_MATCH=7, + CLEANUP_THROW=8, + DELETE_SUBSCR=9, + END_FOR=10, + END_SEND=11, + EXIT_INIT_CHECK=12, + FORMAT_SIMPLE=13, + FORMAT_WITH_SPEC=14, + GET_AITER=15, + GET_ANEXT=16, + GET_LEN=18, + INTERPRETER_EXIT=19, + LOAD_BUILD_CLASS=20, + LOAD_LOCALS=21, + MAKE_FUNCTION=22, + MATCH_KEYS=23, + MATCH_MAPPING=24, + MATCH_SEQUENCE=25, + NOP=26, + NOT_TAKEN=27, + POP_EXCEPT=28, + POP_ITER=29, + POP_TOP=30, + PUSH_EXC_INFO=31, + PUSH_NULL=32, + RETURN_GENERATOR=33, + RETURN_VALUE=34, + SETUP_ANNOTATIONS=35, + STORE_SLICE=36, + STORE_SUBSCR=37, + TO_BOOL=38, + UNARY_INVERT=39, + UNARY_NEGATIVE=40, + UNARY_NOT=41, + WITH_EXCEPT_START=42, + BINARY_OP=43, + BUILD_FROZENSET=44, + BUILD_INTERPOLATION=45, + BUILD_LIST=46, + BUILD_MAP=47, + BUILD_SET=48, + BUILD_SLICE=49, + BUILD_STRING=50, + BUILD_TUPLE=51, + CALL=52, + CALL_INTRINSIC_1=53, + CALL_INTRINSIC_2=54, + CALL_KW=55, + COMPARE_OP=56, + CONTAINS_OP=57, + CONVERT_VALUE=58, + COPY=59, + COPY_FREE_VARS=60, + DELETE_ATTR=61, + DELETE_DEREF=62, + DELETE_FAST=63, + DICT_MERGE=64, + DICT_UPDATE=65, + END_ASYNC_FOR=66, + EXTENDED_ARG=67, + FOR_ITER=68, + GET_AWAITABLE=69, + GET_ITER=70, + IMPORT_FROM=71, + IMPORT_NAME=72, + IS_OP=73, + JUMP_BACKWARD=74, + JUMP_BACKWARD_NO_INTERRUPT=75, + JUMP_FORWARD=76, + LIST_APPEND=77, + LIST_EXTEND=78, + LOAD_ATTR=79, + LOAD_COMMON_CONSTANT=80, + LOAD_CONST=81, + LOAD_DEREF=82, + LOAD_FAST=83, + LOAD_FAST_AND_CLEAR=84, + LOAD_FAST_BORROW=85, + LOAD_FAST_BORROW_LOAD_FAST_BORROW=86, + LOAD_FAST_CHECK=87, + LOAD_FAST_LOAD_FAST=88, + LOAD_FROM_DICT_OR_DEREF=89, + LOAD_FROM_DICT_OR_GLOBALS=90, + LOAD_GLOBAL=91, + LOAD_NAME=92, + LOAD_SMALL_INT=93, + LOAD_SPECIAL=94, + LOAD_SUPER_ATTR=95, + MAKE_CELL=96, + MAP_ADD=97, + MATCH_CLASS=98, + POP_JUMP_IF_FALSE=99, + POP_JUMP_IF_NONE=100, + POP_JUMP_IF_NOT_NONE=101, + POP_JUMP_IF_TRUE=102, + RAISE_VARARGS=103, + RERAISE=104, + SEND=105, + SET_ADD=106, + SET_FUNCTION_ATTRIBUTE=107, + SET_UPDATE=108, + STORE_ATTR=109, + STORE_DEREF=110, + STORE_FAST=111, + STORE_FAST_LOAD_FAST=112, + STORE_FAST_STORE_FAST=113, + STORE_GLOBAL=114, + STORE_NAME=115, + SWAP=116, + UNPACK_EX=117, + UNPACK_SEQUENCE=118, + YIELD_VALUE=119, INSTRUMENTED_END_FOR=233, INSTRUMENTED_POP_ITER=234, INSTRUMENTED_END_SEND=235, @@ -381,5 +383,5 @@ STORE_FAST_MAYBE_NULL=266, ) -HAVE_ARGUMENT = 41 +HAVE_ARGUMENT = 42 MIN_INSTRUMENTED_OPCODE = 233 diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py index 31e218df127ae6b..a166f5deae61f98 100644 --- a/Lib/test/test_ast/test_ast.py +++ b/Lib/test/test_ast/test_ast.py @@ -2048,6 +2048,12 @@ def test_literal_eval_malformed_dict_nodes(self): malformed = ast.Dict(keys=[ast.Constant(1)], values=[ast.Constant(2), ast.Constant(3)]) self.assertRaises(ValueError, ast.literal_eval, malformed) + def test_literal_eval_malformed_frozen_dict_nodes(self): + malformed = ast.FrozenDict(keys=[ast.Constant(1), ast.Constant(2)], values=[ast.Constant(3)]) + self.assertRaises(ValueError, ast.literal_eval, malformed) + malformed = ast.FrozenDict(keys=[ast.Constant(1)], values=[ast.Constant(2), ast.Constant(3)]) + self.assertRaises(ValueError, ast.literal_eval, malformed) + def test_literal_eval_trailing_ws(self): self.assertEqual(ast.literal_eval(" -1"), -1) self.assertEqual(ast.literal_eval("\t\t-1"), -1) @@ -2408,11 +2414,22 @@ def test_dict(self): d = ast.Dict([ast.Name("x", ast.Load())], [None]) self.expr(d, "None disallowed") + def test_frozen_dict(self): + d = ast.FrozenDict([], [ast.Name("x", ast.Load())]) + self.expr(d, "same number of keys as values") + d = ast.FrozenDict([ast.Name("x", ast.Load())], [None]) + self.expr(d, "None disallowed") + def test_set(self): self.expr(ast.Set([None]), "None disallowed") s = ast.Set([ast.Name("x", ast.Store())]) self.expr(s, "must have Load context") + def test_frozen_set(self): + self.expr(ast.Set([None]), "None disallowed") + s = ast.Set([ast.Name("x", ast.Store())]) + self.expr(s, "must have Load context") + def _check_comprehension(self, fac): self.expr(fac([]), "comprehension with no generators") g = ast.comprehension(ast.Name("x", ast.Load()), @@ -2443,6 +2460,9 @@ def test_listcomp(self): def test_setcomp(self): self._simple_comp(ast.SetComp) + def test_frozensetcomp(self): + self._simple_comp(ast.FrozenSetComp) + def test_generatorexp(self): self._simple_comp(ast.GeneratorExp) @@ -2461,6 +2481,21 @@ def factory(comps): return ast.DictComp(k, v, comps) self._check_comprehension(factory) + def test_frozendictcomp(self): + g = ast.comprehension(ast.Name("y", ast.Store()), + ast.Name("p", ast.Load()), [], 0) + c = ast.FrozenDictComp(ast.Name("x", ast.Store()), + ast.Name("y", ast.Load()), [g]) + self.expr(c, "must have Load context") + c = ast.FrozenDictComp(ast.Name("x", ast.Load()), + ast.Name("y", ast.Store()), [g]) + self.expr(c, "must have Load context") + def factory(comps): + k = ast.Name("x", ast.Load()) + v = ast.Name("y", ast.Load()) + return ast.FrozenDictComp(k, v, comps) + self._check_comprehension(factory) + def test_yield(self): self.expr(ast.Yield(ast.Name("x", ast.Store())), "must have Load") self.expr(ast.YieldFrom(ast.Name("x", ast.Store())), "must have Load") diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 1d2c105ac047e18..1289f9b8eb6d2db 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -603,6 +603,7 @@ async def __aexit__(self, *exc_info): '''def f(): await arange(10)\n''', '''def f(): [x async for x in arange(10)]\n''', '''def f(): [await x async for x in arange(10)]\n''', + '''def f(): f{await x async for x in arange(10)}\n''', '''def f(): async for i in arange(1): a = 1 diff --git a/Lib/test/test_capi/test_set.py b/Lib/test/test_capi/test_set.py index a41c2fcaf12270f..d2716336bcb4135 100644 --- a/Lib/test/test_capi/test_set.py +++ b/Lib/test/test_capi/test_set.py @@ -229,7 +229,7 @@ def test_clear(self): class TestInternalCAPI(BaseSetTests, unittest.TestCase): def test_set_update(self): update = _testinternalcapi.set_update - for cls in (set, set_subclass): + for cls in (set, set_subclass, frozenset): for it in ('ab', ('a', 'b'), ['a', 'b'], set('ab'), set_subclass('ab'), frozenset('ab'), frozenset_subclass('ab')): @@ -246,7 +246,6 @@ def test_set_update(self): update(cls(), [{}]) with self.assertRaises(SystemError): update(object(), 'ab') - self.assertImmutable(update, 'ab') # CRASHES: update(NULL, object()) # CRASHES: update(instance, NULL) # CRASHES: update(NULL, NULL) diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py index 9edbca3c383b43d..79f53b75bfafe86 100644 --- a/Lib/test/test_compile.py +++ b/Lib/test/test_compile.py @@ -2115,6 +2115,24 @@ def test_multiline_set_comprehension(self): self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD', line=1, end_line=2, column=1, end_column=8, occurrence=1) + def test_multiline_frozenset_comprehension(self): + snippet = textwrap.dedent("""\ + f{(x, + 2*x) + for x + in [1,2,3] if (x > 0 + and x < 100 + and x != 50)} + """) + compiled_code, _ = self.check_positions_against_ast(snippet) + self.assertIsInstance(compiled_code, types.CodeType) + self.assertOpcodeSourcePositionIs(compiled_code, 'BUILD_FROZENSET', + line=1, end_line=6, column=0, end_column=32, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'SET_ADD', + line=1, end_line=2, column=2, end_column=8, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD', + line=1, end_line=2, column=2, end_column=8, occurrence=1) + def test_multiline_async_set_comprehension(self): snippet = textwrap.dedent("""\ async def f(): @@ -2137,6 +2155,30 @@ async def f(): self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE', line=2, end_line=7, column=4, end_column=36, occurrence=1) + def test_multiline_async_frozenset_comprehension(self): + snippet = textwrap.dedent("""\ + async def f(): + f{(x, + 2*x) + async for x + in [1,2,3] if (x > 0 + and x < 100 + and x != 50)} + """) + compiled_code, _ = self.check_positions_against_ast(snippet) + g = {} + eval(compiled_code, g) + compiled_code = g['f'].__code__ + self.assertIsInstance(compiled_code, types.CodeType) + self.assertOpcodeSourcePositionIs(compiled_code, 'BUILD_FROZENSET', + line=2, end_line=7, column=4, end_column=36, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'SET_ADD', + line=2, end_line=3, column=6, end_column=12, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD', + line=2, end_line=3, column=6, end_column=12, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE', + line=2, end_line=7, column=4, end_column=36, occurrence=1) + def test_multiline_dict_comprehension(self): snippet = textwrap.dedent("""\ {x: @@ -2153,6 +2195,24 @@ def test_multiline_dict_comprehension(self): self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD', line=1, end_line=2, column=1, end_column=7, occurrence=1) + def test_multiline_frozendict_comprehension(self): + snippet = textwrap.dedent("""\ + f{x: + 2*x + for x + in [1,2,3] if (x > 0 + and x < 100 + and x != 50)} + """) + compiled_code, _ = self.check_positions_against_ast(snippet) + self.assertIsInstance(compiled_code, types.CodeType) + self.assertOpcodeSourcePositionIs(compiled_code, 'MAP_ADD', + line=1, end_line=2, column=2, end_column=7, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD', + line=1, end_line=2, column=2, end_column=7, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'BUILD_FROZENDICT', + line=1, end_line=6, column=0, end_column=32, occurrence=1) + def test_multiline_async_dict_comprehension(self): snippet = textwrap.dedent("""\ async def f(): @@ -2175,6 +2235,30 @@ async def f(): self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE', line=2, end_line=7, column=4, end_column=36, occurrence=1) + def test_multiline_async_frozendict_comprehension(self): + snippet = textwrap.dedent("""\ + async def f(): + f{x: + 2*x + async for x + in [1,2,3] if (x > 0 + and x < 100 + and x != 50)} + """) + compiled_code, _ = self.check_positions_against_ast(snippet) + g = {} + eval(compiled_code, g) + compiled_code = g['f'].__code__ + self.assertIsInstance(compiled_code, types.CodeType) + self.assertOpcodeSourcePositionIs(compiled_code, 'MAP_ADD', + line=2, end_line=3, column=6, end_column=11, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD', + line=2, end_line=3, column=6, end_column=11, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'BUILD_FROZENDICT', + line=2, end_line=7, column=4, end_column=36, occurrence=1) + self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE', + line=2, end_line=7, column=4, end_column=36, occurrence=1) + def test_matchcase_sequence(self): snippet = textwrap.dedent("""\ match x: diff --git a/Lib/test/test_coroutines.py b/Lib/test/test_coroutines.py index 9d415238876c8f1..77860d02d04a47b 100644 --- a/Lib/test/test_coroutines.py +++ b/Lib/test/test_coroutines.py @@ -39,7 +39,7 @@ async def asynciter(iterable): yield x -def run_async(coro): +def run_async(coro, typ=None): assert coro.__class__ in {types.GeneratorType, types.CoroutineType} buffer = [] @@ -50,6 +50,8 @@ def run_async(coro): except StopIteration as ex: result = ex.args[0] if ex.args else None break + if typ is not None: + assert type(result) is typ return buffer, result @@ -1854,16 +1856,28 @@ async def run_list(): async def run_set(): return {await c for c in [f(1), f(41)]} + async def run_frozenset(): + return f{await c for c in [f(1), f(41)]} + async def run_dict1(): return {await c: 'a' for c in [f(1), f(41)]} async def run_dict2(): return {i: await c for i, c in enumerate([f(1), f(41)])} + async def run_frozendict1(): + return f{await c: 'a' for c in [f(1), f(41)]} + + async def run_frozendict2(): + return f{i: await c for i, c in enumerate([f(1), f(41)])} + self.assertEqual(run_async(run_list()), ([], [1, 41])) - self.assertEqual(run_async(run_set()), ([], {1, 41})) - self.assertEqual(run_async(run_dict1()), ([], {1: 'a', 41: 'a'})) - self.assertEqual(run_async(run_dict2()), ([], {0: 1, 1: 41})) + self.assertEqual(run_async(run_set(), set), ([], {1, 41})) + self.assertEqual(run_async(run_frozenset(), frozenset), ([], f{1, 41})) + self.assertEqual(run_async(run_dict1(), dict), ([], {1: 'a', 41: 'a'})) + self.assertEqual(run_async(run_dict2(), dict), ([], {0: 1, 1: 41})) + self.assertEqual(run_async(run_frozendict1(), frozendict), ([], f{1: 'a', 41: 'a'})) + self.assertEqual(run_async(run_frozendict2(), frozendict), ([], f{0: 1, 1: 41})) def test_comp_2(self): async def f(i): @@ -1885,7 +1899,7 @@ async def run_set(): for d in await s} self.assertEqual( - run_async(run_set()), + run_async(run_set(), set), ([], {10, 20, 30})) async def run_set2(): @@ -1894,9 +1908,29 @@ async def run_set2(): for s in await c} self.assertEqual( - run_async(run_set2()), + run_async(run_set2(), set), ([], {10, 20})) + async def run_frozenset(): + return f{d + for c in [f([f([10, 30]), + f([20])])] + for s in await c + for d in await s} + + self.assertEqual( + run_async(run_frozenset(), frozenset), + ([], f{10, 20, 30})) + + async def run_frozenset2(): + return f{await s + for c in [f([f(10), f(20)])] + for s in await c} + + self.assertEqual( + run_async(run_frozenset2(), frozenset), + ([], f{10, 20})) + def test_comp_3(self): async def f(it): for i in it: @@ -1911,15 +1945,27 @@ async def run_list(): async def run_set(): return {i + 1 async for i in f([10, 20])} self.assertEqual( - run_async(run_set()), + run_async(run_set(), set), ([], {11, 21})) + async def run_frozenset(): + return f{i + 1 async for i in f([10, 20])} + self.assertEqual( + run_async(run_frozenset(), frozenset), + ([], f{11, 21})) + async def run_dict(): return {i + 1: i + 2 async for i in f([10, 20])} self.assertEqual( - run_async(run_dict()), + run_async(run_dict(), dict), ([], {11: 12, 21: 22})) + async def run_frozendict(): + return f{i + 1: i + 2 async for i in f([10, 20])} + self.assertEqual( + run_async(run_frozendict(), frozendict), + ([], f{11: 12, 21: 22})) + async def run_gen(): gen = (i + 1 async for i in f([10, 20])) return [g + 100 async for g in gen] @@ -1944,12 +1990,28 @@ async def run_set(): run_async(run_set()), ([], {21})) + async def run_frozenset(): + return f{i + 1 async for i in f([10, 20]) if i > 10} + res = run_async(run_frozenset()) + self.assertEqual( + res, + ([], f{21})) + self.assertIs(type(res[1]), frozenset) + async def run_dict(): return {i + 1: i + 2 async for i in f([10, 20]) if i > 10} self.assertEqual( run_async(run_dict()), ([], {21: 22})) + async def run_frozendict(): + return f{i + 1: i + 2 async for i in f([10, 20]) if i > 10} + res = run_async(run_frozendict()) + self.assertEqual( + res, + ([], f{21: 22})) + self.assertIs(type(res[1]), frozendict) + async def run_gen(): gen = (i + 1 async for i in f([10, 20]) if i > 10) return [g + 100 async for g in gen] @@ -1974,6 +2036,12 @@ async def run_set(): run_async(run_set()), ([], {11, 12, 13})) + async def run_set(): + return f{i + 10 async for i in f(range(5)) if 0 < i < 4} + self.assertEqual( + run_async(run_set()), + ([], {11, 12, 13})) + async def run_dict(): return {i + 10: i + 100 async for i in f(range(5)) if 0 < i < 4} self.assertEqual( @@ -2066,6 +2134,12 @@ async def run_set_inside_list(): run_async(run_set_inside_list()), ([], [{11, 12}, {21, 22}])) + async def run_frozenset_inside_list(): + return [f{i + j async for i in asynciter([1, 2])} for j in [10, 20]] + self.assertEqual( + run_async(run_frozenset_inside_list()), + ([], [f{11, 12}, f{21, 22}])) + async def run_list_inside_set(): return {sum([i async for i in asynciter(range(j))]) for j in [3, 5]} self.assertEqual( @@ -2078,6 +2152,12 @@ async def run_dict_inside_dict(): run_async(run_dict_inside_dict()), ([], {10: {1: 11, 2: 12}, 20: {1: 21, 2: 22}})) + async def run_frozendict_inside_dict(): + return {j: f{i: i + j async for i in asynciter([1, 2])} for j in [10, 20]} + self.assertEqual( + run_async(run_frozendict_inside_dict()), + ([], {10: f{1: 11, 2: 12}, 20: f{1: 21, 2: 22}})) + async def run_list_inside_gen(): gen = ([i + j async for i in asynciter([1, 2])] for j in [10, 20]) return [x async for x in gen] diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index 6d61c71e162f8be..2121009c2c0912a 100644 --- a/Lib/test/test_dict.py +++ b/Lib/test/test_dict.py @@ -1819,6 +1819,18 @@ class FrozenDictSlots(frozendict): class FrozenDictTests(unittest.TestCase): + def test_literal(self): + d = f{} + self.assertIs(type(d), frozendict) + self.assertEqual(d, frozendict()) + + d = f{'a': 1, 'b': 2, 'c': 3} + self.assertIs(type(d), frozendict) + self.assertEqual(d, frozendict(a=1, b=2, c=3)) + self.assertEqual(f{**d}, d) + self.assertNotEqual(f{**d, 'a': 2}, d) + self.assertEqual(f{'a': 1, **d, 'c': 3}, d) + def test_constructor(self): # frozendict.__init__() has no effect d = frozendict(a=1, b=2, c=3) @@ -1928,6 +1940,8 @@ def test_hash_cpython(self): frozendict(y=2, x=1), frozendict(a=False, b=True, c=True), frozendict.fromkeys('abc'), + f{}, + f{1: 2, 3: 4}, ): with self.subTest(fd=fd): self.assertEqual(hash(fd), hash(frozenset(fd.items()))) diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py index cc7faef93e1af7c..16640cc4f9139c0 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -246,7 +246,6 @@ def testSyntaxErrorOffset(self): check(b'\xef\xbb\xbfPython = "\xcf\xb3\xf2\xee\xed" +', 1, 12) check('x = "a', 1, 5) check('lambda x: x = 2', 1, 1) - check('f{a + b + c}', 1, 2) check('[file for str(file) in []\n]', 1, 11) check('a = « hello » « world »', 1, 5) check('[\nfile\nfor str(file)\nin\n[]\n]', 3, 5) diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py index 5cc02c30ec2ba33..d728918a67d1359 100644 --- a/Lib/test/test_fstring.py +++ b/Lib/test/test_fstring.py @@ -639,6 +639,10 @@ def test_mismatched_parens(self): r"does not match opening parenthesis '\('", ["f'{a(4}'", ]) + self.assertAllRaise(SyntaxError, r"closing parenthesis '\)' " + r"does not match opening parenthesis '\{'", + ["f'{f{4)}'", + ]) self.assertRaises(SyntaxError, eval, "f'{" + "("*20 + "}'") @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI") diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py index ebcd98a0a37776d..e0b346bd73dbb96 100644 --- a/Lib/test/test_grammar.py +++ b/Lib/test/test_grammar.py @@ -266,6 +266,16 @@ def test_max_level(self): eval("(" * (MAXLEVEL + 1) + ")" * (MAXLEVEL + 1)) self.assertStartsWith(str(cm.exception), 'too many nested parentheses') + # Dict: + with self.assertRaises(SyntaxError) as cm: + eval("{1: " * (MAXLEVEL + 1) + "}" * (MAXLEVEL + 1)) + self.assertStartsWith(str(cm.exception), 'too many nested parentheses') + + # Frozendict: + with self.assertRaises(SyntaxError) as cm: + eval("f{1: " * (MAXLEVEL + 1) + "}" * (MAXLEVEL + 1)) + self.assertStartsWith(str(cm.exception), 'too many nested parentheses') + var_annot_global: int # a global annotated is necessary for test_var_annot @@ -1218,10 +1228,16 @@ def g(): [x for x in [(yield from ())]] "'yield' inside list comprehension") check("def g(): {(yield x) for x in ()}", "'yield' inside set comprehension") + check("def g(): f{(yield x) for x in ()}", + "'yield' inside frozenset comprehension") check("def g(): {(yield x): x for x in ()}", "'yield' inside dict comprehension") check("def g(): {x: (yield x) for x in ()}", "'yield' inside dict comprehension") + check("def g(): f{(yield x): x for x in ()}", + "'yield' inside frozendict comprehension") + check("def g(): f{x: (yield x) for x in ()}", + "'yield' inside frozendict comprehension") check("def g(): ((yield x) for x in ())", "'yield' inside generator expression") check("def g(): [(yield from x) for x in ()]", @@ -1742,7 +1758,27 @@ def test_dictcomps(self): # (',' test ':' test)* [','])) | # (test (comp_for | (',' test)* [','])) ) nums = [1, 2, 3] - self.assertEqual({i:i+1 for i in nums}, {1: 2, 2: 3, 3: 4}) + expr = {i:i+1 for i in nums} + self.assertEqual(expr, {1: 2, 2: 3, 3: 4}) + self.assertIs(type(expr), dict) + + def test_frozendictcomps(self): + nums = [1, 2, 3] + expr = f{i:i+1 for i in nums} + self.assertEqual(expr, f{1: 2, 2: 3, 3: 4}) + self.assertIs(type(expr), frozendict) + + def test_setcomps(self): + nums = [1, 2, 3] + expr = {i for i in nums} + self.assertEqual(expr, {1, 2, 3}) + self.assertIs(type(expr), set) + + def test_frozensetcomps(self): + nums = [1, 2, 3] + expr = f{i for i in nums} + self.assertEqual(expr, f{1, 2, 3}) + self.assertIs(type(expr), frozenset) def test_listcomps(self): # list comprehension tests diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py index 9bfd4bc7d636699..c435929233d6330 100644 --- a/Lib/test/test_set.py +++ b/Lib/test/test_set.py @@ -752,6 +752,15 @@ class TestFrozenSet(TestJointOps, unittest.TestCase): thetype = frozenset basetype = frozenset + def test_literal(self): + s = f{1, 2, 3} + self.assertIs(type(s), frozenset) + self.assertEqual(s, frozenset((1, 2, 3))) + + s = f{0, *s, 4} + self.assertIs(type(s), frozenset) + self.assertEqual(s, frozenset((0, 1, 2, 3, 4))) + def test_init(self): s = self.thetype(self.word) s.__init__(self.otherword) diff --git a/Lib/test/test_setcomps.py b/Lib/test/test_setcomps.py index 6fc5bb74036c5fa..6caa0c48dd2c497 100644 --- a/Lib/test/test_setcomps.py +++ b/Lib/test/test_setcomps.py @@ -13,11 +13,17 @@ >>> sum({i*i for i in range(100) if i&1 == 1}) 166650 + >>> sum(f{i*i for i in range(100) if i&1 == 1}) + 166650 + Test simple case >>> {2*y + x + 1 for x in (0,) for y in (1,)} {3} + >>> f{2*y + x + 1 for x in (0,) for y in (1,)} + frozenset({3}) + Test simple nesting >>> list(sorted({(i,j) for i in range(3) for j in range(4)})) @@ -53,6 +59,12 @@ >>> i 20 + >>> sum(f{i*i for i in range(100)}) + 328350 + + >>> i + 20 + Verify that syntax error's are raised for setcomps used as lvalues >>> {y for y in (1,2)} = 10 # doctest: +IGNORE_EXCEPTION_DETAIL @@ -93,6 +105,9 @@ >>> {None for i in range(10)} {None} + >>> f{None for i in range(10)} + frozenset({None}) + ########### Tests for various scoping corner cases ############ Return lambdas that use the iteration variable as a default argument @@ -121,6 +136,11 @@ >>> {x() for x in items} {2} + >>> items = f{(lambda: y) for i in range(5)} + >>> y = 2 + >>> f{x() for x in items} + frozenset({2}) + We also repeat each of the above scoping tests inside a function >>> def test_func(): @@ -151,7 +171,18 @@ """ -class SetComprehensionTest(unittest.TestCase): +class BaseComprehensionTest: + def check_exception_location(self, func, indent, expected): + exc = func() + f = traceback.extract_tb(exc.__traceback__)[0] + co = func.__code__ + self.assertEqual(f.lineno, co.co_firstlineno + 2) + self.assertEqual(f.end_lineno, co.co_firstlineno + 2) + self.assertEqual(f.line[f.colno - indent : f.end_colno - indent], + expected) + + +class SetComprehensionTest(BaseComprehensionTest, unittest.TestCase): def test_exception_locations(self): # The location of an exception raised from __init__ or # __next__ should be the iterator expression @@ -179,14 +210,41 @@ def iter_raises(): (iter_raises, "BrokenIter(iter_raises=True)"), ]: with self.subTest(func): - exc = func() - f = traceback.extract_tb(exc.__traceback__)[0] - indent = 16 - co = func.__code__ - self.assertEqual(f.lineno, co.co_firstlineno + 2) - self.assertEqual(f.end_lineno, co.co_firstlineno + 2) - self.assertEqual(f.line[f.colno - indent : f.end_colno - indent], - expected) + self.check_exception_location( + func, indent=16, expected=expected, + ) + +class FrozenSetComprehensionTest(BaseComprehensionTest, unittest.TestCase): + def test_exception_locations(self): + # The location of an exception raised from __init__ or + # __next__ should be the iterator expression + + def init_raises(): + try: + f{x for x in BrokenIter(init_raises=True)} + except Exception as e: + return e + + def next_raises(): + try: + f{x for x in BrokenIter(next_raises=True)} + except Exception as e: + return e + + def iter_raises(): + try: + f{x for x in BrokenIter(iter_raises=True)} + except Exception as e: + return e + + for func, expected in [(init_raises, "BrokenIter(init_raises=True)"), + (next_raises, "BrokenIter(next_raises=True)"), + (iter_raises, "BrokenIter(iter_raises=True)"), + ]: + with self.subTest(func): + self.check_exception_location( + func, indent=16, expected=expected, + ) __test__ = {'doctests' : doctests} diff --git a/Lib/test/test_symtable.py b/Lib/test/test_symtable.py index 8c03420c4c5e4b1..8ed10309d3598c8 100644 --- a/Lib/test/test_symtable.py +++ b/Lib/test/test_symtable.py @@ -445,6 +445,13 @@ def test_symbol_repr(self): self.assertEqual(repr(class_A.lookup('x')), "") + st4 = symtable.symtable("f{x for x in [1]}", "?", "exec") + self.assertEqual(repr(st4.lookup("x")), + "") + st5 = symtable.symtable("f{x: 1 for x in [1]}", "?", "exec") + self.assertEqual(repr(st5.lookup("x")), + "") + def test_symtable_entry_repr(self): expected = f"" self.assertEqual(repr(self.top._table), expected) diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 80577cf5c84fac2..92cddd51a1a8b17 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -324,6 +324,10 @@ Traceback (most recent call last): SyntaxError: did you forget parentheses around the comprehension target? +>>> f{x,y for x,y in range(100)} +Traceback (most recent call last): +SyntaxError: did you forget parentheses around the comprehension target? + # Incorrectly closed strings >>> "The interesting object "The important object" is very important" @@ -1544,6 +1548,74 @@ Traceback (most recent call last): SyntaxError: invalid syntax +Incomplete frozen dictionary literals + + >>> f{1:2, 3:4, 5} + Traceback (most recent call last): + SyntaxError: ':' expected after dictionary key + + >>> f{1:2, 3:4, 5:} + Traceback (most recent call last): + SyntaxError: expression expected after dictionary key and ':' + + >>> f{1: *12+1, 23: 1} + Traceback (most recent call last): + SyntaxError: cannot use a starred expression in a dictionary value + + >>> f{1: *12+1} + Traceback (most recent call last): + SyntaxError: cannot use a starred expression in a dictionary value + + >>> f{1: 23, 1: *12+1} + Traceback (most recent call last): + SyntaxError: cannot use a starred expression in a dictionary value + + >>> f{1:} + Traceback (most recent call last): + SyntaxError: expression expected after dictionary key and ':' + + # Ensure that the error is not raised for syntax errors that happen after sets + + >>> f{1} $ + Traceback (most recent call last): + SyntaxError: invalid syntax + + # Ensure that the error is not raised for invalid expressions + + >>> f{1: 2, 3: foo(,), 4: 5} + Traceback (most recent call last): + SyntaxError: invalid syntax + + >>> f{1: $, 2: 3} + Traceback (most recent call last): + SyntaxError: invalid syntax + +Specific errors for frozen literals: + + >>> f {} + Traceback (most recent call last): + SyntaxError: invalid syntax + + >>> f {1} + Traceback (most recent call last): + SyntaxError: invalid syntax + + >>> f {1: 2} + Traceback (most recent call last): + SyntaxError: invalid syntax + + >>> f{1) + Traceback (most recent call last): + SyntaxError: closing parenthesis ')' does not match opening parenthesis '{' + + >>> F{1} # big `F` is not allowed, unlike `f` strings + Traceback (most recent call last): + SyntaxError: frozen literals must start from lower case 'f' + + >>> F{1: 2} # big `F` is not allowed, unlike `f` strings + Traceback (most recent call last): + SyntaxError: frozen literals must start from lower case 'f' + Specialized indentation errors: >>> while condition: @@ -1945,6 +2017,14 @@ Traceback (most recent call last): SyntaxError: cannot assign to dict literal here. Maybe you meant '==' instead of '='? +>>> f{1, 2, 3} = 42 +Traceback (most recent call last): +SyntaxError: cannot assign to frozenset display here. Maybe you meant '==' instead of '='? + +>>> f{1: 2, 3: 4} = 42 +Traceback (most recent call last): +SyntaxError: cannot assign to frozendict literal here. Maybe you meant '==' instead of '='? + >>> f'{x}' = 42 Traceback (most recent call last): SyntaxError: cannot assign to f-string expression here. Maybe you meant '==' instead of '='? @@ -2983,9 +3063,6 @@ def test_expression_with_assignment(self): offset=7 ) - def test_curly_brace_after_primary_raises_immediately(self): - self._check_error("f{}", "invalid syntax", mode="single") - def test_assign_call(self): self._check_error("f() = 1", "assign") diff --git a/Lib/test/test_tokenize.py b/Lib/test/test_tokenize.py index ab53a20cff55392..8b010d4ff6c178a 100644 --- a/Lib/test/test_tokenize.py +++ b/Lib/test/test_tokenize.py @@ -1838,6 +1838,7 @@ def test_exact_type(self): self.assertExactTypeEqual('.', token.DOT) self.assertExactTypeEqual('%', token.PERCENT) self.assertExactTypeEqual('{}', token.LBRACE, token.RBRACE) + self.assertExactTypeEqual('f{}', token.LFBRACE, token.RBRACE) self.assertExactTypeEqual('==', token.EQEQUAL) self.assertExactTypeEqual('!=', token.NOTEQUAL) self.assertExactTypeEqual('<=', token.LESSEQUAL) @@ -1879,6 +1880,12 @@ def test_exact_type(self): token.NUMBER, token.COMMA, token.NUMBER, token.RBRACE) + self.assertExactTypeEqual('f{1, 2, 3}', + token.LFBRACE, + token.NUMBER, token.COMMA, + token.NUMBER, token.COMMA, + token.NUMBER, + token.RBRACE) self.assertExactTypeEqual('^(x & 0x1)', token.CIRCUMFLEX, token.LPAR, @@ -2555,6 +2562,18 @@ def test_string(self): RBRACE '}' (1, 6) (1, 7) FSTRING_MIDDLE 'c' (1, 7) (1, 8) FSTRING_END '"' (1, 8) (1, 9) + """) + + self.check_tokenize('fR"a{f{b}}c"', """\ + FSTRING_START \'fR"\' (1, 0) (1, 3) + FSTRING_MIDDLE 'a' (1, 3) (1, 4) + LBRACE '{' (1, 4) (1, 5) + LFBRACE 'f{' (1, 5) (1, 7) + NAME 'b' (1, 7) (1, 8) + RBRACE '}' (1, 8) (1, 9) + RBRACE '}' (1, 9) (1, 10) + FSTRING_MIDDLE 'c' (1, 10) (1, 11) + FSTRING_END \'"\' (1, 11) (1, 12) """) self.check_tokenize('f"""abc"""', """\ @@ -2626,6 +2645,24 @@ def test_string(self): FSTRING_END "'''" (6, 3) (6, 6) """) + def test_frozen_objects(self): + self.check_tokenize('f{}', """\ + LFBRACE 'f{' (1, 0) (1, 2) + RBRACE '}' (1, 2) (1, 3) +""") + self.check_tokenize('f{1}', """\ + LFBRACE 'f{' (1, 0) (1, 2) + NUMBER '1' (1, 2) (1, 3) + RBRACE '}' (1, 3) (1, 4) +""") + self.check_tokenize('f{1: 2}', """\ + LFBRACE 'f{' (1, 0) (1, 2) + NUMBER '1' (1, 2) (1, 3) + COLON ':' (1, 3) (1, 4) + NUMBER '2' (1, 5) (1, 6) + RBRACE '}' (1, 6) (1, 7) +""") + def test_function(self): self.check_tokenize('def d22(a, b, c=2, d=2, *k): pass', """\ diff --git a/Lib/test/test_unparse.py b/Lib/test/test_unparse.py index dcaad49ffab5d26..f95a017199abfa8 100644 --- a/Lib/test/test_unparse.py +++ b/Lib/test/test_unparse.py @@ -388,8 +388,25 @@ def test_annotations(self): self.check_ast_roundtrip("def f(**kwargs: dict): pass") self.check_ast_roundtrip("def f() -> None: pass") + def test_dict_literal(self): + self.check_ast_roundtrip("{}") + self.check_ast_roundtrip("{'a': 1}") + self.check_ast_roundtrip("{**a}") + self.check_ast_roundtrip("{**a, 'a': 1, **{}}") + + def test_frozendict_literal(self): + self.check_ast_roundtrip("f{}") + self.check_ast_roundtrip("f{'a': 1}") + self.check_ast_roundtrip("f{**a}") + self.check_ast_roundtrip("f{**a, 'a': 1, **f{}, **{}}") + def test_set_literal(self): self.check_ast_roundtrip("{'a', 'b', 'c'}") + self.check_ast_roundtrip("{'a', *b}") + + def test_frozenset_literal(self): + self.check_ast_roundtrip("f{'a', 'b', 'c'}") + self.check_ast_roundtrip("f{'a', *b}") def test_empty_set(self): self.assertASTEqual( @@ -400,14 +417,24 @@ def test_empty_set(self): def test_set_comprehension(self): self.check_ast_roundtrip("{x for x in range(5)}") + def test_frozenset_comprehension(self): + self.check_ast_roundtrip("f{x for x in range(5)}") + def test_dict_comprehension(self): self.check_ast_roundtrip("{x: x*x for x in range(10)}") + def test_frozendict_comprehension(self): + self.check_ast_roundtrip("f{x: x*x for x in range(10)}") + def test_dict_comprehension_unpacking(self): self.check_ast_roundtrip("{**x for x in ()}") self.check_ast_roundtrip("{**x for x in range(10)}") self.check_ast_roundtrip("[*x for x in ()]") + def test_frozendict_comprehension_unpacking(self): + self.check_ast_roundtrip("f{**x for x in ()}") + self.check_ast_roundtrip("f{**x for x in range(10)}") + def test_class_decorators(self): self.check_ast_roundtrip(class_decorator) diff --git a/Lib/token.py b/Lib/token.py index f61723cc09da02c..c6f7c42de7c7587 100644 --- a/Lib/token.py +++ b/Lib/token.py @@ -59,22 +59,23 @@ ELLIPSIS = 52 COLONEQUAL = 53 EXCLAMATION = 54 -OP = 55 -TYPE_IGNORE = 56 -TYPE_COMMENT = 57 -SOFT_KEYWORD = 58 -FSTRING_START = 59 -FSTRING_MIDDLE = 60 -FSTRING_END = 61 -TSTRING_START = 62 -TSTRING_MIDDLE = 63 -TSTRING_END = 64 -COMMENT = 65 -NL = 66 +LFBRACE = 55 +OP = 56 +TYPE_IGNORE = 57 +TYPE_COMMENT = 58 +SOFT_KEYWORD = 59 +FSTRING_START = 60 +FSTRING_MIDDLE = 61 +FSTRING_END = 62 +TSTRING_START = 63 +TSTRING_MIDDLE = 64 +TSTRING_END = 65 +COMMENT = 66 +NL = 67 # These aren't used by the C tokenizer but are needed for tokenize.py -ERRORTOKEN = 67 -ENCODING = 68 -N_TOKENS = 69 +ERRORTOKEN = 68 +ENCODING = 69 +N_TOKENS = 70 # Special definitions for cooperation with parser NT_OFFSET = 256 @@ -127,6 +128,7 @@ ']': RSQB, '^': CIRCUMFLEX, '^=': CIRCUMFLEXEQUAL, + 'f{': LFBRACE, '{': LBRACE, '|': VBAR, '|=': VBAREQUAL, diff --git a/Modules/_testinternalcapi/test_cases.c.h b/Modules/_testinternalcapi/test_cases.c.h index f36c8192ff26623..b6319cdda7d3fc0 100644 --- a/Modules/_testinternalcapi/test_cases.c.h +++ b/Modules/_testinternalcapi/test_cases.c.h @@ -1498,6 +1498,87 @@ DISPATCH(); } + TARGET(BUILD_FROZENDICT) { + #if _Py_TAIL_CALL_INTERP + int opcode = BUILD_FROZENDICT; + (void)(opcode); + #endif + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_FROZENDICT); + _PyStackRef dict; + _PyStackRef map; + dict = stack_pointer[-1]; + PyObject *dict_o = PyStackRef_AsPyObjectSteal(dict); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + PyObject *map_o = PyFrozenDict_New(dict_o); + _PyFrame_StackPointerInvalidate(frame); + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + Py_DECREF(dict_o); + _PyFrame_StackPointerInvalidate(frame); + if (map_o == NULL) { + JUMP_TO_LABEL(error); + } + map = PyStackRef_FromPyObjectStealMortal(map_o); + stack_pointer[0] = map; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + DISPATCH(); + } + + TARGET(BUILD_FROZENSET) { + #if _Py_TAIL_CALL_INTERP + int opcode = BUILD_FROZENSET; + (void)(opcode); + #endif + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_FROZENSET); + _PyStackRef *values; + _PyStackRef set; + values = &stack_pointer[-oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + PyObject *set_o = PyFrozenSet_New(NULL); + _PyFrame_StackPointerInvalidate(frame); + if (set_o == NULL) { + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + _PyStackRef tmp; + for (int _i = oparg; --_i >= 0;) { + tmp = values[_i]; + values[_i] = PyStackRef_NULL; + PyStackRef_CLOSE(tmp); + } + _PyFrame_StackPointerInvalidate(frame); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_LABEL(error); + } + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + _PyFrame_StackPointerInvalidate(frame); + if (err) { + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + Py_DECREF(set_o); + _PyFrame_StackPointerInvalidate(frame); + JUMP_TO_LABEL(error); + } + set = PyStackRef_FromPyObjectStealMortal(set_o); + stack_pointer[-oparg] = set; + stack_pointer += 1 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + DISPATCH(); + } + TARGET(BUILD_INTERPOLATION) { #if _Py_TAIL_CALL_INTERP int opcode = BUILD_INTERPOLATION; @@ -1641,23 +1722,10 @@ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); JUMP_TO_LABEL(error); } - int err = 0; - for (Py_ssize_t i = 0; i < oparg; i++) { - _PyStackRef value = values[i]; - values[i] = PyStackRef_NULL; - if (err == 0) { - assert(stack_pointer == _PyFrame_GetStackPointer(frame)); - _PyFrame_StackPointerValidate(frame); - err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); - _PyFrame_StackPointerInvalidate(frame); - } - else { - assert(stack_pointer == _PyFrame_GetStackPointer(frame)); - _PyFrame_StackPointerValidate(frame); - PyStackRef_CLOSE(value); - _PyFrame_StackPointerInvalidate(frame); - } - } + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + _PyFrame_StackPointerInvalidate(frame); if (err) { stack_pointer += -oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); diff --git a/Modules/_testinternalcapi/test_targets.h b/Modules/_testinternalcapi/test_targets.h index 9133af142723484..3eae2191e470fe0 100644 --- a/Modules/_testinternalcapi/test_targets.h +++ b/Modules/_testinternalcapi/test_targets.h @@ -2,8 +2,9 @@ static void *opcode_targets_table[256] = { &&TARGET_CACHE, &&TARGET_BINARY_SLICE, - &&TARGET_BUILD_TEMPLATE, + &&TARGET_BUILD_FROZENDICT, &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, + &&TARGET_BUILD_TEMPLATE, &&TARGET_CALL_FUNCTION_EX, &&TARGET_CHECK_EG_MATCH, &&TARGET_CHECK_EXC_MATCH, @@ -16,8 +17,8 @@ static void *opcode_targets_table[256] = { &&TARGET_FORMAT_WITH_SPEC, &&TARGET_GET_AITER, &&TARGET_GET_ANEXT, - &&TARGET_GET_LEN, &&TARGET_RESERVED, + &&TARGET_GET_LEN, &&TARGET_INTERPRETER_EXIT, &&TARGET_LOAD_BUILD_CLASS, &&TARGET_LOAD_LOCALS, @@ -43,6 +44,7 @@ static void *opcode_targets_table[256] = { &&TARGET_UNARY_NOT, &&TARGET_WITH_EXCEPT_START, &&TARGET_BINARY_OP, + &&TARGET_BUILD_FROZENSET, &&TARGET_BUILD_INTERPOLATION, &&TARGET_BUILD_LIST, &&TARGET_BUILD_MAP, @@ -126,8 +128,6 @@ static void *opcode_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, @@ -377,8 +377,8 @@ static void *opcode_tracing_targets_table[256] = { &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_TRACE_RECORD, + &&TARGET_TRACE_RECORD, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, @@ -549,6 +549,8 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_OP_SUBSCR_USTR_INT(TAIL_C static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_OP_SUBTRACT_FLOAT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_OP_SUBTRACT_INT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_SLICE(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_FROZENDICT(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_FROZENSET(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_INTERPOLATION(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_LIST(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_MAP(TAIL_CALL_PARAMS); @@ -793,6 +795,8 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [BINARY_OP_SUBTRACT_FLOAT] = _TAIL_CALL_BINARY_OP_SUBTRACT_FLOAT, [BINARY_OP_SUBTRACT_INT] = _TAIL_CALL_BINARY_OP_SUBTRACT_INT, [BINARY_SLICE] = _TAIL_CALL_BINARY_SLICE, + [BUILD_FROZENDICT] = _TAIL_CALL_BUILD_FROZENDICT, + [BUILD_FROZENSET] = _TAIL_CALL_BUILD_FROZENSET, [BUILD_INTERPOLATION] = _TAIL_CALL_BUILD_INTERPOLATION, [BUILD_LIST] = _TAIL_CALL_BUILD_LIST, [BUILD_MAP] = _TAIL_CALL_BUILD_MAP, @@ -1007,8 +1011,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_UNPACK_SEQUENCE_TWO_TUPLE, [WITH_EXCEPT_START] = _TAIL_CALL_WITH_EXCEPT_START, [YIELD_VALUE] = _TAIL_CALL_YIELD_VALUE, - [118] = _TAIL_CALL_UNKNOWN_OPCODE, - [119] = _TAIL_CALL_UNKNOWN_OPCODE, [120] = _TAIL_CALL_UNKNOWN_OPCODE, [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, @@ -1051,6 +1053,8 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [BINARY_OP_SUBTRACT_FLOAT] = _TAIL_CALL_TRACE_RECORD, [BINARY_OP_SUBTRACT_INT] = _TAIL_CALL_TRACE_RECORD, [BINARY_SLICE] = _TAIL_CALL_TRACE_RECORD, + [BUILD_FROZENDICT] = _TAIL_CALL_TRACE_RECORD, + [BUILD_FROZENSET] = _TAIL_CALL_TRACE_RECORD, [BUILD_INTERPOLATION] = _TAIL_CALL_TRACE_RECORD, [BUILD_LIST] = _TAIL_CALL_TRACE_RECORD, [BUILD_MAP] = _TAIL_CALL_TRACE_RECORD, @@ -1265,8 +1269,6 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_TRACE_RECORD, [WITH_EXCEPT_START] = _TAIL_CALL_TRACE_RECORD, [YIELD_VALUE] = _TAIL_CALL_TRACE_RECORD, - [118] = _TAIL_CALL_UNKNOWN_OPCODE, - [119] = _TAIL_CALL_UNKNOWN_OPCODE, [120] = _TAIL_CALL_UNKNOWN_OPCODE, [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, diff --git a/Objects/setobject.c b/Objects/setobject.c index 8fdd1eb26118c0a..0f1dc1c088821ea 100644 --- a/Objects/setobject.c +++ b/Objects/setobject.c @@ -3178,7 +3178,8 @@ PySet_Pop(PyObject *set) int _PySet_Update(PyObject *set, PyObject *iterable) { - if (!PySet_Check(set)) { + // TODO: this works with `frozenset` to support `f{1}`, but API might change: + if (!PyAnySet_Check(set)) { PyErr_BadInternalCall(); return -1; } diff --git a/Parser/Python.asdl b/Parser/Python.asdl index 2f0b123858f8d18..466431d439a54c3 100644 --- a/Parser/Python.asdl +++ b/Parser/Python.asdl @@ -64,10 +64,14 @@ module Python | Lambda(arguments args, expr body) | IfExp(expr test, expr body, expr orelse) | Dict(expr?* keys, expr* values) + | FrozenDict(expr?* keys, expr* values) | Set(expr* elts) + | FrozenSet(expr* elts) | ListComp(expr elt, comprehension* generators) | SetComp(expr elt, comprehension* generators) + | FrozenSetComp(expr elt, comprehension* generators) | DictComp(expr key, expr? value, comprehension* generators) + | FrozenDictComp(expr key, expr? value, comprehension* generators) | GeneratorExp(expr elt, comprehension* generators) -- the grammar constrains where yield expressions can occur | Await(expr value) diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 381c173589904ba..718fa560eac13ea 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1114,12 +1114,20 @@ _PyPegen_get_expr_name(expr_ty e) return "list comprehension"; case SetComp_kind: return "set comprehension"; + case FrozenSetComp_kind: + return "frozenset comprehension"; case DictComp_kind: return "dict comprehension"; + case FrozenDictComp_kind: + return "frozendict comprehension"; case Dict_kind: return "dict literal"; + case FrozenDict_kind: + return "frozendict literal"; case Set_kind: return "set display"; + case FrozenSet_kind: + return "frozenset display"; case JoinedStr_kind: case FormattedValue_kind: return "f-string expression"; diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index 7f25afec302c225..5a99fbdca0673be 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -780,6 +780,9 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t } goto letter_quote; } + if (saw_f && c == '{') { + goto parentheses; + } } while (is_potential_identifier_char(c)) { if (c >= 128) { @@ -1297,6 +1300,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t tok_backup(tok, c2); } + parentheses: /* Keep track of parentheses nesting level */ switch (c) { case '(': @@ -1375,6 +1379,21 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t break; } + if (*tok->start == 'f' && c == '{') { + p_start = tok->start; + p_end = tok->cur; + + return MAKE_TOKEN(LFBRACE); + } + else if (*tok->start == 'F' && c == '{') { + // We don't allow `F{}` notation: + p_start = tok->start; + p_end = tok->cur; + + return MAKE_TOKEN(_PyTokenizer_syntaxerror( + tok, "frozen literals must start from lower case 'f'")); + } + if (!Py_UNICODE_ISPRINTABLE(c)) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "invalid non-printable character U+%04X", c)); } diff --git a/Parser/parser.c b/Parser/parser.c index 58b6dd77a38b26d..aeacce842017914 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -263,287 +263,292 @@ static char *soft_keywords[] = { #define list_type 1174 #define tuple_type 1175 #define set_type 1176 -#define dict_type 1177 -#define double_starred_kvpairs_type 1178 -#define double_starred_kvpair_type 1179 -#define kvpair_type 1180 -#define for_if_clauses_type 1181 -#define for_if_clause_type 1182 -#define listcomp_type 1183 -#define setcomp_type 1184 -#define genexp_type 1185 -#define dictcomp_type 1186 -#define arguments_type 1187 -#define args_type 1188 -#define kwargs_type 1189 -#define starred_expression_type 1190 -#define kwarg_or_starred_type 1191 -#define kwarg_or_double_starred_type 1192 -#define star_targets_type 1193 -#define star_targets_list_seq_type 1194 -#define star_targets_tuple_seq_type 1195 -#define star_target_type 1196 -#define target_with_star_atom_type 1197 -#define star_atom_type 1198 -#define single_target_type 1199 -#define single_subscript_attribute_target_type 1200 -#define t_primary_type 1201 // Left-recursive -#define t_lookahead_type 1202 -#define del_targets_type 1203 -#define del_target_type 1204 -#define del_t_atom_type 1205 -#define type_expressions_type 1206 -#define func_type_comment_type 1207 -#define invalid_arguments_type 1208 -#define invalid_kwarg_type 1209 -#define expression_without_invalid_type 1210 -#define invalid_legacy_expression_type 1211 -#define invalid_type_param_type 1212 -#define invalid_expression_type 1213 -#define invalid_if_expression_type 1214 -#define invalid_named_expression_type 1215 -#define invalid_assignment_type 1216 -#define invalid_ann_assign_target_type 1217 -#define invalid_raise_stmt_type 1218 -#define invalid_del_stmt_type 1219 -#define invalid_assert_stmt_type 1220 -#define invalid_block_type 1221 -#define invalid_comprehension_type 1222 -#define invalid_parameters_type 1223 -#define invalid_default_type 1224 -#define invalid_star_etc_type 1225 -#define invalid_kwds_type 1226 -#define invalid_parameters_helper_type 1227 -#define invalid_lambda_parameters_type 1228 -#define invalid_lambda_parameters_helper_type 1229 -#define invalid_lambda_star_etc_type 1230 -#define invalid_lambda_kwds_type 1231 -#define invalid_double_type_comments_type 1232 -#define invalid_with_item_type 1233 -#define invalid_for_if_clause_type 1234 -#define invalid_for_target_type 1235 -#define invalid_group_type 1236 -#define invalid_import_type 1237 -#define invalid_dotted_as_name_type 1238 -#define invalid_import_from_as_name_type 1239 -#define invalid_import_from_targets_type 1240 -#define invalid_with_stmt_type 1241 -#define invalid_with_stmt_indent_type 1242 -#define invalid_try_stmt_type 1243 -#define invalid_except_stmt_type 1244 -#define invalid_except_star_stmt_type 1245 -#define invalid_finally_stmt_type 1246 -#define invalid_except_stmt_indent_type 1247 -#define invalid_except_star_stmt_indent_type 1248 -#define invalid_match_stmt_type 1249 -#define invalid_case_block_type 1250 -#define invalid_as_pattern_type 1251 -#define invalid_class_pattern_type 1252 -#define invalid_mapping_pattern_type 1253 -#define invalid_class_argument_pattern_type 1254 -#define invalid_if_stmt_type 1255 -#define invalid_elif_stmt_type 1256 -#define invalid_else_stmt_type 1257 -#define invalid_while_stmt_type 1258 -#define invalid_for_stmt_type 1259 -#define invalid_def_raw_type 1260 -#define invalid_class_def_raw_type 1261 -#define invalid_double_starred_kvpairs_type 1262 -#define invalid_kvpair_unpacking_type 1263 -#define invalid_kvpair_type 1264 -#define invalid_starred_expression_unpacking_type 1265 -#define invalid_starred_expression_unpacking_sequence_type 1266 -#define invalid_starred_expression_type 1267 -#define invalid_fstring_replacement_field_type 1268 -#define invalid_fstring_conversion_character_type 1269 -#define invalid_tstring_replacement_field_type 1270 -#define invalid_tstring_conversion_character_type 1271 -#define invalid_string_tstring_concat_type 1272 -#define invalid_arithmetic_type 1273 -#define invalid_factor_type 1274 -#define invalid_type_params_type 1275 -#define invalid_bitwise_and_type 1276 // Left-recursive -#define invalid_bitwise_or_type 1277 // Left-recursive -#define _loop0_1_type 1278 -#define _loop1_2_type 1279 -#define _loop0_3_type 1280 -#define _gather_4_type 1281 -#define _tmp_5_type 1282 -#define _tmp_6_type 1283 -#define _tmp_7_type 1284 -#define _tmp_8_type 1285 -#define _tmp_9_type 1286 -#define _tmp_10_type 1287 -#define _tmp_11_type 1288 -#define _loop1_12_type 1289 -#define _loop0_13_type 1290 -#define _gather_14_type 1291 -#define _tmp_15_type 1292 -#define _tmp_16_type 1293 -#define _loop0_17_type 1294 -#define _loop1_18_type 1295 -#define _loop0_19_type 1296 -#define _gather_20_type 1297 -#define _tmp_21_type 1298 -#define _loop0_22_type 1299 -#define _gather_23_type 1300 -#define _loop1_24_type 1301 -#define _tmp_25_type 1302 -#define _tmp_26_type 1303 -#define _loop0_27_type 1304 -#define _loop0_28_type 1305 -#define _loop1_29_type 1306 -#define _loop1_30_type 1307 -#define _loop0_31_type 1308 -#define _loop1_32_type 1309 -#define _loop0_33_type 1310 -#define _gather_34_type 1311 -#define _tmp_35_type 1312 -#define _loop1_36_type 1313 -#define _loop1_37_type 1314 -#define _loop1_38_type 1315 -#define _loop0_39_type 1316 -#define _gather_40_type 1317 -#define _tmp_41_type 1318 -#define _tmp_42_type 1319 -#define _tmp_43_type 1320 -#define _loop0_44_type 1321 -#define _gather_45_type 1322 -#define _loop0_46_type 1323 -#define _gather_47_type 1324 -#define _tmp_48_type 1325 -#define _loop0_49_type 1326 -#define _gather_50_type 1327 -#define _loop0_51_type 1328 -#define _gather_52_type 1329 -#define _loop0_53_type 1330 -#define _gather_54_type 1331 -#define _loop1_55_type 1332 -#define _loop1_56_type 1333 -#define _loop0_57_type 1334 -#define _gather_58_type 1335 -#define _loop0_59_type 1336 -#define _gather_60_type 1337 -#define _loop1_61_type 1338 -#define _loop1_62_type 1339 -#define _loop1_63_type 1340 -#define _tmp_64_type 1341 -#define _loop0_65_type 1342 -#define _gather_66_type 1343 -#define _tmp_67_type 1344 -#define _tmp_68_type 1345 -#define _tmp_69_type 1346 -#define _tmp_70_type 1347 -#define _tmp_71_type 1348 -#define _loop0_72_type 1349 -#define _loop0_73_type 1350 -#define _loop1_74_type 1351 -#define _loop1_75_type 1352 -#define _loop0_76_type 1353 -#define _loop1_77_type 1354 -#define _loop0_78_type 1355 -#define _loop0_79_type 1356 -#define _loop0_80_type 1357 -#define _loop0_81_type 1358 -#define _loop1_82_type 1359 -#define _loop1_83_type 1360 -#define _tmp_84_type 1361 -#define _loop0_85_type 1362 -#define _gather_86_type 1363 -#define _loop1_87_type 1364 -#define _loop0_88_type 1365 -#define _tmp_89_type 1366 -#define _loop0_90_type 1367 -#define _gather_91_type 1368 -#define _tmp_92_type 1369 -#define _loop0_93_type 1370 -#define _gather_94_type 1371 -#define _loop0_95_type 1372 -#define _gather_96_type 1373 -#define _loop0_97_type 1374 -#define _loop0_98_type 1375 -#define _gather_99_type 1376 -#define _loop1_100_type 1377 -#define _tmp_101_type 1378 -#define _loop0_102_type 1379 -#define _gather_103_type 1380 -#define _loop0_104_type 1381 -#define _gather_105_type 1382 -#define _tmp_106_type 1383 -#define _tmp_107_type 1384 -#define _loop0_108_type 1385 -#define _gather_109_type 1386 -#define _tmp_110_type 1387 -#define _tmp_111_type 1388 -#define _tmp_112_type 1389 -#define _tmp_113_type 1390 -#define _tmp_114_type 1391 -#define _loop1_115_type 1392 -#define _tmp_116_type 1393 -#define _tmp_117_type 1394 -#define _tmp_118_type 1395 -#define _tmp_119_type 1396 -#define _tmp_120_type 1397 -#define _loop0_121_type 1398 -#define _loop0_122_type 1399 -#define _tmp_123_type 1400 -#define _tmp_124_type 1401 -#define _tmp_125_type 1402 -#define _tmp_126_type 1403 -#define _tmp_127_type 1404 -#define _tmp_128_type 1405 -#define _tmp_129_type 1406 -#define _tmp_130_type 1407 -#define _loop0_131_type 1408 -#define _gather_132_type 1409 -#define _tmp_133_type 1410 -#define _tmp_134_type 1411 -#define _tmp_135_type 1412 -#define _tmp_136_type 1413 -#define _loop0_137_type 1414 -#define _gather_138_type 1415 -#define _tmp_139_type 1416 -#define _loop0_140_type 1417 -#define _gather_141_type 1418 -#define _loop0_142_type 1419 -#define _gather_143_type 1420 -#define _tmp_144_type 1421 -#define _loop0_145_type 1422 -#define _tmp_146_type 1423 -#define _tmp_147_type 1424 -#define _tmp_148_type 1425 -#define _tmp_149_type 1426 -#define _tmp_150_type 1427 -#define _tmp_151_type 1428 -#define _tmp_152_type 1429 -#define _tmp_153_type 1430 -#define _tmp_154_type 1431 -#define _tmp_155_type 1432 -#define _tmp_156_type 1433 -#define _tmp_157_type 1434 -#define _tmp_158_type 1435 -#define _tmp_159_type 1436 -#define _tmp_160_type 1437 -#define _tmp_161_type 1438 -#define _tmp_162_type 1439 -#define _tmp_163_type 1440 -#define _tmp_164_type 1441 -#define _tmp_165_type 1442 -#define _tmp_166_type 1443 -#define _tmp_167_type 1444 -#define _tmp_168_type 1445 -#define _tmp_169_type 1446 -#define _tmp_170_type 1447 -#define _tmp_171_type 1448 -#define _tmp_172_type 1449 -#define _tmp_173_type 1450 -#define _loop0_174_type 1451 -#define _tmp_175_type 1452 -#define _tmp_176_type 1453 -#define _tmp_177_type 1454 -#define _tmp_178_type 1455 -#define _tmp_179_type 1456 -#define _tmp_180_type 1457 +#define frozenset_type 1177 +#define dict_type 1178 +#define frozendict_type 1179 +#define double_starred_kvpairs_type 1180 +#define double_starred_kvpair_type 1181 +#define kvpair_type 1182 +#define for_if_clauses_type 1183 +#define for_if_clause_type 1184 +#define listcomp_type 1185 +#define setcomp_type 1186 +#define frozensetcomp_type 1187 +#define genexp_type 1188 +#define dictcomp_type 1189 +#define frozendictcomp_type 1190 +#define arguments_type 1191 +#define args_type 1192 +#define kwargs_type 1193 +#define starred_expression_type 1194 +#define kwarg_or_starred_type 1195 +#define kwarg_or_double_starred_type 1196 +#define star_targets_type 1197 +#define star_targets_list_seq_type 1198 +#define star_targets_tuple_seq_type 1199 +#define star_target_type 1200 +#define target_with_star_atom_type 1201 +#define star_atom_type 1202 +#define single_target_type 1203 +#define single_subscript_attribute_target_type 1204 +#define t_primary_type 1205 // Left-recursive +#define t_lookahead_type 1206 +#define del_targets_type 1207 +#define del_target_type 1208 +#define del_t_atom_type 1209 +#define type_expressions_type 1210 +#define func_type_comment_type 1211 +#define invalid_arguments_type 1212 +#define invalid_kwarg_type 1213 +#define expression_without_invalid_type 1214 +#define invalid_legacy_expression_type 1215 +#define invalid_type_param_type 1216 +#define invalid_expression_type 1217 +#define invalid_if_expression_type 1218 +#define invalid_named_expression_type 1219 +#define invalid_assignment_type 1220 +#define invalid_ann_assign_target_type 1221 +#define invalid_raise_stmt_type 1222 +#define invalid_del_stmt_type 1223 +#define invalid_assert_stmt_type 1224 +#define invalid_block_type 1225 +#define invalid_comprehension_type 1226 +#define invalid_parameters_type 1227 +#define invalid_default_type 1228 +#define invalid_star_etc_type 1229 +#define invalid_kwds_type 1230 +#define invalid_parameters_helper_type 1231 +#define invalid_lambda_parameters_type 1232 +#define invalid_lambda_parameters_helper_type 1233 +#define invalid_lambda_star_etc_type 1234 +#define invalid_lambda_kwds_type 1235 +#define invalid_double_type_comments_type 1236 +#define invalid_with_item_type 1237 +#define invalid_for_if_clause_type 1238 +#define invalid_for_target_type 1239 +#define invalid_group_type 1240 +#define invalid_import_type 1241 +#define invalid_dotted_as_name_type 1242 +#define invalid_import_from_as_name_type 1243 +#define invalid_import_from_targets_type 1244 +#define invalid_with_stmt_type 1245 +#define invalid_with_stmt_indent_type 1246 +#define invalid_try_stmt_type 1247 +#define invalid_except_stmt_type 1248 +#define invalid_except_star_stmt_type 1249 +#define invalid_finally_stmt_type 1250 +#define invalid_except_stmt_indent_type 1251 +#define invalid_except_star_stmt_indent_type 1252 +#define invalid_match_stmt_type 1253 +#define invalid_case_block_type 1254 +#define invalid_as_pattern_type 1255 +#define invalid_class_pattern_type 1256 +#define invalid_mapping_pattern_type 1257 +#define invalid_class_argument_pattern_type 1258 +#define invalid_if_stmt_type 1259 +#define invalid_elif_stmt_type 1260 +#define invalid_else_stmt_type 1261 +#define invalid_while_stmt_type 1262 +#define invalid_for_stmt_type 1263 +#define invalid_def_raw_type 1264 +#define invalid_class_def_raw_type 1265 +#define invalid_double_starred_kvpairs_type 1266 +#define invalid_kvpair_unpacking_type 1267 +#define invalid_kvpair_type 1268 +#define invalid_starred_expression_unpacking_type 1269 +#define invalid_starred_expression_unpacking_sequence_type 1270 +#define invalid_starred_expression_type 1271 +#define invalid_fstring_replacement_field_type 1272 +#define invalid_fstring_conversion_character_type 1273 +#define invalid_tstring_replacement_field_type 1274 +#define invalid_tstring_conversion_character_type 1275 +#define invalid_string_tstring_concat_type 1276 +#define invalid_arithmetic_type 1277 +#define invalid_factor_type 1278 +#define invalid_type_params_type 1279 +#define invalid_bitwise_and_type 1280 // Left-recursive +#define invalid_bitwise_or_type 1281 // Left-recursive +#define _loop0_1_type 1282 +#define _loop1_2_type 1283 +#define _loop0_3_type 1284 +#define _gather_4_type 1285 +#define _tmp_5_type 1286 +#define _tmp_6_type 1287 +#define _tmp_7_type 1288 +#define _tmp_8_type 1289 +#define _tmp_9_type 1290 +#define _tmp_10_type 1291 +#define _tmp_11_type 1292 +#define _loop1_12_type 1293 +#define _loop0_13_type 1294 +#define _gather_14_type 1295 +#define _tmp_15_type 1296 +#define _tmp_16_type 1297 +#define _loop0_17_type 1298 +#define _loop1_18_type 1299 +#define _loop0_19_type 1300 +#define _gather_20_type 1301 +#define _tmp_21_type 1302 +#define _loop0_22_type 1303 +#define _gather_23_type 1304 +#define _loop1_24_type 1305 +#define _tmp_25_type 1306 +#define _tmp_26_type 1307 +#define _loop0_27_type 1308 +#define _loop0_28_type 1309 +#define _loop1_29_type 1310 +#define _loop1_30_type 1311 +#define _loop0_31_type 1312 +#define _loop1_32_type 1313 +#define _loop0_33_type 1314 +#define _gather_34_type 1315 +#define _tmp_35_type 1316 +#define _loop1_36_type 1317 +#define _loop1_37_type 1318 +#define _loop1_38_type 1319 +#define _loop0_39_type 1320 +#define _gather_40_type 1321 +#define _tmp_41_type 1322 +#define _tmp_42_type 1323 +#define _tmp_43_type 1324 +#define _loop0_44_type 1325 +#define _gather_45_type 1326 +#define _loop0_46_type 1327 +#define _gather_47_type 1328 +#define _tmp_48_type 1329 +#define _loop0_49_type 1330 +#define _gather_50_type 1331 +#define _loop0_51_type 1332 +#define _gather_52_type 1333 +#define _loop0_53_type 1334 +#define _gather_54_type 1335 +#define _loop1_55_type 1336 +#define _loop1_56_type 1337 +#define _loop0_57_type 1338 +#define _gather_58_type 1339 +#define _loop0_59_type 1340 +#define _gather_60_type 1341 +#define _loop1_61_type 1342 +#define _loop1_62_type 1343 +#define _loop1_63_type 1344 +#define _tmp_64_type 1345 +#define _loop0_65_type 1346 +#define _gather_66_type 1347 +#define _tmp_67_type 1348 +#define _tmp_68_type 1349 +#define _tmp_69_type 1350 +#define _tmp_70_type 1351 +#define _tmp_71_type 1352 +#define _tmp_72_type 1353 +#define _loop0_73_type 1354 +#define _loop0_74_type 1355 +#define _loop1_75_type 1356 +#define _loop1_76_type 1357 +#define _loop0_77_type 1358 +#define _loop1_78_type 1359 +#define _loop0_79_type 1360 +#define _loop0_80_type 1361 +#define _loop0_81_type 1362 +#define _loop0_82_type 1363 +#define _loop1_83_type 1364 +#define _loop1_84_type 1365 +#define _tmp_85_type 1366 +#define _loop0_86_type 1367 +#define _gather_87_type 1368 +#define _loop1_88_type 1369 +#define _loop0_89_type 1370 +#define _tmp_90_type 1371 +#define _loop0_91_type 1372 +#define _gather_92_type 1373 +#define _tmp_93_type 1374 +#define _loop0_94_type 1375 +#define _gather_95_type 1376 +#define _loop0_96_type 1377 +#define _gather_97_type 1378 +#define _loop0_98_type 1379 +#define _loop0_99_type 1380 +#define _gather_100_type 1381 +#define _loop1_101_type 1382 +#define _tmp_102_type 1383 +#define _loop0_103_type 1384 +#define _gather_104_type 1385 +#define _loop0_105_type 1386 +#define _gather_106_type 1387 +#define _tmp_107_type 1388 +#define _tmp_108_type 1389 +#define _loop0_109_type 1390 +#define _gather_110_type 1391 +#define _tmp_111_type 1392 +#define _tmp_112_type 1393 +#define _tmp_113_type 1394 +#define _tmp_114_type 1395 +#define _tmp_115_type 1396 +#define _loop1_116_type 1397 +#define _tmp_117_type 1398 +#define _tmp_118_type 1399 +#define _tmp_119_type 1400 +#define _tmp_120_type 1401 +#define _tmp_121_type 1402 +#define _loop0_122_type 1403 +#define _loop0_123_type 1404 +#define _tmp_124_type 1405 +#define _tmp_125_type 1406 +#define _tmp_126_type 1407 +#define _tmp_127_type 1408 +#define _tmp_128_type 1409 +#define _tmp_129_type 1410 +#define _tmp_130_type 1411 +#define _tmp_131_type 1412 +#define _loop0_132_type 1413 +#define _gather_133_type 1414 +#define _tmp_134_type 1415 +#define _tmp_135_type 1416 +#define _tmp_136_type 1417 +#define _tmp_137_type 1418 +#define _loop0_138_type 1419 +#define _gather_139_type 1420 +#define _tmp_140_type 1421 +#define _loop0_141_type 1422 +#define _gather_142_type 1423 +#define _loop0_143_type 1424 +#define _gather_144_type 1425 +#define _tmp_145_type 1426 +#define _loop0_146_type 1427 +#define _tmp_147_type 1428 +#define _tmp_148_type 1429 +#define _tmp_149_type 1430 +#define _tmp_150_type 1431 +#define _tmp_151_type 1432 +#define _tmp_152_type 1433 +#define _tmp_153_type 1434 +#define _tmp_154_type 1435 +#define _tmp_155_type 1436 +#define _tmp_156_type 1437 +#define _tmp_157_type 1438 +#define _tmp_158_type 1439 +#define _tmp_159_type 1440 +#define _tmp_160_type 1441 +#define _tmp_161_type 1442 +#define _tmp_162_type 1443 +#define _tmp_163_type 1444 +#define _tmp_164_type 1445 +#define _tmp_165_type 1446 +#define _tmp_166_type 1447 +#define _tmp_167_type 1448 +#define _tmp_168_type 1449 +#define _tmp_169_type 1450 +#define _tmp_170_type 1451 +#define _tmp_171_type 1452 +#define _tmp_172_type 1453 +#define _tmp_173_type 1454 +#define _tmp_174_type 1455 +#define _loop0_175_type 1456 +#define _tmp_176_type 1457 +#define _tmp_177_type 1458 +#define _tmp_178_type 1459 +#define _tmp_179_type 1460 +#define _tmp_180_type 1461 +#define _tmp_181_type 1462 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -722,7 +727,9 @@ static expr_ty strings_rule(Parser *p); static expr_ty list_rule(Parser *p); static expr_ty tuple_rule(Parser *p); static expr_ty set_rule(Parser *p); +static expr_ty frozenset_rule(Parser *p); static expr_ty dict_rule(Parser *p); +static expr_ty frozendict_rule(Parser *p); static asdl_seq* double_starred_kvpairs_rule(Parser *p); static KeyValuePair* double_starred_kvpair_rule(Parser *p); static KeyValuePair* kvpair_rule(Parser *p); @@ -730,8 +737,10 @@ static asdl_comprehension_seq* for_if_clauses_rule(Parser *p); static comprehension_ty for_if_clause_rule(Parser *p); static expr_ty listcomp_rule(Parser *p); static expr_ty setcomp_rule(Parser *p); +static expr_ty frozensetcomp_rule(Parser *p); static expr_ty genexp_rule(Parser *p); static expr_ty dictcomp_rule(Parser *p); +static expr_ty frozendictcomp_rule(Parser *p); static expr_ty arguments_rule(Parser *p); static expr_ty args_rule(Parser *p); static asdl_seq* kwargs_rule(Parser *p); @@ -894,58 +903,58 @@ static void *_tmp_68_rule(Parser *p); static void *_tmp_69_rule(Parser *p); static void *_tmp_70_rule(Parser *p); static void *_tmp_71_rule(Parser *p); -static asdl_seq *_loop0_72_rule(Parser *p); +static void *_tmp_72_rule(Parser *p); static asdl_seq *_loop0_73_rule(Parser *p); -static asdl_seq *_loop1_74_rule(Parser *p); +static asdl_seq *_loop0_74_rule(Parser *p); static asdl_seq *_loop1_75_rule(Parser *p); -static asdl_seq *_loop0_76_rule(Parser *p); -static asdl_seq *_loop1_77_rule(Parser *p); -static asdl_seq *_loop0_78_rule(Parser *p); +static asdl_seq *_loop1_76_rule(Parser *p); +static asdl_seq *_loop0_77_rule(Parser *p); +static asdl_seq *_loop1_78_rule(Parser *p); static asdl_seq *_loop0_79_rule(Parser *p); static asdl_seq *_loop0_80_rule(Parser *p); static asdl_seq *_loop0_81_rule(Parser *p); -static asdl_seq *_loop1_82_rule(Parser *p); +static asdl_seq *_loop0_82_rule(Parser *p); static asdl_seq *_loop1_83_rule(Parser *p); -static void *_tmp_84_rule(Parser *p); -static asdl_seq *_loop0_85_rule(Parser *p); -static asdl_seq *_gather_86_rule(Parser *p); -static asdl_seq *_loop1_87_rule(Parser *p); -static asdl_seq *_loop0_88_rule(Parser *p); -static void *_tmp_89_rule(Parser *p); -static asdl_seq *_loop0_90_rule(Parser *p); -static asdl_seq *_gather_91_rule(Parser *p); -static void *_tmp_92_rule(Parser *p); -static asdl_seq *_loop0_93_rule(Parser *p); -static asdl_seq *_gather_94_rule(Parser *p); -static asdl_seq *_loop0_95_rule(Parser *p); -static asdl_seq *_gather_96_rule(Parser *p); -static asdl_seq *_loop0_97_rule(Parser *p); +static asdl_seq *_loop1_84_rule(Parser *p); +static void *_tmp_85_rule(Parser *p); +static asdl_seq *_loop0_86_rule(Parser *p); +static asdl_seq *_gather_87_rule(Parser *p); +static asdl_seq *_loop1_88_rule(Parser *p); +static asdl_seq *_loop0_89_rule(Parser *p); +static void *_tmp_90_rule(Parser *p); +static asdl_seq *_loop0_91_rule(Parser *p); +static asdl_seq *_gather_92_rule(Parser *p); +static void *_tmp_93_rule(Parser *p); +static asdl_seq *_loop0_94_rule(Parser *p); +static asdl_seq *_gather_95_rule(Parser *p); +static asdl_seq *_loop0_96_rule(Parser *p); +static asdl_seq *_gather_97_rule(Parser *p); static asdl_seq *_loop0_98_rule(Parser *p); -static asdl_seq *_gather_99_rule(Parser *p); -static asdl_seq *_loop1_100_rule(Parser *p); -static void *_tmp_101_rule(Parser *p); -static asdl_seq *_loop0_102_rule(Parser *p); -static asdl_seq *_gather_103_rule(Parser *p); -static asdl_seq *_loop0_104_rule(Parser *p); -static asdl_seq *_gather_105_rule(Parser *p); -static void *_tmp_106_rule(Parser *p); +static asdl_seq *_loop0_99_rule(Parser *p); +static asdl_seq *_gather_100_rule(Parser *p); +static asdl_seq *_loop1_101_rule(Parser *p); +static void *_tmp_102_rule(Parser *p); +static asdl_seq *_loop0_103_rule(Parser *p); +static asdl_seq *_gather_104_rule(Parser *p); +static asdl_seq *_loop0_105_rule(Parser *p); +static asdl_seq *_gather_106_rule(Parser *p); static void *_tmp_107_rule(Parser *p); -static asdl_seq *_loop0_108_rule(Parser *p); -static asdl_seq *_gather_109_rule(Parser *p); -static void *_tmp_110_rule(Parser *p); +static void *_tmp_108_rule(Parser *p); +static asdl_seq *_loop0_109_rule(Parser *p); +static asdl_seq *_gather_110_rule(Parser *p); static void *_tmp_111_rule(Parser *p); static void *_tmp_112_rule(Parser *p); static void *_tmp_113_rule(Parser *p); static void *_tmp_114_rule(Parser *p); -static asdl_seq *_loop1_115_rule(Parser *p); -static void *_tmp_116_rule(Parser *p); +static void *_tmp_115_rule(Parser *p); +static asdl_seq *_loop1_116_rule(Parser *p); static void *_tmp_117_rule(Parser *p); static void *_tmp_118_rule(Parser *p); static void *_tmp_119_rule(Parser *p); static void *_tmp_120_rule(Parser *p); -static asdl_seq *_loop0_121_rule(Parser *p); +static void *_tmp_121_rule(Parser *p); static asdl_seq *_loop0_122_rule(Parser *p); -static void *_tmp_123_rule(Parser *p); +static asdl_seq *_loop0_123_rule(Parser *p); static void *_tmp_124_rule(Parser *p); static void *_tmp_125_rule(Parser *p); static void *_tmp_126_rule(Parser *p); @@ -953,22 +962,22 @@ static void *_tmp_127_rule(Parser *p); static void *_tmp_128_rule(Parser *p); static void *_tmp_129_rule(Parser *p); static void *_tmp_130_rule(Parser *p); -static asdl_seq *_loop0_131_rule(Parser *p); -static asdl_seq *_gather_132_rule(Parser *p); -static void *_tmp_133_rule(Parser *p); +static void *_tmp_131_rule(Parser *p); +static asdl_seq *_loop0_132_rule(Parser *p); +static asdl_seq *_gather_133_rule(Parser *p); static void *_tmp_134_rule(Parser *p); static void *_tmp_135_rule(Parser *p); static void *_tmp_136_rule(Parser *p); -static asdl_seq *_loop0_137_rule(Parser *p); -static asdl_seq *_gather_138_rule(Parser *p); -static void *_tmp_139_rule(Parser *p); -static asdl_seq *_loop0_140_rule(Parser *p); -static asdl_seq *_gather_141_rule(Parser *p); -static asdl_seq *_loop0_142_rule(Parser *p); -static asdl_seq *_gather_143_rule(Parser *p); -static void *_tmp_144_rule(Parser *p); -static asdl_seq *_loop0_145_rule(Parser *p); -static void *_tmp_146_rule(Parser *p); +static void *_tmp_137_rule(Parser *p); +static asdl_seq *_loop0_138_rule(Parser *p); +static asdl_seq *_gather_139_rule(Parser *p); +static void *_tmp_140_rule(Parser *p); +static asdl_seq *_loop0_141_rule(Parser *p); +static asdl_seq *_gather_142_rule(Parser *p); +static asdl_seq *_loop0_143_rule(Parser *p); +static asdl_seq *_gather_144_rule(Parser *p); +static void *_tmp_145_rule(Parser *p); +static asdl_seq *_loop0_146_rule(Parser *p); static void *_tmp_147_rule(Parser *p); static void *_tmp_148_rule(Parser *p); static void *_tmp_149_rule(Parser *p); @@ -996,13 +1005,14 @@ static void *_tmp_170_rule(Parser *p); static void *_tmp_171_rule(Parser *p); static void *_tmp_172_rule(Parser *p); static void *_tmp_173_rule(Parser *p); -static asdl_seq *_loop0_174_rule(Parser *p); -static void *_tmp_175_rule(Parser *p); +static void *_tmp_174_rule(Parser *p); +static asdl_seq *_loop0_175_rule(Parser *p); static void *_tmp_176_rule(Parser *p); static void *_tmp_177_rule(Parser *p); static void *_tmp_178_rule(Parser *p); static void *_tmp_179_rule(Parser *p); static void *_tmp_180_rule(Parser *p); +static void *_tmp_181_rule(Parser *p); // file: statements? $ @@ -15331,6 +15341,7 @@ slice_rule(Parser *p) // | &'(' (genexp | tuple | group) // | &'[' (listcomp | list) // | &'{' (dictcomp | setcomp | dict | set) +// | &'f{' (frozendictcomp | frozensetcomp | frozendict | frozenset) // | '...' static expr_ty atom_rule(Parser *p) @@ -15574,6 +15585,27 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dictcomp | setcomp | dict | set)")); } + { // &'f{' (frozendictcomp | frozensetcomp | frozendict | frozenset) + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'f{' (frozendictcomp | frozensetcomp | frozendict | frozenset)")); + void *_tmp_71_var; + if ( + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 55) // token='f{' + && + (_tmp_71_var = _tmp_71_rule(p)) // frozendictcomp | frozensetcomp | frozendict | frozenset + ) + { + D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'f{' (frozendictcomp | frozensetcomp | frozendict | frozenset)")); + _res = _tmp_71_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'f{' (frozendictcomp | frozensetcomp | frozendict | frozenset)")); + } { // '...' if (p->error_indicator) { p->level--; @@ -15638,7 +15670,7 @@ group_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_71_rule(p)) // yield_expr | named_expression + (a = _tmp_72_rule(p)) // yield_expr | named_expression && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -15839,9 +15871,9 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default && - (b = (asdl_arg_seq*)_loop0_72_rule(p)) // lambda_param_no_default* + (b = (asdl_arg_seq*)_loop0_73_rule(p)) // lambda_param_no_default* && - (c = _loop0_73_rule(p)) // lambda_param_with_default* + (c = _loop0_74_rule(p)) // lambda_param_with_default* && (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15871,7 +15903,7 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default && - (b = _loop0_73_rule(p)) // lambda_param_with_default* + (b = _loop0_74_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15899,9 +15931,9 @@ lambda_parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_74_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_75_rule(p)) // lambda_param_no_default+ && - (b = _loop0_73_rule(p)) // lambda_param_with_default* + (b = _loop0_74_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15928,7 +15960,7 @@ lambda_parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_75_rule(p)) // lambda_param_with_default+ + (a = _loop1_76_rule(p)) // lambda_param_with_default+ && (b = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -16001,7 +16033,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_74_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_75_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -16030,7 +16062,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_74_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_75_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -16082,9 +16114,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_72_rule(p)) // lambda_param_no_default* + (a = _loop0_73_rule(p)) // lambda_param_no_default* && - (b = _loop1_75_rule(p)) // lambda_param_with_default+ + (b = _loop1_76_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -16114,9 +16146,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_72_rule(p)) // lambda_param_no_default* + (a = _loop0_73_rule(p)) // lambda_param_no_default* && - (b = _loop1_75_rule(p)) // lambda_param_with_default+ + (b = _loop1_76_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -16193,7 +16225,7 @@ lambda_star_etc_rule(Parser *p) && (a = lambda_param_no_default_rule(p)) // lambda_param_no_default && - (b = _loop0_76_rule(p)) // lambda_param_maybe_default* + (b = _loop0_77_rule(p)) // lambda_param_maybe_default* && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -16226,7 +16258,7 @@ lambda_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_77_rule(p)) // lambda_param_maybe_default+ + (b = _loop1_78_rule(p)) // lambda_param_maybe_default+ && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -16866,7 +16898,7 @@ fstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_78_rule(p)) // fstring_format_spec* + (spec = _loop0_79_rule(p)) // fstring_format_spec* ) { D(fprintf(stderr, "%*c+ fstring_full_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' fstring_format_spec*")); @@ -16984,7 +17016,7 @@ fstring_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START' && - (b = _loop0_79_rule(p)) // fstring_middle* + (b = _loop0_80_rule(p)) // fstring_middle* && (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' ) @@ -17200,7 +17232,7 @@ tstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_80_rule(p)) // tstring_format_spec* + (spec = _loop0_81_rule(p)) // tstring_format_spec* ) { D(fprintf(stderr, "%*c+ tstring_full_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' tstring_format_spec*")); @@ -17419,7 +17451,7 @@ tstring_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' && - (b = _loop0_81_rule(p)) // tstring_middle* + (b = _loop0_82_rule(p)) // tstring_middle* && (c = _PyPegen_expect_token(p, TSTRING_END)) // token='TSTRING_END' ) @@ -17540,7 +17572,7 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_82_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_83_rule(p)) // ((fstring | string))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); @@ -17573,7 +17605,7 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_83_rule(p)) // tstring+ + (a = (asdl_expr_seq*)_loop1_84_rule(p)) // tstring+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring+")); @@ -17706,7 +17738,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_84_rule(p), !p->error_indicator) // [star_named_expression_sequence ',' star_named_expressions_sequence?] + (a = _tmp_85_rule(p), !p->error_indicator) // [star_named_expression_sequence ',' star_named_expressions_sequence?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -17806,6 +17838,73 @@ set_rule(Parser *p) return _res; } +// frozenset: 'f{' star_named_expressions_sequence '}' +static expr_ty +frozenset_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'f{' star_named_expressions_sequence '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozenset[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{' star_named_expressions_sequence '}'")); + Token * _literal; + Token * _literal_1; + asdl_expr_seq* a; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + && + (a = star_named_expressions_sequence_rule(p)) // star_named_expressions_sequence + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ frozenset[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{' star_named_expressions_sequence '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_FrozenSet ( a , EXTRA ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozenset[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{' star_named_expressions_sequence '}'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}' static expr_ty dict_rule(Parser *p) @@ -17898,6 +17997,98 @@ dict_rule(Parser *p) return _res; } +// frozendict: 'f{' double_starred_kvpairs? '}' | 'f{' invalid_double_starred_kvpairs '}' +static expr_ty +frozendict_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'f{' double_starred_kvpairs? '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozendict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{' double_starred_kvpairs? '}'")); + Token * _literal; + Token * _literal_1; + void *a; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + && + (a = double_starred_kvpairs_rule(p), !p->error_indicator) // double_starred_kvpairs? + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ frozendict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{' double_starred_kvpairs? '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_FrozenDict ( CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_values ( p , a ) ) , EXTRA ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozendict[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{' double_starred_kvpairs? '}'")); + } + { // 'f{' invalid_double_starred_kvpairs '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozendict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{' invalid_double_starred_kvpairs '}'")); + Token * _literal; + Token * _literal_1; + void *invalid_double_starred_kvpairs_var; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + && + (invalid_double_starred_kvpairs_var = invalid_double_starred_kvpairs_rule(p)) // invalid_double_starred_kvpairs + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ frozendict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{' invalid_double_starred_kvpairs '}'")); + _res = _PyPegen_dummy_name(p, _literal, invalid_double_starred_kvpairs_var, _literal_1); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozendict[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{' invalid_double_starred_kvpairs '}'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // double_starred_kvpairs: ','.double_starred_kvpair+ ','? static asdl_seq* double_starred_kvpairs_rule(Parser *p) @@ -17921,7 +18112,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_86_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_87_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18080,7 +18271,7 @@ for_if_clauses_rule(Parser *p) D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); asdl_comprehension_seq* a; if ( - (a = (asdl_comprehension_seq*)_loop1_87_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_88_rule(p)) // for_if_clause+ ) { D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); @@ -18145,7 +18336,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_88_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_89_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); @@ -18188,7 +18379,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_88_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_89_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); @@ -18430,6 +18621,95 @@ setcomp_rule(Parser *p) return _res; } +// frozensetcomp: 'f{' star_named_expression for_if_clauses '}' | invalid_comprehension +static expr_ty +frozensetcomp_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'f{' star_named_expression for_if_clauses '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozensetcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{' star_named_expression for_if_clauses '}'")); + Token * _literal; + Token * _literal_1; + expr_ty a; + asdl_comprehension_seq* b; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + && + (a = star_named_expression_rule(p)) // star_named_expression + && + (b = for_if_clauses_rule(p)) // for_if_clauses + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ frozensetcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{' star_named_expression for_if_clauses '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_FrozenSetComp ( a , b , EXTRA ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozensetcomp[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{' star_named_expression for_if_clauses '}'")); + } + if (p->call_invalid_rules) { // invalid_comprehension + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozensetcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); + void *invalid_comprehension_var; + if ( + (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension + ) + { + D(fprintf(stderr, "%*c+ frozensetcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); + _res = invalid_comprehension_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozensetcomp[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // genexp: // | '(' (assignment_expression | expression !':=' | starred_expression) for_if_clauses ')' // | invalid_comprehension @@ -18467,7 +18747,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_89_rule(p)) // assignment_expression | expression !':=' | starred_expression + (a = _tmp_90_rule(p)) // assignment_expression | expression !':=' | starred_expression && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -18636,6 +18916,123 @@ dictcomp_rule(Parser *p) return _res; } +// frozendictcomp: +// | 'f{' kvpair for_if_clauses '}' +// | 'f{' '**' expression for_if_clauses '}' +static expr_ty +frozendictcomp_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'f{' kvpair for_if_clauses '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozendictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{' kvpair for_if_clauses '}'")); + Token * _literal; + Token * _literal_1; + KeyValuePair* a; + asdl_comprehension_seq* b; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + && + (a = kvpair_rule(p)) // kvpair + && + (b = for_if_clauses_rule(p)) // for_if_clauses + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ frozendictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{' kvpair for_if_clauses '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_FrozenDictComp ( a -> key , a -> value , b , EXTRA ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozendictcomp[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{' kvpair for_if_clauses '}'")); + } + { // 'f{' '**' expression for_if_clauses '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> frozendictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{' '**' expression for_if_clauses '}'")); + Token * _literal; + Token * _literal_1; + Token * _literal_2; + expr_ty a; + asdl_comprehension_seq* b; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + && + (_literal_1 = _PyPegen_expect_token(p, 35)) // token='**' + && + (a = expression_rule(p)) // expression + && + (b = for_if_clauses_rule(p)) // for_if_clauses + && + (_literal_2 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ frozendictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{' '**' expression for_if_clauses '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_FrozenDictComp ( a , NULL , b , EXTRA ); + if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s frozendictcomp[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{' '**' expression for_if_clauses '}'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // arguments: args ','? &')' | invalid_arguments static expr_ty arguments_rule(Parser *p) @@ -18742,9 +19139,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_91_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_92_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_92_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_93_rule(p), !p->error_indicator) // [',' kwargs] ) { D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); @@ -18834,11 +19231,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_94_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_95_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_96_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_97_rule(p)) // ','.kwarg_or_double_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); @@ -18860,13 +19257,13 @@ kwargs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); - asdl_seq * _gather_94_var; + asdl_seq * _gather_95_var; if ( - (_gather_94_var = _gather_94_rule(p)) // ','.kwarg_or_starred+ + (_gather_95_var = _gather_95_rule(p)) // ','.kwarg_or_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); - _res = _gather_94_var; + _res = _gather_95_var; goto done; } p->mark = _mark; @@ -18879,13 +19276,13 @@ kwargs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); - asdl_seq * _gather_96_var; + asdl_seq * _gather_97_var; if ( - (_gather_96_var = _gather_96_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_97_var = _gather_97_rule(p)) // ','.kwarg_or_double_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); - _res = _gather_96_var; + _res = _gather_97_var; goto done; } p->mark = _mark; @@ -19296,7 +19693,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_97_rule(p)) // ((',' star_target))* + (b = _loop0_98_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19352,7 +19749,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_99_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_100_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19402,7 +19799,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_100_rule(p)) // ((',' star_target))+ + (b = _loop1_101_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19490,7 +19887,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_101_rule(p)) // !'*' star_target + (a = _tmp_102_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); @@ -20413,7 +20810,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_103_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_104_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -20771,7 +21168,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_105_rule(p)) // ','.expression+ + (a = _gather_106_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20810,7 +21207,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_105_rule(p)) // ','.expression+ + (a = _gather_106_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20843,7 +21240,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_105_rule(p)) // ','.expression+ + (a = _gather_106_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20963,7 +21360,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_105_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_106_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); @@ -21014,7 +21411,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, _tmp_106_rule, p) + _PyPegen_lookahead(1, _tmp_107_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -21100,15 +21497,15 @@ invalid_arguments_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+")); - asdl_seq * _gather_109_var; - void *_tmp_107_var; + asdl_seq * _gather_110_var; + void *_tmp_108_var; Token * a; if ( - (_tmp_107_var = _tmp_107_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs + (_tmp_108_var = _tmp_108_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs && (a = _PyPegen_expect_token(p, 12)) // token=',' && - (_gather_109_var = _gather_109_rule(p)) // ','.(starred_expression !'=')+ + (_gather_110_var = _gather_110_rule(p)) // ','.(starred_expression !'=')+ ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+")); @@ -21142,7 +21539,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_110_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_111_rule(p), !p->error_indicator) // [args | expression for_if_clauses] ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); @@ -21202,13 +21599,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_111_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_112_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_112_rule, p) + _PyPegen_lookahead(1, _tmp_113_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); @@ -21346,7 +21743,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_113_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_114_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -21406,7 +21803,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, _tmp_114_rule, p) + _PyPegen_lookahead(0, _tmp_115_rule, p) && (a = expression_rule(p)) // expression && @@ -21754,7 +22151,7 @@ invalid_expression_rule(Parser *p) if ( (string_var = _PyPegen_string_token(p)) // STRING && - (a = _loop1_115_rule(p)) // ((!STRING expression_without_invalid))+ + (a = _loop1_116_rule(p)) // ((!STRING expression_without_invalid))+ && (string_var_1 = _PyPegen_string_token(p)) // STRING ) @@ -21781,7 +22178,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, _tmp_116_rule, p) + _PyPegen_lookahead(0, _tmp_117_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -21817,7 +22214,7 @@ invalid_expression_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, _tmp_117_rule, p) + _PyPegen_lookahead(0, _tmp_118_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); @@ -21880,7 +22277,7 @@ invalid_expression_rule(Parser *p) expr_ty b; stmt_ty c; if ( - (a = (stmt_ty)_tmp_118_rule(p)) // pass_stmt | break_stmt | continue_stmt + (a = (stmt_ty)_tmp_119_rule(p)) // pass_stmt | break_stmt | continue_stmt && (_keyword = _PyPegen_expect_token(p, 698)) // token='if' && @@ -22135,7 +22532,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_119_rule, p) + _PyPegen_lookahead(0, _tmp_120_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); @@ -22161,7 +22558,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, _tmp_120_rule, p) + _PyPegen_lookahead(0, _tmp_121_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -22169,7 +22566,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_119_rule, p) + _PyPegen_lookahead(0, _tmp_120_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')")); @@ -22249,7 +22646,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_121_var; + asdl_seq * _loop0_122_var; expr_ty a; expr_ty expression_var; if ( @@ -22257,7 +22654,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_121_var = _loop0_121_rule(p)) // star_named_expressions* + (_loop0_122_var = _loop0_122_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -22314,10 +22711,10 @@ invalid_assignment_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='")); Token * _literal; - asdl_seq * _loop0_122_var; + asdl_seq * _loop0_123_var; expr_ty a; if ( - (_loop0_122_var = _loop0_122_rule(p)) // ((star_targets '='))* + (_loop0_123_var = _loop0_123_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -22344,10 +22741,10 @@ invalid_assignment_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='")); Token * _literal; - asdl_seq * _loop0_122_var; + asdl_seq * _loop0_123_var; expr_ty a; if ( - (_loop0_122_var = _loop0_122_rule(p)) // ((star_targets '='))* + (_loop0_123_var = _loop0_123_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -22827,8 +23224,8 @@ invalid_block_rule(Parser *p) // invalid_comprehension: // | '[' '**' expression for_if_clauses // | '(' '**' expression for_if_clauses -// | ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses -// | ('[' | '{') star_named_expression ',' for_if_clauses +// | ('[' | '{' | 'f{') star_named_expression ',' star_named_expressions for_if_clauses +// | ('[' | '{' | 'f{') star_named_expression ',' for_if_clauses static void * invalid_comprehension_rule(Parser *p) { @@ -22907,19 +23304,19 @@ invalid_comprehension_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression for_if_clauses")); } - { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses + { // ('[' | '{' | 'f{') star_named_expression ',' star_named_expressions for_if_clauses if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); + D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{' | 'f{') star_named_expression ',' star_named_expressions for_if_clauses")); Token * _literal; - void *_tmp_123_var; + void *_tmp_124_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_123_var = _tmp_123_rule(p)) // '[' | '{' + (_tmp_124_var = _tmp_124_rule(p)) // '[' | '{' | 'f{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -22930,7 +23327,7 @@ invalid_comprehension_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); + D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{' | 'f{') star_named_expression ',' star_named_expressions for_if_clauses")); _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" ); if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -22941,20 +23338,20 @@ invalid_comprehension_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{' | 'f{') star_named_expression ',' star_named_expressions for_if_clauses")); } - { // ('[' | '{') star_named_expression ',' for_if_clauses + { // ('[' | '{' | 'f{') star_named_expression ',' for_if_clauses if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); - void *_tmp_123_var; + D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{' | 'f{') star_named_expression ',' for_if_clauses")); + void *_tmp_124_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_123_var = _tmp_123_rule(p)) // '[' | '{' + (_tmp_124_var = _tmp_124_rule(p)) // '[' | '{' | 'f{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -22963,7 +23360,7 @@ invalid_comprehension_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); + D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{' | 'f{') star_named_expression ',' for_if_clauses")); _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" ); if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -22974,7 +23371,7 @@ invalid_comprehension_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{' | 'f{') star_named_expression ',' for_if_clauses")); } _res = NULL; done: @@ -23035,10 +23432,10 @@ invalid_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); asdl_seq * _loop0_31_var; - void *_tmp_124_var; + void *_tmp_125_var; Token * a; if ( - (_tmp_124_var = _tmp_124_rule(p)) // slash_no_default | slash_with_default + (_tmp_125_var = _tmp_125_rule(p)) // slash_no_default | slash_with_default && (_loop0_31_var = _loop0_31_rule(p)) // param_maybe_default* && @@ -23140,16 +23537,16 @@ invalid_parameters_rule(Parser *p) asdl_seq * _loop0_31_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_125_var; + void *_tmp_126_var; Token * a; if ( - (_opt_var = _tmp_124_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_125_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && (_loop0_31_var = _loop0_31_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_125_var = _tmp_125_rule(p)) // ',' | param_no_default + (_tmp_126_var = _tmp_126_rule(p)) // ',' | param_no_default && (_loop0_31_var_1 = _loop0_31_rule(p)) // param_maybe_default* && @@ -23228,7 +23625,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_126_rule, p) + _PyPegen_lookahead(1, _tmp_127_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); @@ -23273,12 +23670,12 @@ invalid_star_etc_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); - void *_tmp_127_var; + void *_tmp_128_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_127_var = _tmp_127_rule(p)) // ')' | ',' (')' | '**') + (_tmp_128_var = _tmp_128_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); @@ -23362,19 +23759,19 @@ invalid_star_etc_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); Token * _literal; asdl_seq * _loop0_31_var; - void *_tmp_128_var; - void *_tmp_128_var_1; + void *_tmp_129_var; + void *_tmp_129_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_128_var = _tmp_128_rule(p)) // param_no_default | ',' + (_tmp_129_var = _tmp_129_rule(p)) // param_no_default | ',' && (_loop0_31_var = _loop0_31_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_128_var_1 = _tmp_128_rule(p)) // param_no_default | ',' + (_tmp_129_var_1 = _tmp_129_rule(p)) // param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); @@ -23489,7 +23886,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_129_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_130_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); @@ -23625,13 +24022,13 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); - asdl_seq * _loop0_76_var; - void *_tmp_130_var; + asdl_seq * _loop0_77_var; + void *_tmp_131_var; Token * a; if ( - (_tmp_130_var = _tmp_130_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_131_var = _tmp_131_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && - (_loop0_76_var = _loop0_76_rule(p)) // lambda_param_maybe_default* + (_loop0_77_var = _loop0_77_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -23655,7 +24052,7 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); - asdl_seq * _loop0_72_var; + asdl_seq * _loop0_73_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -23663,7 +24060,7 @@ invalid_lambda_parameters_rule(Parser *p) if ( (_opt_var = lambda_slash_no_default_rule(p), !p->error_indicator) // lambda_slash_no_default? && - (_loop0_72_var = _loop0_72_rule(p)) // lambda_param_no_default* + (_loop0_73_var = _loop0_73_rule(p)) // lambda_param_no_default* && (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper && @@ -23689,18 +24086,18 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_132_var; - asdl_seq * _loop0_72_var; + asdl_seq * _gather_133_var; + asdl_seq * _loop0_73_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_72_var = _loop0_72_rule(p)) // lambda_param_no_default* + (_loop0_73_var = _loop0_73_rule(p)) // lambda_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_132_var = _gather_132_rule(p)) // ','.lambda_param+ + (_gather_133_var = _gather_133_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23727,22 +24124,22 @@ invalid_lambda_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'")); Token * _literal; - asdl_seq * _loop0_76_var; - asdl_seq * _loop0_76_var_1; + asdl_seq * _loop0_77_var; + asdl_seq * _loop0_77_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_133_var; + void *_tmp_134_var; Token * a; if ( - (_opt_var = _tmp_130_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_131_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && - (_loop0_76_var = _loop0_76_rule(p)) // lambda_param_maybe_default* + (_loop0_77_var = _loop0_77_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_133_var = _tmp_133_rule(p)) // ',' | lambda_param_no_default + (_tmp_134_var = _tmp_134_rule(p)) // ',' | lambda_param_no_default && - (_loop0_76_var_1 = _loop0_76_rule(p)) // lambda_param_maybe_default* + (_loop0_77_var_1 = _loop0_77_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -23767,10 +24164,10 @@ invalid_lambda_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default+ '/' '*'")); Token * _literal; - asdl_seq * _loop1_77_var; + asdl_seq * _loop1_78_var; Token * a; if ( - (_loop1_77_var = _loop1_77_rule(p)) // lambda_param_maybe_default+ + (_loop1_78_var = _loop1_78_rule(p)) // lambda_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -23841,13 +24238,13 @@ invalid_lambda_parameters_helper_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); - asdl_seq * _loop1_75_var; + asdl_seq * _loop1_76_var; if ( - (_loop1_75_var = _loop1_75_rule(p)) // lambda_param_with_default+ + (_loop1_76_var = _loop1_76_rule(p)) // lambda_param_with_default+ ) { D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); - _res = _loop1_75_var; + _res = _loop1_76_var; goto done; } p->mark = _mark; @@ -23883,11 +24280,11 @@ invalid_lambda_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); Token * _literal; - void *_tmp_134_var; + void *_tmp_135_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_134_var = _tmp_134_rule(p)) // ':' | ',' (':' | '**') + (_tmp_135_var = _tmp_135_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); @@ -23940,20 +24337,20 @@ invalid_lambda_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); Token * _literal; - asdl_seq * _loop0_76_var; - void *_tmp_135_var; - void *_tmp_135_var_1; + asdl_seq * _loop0_77_var; + void *_tmp_136_var; + void *_tmp_136_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_135_var = _tmp_135_rule(p)) // lambda_param_no_default | ',' + (_tmp_136_var = _tmp_136_rule(p)) // lambda_param_no_default | ',' && - (_loop0_76_var = _loop0_76_rule(p)) // lambda_param_maybe_default* + (_loop0_77_var = _loop0_77_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_135_var_1 = _tmp_135_rule(p)) // lambda_param_no_default | ',' + (_tmp_136_var_1 = _tmp_136_rule(p)) // lambda_param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); @@ -24071,7 +24468,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_129_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_130_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -24221,13 +24618,13 @@ invalid_for_if_clause_rule(Parser *p) Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_136_var; + void *_tmp_137_var; if ( (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? && (_keyword = _PyPegen_expect_token(p, 710)) // token='for' && - (_tmp_136_var = _tmp_136_rule(p)) // bitwise_or ((',' bitwise_or))* ','? + (_tmp_137_var = _tmp_137_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 711) // token='in' ) @@ -24402,14 +24799,14 @@ invalid_import_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_import[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' ','.dotted_name+ 'from' dotted_name")); - asdl_seq * _gather_138_var; + asdl_seq * _gather_139_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( (a = _PyPegen_expect_token(p, 647)) // token='import' && - (_gather_138_var = _gather_138_rule(p)) // ','.dotted_name+ + (_gather_139_var = _gather_139_rule(p)) // ','.dotted_name+ && (_keyword = _PyPegen_expect_token(p, 646)) // token='from' && @@ -24489,7 +24886,7 @@ invalid_dotted_as_name_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 696)) // token='as' && - _PyPegen_lookahead(0, _tmp_139_rule, p) + _PyPegen_lookahead(0, _tmp_140_rule, p) && (a = expression_rule(p)) // expression ) @@ -24540,7 +24937,7 @@ invalid_import_from_as_name_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 696)) // token='as' && - _PyPegen_lookahead(0, _tmp_139_rule, p) + _PyPegen_lookahead(0, _tmp_140_rule, p) && (a = expression_rule(p)) // expression ) @@ -24659,7 +25056,7 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ ',' ':'")); - asdl_seq * _gather_141_var; + asdl_seq * _gather_142_var; Token * _keyword; Token * _literal; void *_opt_var; @@ -24670,7 +25067,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 663)) // token='with' && - (_gather_141_var = _gather_141_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_142_var = _gather_142_rule(p)) // ','.(expression ['as' star_target])+ && (trailing = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24696,7 +25093,7 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE")); - asdl_seq * _gather_141_var; + asdl_seq * _gather_142_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -24706,7 +25103,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 663)) // token='with' && - (_gather_141_var = _gather_141_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_142_var = _gather_142_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -24730,7 +25127,7 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE")); - asdl_seq * _gather_143_var; + asdl_seq * _gather_144_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -24746,7 +25143,7 @@ invalid_with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_143_var = _gather_143_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_144_var = _gather_144_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -24795,7 +25192,7 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); - asdl_seq * _gather_141_var; + asdl_seq * _gather_142_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -24806,7 +25203,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (a = _PyPegen_expect_token(p, 663)) // token='with' && - (_gather_141_var = _gather_141_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_142_var = _gather_142_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -24834,7 +25231,7 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT")); - asdl_seq * _gather_143_var; + asdl_seq * _gather_144_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -24851,7 +25248,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_143_var = _gather_143_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_144_var = _gather_144_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -24948,7 +25345,7 @@ invalid_try_stmt_rule(Parser *p) && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, _tmp_144_rule, p) + _PyPegen_lookahead(0, _tmp_145_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); @@ -24973,7 +25370,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_145_var; + asdl_seq * _loop0_146_var; asdl_seq * _loop1_36_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -24985,7 +25382,7 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_145_var = _loop0_145_rule(p)) // block* + (_loop0_146_var = _loop0_146_rule(p)) // block* && (_loop1_36_var = _loop1_36_rule(p)) // except_block+ && @@ -25022,7 +25419,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_145_var; + asdl_seq * _loop0_146_var; asdl_seq * _loop1_37_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -25032,13 +25429,13 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_145_var = _loop0_145_rule(p)) // block* + (_loop0_146_var = _loop0_146_rule(p)) // block* && (_loop1_37_var = _loop1_37_rule(p)) // except_star_block+ && (a = _PyPegen_expect_token(p, 693)) // token='except' && - (_opt_var = _tmp_146_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_147_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -25333,14 +25730,14 @@ invalid_except_star_stmt_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_except_star_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); Token * _literal; - void *_tmp_147_var; + void *_tmp_148_var; Token * a; if ( (a = _PyPegen_expect_token(p, 693)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_147_var = _tmp_147_rule(p)) // NEWLINE | ':' + (_tmp_148_var = _tmp_148_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_star_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); @@ -25987,7 +26384,7 @@ invalid_mapping_pattern_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_opt_var = _tmp_148_rule(p), !p->error_indicator) // [(items_pattern ',')] + (_opt_var = _tmp_149_rule(p), !p->error_indicator) // [(items_pattern ',')] && (rest = double_star_pattern_rule(p)) // double_star_pattern && @@ -26045,7 +26442,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_149_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_150_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -26800,19 +27197,19 @@ invalid_double_starred_kvpairs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)")); - asdl_seq * _gather_86_var; + asdl_seq * _gather_87_var; Token * _literal; - void *_tmp_150_var; + void *_tmp_151_var; if ( - (_gather_86_var = _gather_86_rule(p)) // ','.double_starred_kvpair+ + (_gather_87_var = _gather_87_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_150_var = _tmp_150_rule(p)) // invalid_kvpair | invalid_kvpair_unpacking + (_tmp_151_var = _tmp_151_rule(p)) // invalid_kvpair | invalid_kvpair_unpacking ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)")); - _res = _PyPegen_dummy_name(p, _gather_86_var, _literal, _tmp_150_var); + _res = _PyPegen_dummy_name(p, _gather_87_var, _literal, _tmp_151_var); goto done; } p->mark = _mark; @@ -26832,7 +27229,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_151_rule, p) + _PyPegen_lookahead(1, _tmp_152_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -27159,7 +27556,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_151_rule, p) + _PyPegen_lookahead(1, _tmp_152_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -27541,7 +27938,7 @@ invalid_fstring_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, _tmp_152_rule, p) + _PyPegen_lookahead(0, _tmp_153_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); @@ -27573,7 +27970,7 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_153_rule, p) + _PyPegen_lookahead(0, _tmp_154_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); @@ -27637,9 +28034,9 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_155_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_155_rule, p) + _PyPegen_lookahead(0, _tmp_156_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); @@ -27663,7 +28060,7 @@ invalid_fstring_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_78_var; + asdl_seq * _loop0_79_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; @@ -27676,11 +28073,11 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_155_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_78_var = _loop0_78_rule(p)) // fstring_format_spec* + (_loop0_79_var = _loop0_79_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -27717,7 +28114,7 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_155_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -27764,7 +28161,7 @@ invalid_fstring_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_155_rule, p) + _PyPegen_lookahead(1, _tmp_156_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); @@ -27983,7 +28380,7 @@ invalid_tstring_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, _tmp_152_rule, p) + _PyPegen_lookahead(0, _tmp_153_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); @@ -28015,7 +28412,7 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_153_rule, p) + _PyPegen_lookahead(0, _tmp_154_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); @@ -28079,9 +28476,9 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_155_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_155_rule, p) + _PyPegen_lookahead(0, _tmp_156_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); @@ -28105,7 +28502,7 @@ invalid_tstring_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_78_var; + asdl_seq * _loop0_79_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; @@ -28118,11 +28515,11 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_155_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_78_var = _loop0_78_rule(p)) // fstring_format_spec* + (_loop0_79_var = _loop0_79_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -28159,7 +28556,7 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_155_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -28206,7 +28603,7 @@ invalid_tstring_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_155_rule, p) + _PyPegen_lookahead(1, _tmp_156_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); @@ -28278,7 +28675,7 @@ invalid_string_tstring_concat_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _loop1_82_rule(p)) // ((fstring | string))+ + (a = _loop1_83_rule(p)) // ((fstring | string))+ && (b = (expr_ty)tstring_rule(p)) // tstring ) @@ -28305,9 +28702,9 @@ invalid_string_tstring_concat_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _loop1_83_rule(p)) // tstring+ + (a = _loop1_84_rule(p)) // tstring+ && - (b = (expr_ty)_tmp_156_rule(p)) // fstring | string + (b = (expr_ty)_tmp_157_rule(p)) // fstring | string ) { D(fprintf(stderr, "%*c+ invalid_string_tstring_concat[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring+ (fstring | string)")); @@ -28348,14 +28745,14 @@ invalid_arithmetic_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_arithmetic[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion")); - void *_tmp_157_var; + void *_tmp_158_var; Token * a; expr_ty b; expr_ty sum_var; if ( (sum_var = sum_rule(p)) // sum && - (_tmp_157_var = _tmp_157_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' + (_tmp_158_var = _tmp_158_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && (a = _PyPegen_expect_token(p, 719)) // token='not' && @@ -28400,11 +28797,11 @@ invalid_factor_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('+' | '-' | '~') 'not' factor")); - void *_tmp_158_var; + void *_tmp_159_var; Token * a; expr_ty b; if ( - (_tmp_158_var = _tmp_158_rule(p)) // '+' | '-' | '~' + (_tmp_159_var = _tmp_159_rule(p)) // '+' | '-' | '~' && (a = _PyPegen_expect_token(p, 719)) // token='not' && @@ -29297,12 +29694,12 @@ _loop1_12_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_159_var; + void *_tmp_160_var; while ( - (_tmp_159_var = _tmp_159_rule(p)) // star_targets '=' + (_tmp_160_var = _tmp_160_rule(p)) // star_targets '=' ) { - _res = _tmp_159_var; + _res = _tmp_160_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29589,12 +29986,12 @@ _loop0_17_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_160_var; + void *_tmp_161_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // '.' | '...' + (_tmp_161_var = _tmp_161_rule(p)) // '.' | '...' ) { - _res = _tmp_160_var; + _res = _tmp_161_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29656,12 +30053,12 @@ _loop1_18_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_160_var; + void *_tmp_161_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // '.' | '...' + (_tmp_161_var = _tmp_161_rule(p)) // '.' | '...' ) { - _res = _tmp_160_var; + _res = _tmp_161_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30008,12 +30405,12 @@ _loop1_24_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); - void *_tmp_161_var; + void *_tmp_162_var; while ( - (_tmp_161_var = _tmp_161_rule(p)) // '@' named_expression NEWLINE + (_tmp_162_var = _tmp_162_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_161_var; + _res = _tmp_162_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32041,12 +32438,12 @@ _loop1_56_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); - void *_tmp_162_var; + void *_tmp_163_var; while ( - (_tmp_162_var = _tmp_162_rule(p)) // ',' star_expression + (_tmp_163_var = _tmp_163_rule(p)) // ',' star_expression ) { - _res = _tmp_162_var; + _res = _tmp_163_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32347,12 +32744,12 @@ _loop1_61_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); - void *_tmp_163_var; + void *_tmp_164_var; while ( - (_tmp_163_var = _tmp_163_rule(p)) // 'or' conjunction + (_tmp_164_var = _tmp_164_rule(p)) // 'or' conjunction ) { - _res = _tmp_163_var; + _res = _tmp_164_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32419,12 +32816,12 @@ _loop1_62_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); - void *_tmp_164_var; + void *_tmp_165_var; while ( - (_tmp_164_var = _tmp_164_rule(p)) // 'and' inversion + (_tmp_165_var = _tmp_165_rule(p)) // 'and' inversion ) { - _res = _tmp_164_var; + _res = _tmp_165_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32611,7 +33008,7 @@ _loop0_65_rule(Parser *p) while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_165_rule(p)) // slice | starred_expression + (elem = _tmp_166_rule(p)) // slice | starred_expression ) { _res = elem; @@ -32676,7 +33073,7 @@ _gather_66_rule(Parser *p) void *elem; asdl_seq * seq; if ( - (elem = _tmp_165_rule(p)) // slice | starred_expression + (elem = _tmp_166_rule(p)) // slice | starred_expression && (seq = _loop0_65_rule(p)) // _loop0_65 ) @@ -32969,9 +33366,104 @@ _tmp_70_rule(Parser *p) return _res; } -// _tmp_71: yield_expr | named_expression +// _tmp_71: frozendictcomp | frozensetcomp | frozendict | frozenset static void * _tmp_71_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // frozendictcomp + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "frozendictcomp")); + expr_ty frozendictcomp_var; + if ( + (frozendictcomp_var = frozendictcomp_rule(p)) // frozendictcomp + ) + { + D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "frozendictcomp")); + _res = frozendictcomp_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "frozendictcomp")); + } + { // frozensetcomp + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "frozensetcomp")); + expr_ty frozensetcomp_var; + if ( + (frozensetcomp_var = frozensetcomp_rule(p)) // frozensetcomp + ) + { + D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "frozensetcomp")); + _res = frozensetcomp_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "frozensetcomp")); + } + { // frozendict + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "frozendict")); + expr_ty frozendict_var; + if ( + (frozendict_var = frozendict_rule(p)) // frozendict + ) + { + D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "frozendict")); + _res = frozendict_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "frozendict")); + } + { // frozenset + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "frozenset")); + expr_ty frozenset_var; + if ( + (frozenset_var = frozenset_rule(p)) // frozenset + ) + { + D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "frozenset")); + _res = frozenset_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "frozenset")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_72: yield_expr | named_expression +static void * +_tmp_72_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32987,18 +33479,18 @@ _tmp_71_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_72[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_72[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); } { // named_expression @@ -33006,18 +33498,18 @@ _tmp_71_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); + D(fprintf(stderr, "%*c> _tmp_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); expr_ty named_expression_var; if ( (named_expression_var = named_expression_rule(p)) // named_expression ) { - D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); + D(fprintf(stderr, "%*c+ _tmp_72[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); _res = named_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_72[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); } _res = NULL; @@ -33026,9 +33518,9 @@ _tmp_71_rule(Parser *p) return _res; } -// _loop0_72: lambda_param_no_default +// _loop0_73: lambda_param_no_default static asdl_seq * -_loop0_72_rule(Parser *p) +_loop0_73_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33053,7 +33545,7 @@ _loop0_72_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -33076,7 +33568,7 @@ _loop0_72_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_73[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33093,9 +33585,9 @@ _loop0_72_rule(Parser *p) return _seq; } -// _loop0_73: lambda_param_with_default +// _loop0_74: lambda_param_with_default static asdl_seq * -_loop0_73_rule(Parser *p) +_loop0_74_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33120,7 +33612,7 @@ _loop0_73_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -33143,7 +33635,7 @@ _loop0_73_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_73[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33160,9 +33652,9 @@ _loop0_73_rule(Parser *p) return _seq; } -// _loop1_74: lambda_param_no_default +// _loop1_75: lambda_param_no_default static asdl_seq * -_loop1_74_rule(Parser *p) +_loop1_75_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33187,7 +33679,7 @@ _loop1_74_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -33210,7 +33702,7 @@ _loop1_74_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_74[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_75[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -33232,9 +33724,9 @@ _loop1_74_rule(Parser *p) return _seq; } -// _loop1_75: lambda_param_with_default +// _loop1_76: lambda_param_with_default static asdl_seq * -_loop1_75_rule(Parser *p) +_loop1_76_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33259,7 +33751,7 @@ _loop1_75_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -33282,7 +33774,7 @@ _loop1_75_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_75[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_76[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -33304,9 +33796,9 @@ _loop1_75_rule(Parser *p) return _seq; } -// _loop0_76: lambda_param_maybe_default +// _loop0_77: lambda_param_maybe_default static asdl_seq * -_loop0_76_rule(Parser *p) +_loop0_77_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33331,7 +33823,7 @@ _loop0_76_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -33354,7 +33846,7 @@ _loop0_76_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_76[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_77[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33371,9 +33863,9 @@ _loop0_76_rule(Parser *p) return _seq; } -// _loop1_77: lambda_param_maybe_default +// _loop1_78: lambda_param_maybe_default static asdl_seq * -_loop1_77_rule(Parser *p) +_loop1_78_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33398,7 +33890,7 @@ _loop1_77_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -33421,7 +33913,7 @@ _loop1_77_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_77[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_78[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -33443,9 +33935,9 @@ _loop1_77_rule(Parser *p) return _seq; } -// _loop0_78: fstring_format_spec +// _loop0_79: fstring_format_spec static asdl_seq * -_loop0_78_rule(Parser *p) +_loop0_79_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33470,7 +33962,7 @@ _loop0_78_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec")); expr_ty fstring_format_spec_var; while ( (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec @@ -33493,7 +33985,7 @@ _loop0_78_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_78[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33510,9 +34002,9 @@ _loop0_78_rule(Parser *p) return _seq; } -// _loop0_79: fstring_middle +// _loop0_80: fstring_middle static asdl_seq * -_loop0_79_rule(Parser *p) +_loop0_80_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33537,7 +34029,7 @@ _loop0_79_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle")); + D(fprintf(stderr, "%*c> _loop0_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle")); expr_ty fstring_middle_var; while ( (fstring_middle_var = fstring_middle_rule(p)) // fstring_middle @@ -33560,7 +34052,7 @@ _loop0_79_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_80[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_middle")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33577,9 +34069,9 @@ _loop0_79_rule(Parser *p) return _seq; } -// _loop0_80: tstring_format_spec +// _loop0_81: tstring_format_spec static asdl_seq * -_loop0_80_rule(Parser *p) +_loop0_81_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33604,7 +34096,7 @@ _loop0_80_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec")); expr_ty tstring_format_spec_var; while ( (tstring_format_spec_var = tstring_format_spec_rule(p)) // tstring_format_spec @@ -33627,7 +34119,7 @@ _loop0_80_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_80[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_81[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33644,9 +34136,9 @@ _loop0_80_rule(Parser *p) return _seq; } -// _loop0_81: tstring_middle +// _loop0_82: tstring_middle static asdl_seq * -_loop0_81_rule(Parser *p) +_loop0_82_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33671,7 +34163,7 @@ _loop0_81_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); + D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); expr_ty tstring_middle_var; while ( (tstring_middle_var = tstring_middle_rule(p)) // tstring_middle @@ -33694,7 +34186,7 @@ _loop0_81_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_81[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_82[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_middle")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33711,9 +34203,9 @@ _loop0_81_rule(Parser *p) return _seq; } -// _loop1_82: (fstring | string) +// _loop1_83: (fstring | string) static asdl_seq * -_loop1_82_rule(Parser *p) +_loop1_83_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33738,13 +34230,13 @@ _loop1_82_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); - void *_tmp_156_var; + D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); + void *_tmp_157_var; while ( - (_tmp_156_var = _tmp_156_rule(p)) // fstring | string + (_tmp_157_var = _tmp_157_rule(p)) // fstring | string ) { - _res = _tmp_156_var; + _res = _tmp_157_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33761,7 +34253,7 @@ _loop1_82_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_82[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)")); } if (_n == 0 || p->error_indicator) { @@ -33783,9 +34275,9 @@ _loop1_82_rule(Parser *p) return _seq; } -// _loop1_83: tstring +// _loop1_84: tstring static asdl_seq * -_loop1_83_rule(Parser *p) +_loop1_84_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33810,7 +34302,7 @@ _loop1_83_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); + D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); expr_ty tstring_var; while ( (tstring_var = tstring_rule(p)) // tstring @@ -33833,7 +34325,7 @@ _loop1_83_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_84[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring")); } if (_n == 0 || p->error_indicator) { @@ -33855,9 +34347,9 @@ _loop1_83_rule(Parser *p) return _seq; } -// _tmp_84: star_named_expression_sequence ',' star_named_expressions_sequence? +// _tmp_85: star_named_expression_sequence ',' star_named_expressions_sequence? static void * -_tmp_84_rule(Parser *p) +_tmp_85_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33873,7 +34365,7 @@ _tmp_84_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); + D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); Token * _literal; expr_ty y; void *z; @@ -33885,7 +34377,7 @@ _tmp_84_rule(Parser *p) (z = star_named_expressions_sequence_rule(p), !p->error_indicator) // star_named_expressions_sequence? ) { - D(fprintf(stderr, "%*c+ _tmp_84[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); + D(fprintf(stderr, "%*c+ _tmp_85[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); _res = _PyPegen_seq_insert_in_front ( p , y , z ); if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -33895,7 +34387,7 @@ _tmp_84_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_84[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_85[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); } _res = NULL; @@ -33904,9 +34396,9 @@ _tmp_84_rule(Parser *p) return _res; } -// _loop0_85: ',' double_starred_kvpair +// _loop0_86: ',' double_starred_kvpair static asdl_seq * -_loop0_85_rule(Parser *p) +_loop0_86_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33931,7 +34423,7 @@ _loop0_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -33963,7 +34455,7 @@ _loop0_85_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_85[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_86[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33980,9 +34472,9 @@ _loop0_85_rule(Parser *p) return _seq; } -// _gather_86: double_starred_kvpair _loop0_85 +// _gather_87: double_starred_kvpair _loop0_86 static asdl_seq * -_gather_86_rule(Parser *p) +_gather_87_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33993,27 +34485,27 @@ _gather_86_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_85 + { // double_starred_kvpair _loop0_86 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_85")); + D(fprintf(stderr, "%*c> _gather_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_86")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_85_rule(p)) // _loop0_85 + (seq = _loop0_86_rule(p)) // _loop0_86 ) { - D(fprintf(stderr, "%*c+ _gather_86[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_85")); + D(fprintf(stderr, "%*c+ _gather_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_86")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_86[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_85")); + D(fprintf(stderr, "%*c%s _gather_87[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_86")); } _res = NULL; done: @@ -34021,9 +34513,9 @@ _gather_86_rule(Parser *p) return _res; } -// _loop1_87: for_if_clause +// _loop1_88: for_if_clause static asdl_seq * -_loop1_87_rule(Parser *p) +_loop1_88_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34048,7 +34540,7 @@ _loop1_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); comprehension_ty for_if_clause_var; while ( (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause @@ -34071,7 +34563,7 @@ _loop1_87_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_87[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_88[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); } if (_n == 0 || p->error_indicator) { @@ -34093,9 +34585,9 @@ _loop1_87_rule(Parser *p) return _seq; } -// _loop0_88: ('if' disjunction) +// _loop0_89: ('if' disjunction) static asdl_seq * -_loop0_88_rule(Parser *p) +_loop0_89_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34120,13 +34612,13 @@ _loop0_88_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); - void *_tmp_166_var; + D(fprintf(stderr, "%*c> _loop0_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + void *_tmp_167_var; while ( - (_tmp_166_var = _tmp_166_rule(p)) // 'if' disjunction + (_tmp_167_var = _tmp_167_rule(p)) // 'if' disjunction ) { - _res = _tmp_166_var; + _res = _tmp_167_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34143,7 +34635,7 @@ _loop0_88_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_88[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34160,9 +34652,9 @@ _loop0_88_rule(Parser *p) return _seq; } -// _tmp_89: assignment_expression | expression !':=' | starred_expression +// _tmp_90: assignment_expression | expression !':=' | starred_expression static void * -_tmp_89_rule(Parser *p) +_tmp_90_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34178,18 +34670,18 @@ _tmp_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); expr_ty assignment_expression_var; if ( (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); _res = assignment_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_90[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } { // expression !':=' @@ -34197,7 +34689,7 @@ _tmp_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -34205,12 +34697,12 @@ _tmp_89_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_90[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } { // starred_expression @@ -34218,18 +34710,18 @@ _tmp_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_90[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } _res = NULL; @@ -34238,9 +34730,9 @@ _tmp_89_rule(Parser *p) return _res; } -// _loop0_90: ',' (starred_expression | (assignment_expression | expression !':=') !'=') +// _loop0_91: ',' (starred_expression | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_90_rule(Parser *p) +_loop0_91_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34265,13 +34757,13 @@ _loop0_90_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_167_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_168_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -34297,7 +34789,7 @@ _loop0_90_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_90[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_91[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34314,10 +34806,10 @@ _loop0_90_rule(Parser *p) return _seq; } -// _gather_91: -// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90 +// _gather_92: +// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_91 static asdl_seq * -_gather_91_rule(Parser *p) +_gather_92_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34328,27 +34820,27 @@ _gather_91_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90 + { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_91 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90")); + D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_91")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_167_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_168_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_90_rule(p)) // _loop0_90 + (seq = _loop0_91_rule(p)) // _loop0_91 ) { - D(fprintf(stderr, "%*c+ _gather_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90")); + D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_91")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_91[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90")); + D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_91")); } _res = NULL; done: @@ -34356,9 +34848,9 @@ _gather_91_rule(Parser *p) return _res; } -// _tmp_92: ',' kwargs +// _tmp_93: ',' kwargs static void * -_tmp_92_rule(Parser *p) +_tmp_93_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34374,7 +34866,7 @@ _tmp_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -34383,7 +34875,7 @@ _tmp_92_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); _res = k; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -34393,7 +34885,7 @@ _tmp_92_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); } _res = NULL; @@ -34402,9 +34894,9 @@ _tmp_92_rule(Parser *p) return _res; } -// _loop0_93: ',' kwarg_or_starred +// _loop0_94: ',' kwarg_or_starred static asdl_seq * -_loop0_93_rule(Parser *p) +_loop0_94_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34429,7 +34921,7 @@ _loop0_93_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -34461,7 +34953,7 @@ _loop0_93_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_93[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_94[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34478,9 +34970,9 @@ _loop0_93_rule(Parser *p) return _seq; } -// _gather_94: kwarg_or_starred _loop0_93 +// _gather_95: kwarg_or_starred _loop0_94 static asdl_seq * -_gather_94_rule(Parser *p) +_gather_95_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34491,27 +34983,27 @@ _gather_94_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_93 + { // kwarg_or_starred _loop0_94 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_93")); + D(fprintf(stderr, "%*c> _gather_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_94")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_93_rule(p)) // _loop0_93 + (seq = _loop0_94_rule(p)) // _loop0_94 ) { - D(fprintf(stderr, "%*c+ _gather_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_93")); + D(fprintf(stderr, "%*c+ _gather_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_94")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_94[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_93")); + D(fprintf(stderr, "%*c%s _gather_95[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_94")); } _res = NULL; done: @@ -34519,9 +35011,9 @@ _gather_94_rule(Parser *p) return _res; } -// _loop0_95: ',' kwarg_or_double_starred +// _loop0_96: ',' kwarg_or_double_starred static asdl_seq * -_loop0_95_rule(Parser *p) +_loop0_96_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34546,7 +35038,7 @@ _loop0_95_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -34578,7 +35070,7 @@ _loop0_95_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_95[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_96[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34595,9 +35087,9 @@ _loop0_95_rule(Parser *p) return _seq; } -// _gather_96: kwarg_or_double_starred _loop0_95 +// _gather_97: kwarg_or_double_starred _loop0_96 static asdl_seq * -_gather_96_rule(Parser *p) +_gather_97_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34608,27 +35100,27 @@ _gather_96_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_95 + { // kwarg_or_double_starred _loop0_96 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_95")); + D(fprintf(stderr, "%*c> _gather_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_96")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_95_rule(p)) // _loop0_95 + (seq = _loop0_96_rule(p)) // _loop0_96 ) { - D(fprintf(stderr, "%*c+ _gather_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_95")); + D(fprintf(stderr, "%*c+ _gather_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_96")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_96[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_95")); + D(fprintf(stderr, "%*c%s _gather_97[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_96")); } _res = NULL; done: @@ -34636,9 +35128,9 @@ _gather_96_rule(Parser *p) return _res; } -// _loop0_97: (',' star_target) +// _loop0_98: (',' star_target) static asdl_seq * -_loop0_97_rule(Parser *p) +_loop0_98_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34663,13 +35155,13 @@ _loop0_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_168_var; + D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_169_var; while ( - (_tmp_168_var = _tmp_168_rule(p)) // ',' star_target + (_tmp_169_var = _tmp_169_rule(p)) // ',' star_target ) { - _res = _tmp_168_var; + _res = _tmp_169_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34686,7 +35178,7 @@ _loop0_97_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_97[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_98[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34703,9 +35195,9 @@ _loop0_97_rule(Parser *p) return _seq; } -// _loop0_98: ',' star_target +// _loop0_99: ',' star_target static asdl_seq * -_loop0_98_rule(Parser *p) +_loop0_99_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34730,7 +35222,7 @@ _loop0_98_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -34762,7 +35254,7 @@ _loop0_98_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_98[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_99[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34779,9 +35271,9 @@ _loop0_98_rule(Parser *p) return _seq; } -// _gather_99: star_target _loop0_98 +// _gather_100: star_target _loop0_99 static asdl_seq * -_gather_99_rule(Parser *p) +_gather_100_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34792,27 +35284,27 @@ _gather_99_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_98 + { // star_target _loop0_99 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_98")); + D(fprintf(stderr, "%*c> _gather_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_99")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_98_rule(p)) // _loop0_98 + (seq = _loop0_99_rule(p)) // _loop0_99 ) { - D(fprintf(stderr, "%*c+ _gather_99[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_98")); + D(fprintf(stderr, "%*c+ _gather_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_99")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_99[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_98")); + D(fprintf(stderr, "%*c%s _gather_100[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_99")); } _res = NULL; done: @@ -34820,9 +35312,9 @@ _gather_99_rule(Parser *p) return _res; } -// _loop1_100: (',' star_target) +// _loop1_101: (',' star_target) static asdl_seq * -_loop1_100_rule(Parser *p) +_loop1_101_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34847,13 +35339,13 @@ _loop1_100_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_168_var; + D(fprintf(stderr, "%*c> _loop1_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_169_var; while ( - (_tmp_168_var = _tmp_168_rule(p)) // ',' star_target + (_tmp_169_var = _tmp_169_rule(p)) // ',' star_target ) { - _res = _tmp_168_var; + _res = _tmp_169_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34870,7 +35362,7 @@ _loop1_100_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_100[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_101[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -34892,9 +35384,9 @@ _loop1_100_rule(Parser *p) return _seq; } -// _tmp_101: !'*' star_target +// _tmp_102: !'*' star_target static void * -_tmp_101_rule(Parser *p) +_tmp_102_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34910,7 +35402,7 @@ _tmp_101_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); expr_ty star_target_var; if ( _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*' @@ -34918,12 +35410,12 @@ _tmp_101_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); _res = star_target_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_101[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_102[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); } _res = NULL; @@ -34932,9 +35424,9 @@ _tmp_101_rule(Parser *p) return _res; } -// _loop0_102: ',' del_target +// _loop0_103: ',' del_target static asdl_seq * -_loop0_102_rule(Parser *p) +_loop0_103_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34959,7 +35451,7 @@ _loop0_102_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -34991,7 +35483,7 @@ _loop0_102_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_103[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35008,9 +35500,9 @@ _loop0_102_rule(Parser *p) return _seq; } -// _gather_103: del_target _loop0_102 +// _gather_104: del_target _loop0_103 static asdl_seq * -_gather_103_rule(Parser *p) +_gather_104_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35021,27 +35513,27 @@ _gather_103_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_102 + { // del_target _loop0_103 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_102")); + D(fprintf(stderr, "%*c> _gather_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_103")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_102_rule(p)) // _loop0_102 + (seq = _loop0_103_rule(p)) // _loop0_103 ) { - D(fprintf(stderr, "%*c+ _gather_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_102")); + D(fprintf(stderr, "%*c+ _gather_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_103")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_103[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_102")); + D(fprintf(stderr, "%*c%s _gather_104[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_103")); } _res = NULL; done: @@ -35049,9 +35541,9 @@ _gather_103_rule(Parser *p) return _res; } -// _loop0_104: ',' expression +// _loop0_105: ',' expression static asdl_seq * -_loop0_104_rule(Parser *p) +_loop0_105_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35076,7 +35568,7 @@ _loop0_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -35108,7 +35600,7 @@ _loop0_104_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_104[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35125,9 +35617,9 @@ _loop0_104_rule(Parser *p) return _seq; } -// _gather_105: expression _loop0_104 +// _gather_106: expression _loop0_105 static asdl_seq * -_gather_105_rule(Parser *p) +_gather_106_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35138,27 +35630,27 @@ _gather_105_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_104 + { // expression _loop0_105 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_104")); + D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_105")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_104_rule(p)) // _loop0_104 + (seq = _loop0_105_rule(p)) // _loop0_105 ) { - D(fprintf(stderr, "%*c+ _gather_105[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_104")); + D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_105")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_105[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_104")); + D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_105")); } _res = NULL; done: @@ -35166,9 +35658,9 @@ _gather_105_rule(Parser *p) return _res; } -// _tmp_106: NEWLINE INDENT +// _tmp_107: NEWLINE INDENT static void * -_tmp_106_rule(Parser *p) +_tmp_107_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35184,7 +35676,7 @@ _tmp_106_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -35193,12 +35685,12 @@ _tmp_106_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); _res = _PyPegen_dummy_name(p, newline_var, indent_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_106[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_107[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); } _res = NULL; @@ -35207,11 +35699,11 @@ _tmp_106_rule(Parser *p) return _res; } -// _tmp_107: +// _tmp_108: // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) // | kwargs static void * -_tmp_107_rule(Parser *p) +_tmp_108_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35227,18 +35719,18 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - void *_tmp_169_var; + D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + void *_tmp_170_var; if ( - (_tmp_169_var = _tmp_169_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs + (_tmp_170_var = _tmp_170_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - _res = _tmp_169_var; + D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + _res = _tmp_170_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_107[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } { // kwargs @@ -35246,18 +35738,18 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); asdl_seq* kwargs_var; if ( (kwargs_var = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); _res = kwargs_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_107[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); } _res = NULL; @@ -35266,9 +35758,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _loop0_108: ',' (starred_expression !'=') +// _loop0_109: ',' (starred_expression !'=') static asdl_seq * -_loop0_108_rule(Parser *p) +_loop0_109_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35293,13 +35785,13 @@ _loop0_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); + D(fprintf(stderr, "%*c> _loop0_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_170_rule(p)) // starred_expression !'=' + (elem = _tmp_171_rule(p)) // starred_expression !'=' ) { _res = elem; @@ -35325,7 +35817,7 @@ _loop0_108_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35342,9 +35834,9 @@ _loop0_108_rule(Parser *p) return _seq; } -// _gather_109: (starred_expression !'=') _loop0_108 +// _gather_110: (starred_expression !'=') _loop0_109 static asdl_seq * -_gather_109_rule(Parser *p) +_gather_110_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35355,27 +35847,27 @@ _gather_109_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression !'=') _loop0_108 + { // (starred_expression !'=') _loop0_109 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_108")); + D(fprintf(stderr, "%*c> _gather_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_109")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_170_rule(p)) // starred_expression !'=' + (elem = _tmp_171_rule(p)) // starred_expression !'=' && - (seq = _loop0_108_rule(p)) // _loop0_108 + (seq = _loop0_109_rule(p)) // _loop0_109 ) { - D(fprintf(stderr, "%*c+ _gather_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_108")); + D(fprintf(stderr, "%*c+ _gather_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_109")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_109[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_108")); + D(fprintf(stderr, "%*c%s _gather_110[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_109")); } _res = NULL; done: @@ -35383,9 +35875,9 @@ _gather_109_rule(Parser *p) return _res; } -// _tmp_110: args | expression for_if_clauses +// _tmp_111: args | expression for_if_clauses static void * -_tmp_110_rule(Parser *p) +_tmp_111_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35401,18 +35893,18 @@ _tmp_110_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); expr_ty args_var; if ( (args_var = args_rule(p)) // args ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); _res = args_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); } { // expression for_if_clauses @@ -35420,7 +35912,7 @@ _tmp_110_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); expr_ty expression_var; asdl_comprehension_seq* for_if_clauses_var; if ( @@ -35429,12 +35921,12 @@ _tmp_110_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses")); } _res = NULL; @@ -35443,9 +35935,9 @@ _tmp_110_rule(Parser *p) return _res; } -// _tmp_111: args ',' +// _tmp_112: args ',' static void * -_tmp_111_rule(Parser *p) +_tmp_112_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35461,7 +35953,7 @@ _tmp_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -35470,12 +35962,12 @@ _tmp_111_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); _res = _PyPegen_dummy_name(p, args_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','")); } _res = NULL; @@ -35484,9 +35976,9 @@ _tmp_111_rule(Parser *p) return _res; } -// _tmp_112: ',' | ')' +// _tmp_113: ',' | ')' static void * -_tmp_112_rule(Parser *p) +_tmp_113_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35502,18 +35994,18 @@ _tmp_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -35521,18 +36013,18 @@ _tmp_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } _res = NULL; @@ -35541,9 +36033,9 @@ _tmp_112_rule(Parser *p) return _res; } -// _tmp_113: 'True' | 'False' | 'None' +// _tmp_114: 'True' | 'False' | 'None' static void * -_tmp_113_rule(Parser *p) +_tmp_114_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35559,18 +36051,18 @@ _tmp_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'False' @@ -35578,18 +36070,18 @@ _tmp_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } { // 'None' @@ -35597,18 +36089,18 @@ _tmp_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } _res = NULL; @@ -35617,9 +36109,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: NAME '=' +// _tmp_115: NAME '=' static void * -_tmp_114_rule(Parser *p) +_tmp_115_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35635,7 +36127,7 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -35644,12 +36136,12 @@ _tmp_114_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); _res = _PyPegen_dummy_name(p, name_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='")); } _res = NULL; @@ -35658,9 +36150,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _loop1_115: (!STRING expression_without_invalid) +// _loop1_116: (!STRING expression_without_invalid) static asdl_seq * -_loop1_115_rule(Parser *p) +_loop1_116_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35685,13 +36177,13 @@ _loop1_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); - void *_tmp_171_var; + D(fprintf(stderr, "%*c> _loop1_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); + void *_tmp_172_var; while ( - (_tmp_171_var = _tmp_171_rule(p)) // !STRING expression_without_invalid + (_tmp_172_var = _tmp_172_rule(p)) // !STRING expression_without_invalid ) { - _res = _tmp_171_var; + _res = _tmp_172_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35708,7 +36200,7 @@ _loop1_115_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(!STRING expression_without_invalid)")); } if (_n == 0 || p->error_indicator) { @@ -35730,9 +36222,9 @@ _loop1_115_rule(Parser *p) return _seq; } -// _tmp_116: NAME STRING | SOFT_KEYWORD +// _tmp_117: NAME STRING | SOFT_KEYWORD static void * -_tmp_116_rule(Parser *p) +_tmp_117_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35748,7 +36240,7 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -35757,12 +36249,12 @@ _tmp_116_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); _res = _PyPegen_dummy_name(p, name_var, string_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME STRING")); } { // SOFT_KEYWORD @@ -35770,18 +36262,18 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); expr_ty soft_keyword_var; if ( (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); _res = soft_keyword_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "SOFT_KEYWORD")); } _res = NULL; @@ -35790,9 +36282,9 @@ _tmp_116_rule(Parser *p) return _res; } -// _tmp_117: 'else' | ':' +// _tmp_118: 'else' | ':' static void * -_tmp_117_rule(Parser *p) +_tmp_118_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35808,18 +36300,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 702)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'")); } { // ':' @@ -35827,18 +36319,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -35847,9 +36339,9 @@ _tmp_117_rule(Parser *p) return _res; } -// _tmp_118: pass_stmt | break_stmt | continue_stmt +// _tmp_119: pass_stmt | break_stmt | continue_stmt static void * -_tmp_118_rule(Parser *p) +_tmp_119_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35865,18 +36357,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pass_stmt")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pass_stmt")); stmt_ty pass_stmt_var; if ( (pass_stmt_var = pass_stmt_rule(p)) // pass_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pass_stmt")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pass_stmt")); _res = pass_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pass_stmt")); } { // break_stmt @@ -35884,18 +36376,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "break_stmt")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "break_stmt")); stmt_ty break_stmt_var; if ( (break_stmt_var = break_stmt_rule(p)) // break_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "break_stmt")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "break_stmt")); _res = break_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "break_stmt")); } { // continue_stmt @@ -35903,18 +36395,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "continue_stmt")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "continue_stmt")); stmt_ty continue_stmt_var; if ( (continue_stmt_var = continue_stmt_rule(p)) // continue_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "continue_stmt")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "continue_stmt")); _res = continue_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "continue_stmt")); } _res = NULL; @@ -35923,9 +36415,9 @@ _tmp_118_rule(Parser *p) return _res; } -// _tmp_119: '=' | ':=' +// _tmp_120: '=' | ':=' static void * -_tmp_119_rule(Parser *p) +_tmp_120_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35941,18 +36433,18 @@ _tmp_119_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } { // ':=' @@ -35960,18 +36452,18 @@ _tmp_119_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); } _res = NULL; @@ -35980,9 +36472,9 @@ _tmp_119_rule(Parser *p) return _res; } -// _tmp_120: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_121: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_120_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35998,18 +36490,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); expr_ty list_var; if ( (list_var = list_rule(p)) // list ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); _res = list_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); } { // tuple @@ -36017,18 +36509,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); expr_ty tuple_var; if ( (tuple_var = tuple_rule(p)) // tuple ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); _res = tuple_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); } { // genexp @@ -36036,18 +36528,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); expr_ty genexp_var; if ( (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); } { // 'True' @@ -36055,18 +36547,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'None' @@ -36074,18 +36566,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } { // 'False' @@ -36093,18 +36585,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } _res = NULL; @@ -36113,9 +36605,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _loop0_121: star_named_expressions +// _loop0_122: star_named_expressions static asdl_seq * -_loop0_121_rule(Parser *p) +_loop0_122_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36140,7 +36632,7 @@ _loop0_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); asdl_expr_seq* star_named_expressions_var; while ( (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions @@ -36163,7 +36655,7 @@ _loop0_121_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36180,9 +36672,9 @@ _loop0_121_rule(Parser *p) return _seq; } -// _loop0_122: (star_targets '=') +// _loop0_123: (star_targets '=') static asdl_seq * -_loop0_122_rule(Parser *p) +_loop0_123_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36207,13 +36699,13 @@ _loop0_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_159_var; + D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); + void *_tmp_160_var; while ( - (_tmp_159_var = _tmp_159_rule(p)) // star_targets '=' + (_tmp_160_var = _tmp_160_rule(p)) // star_targets '=' ) { - _res = _tmp_159_var; + _res = _tmp_160_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36230,7 +36722,7 @@ _loop0_122_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36247,9 +36739,9 @@ _loop0_122_rule(Parser *p) return _seq; } -// _tmp_123: '[' | '{' +// _tmp_124: '[' | '{' | 'f{' static void * -_tmp_123_rule(Parser *p) +_tmp_124_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36265,18 +36757,18 @@ _tmp_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); } { // '{' @@ -36284,29 +36776,48 @@ _tmp_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); } + { // 'f{' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'f{'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 55)) // token='f{' + ) + { + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'f{'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'f{'")); + } _res = NULL; done: p->level--; return _res; } -// _tmp_124: slash_no_default | slash_with_default +// _tmp_125: slash_no_default | slash_with_default static void * -_tmp_124_rule(Parser *p) +_tmp_125_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36322,18 +36833,18 @@ _tmp_124_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); asdl_arg_seq* slash_no_default_var; if ( (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); _res = slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); } { // slash_with_default @@ -36341,18 +36852,18 @@ _tmp_124_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); SlashWithDefault* slash_with_default_var; if ( (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); _res = slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); } _res = NULL; @@ -36361,9 +36872,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _tmp_125: ',' | param_no_default +// _tmp_126: ',' | param_no_default static void * -_tmp_125_rule(Parser *p) +_tmp_126_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36379,18 +36890,18 @@ _tmp_125_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // param_no_default @@ -36398,18 +36909,18 @@ _tmp_125_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); arg_ty param_no_default_var; if ( (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } _res = NULL; @@ -36418,9 +36929,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _tmp_126: ')' | ',' +// _tmp_127: ')' | ',' static void * -_tmp_126_rule(Parser *p) +_tmp_127_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36436,18 +36947,18 @@ _tmp_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' @@ -36455,18 +36966,18 @@ _tmp_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -36475,9 +36986,9 @@ _tmp_126_rule(Parser *p) return _res; } -// _tmp_127: ')' | ',' (')' | '**') +// _tmp_128: ')' | ',' (')' | '**') static void * -_tmp_127_rule(Parser *p) +_tmp_128_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36493,18 +37004,18 @@ _tmp_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' (')' | '**') @@ -36512,21 +37023,21 @@ _tmp_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); Token * _literal; - void *_tmp_172_var; + void *_tmp_173_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_172_var = _tmp_172_rule(p)) // ')' | '**' + (_tmp_173_var = _tmp_173_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_172_var); + D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_173_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); } _res = NULL; @@ -36535,9 +37046,9 @@ _tmp_127_rule(Parser *p) return _res; } -// _tmp_128: param_no_default | ',' +// _tmp_129: param_no_default | ',' static void * -_tmp_128_rule(Parser *p) +_tmp_129_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36553,18 +37064,18 @@ _tmp_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); arg_ty param_no_default_var; if ( (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } { // ',' @@ -36572,18 +37083,18 @@ _tmp_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -36592,9 +37103,9 @@ _tmp_128_rule(Parser *p) return _res; } -// _tmp_129: '*' | '**' | '/' +// _tmp_130: '*' | '**' | '/' static void * -_tmp_129_rule(Parser *p) +_tmp_130_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36610,18 +37121,18 @@ _tmp_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } { // '**' @@ -36629,18 +37140,18 @@ _tmp_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } { // '/' @@ -36648,18 +37159,18 @@ _tmp_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); } _res = NULL; @@ -36668,9 +37179,9 @@ _tmp_129_rule(Parser *p) return _res; } -// _tmp_130: lambda_slash_no_default | lambda_slash_with_default +// _tmp_131: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_130_rule(Parser *p) +_tmp_131_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36686,18 +37197,18 @@ _tmp_130_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); asdl_arg_seq* lambda_slash_no_default_var; if ( (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); _res = lambda_slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -36705,18 +37216,18 @@ _tmp_130_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); SlashWithDefault* lambda_slash_with_default_var; if ( (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default ) { - D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); _res = lambda_slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); } _res = NULL; @@ -36725,9 +37236,9 @@ _tmp_130_rule(Parser *p) return _res; } -// _loop0_131: ',' lambda_param +// _loop0_132: ',' lambda_param static asdl_seq * -_loop0_131_rule(Parser *p) +_loop0_132_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36752,7 +37263,7 @@ _loop0_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -36784,7 +37295,7 @@ _loop0_131_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_131[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' lambda_param")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36801,9 +37312,9 @@ _loop0_131_rule(Parser *p) return _seq; } -// _gather_132: lambda_param _loop0_131 +// _gather_133: lambda_param _loop0_132 static asdl_seq * -_gather_132_rule(Parser *p) +_gather_133_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36814,27 +37325,27 @@ _gather_132_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_131 + { // lambda_param _loop0_132 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_131")); + D(fprintf(stderr, "%*c> _gather_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_132")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_131_rule(p)) // _loop0_131 + (seq = _loop0_132_rule(p)) // _loop0_132 ) { - D(fprintf(stderr, "%*c+ _gather_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_131")); + D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_132")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_132[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_131")); + D(fprintf(stderr, "%*c%s _gather_133[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_132")); } _res = NULL; done: @@ -36842,9 +37353,9 @@ _gather_132_rule(Parser *p) return _res; } -// _tmp_133: ',' | lambda_param_no_default +// _tmp_134: ',' | lambda_param_no_default static void * -_tmp_133_rule(Parser *p) +_tmp_134_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36860,18 +37371,18 @@ _tmp_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // lambda_param_no_default @@ -36879,18 +37390,18 @@ _tmp_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; if ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } _res = NULL; @@ -36899,9 +37410,9 @@ _tmp_133_rule(Parser *p) return _res; } -// _tmp_134: ':' | ',' (':' | '**') +// _tmp_135: ':' | ',' (':' | '**') static void * -_tmp_134_rule(Parser *p) +_tmp_135_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36917,18 +37428,18 @@ _tmp_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // ',' (':' | '**') @@ -36936,21 +37447,21 @@ _tmp_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); Token * _literal; - void *_tmp_173_var; + void *_tmp_174_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_173_var = _tmp_173_rule(p)) // ':' | '**' + (_tmp_174_var = _tmp_174_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_173_var); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_174_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); } _res = NULL; @@ -36959,9 +37470,9 @@ _tmp_134_rule(Parser *p) return _res; } -// _tmp_135: lambda_param_no_default | ',' +// _tmp_136: lambda_param_no_default | ',' static void * -_tmp_135_rule(Parser *p) +_tmp_136_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36977,18 +37488,18 @@ _tmp_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; if ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } { // ',' @@ -36996,18 +37507,18 @@ _tmp_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -37016,9 +37527,9 @@ _tmp_135_rule(Parser *p) return _res; } -// _tmp_136: bitwise_or ((',' bitwise_or))* ','? +// _tmp_137: bitwise_or ((',' bitwise_or))* ','? static void * -_tmp_136_rule(Parser *p) +_tmp_137_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37034,25 +37545,25 @@ _tmp_136_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - asdl_seq * _loop0_174_var; + D(fprintf(stderr, "%*c> _tmp_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + asdl_seq * _loop0_175_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty bitwise_or_var; if ( (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - (_loop0_174_var = _loop0_174_rule(p)) // ((',' bitwise_or))* + (_loop0_175_var = _loop0_175_rule(p)) // ((',' bitwise_or))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) { - D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_174_var, _opt_var); + D(fprintf(stderr, "%*c+ _tmp_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_175_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_137[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); } _res = NULL; @@ -37061,9 +37572,9 @@ _tmp_136_rule(Parser *p) return _res; } -// _loop0_137: ',' dotted_name +// _loop0_138: ',' dotted_name static asdl_seq * -_loop0_137_rule(Parser *p) +_loop0_138_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37088,7 +37599,7 @@ _loop0_137_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -37120,7 +37631,7 @@ _loop0_137_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_137[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_138[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_name")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37137,9 +37648,9 @@ _loop0_137_rule(Parser *p) return _seq; } -// _gather_138: dotted_name _loop0_137 +// _gather_139: dotted_name _loop0_138 static asdl_seq * -_gather_138_rule(Parser *p) +_gather_139_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37150,27 +37661,27 @@ _gather_138_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_137 + { // dotted_name _loop0_138 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_137")); + D(fprintf(stderr, "%*c> _gather_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_138")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_137_rule(p)) // _loop0_137 + (seq = _loop0_138_rule(p)) // _loop0_138 ) { - D(fprintf(stderr, "%*c+ _gather_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_137")); + D(fprintf(stderr, "%*c+ _gather_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_138")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_138[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_137")); + D(fprintf(stderr, "%*c%s _gather_139[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_138")); } _res = NULL; done: @@ -37178,9 +37689,9 @@ _gather_138_rule(Parser *p) return _res; } -// _tmp_139: NAME (',' | ')' | ';' | NEWLINE) +// _tmp_140: NAME (',' | ')' | ';' | NEWLINE) static void * -_tmp_139_rule(Parser *p) +_tmp_140_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37196,21 +37707,21 @@ _tmp_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); - void *_tmp_175_var; + D(fprintf(stderr, "%*c> _tmp_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); + void *_tmp_176_var; expr_ty name_var; if ( (name_var = _PyPegen_name_token(p)) // NAME && - (_tmp_175_var = _tmp_175_rule(p)) // ',' | ')' | ';' | NEWLINE + (_tmp_176_var = _tmp_176_rule(p)) // ',' | ')' | ';' | NEWLINE ) { - D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); - _res = _PyPegen_dummy_name(p, name_var, _tmp_175_var); + D(fprintf(stderr, "%*c+ _tmp_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); + _res = _PyPegen_dummy_name(p, name_var, _tmp_176_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_140[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); } _res = NULL; @@ -37219,9 +37730,9 @@ _tmp_139_rule(Parser *p) return _res; } -// _loop0_140: ',' (expression ['as' star_target]) +// _loop0_141: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_140_rule(Parser *p) +_loop0_141_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37246,13 +37757,13 @@ _loop0_140_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_176_rule(p)) // expression ['as' star_target] + (elem = _tmp_177_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -37278,7 +37789,7 @@ _loop0_140_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_140[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_141[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37295,9 +37806,9 @@ _loop0_140_rule(Parser *p) return _seq; } -// _gather_141: (expression ['as' star_target]) _loop0_140 +// _gather_142: (expression ['as' star_target]) _loop0_141 static asdl_seq * -_gather_141_rule(Parser *p) +_gather_142_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37308,27 +37819,27 @@ _gather_141_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_140 + { // (expression ['as' star_target]) _loop0_141 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_140")); + D(fprintf(stderr, "%*c> _gather_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_141")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_176_rule(p)) // expression ['as' star_target] + (elem = _tmp_177_rule(p)) // expression ['as' star_target] && - (seq = _loop0_140_rule(p)) // _loop0_140 + (seq = _loop0_141_rule(p)) // _loop0_141 ) { - D(fprintf(stderr, "%*c+ _gather_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_140")); + D(fprintf(stderr, "%*c+ _gather_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_141")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_141[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_140")); + D(fprintf(stderr, "%*c%s _gather_142[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_141")); } _res = NULL; done: @@ -37336,9 +37847,9 @@ _gather_141_rule(Parser *p) return _res; } -// _loop0_142: ',' (expressions ['as' star_target]) +// _loop0_143: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_142_rule(Parser *p) +_loop0_143_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37363,13 +37874,13 @@ _loop0_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_177_rule(p)) // expressions ['as' star_target] + (elem = _tmp_178_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -37395,7 +37906,7 @@ _loop0_142_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_142[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_143[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37412,9 +37923,9 @@ _loop0_142_rule(Parser *p) return _seq; } -// _gather_143: (expressions ['as' star_target]) _loop0_142 +// _gather_144: (expressions ['as' star_target]) _loop0_143 static asdl_seq * -_gather_143_rule(Parser *p) +_gather_144_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37425,27 +37936,27 @@ _gather_143_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_142 + { // (expressions ['as' star_target]) _loop0_143 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_142")); + D(fprintf(stderr, "%*c> _gather_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_143")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_177_rule(p)) // expressions ['as' star_target] + (elem = _tmp_178_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_142_rule(p)) // _loop0_142 + (seq = _loop0_143_rule(p)) // _loop0_143 ) { - D(fprintf(stderr, "%*c+ _gather_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_142")); + D(fprintf(stderr, "%*c+ _gather_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_143")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_143[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_142")); + D(fprintf(stderr, "%*c%s _gather_144[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_143")); } _res = NULL; done: @@ -37453,9 +37964,9 @@ _gather_143_rule(Parser *p) return _res; } -// _tmp_144: 'except' | 'finally' +// _tmp_145: 'except' | 'finally' static void * -_tmp_144_rule(Parser *p) +_tmp_145_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37471,18 +37982,18 @@ _tmp_144_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 693)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } { // 'finally' @@ -37490,18 +38001,18 @@ _tmp_144_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 689)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } _res = NULL; @@ -37510,9 +38021,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _loop0_145: block +// _loop0_146: block static asdl_seq * -_loop0_145_rule(Parser *p) +_loop0_146_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37537,7 +38048,7 @@ _loop0_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); + D(fprintf(stderr, "%*c> _loop0_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -37560,7 +38071,7 @@ _loop0_145_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37577,9 +38088,9 @@ _loop0_145_rule(Parser *p) return _seq; } -// _tmp_146: expression ['as' NAME] +// _tmp_147: expression ['as' NAME] static void * -_tmp_146_rule(Parser *p) +_tmp_147_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37595,7 +38106,7 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expression_var; @@ -37605,12 +38116,12 @@ _tmp_146_rule(Parser *p) (_opt_var = _tmp_21_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]")); } _res = NULL; @@ -37619,9 +38130,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: NEWLINE | ':' +// _tmp_148: NEWLINE | ':' static void * -_tmp_147_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37637,18 +38148,18 @@ _tmp_147_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } { // ':' @@ -37656,18 +38167,18 @@ _tmp_147_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -37676,9 +38187,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: items_pattern ',' +// _tmp_149: items_pattern ',' static void * -_tmp_148_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37694,7 +38205,7 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); Token * _literal; asdl_seq* items_pattern_var; if ( @@ -37703,12 +38214,12 @@ _tmp_148_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); _res = _PyPegen_dummy_name(p, items_pattern_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "items_pattern ','")); } _res = NULL; @@ -37717,9 +38228,9 @@ _tmp_148_rule(Parser *p) return _res; } -// _tmp_149: positional_patterns ',' +// _tmp_150: positional_patterns ',' static void * -_tmp_149_rule(Parser *p) +_tmp_150_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37735,7 +38246,7 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -37744,12 +38255,12 @@ _tmp_149_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); } _res = NULL; @@ -37758,9 +38269,9 @@ _tmp_149_rule(Parser *p) return _res; } -// _tmp_150: invalid_kvpair | invalid_kvpair_unpacking +// _tmp_151: invalid_kvpair | invalid_kvpair_unpacking static void * -_tmp_150_rule(Parser *p) +_tmp_151_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37776,18 +38287,18 @@ _tmp_150_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair")); void *invalid_kvpair_var; if ( (invalid_kvpair_var = invalid_kvpair_rule(p)) // invalid_kvpair ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair")); _res = invalid_kvpair_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kvpair")); } if (p->call_invalid_rules) { // invalid_kvpair_unpacking @@ -37795,18 +38306,18 @@ _tmp_150_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking")); void *invalid_kvpair_unpacking_var; if ( (invalid_kvpair_unpacking_var = invalid_kvpair_unpacking_rule(p)) // invalid_kvpair_unpacking ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking")); _res = invalid_kvpair_unpacking_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kvpair_unpacking")); } _res = NULL; @@ -37815,9 +38326,9 @@ _tmp_150_rule(Parser *p) return _res; } -// _tmp_151: '}' | ',' +// _tmp_152: '}' | ',' static void * -_tmp_151_rule(Parser *p) +_tmp_152_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37833,18 +38344,18 @@ _tmp_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } { // ',' @@ -37852,18 +38363,18 @@ _tmp_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -37872,9 +38383,9 @@ _tmp_151_rule(Parser *p) return _res; } -// _tmp_152: '=' | '!' | ':' | '}' +// _tmp_153: '=' | '!' | ':' | '}' static void * -_tmp_152_rule(Parser *p) +_tmp_153_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37890,18 +38401,18 @@ _tmp_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } { // '!' @@ -37909,18 +38420,18 @@ _tmp_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -37928,18 +38439,18 @@ _tmp_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -37947,18 +38458,18 @@ _tmp_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -37967,9 +38478,9 @@ _tmp_152_rule(Parser *p) return _res; } -// _tmp_153: '!' | ':' | '}' +// _tmp_154: '!' | ':' | '}' static void * -_tmp_153_rule(Parser *p) +_tmp_154_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37985,18 +38496,18 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -38004,18 +38515,18 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -38023,18 +38534,18 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -38043,9 +38554,9 @@ _tmp_153_rule(Parser *p) return _res; } -// _tmp_154: '!' NAME +// _tmp_155: '!' NAME static void * -_tmp_154_rule(Parser *p) +_tmp_155_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38061,7 +38572,7 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -38070,12 +38581,12 @@ _tmp_154_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); _res = _PyPegen_dummy_name(p, _literal, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME")); } _res = NULL; @@ -38084,9 +38595,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _tmp_155: ':' | '}' +// _tmp_156: ':' | '}' static void * -_tmp_155_rule(Parser *p) +_tmp_156_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38102,18 +38613,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -38121,18 +38632,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -38141,9 +38652,9 @@ _tmp_155_rule(Parser *p) return _res; } -// _tmp_156: fstring | string +// _tmp_157: fstring | string static void * -_tmp_156_rule(Parser *p) +_tmp_157_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38159,18 +38670,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring")); expr_ty fstring_var; if ( (fstring_var = fstring_rule(p)) // fstring ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); _res = fstring_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring")); } { // string @@ -38178,18 +38689,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "string")); expr_ty string_var; if ( (string_var = string_rule(p)) // string ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); _res = string_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string")); } _res = NULL; @@ -38198,9 +38709,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: '+' | '-' | '*' | '/' | '%' | '//' | '@' +// _tmp_158: '+' | '-' | '*' | '/' | '%' | '//' | '@' static void * -_tmp_157_rule(Parser *p) +_tmp_158_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38216,18 +38727,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } { // '-' @@ -38235,18 +38746,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } { // '*' @@ -38254,18 +38765,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } { // '/' @@ -38273,18 +38784,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); } { // '%' @@ -38292,18 +38803,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 24)) // token='%' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%'")); } { // '//' @@ -38311,18 +38822,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 47)) // token='//' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//'")); } { // '@' @@ -38330,18 +38841,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); } _res = NULL; @@ -38350,9 +38861,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: '+' | '-' | '~' +// _tmp_159: '+' | '-' | '~' static void * -_tmp_158_rule(Parser *p) +_tmp_159_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38368,18 +38879,18 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } { // '-' @@ -38387,18 +38898,18 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } { // '~' @@ -38406,18 +38917,18 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 31)) // token='~' ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~'")); } _res = NULL; @@ -38426,9 +38937,9 @@ _tmp_158_rule(Parser *p) return _res; } -// _tmp_159: star_targets '=' +// _tmp_160: star_targets '=' static void * -_tmp_159_rule(Parser *p) +_tmp_160_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38444,7 +38955,7 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -38453,7 +38964,7 @@ _tmp_159_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); _res = z; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38463,7 +38974,7 @@ _tmp_159_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); } _res = NULL; @@ -38472,9 +38983,9 @@ _tmp_159_rule(Parser *p) return _res; } -// _tmp_160: '.' | '...' +// _tmp_161: '.' | '...' static void * -_tmp_160_rule(Parser *p) +_tmp_161_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38490,18 +39001,18 @@ _tmp_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } { // '...' @@ -38509,18 +39020,18 @@ _tmp_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 52)) // token='...' ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); } _res = NULL; @@ -38529,9 +39040,9 @@ _tmp_160_rule(Parser *p) return _res; } -// _tmp_161: '@' named_expression NEWLINE +// _tmp_162: '@' named_expression NEWLINE static void * -_tmp_161_rule(Parser *p) +_tmp_162_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38547,7 +39058,7 @@ _tmp_161_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -38559,7 +39070,7 @@ _tmp_161_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); _res = f; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38569,7 +39080,7 @@ _tmp_161_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE")); } _res = NULL; @@ -38578,9 +39089,9 @@ _tmp_161_rule(Parser *p) return _res; } -// _tmp_162: ',' star_expression +// _tmp_163: ',' star_expression static void * -_tmp_162_rule(Parser *p) +_tmp_163_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38596,7 +39107,7 @@ _tmp_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -38605,7 +39116,7 @@ _tmp_162_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); _res = c; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38615,7 +39126,7 @@ _tmp_162_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression")); } _res = NULL; @@ -38624,9 +39135,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: 'or' conjunction +// _tmp_164: 'or' conjunction static void * -_tmp_163_rule(Parser *p) +_tmp_164_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38642,7 +39153,7 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -38651,7 +39162,7 @@ _tmp_163_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); _res = c; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38661,7 +39172,7 @@ _tmp_163_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction")); } _res = NULL; @@ -38670,9 +39181,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: 'and' inversion +// _tmp_165: 'and' inversion static void * -_tmp_164_rule(Parser *p) +_tmp_165_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38688,7 +39199,7 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -38697,7 +39208,7 @@ _tmp_164_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); _res = c; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38707,7 +39218,7 @@ _tmp_164_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion")); } _res = NULL; @@ -38716,9 +39227,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _tmp_165: slice | starred_expression +// _tmp_166: slice | starred_expression static void * -_tmp_165_rule(Parser *p) +_tmp_166_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38734,18 +39245,18 @@ _tmp_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); expr_ty slice_var; if ( (slice_var = slice_rule(p)) // slice ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); _res = slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice")); } { // starred_expression @@ -38753,18 +39264,18 @@ _tmp_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } _res = NULL; @@ -38773,9 +39284,9 @@ _tmp_165_rule(Parser *p) return _res; } -// _tmp_166: 'if' disjunction +// _tmp_167: 'if' disjunction static void * -_tmp_166_rule(Parser *p) +_tmp_167_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38791,7 +39302,7 @@ _tmp_166_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -38800,7 +39311,7 @@ _tmp_166_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); _res = z; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38810,7 +39321,7 @@ _tmp_166_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); } _res = NULL; @@ -38819,9 +39330,9 @@ _tmp_166_rule(Parser *p) return _res; } -// _tmp_167: starred_expression | (assignment_expression | expression !':=') !'=' +// _tmp_168: starred_expression | (assignment_expression | expression !':=') !'=' static void * -_tmp_167_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38837,18 +39348,18 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } { // (assignment_expression | expression !':=') !'=' @@ -38856,20 +39367,20 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - void *_tmp_178_var; + D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + void *_tmp_179_var; if ( - (_tmp_178_var = _tmp_178_rule(p)) // assignment_expression | expression !':=' + (_tmp_179_var = _tmp_179_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_178_var; + D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_179_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -38878,9 +39389,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _tmp_168: ',' star_target +// _tmp_169: ',' star_target static void * -_tmp_168_rule(Parser *p) +_tmp_169_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38896,7 +39407,7 @@ _tmp_168_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -38905,7 +39416,7 @@ _tmp_168_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); _res = c; if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) { p->error_indicator = 1; @@ -38915,7 +39426,7 @@ _tmp_168_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); } _res = NULL; @@ -38924,10 +39435,10 @@ _tmp_168_rule(Parser *p) return _res; } -// _tmp_169: +// _tmp_170: // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs static void * -_tmp_169_rule(Parser *p) +_tmp_170_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38943,24 +39454,24 @@ _tmp_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - asdl_seq * _gather_91_var; + D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + asdl_seq * _gather_92_var; Token * _literal; asdl_seq* kwargs_var; if ( - (_gather_91_var = _gather_91_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (_gather_92_var = _gather_92_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && (kwargs_var = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - _res = _PyPegen_dummy_name(p, _gather_91_var, _literal, kwargs_var); + D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + _res = _PyPegen_dummy_name(p, _gather_92_var, _literal, kwargs_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); } _res = NULL; @@ -38969,9 +39480,9 @@ _tmp_169_rule(Parser *p) return _res; } -// _tmp_170: starred_expression !'=' +// _tmp_171: starred_expression !'=' static void * -_tmp_170_rule(Parser *p) +_tmp_171_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38987,7 +39498,7 @@ _tmp_170_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression @@ -38995,12 +39506,12 @@ _tmp_170_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression !'='")); } _res = NULL; @@ -39009,9 +39520,9 @@ _tmp_170_rule(Parser *p) return _res; } -// _tmp_171: !STRING expression_without_invalid +// _tmp_172: !STRING expression_without_invalid static void * -_tmp_171_rule(Parser *p) +_tmp_172_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39027,7 +39538,7 @@ _tmp_171_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); + D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); expr_ty expression_without_invalid_var; if ( _PyPegen_lookahead(0, _PyPegen_string_token, p) @@ -39035,12 +39546,12 @@ _tmp_171_rule(Parser *p) (expression_without_invalid_var = expression_without_invalid_rule(p)) // expression_without_invalid ) { - D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); + D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); _res = expression_without_invalid_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_172[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!STRING expression_without_invalid")); } _res = NULL; @@ -39049,9 +39560,9 @@ _tmp_171_rule(Parser *p) return _res; } -// _tmp_172: ')' | '**' +// _tmp_173: ')' | '**' static void * -_tmp_172_rule(Parser *p) +_tmp_173_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39067,18 +39578,18 @@ _tmp_172_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_172[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // '**' @@ -39086,18 +39597,18 @@ _tmp_172_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_172[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } _res = NULL; @@ -39106,9 +39617,9 @@ _tmp_172_rule(Parser *p) return _res; } -// _tmp_173: ':' | '**' +// _tmp_174: ':' | '**' static void * -_tmp_173_rule(Parser *p) +_tmp_174_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39124,18 +39635,18 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '**' @@ -39143,18 +39654,18 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } _res = NULL; @@ -39163,9 +39674,9 @@ _tmp_173_rule(Parser *p) return _res; } -// _loop0_174: (',' bitwise_or) +// _loop0_175: (',' bitwise_or) static asdl_seq * -_loop0_174_rule(Parser *p) +_loop0_175_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39190,13 +39701,13 @@ _loop0_174_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); - void *_tmp_179_var; + D(fprintf(stderr, "%*c> _loop0_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); + void *_tmp_180_var; while ( - (_tmp_179_var = _tmp_179_rule(p)) // ',' bitwise_or + (_tmp_180_var = _tmp_180_rule(p)) // ',' bitwise_or ) { - _res = _tmp_179_var; + _res = _tmp_180_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -39213,7 +39724,7 @@ _loop0_174_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_174[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_175[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' bitwise_or)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39230,9 +39741,9 @@ _loop0_174_rule(Parser *p) return _seq; } -// _tmp_175: ',' | ')' | ';' | NEWLINE +// _tmp_176: ',' | ')' | ';' | NEWLINE static void * -_tmp_175_rule(Parser *p) +_tmp_176_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39248,18 +39759,18 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -39267,18 +39778,18 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ';' @@ -39286,18 +39797,18 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); + D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 13)) // token=';' ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); + D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); } { // NEWLINE @@ -39305,18 +39816,18 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } _res = NULL; @@ -39325,9 +39836,9 @@ _tmp_175_rule(Parser *p) return _res; } -// _tmp_176: expression ['as' star_target] +// _tmp_177: expression ['as' star_target] static void * -_tmp_176_rule(Parser *p) +_tmp_177_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39343,22 +39854,22 @@ _tmp_176_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_180_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_181_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_177[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]")); } _res = NULL; @@ -39367,9 +39878,9 @@ _tmp_176_rule(Parser *p) return _res; } -// _tmp_177: expressions ['as' star_target] +// _tmp_178: expressions ['as' star_target] static void * -_tmp_177_rule(Parser *p) +_tmp_178_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39385,22 +39896,22 @@ _tmp_177_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expressions_var; if ( (expressions_var = expressions_rule(p)) // expressions && - (_opt_var = _tmp_180_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_181_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_177[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_178[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]")); } _res = NULL; @@ -39409,9 +39920,9 @@ _tmp_177_rule(Parser *p) return _res; } -// _tmp_178: assignment_expression | expression !':=' +// _tmp_179: assignment_expression | expression !':=' static void * -_tmp_178_rule(Parser *p) +_tmp_179_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39427,18 +39938,18 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); expr_ty assignment_expression_var; if ( (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression ) { - D(fprintf(stderr, "%*c+ _tmp_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_179[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); _res = assignment_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_178[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } { // expression !':=' @@ -39446,7 +39957,7 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -39454,12 +39965,12 @@ _tmp_178_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_179[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_178[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } _res = NULL; @@ -39468,9 +39979,9 @@ _tmp_178_rule(Parser *p) return _res; } -// _tmp_179: ',' bitwise_or +// _tmp_180: ',' bitwise_or static void * -_tmp_179_rule(Parser *p) +_tmp_180_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39486,7 +39997,7 @@ _tmp_179_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); Token * _literal; expr_ty bitwise_or_var; if ( @@ -39495,12 +40006,12 @@ _tmp_179_rule(Parser *p) (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ _tmp_179[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); _res = _PyPegen_dummy_name(p, _literal, bitwise_or_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' bitwise_or")); } _res = NULL; @@ -39509,9 +40020,9 @@ _tmp_179_rule(Parser *p) return _res; } -// _tmp_180: 'as' star_target +// _tmp_181: 'as' star_target static void * -_tmp_180_rule(Parser *p) +_tmp_181_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -39527,7 +40038,7 @@ _tmp_180_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_181[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( @@ -39536,12 +40047,12 @@ _tmp_180_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_181[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); _res = _PyPegen_dummy_name(p, _keyword, star_target_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_181[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); } _res = NULL; diff --git a/Parser/token.c b/Parser/token.c index a6e7ce35dfad855..40d4643d185342c 100644 --- a/Parser/token.c +++ b/Parser/token.c @@ -61,6 +61,7 @@ const char * const _PyParser_TokenNames[] = { "ELLIPSIS", "COLONEQUAL", "EXCLAMATION", + "LFBRACE", "OP", "TYPE_IGNORE", "TYPE_COMMENT", @@ -187,6 +188,11 @@ _PyToken_TwoChars(int c1, int c2) case '=': return CIRCUMFLEXEQUAL; } break; + case 'f': + switch (c2) { + case '{': return LFBRACE; + } + break; case '|': switch (c2) { case '=': return VBAREQUAL; diff --git a/Programs/test_frozenmain.h b/Programs/test_frozenmain.h index 2fe612dba873008..f24ba178a804a39 100644 --- a/Programs/test_frozenmain.h +++ b/Programs/test_frozenmain.h @@ -1,19 +1,19 @@ // Auto-generated by Programs/freeze_test_frozenmain.py unsigned char M_test_frozenmain[] = { 227,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0, - 0,0,0,0,0,243,188,0,0,0,128,0,0,0,91,0, - 78,7,70,0,113,0,91,0,78,7,70,4,113,1,90,2, - 31,0,79,1,50,1,0,0,0,0,0,0,29,0,90,2, - 31,0,79,2,90,0,77,6,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,50,2,0,0,0,0, - 0,0,29,0,90,1,77,8,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,31,0,50,0,0,0, - 0,0,0,0,79,3,42,26,0,0,0,0,0,0,0,0, - 0,0,113,5,79,6,68,0,0,0,66,24,0,0,113,6, - 90,2,31,0,79,4,90,6,12,0,79,5,90,5,90,6, - 42,26,0,0,0,0,0,0,0,0,0,0,12,0,48,4, - 50,1,0,0,0,0,0,0,29,0,72,26,0,0,9,0, - 28,0,78,7,33,0,41,7,233,0,0,0,0,122,18,70, + 0,0,0,0,0,243,188,0,0,0,128,0,0,0,93,0, + 80,7,72,0,115,0,93,0,80,7,72,4,115,1,92,2, + 32,0,81,1,52,1,0,0,0,0,0,0,30,0,92,2, + 32,0,81,2,92,0,79,6,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,52,2,0,0,0,0, + 0,0,30,0,92,1,79,8,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,32,0,52,0,0,0, + 0,0,0,0,81,3,43,26,0,0,0,0,0,0,0,0, + 0,0,115,5,81,6,70,0,0,0,68,24,0,0,115,6, + 92,2,32,0,81,4,92,6,13,0,81,5,92,5,92,6, + 43,26,0,0,0,0,0,0,0,0,0,0,13,0,50,4, + 52,1,0,0,0,0,0,0,30,0,74,26,0,0,10,0, + 29,0,80,7,34,0,41,7,233,0,0,0,0,122,18,70, 114,111,122,101,110,32,72,101,108,108,111,32,87,111,114,108, 100,122,8,115,121,115,46,97,114,103,118,218,6,99,111,110, 102,105,103,122,7,99,111,110,102,105,103,32,122,2,58,32, diff --git a/Python/Python-ast.c b/Python/Python-ast.c index f36072dfce098c6..a334cbf2800a0ff 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -77,6 +77,10 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->FloorDiv_type); Py_CLEAR(state->For_type); Py_CLEAR(state->FormattedValue_type); + Py_CLEAR(state->FrozenDictComp_type); + Py_CLEAR(state->FrozenDict_type); + Py_CLEAR(state->FrozenSetComp_type); + Py_CLEAR(state->FrozenSet_type); Py_CLEAR(state->FunctionDef_type); Py_CLEAR(state->FunctionType_type); Py_CLEAR(state->GeneratorExp_type); @@ -584,9 +588,16 @@ static const char * const Dict_fields[]={ "keys", "values", }; +static const char * const FrozenDict_fields[]={ + "keys", + "values", +}; static const char * const Set_fields[]={ "elts", }; +static const char * const FrozenSet_fields[]={ + "elts", +}; static const char * const ListComp_fields[]={ "elt", "generators", @@ -595,11 +606,20 @@ static const char * const SetComp_fields[]={ "elt", "generators", }; +static const char * const FrozenSetComp_fields[]={ + "elt", + "generators", +}; static const char * const DictComp_fields[]={ "key", "value", "generators", }; +static const char * const FrozenDictComp_fields[]={ + "key", + "value", + "generators", +}; static const char * const GeneratorExp_fields[]={ "elt", "generators", @@ -2774,6 +2794,52 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(Dict_annotations); + PyObject *FrozenDict_annotations = PyDict_New(); + if (!FrozenDict_annotations) return 0; + { + PyObject *type = state->expr_type; + type = Py_GenericAlias((PyObject *)&PyList_Type, type); + cond = type != NULL; + if (!cond) { + Py_DECREF(FrozenDict_annotations); + return 0; + } + cond = PyDict_SetItemString(FrozenDict_annotations, "keys", type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenDict_annotations); + return 0; + } + } + { + PyObject *type = state->expr_type; + type = Py_GenericAlias((PyObject *)&PyList_Type, type); + cond = type != NULL; + if (!cond) { + Py_DECREF(FrozenDict_annotations); + return 0; + } + cond = PyDict_SetItemString(FrozenDict_annotations, "values", type) == + 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenDict_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->FrozenDict_type, "_field_types", + FrozenDict_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenDict_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->FrozenDict_type, "__annotations__", + FrozenDict_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenDict_annotations); + return 0; + } + Py_DECREF(FrozenDict_annotations); PyObject *Set_annotations = PyDict_New(); if (!Set_annotations) return 0; { @@ -2804,6 +2870,36 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(Set_annotations); + PyObject *FrozenSet_annotations = PyDict_New(); + if (!FrozenSet_annotations) return 0; + { + PyObject *type = state->expr_type; + type = Py_GenericAlias((PyObject *)&PyList_Type, type); + cond = type != NULL; + if (!cond) { + Py_DECREF(FrozenSet_annotations); + return 0; + } + cond = PyDict_SetItemString(FrozenSet_annotations, "elts", type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenSet_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->FrozenSet_type, "_field_types", + FrozenSet_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenSet_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->FrozenSet_type, "__annotations__", + FrozenSet_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenSet_annotations); + return 0; + } + Py_DECREF(FrozenSet_annotations); PyObject *ListComp_annotations = PyDict_New(); if (!ListComp_annotations) return 0; { @@ -2886,6 +2982,48 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(SetComp_annotations); + PyObject *FrozenSetComp_annotations = PyDict_New(); + if (!FrozenSetComp_annotations) return 0; + { + PyObject *type = state->expr_type; + Py_INCREF(type); + cond = PyDict_SetItemString(FrozenSetComp_annotations, "elt", type) == + 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenSetComp_annotations); + return 0; + } + } + { + PyObject *type = state->comprehension_type; + type = Py_GenericAlias((PyObject *)&PyList_Type, type); + cond = type != NULL; + if (!cond) { + Py_DECREF(FrozenSetComp_annotations); + return 0; + } + cond = PyDict_SetItemString(FrozenSetComp_annotations, "generators", + type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenSetComp_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->FrozenSetComp_type, "_field_types", + FrozenSetComp_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenSetComp_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->FrozenSetComp_type, "__annotations__", + FrozenSetComp_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenSetComp_annotations); + return 0; + } + Py_DECREF(FrozenSetComp_annotations); PyObject *DictComp_annotations = PyDict_New(); if (!DictComp_annotations) return 0; { @@ -2942,6 +3080,65 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(DictComp_annotations); + PyObject *FrozenDictComp_annotations = PyDict_New(); + if (!FrozenDictComp_annotations) return 0; + { + PyObject *type = state->expr_type; + Py_INCREF(type); + cond = PyDict_SetItemString(FrozenDictComp_annotations, "key", type) == + 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + } + { + PyObject *type = state->expr_type; + type = _Py_union_type_or(type, Py_None); + cond = type != NULL; + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + cond = PyDict_SetItemString(FrozenDictComp_annotations, "value", type) + == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + } + { + PyObject *type = state->comprehension_type; + type = Py_GenericAlias((PyObject *)&PyList_Type, type); + cond = type != NULL; + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + cond = PyDict_SetItemString(FrozenDictComp_annotations, "generators", + type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->FrozenDictComp_type, "_field_types", + FrozenDictComp_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->FrozenDictComp_type, + "__annotations__", + FrozenDictComp_annotations) == 0; + if (!cond) { + Py_DECREF(FrozenDictComp_annotations); + return 0; + } + Py_DECREF(FrozenDictComp_annotations); PyObject *GeneratorExp_annotations = PyDict_New(); if (!GeneratorExp_annotations) return 0; { @@ -6349,10 +6546,14 @@ init_types(void *arg) " | Lambda(arguments args, expr body)\n" " | IfExp(expr test, expr body, expr orelse)\n" " | Dict(expr?* keys, expr* values)\n" + " | FrozenDict(expr?* keys, expr* values)\n" " | Set(expr* elts)\n" + " | FrozenSet(expr* elts)\n" " | ListComp(expr elt, comprehension* generators)\n" " | SetComp(expr elt, comprehension* generators)\n" + " | FrozenSetComp(expr elt, comprehension* generators)\n" " | DictComp(expr key, expr? value, comprehension* generators)\n" + " | FrozenDictComp(expr key, expr? value, comprehension* generators)\n" " | GeneratorExp(expr elt, comprehension* generators)\n" " | Await(expr value)\n" " | Yield(expr? value)\n" @@ -6408,9 +6609,17 @@ init_types(void *arg) 2, "Dict(expr?* keys, expr* values)"); if (!state->Dict_type) return -1; + state->FrozenDict_type = make_type(state, "FrozenDict", state->expr_type, + FrozenDict_fields, 2, + "FrozenDict(expr?* keys, expr* values)"); + if (!state->FrozenDict_type) return -1; state->Set_type = make_type(state, "Set", state->expr_type, Set_fields, 1, "Set(expr* elts)"); if (!state->Set_type) return -1; + state->FrozenSet_type = make_type(state, "FrozenSet", state->expr_type, + FrozenSet_fields, 1, + "FrozenSet(expr* elts)"); + if (!state->FrozenSet_type) return -1; state->ListComp_type = make_type(state, "ListComp", state->expr_type, ListComp_fields, 2, "ListComp(expr elt, comprehension* generators)"); @@ -6419,12 +6628,25 @@ init_types(void *arg) SetComp_fields, 2, "SetComp(expr elt, comprehension* generators)"); if (!state->SetComp_type) return -1; + state->FrozenSetComp_type = make_type(state, "FrozenSetComp", + state->expr_type, + FrozenSetComp_fields, 2, + "FrozenSetComp(expr elt, comprehension* generators)"); + if (!state->FrozenSetComp_type) return -1; state->DictComp_type = make_type(state, "DictComp", state->expr_type, DictComp_fields, 3, "DictComp(expr key, expr? value, comprehension* generators)"); if (!state->DictComp_type) return -1; if (PyObject_SetAttr(state->DictComp_type, state->value, Py_None) == -1) return -1; + state->FrozenDictComp_type = make_type(state, "FrozenDictComp", + state->expr_type, + FrozenDictComp_fields, 3, + "FrozenDictComp(expr key, expr? value, comprehension* generators)"); + if (!state->FrozenDictComp_type) return -1; + if (PyObject_SetAttr(state->FrozenDictComp_type, state->value, Py_None) == + -1) + return -1; state->GeneratorExp_type = make_type(state, "GeneratorExp", state->expr_type, GeneratorExp_fields, 2, @@ -7917,6 +8139,25 @@ _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, int return p; } +expr_ty +_PyAST_FrozenDict(asdl_expr_seq * keys, asdl_expr_seq * values, 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 = FrozenDict_kind; + p->v.FrozenDict.keys = keys; + p->v.FrozenDict.values = values; + p->lineno = lineno; + p->col_offset = col_offset; + p->end_lineno = end_lineno; + p->end_col_offset = end_col_offset; + return p; +} + expr_ty _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) @@ -7934,6 +8175,23 @@ _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int end_lineno, return p; } +expr_ty +_PyAST_FrozenSet(asdl_expr_seq * elts, 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 = FrozenSet_kind; + p->v.FrozenSet.elts = elts; + p->lineno = lineno; + p->col_offset = col_offset; + p->end_lineno = end_lineno; + p->end_col_offset = end_col_offset; + return p; +} + expr_ty _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena @@ -7982,6 +8240,30 @@ _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int lineno, return p; } +expr_ty +_PyAST_FrozenSetComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena) +{ + expr_ty p; + if (!elt) { + PyErr_SetString(PyExc_ValueError, + "field 'elt' is required for FrozenSetComp"); + return NULL; + } + p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = FrozenSetComp_kind; + p->v.FrozenSetComp.elt = elt; + p->v.FrozenSetComp.generators = generators; + p->lineno = lineno; + p->col_offset = col_offset; + p->end_lineno = end_lineno; + p->end_col_offset = end_col_offset; + return p; +} + expr_ty _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int @@ -8007,6 +8289,31 @@ _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * return p; } +expr_ty +_PyAST_FrozenDictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * + generators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + expr_ty p; + if (!key) { + PyErr_SetString(PyExc_ValueError, + "field 'key' is required for FrozenDictComp"); + return NULL; + } + p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = FrozenDictComp_kind; + p->v.FrozenDictComp.key = key; + p->v.FrozenDictComp.value = value; + p->v.FrozenDictComp.generators = generators; + p->lineno = lineno; + p->col_offset = col_offset; + p->end_lineno = end_lineno; + p->end_col_offset = end_col_offset; + return p; +} + expr_ty _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, int lineno, int col_offset, int end_lineno, int end_col_offset, @@ -9684,6 +9991,23 @@ ast2obj_expr(struct ast_state *state, void* _o) goto failed; Py_DECREF(value); break; + case FrozenDict_kind: + tp = (PyTypeObject *)state->FrozenDict_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_list(state, (asdl_seq*)o->v.FrozenDict.keys, + ast2obj_expr); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->keys, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(state, (asdl_seq*)o->v.FrozenDict.values, + ast2obj_expr); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->values, value) == -1) + goto failed; + Py_DECREF(value); + break; case Set_kind: tp = (PyTypeObject *)state->Set_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -9694,6 +10018,17 @@ ast2obj_expr(struct ast_state *state, void* _o) goto failed; Py_DECREF(value); break; + case FrozenSet_kind: + tp = (PyTypeObject *)state->FrozenSet_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_list(state, (asdl_seq*)o->v.FrozenSet.elts, + ast2obj_expr); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->elts, value) == -1) + goto failed; + Py_DECREF(value); + break; case ListComp_kind: tp = (PyTypeObject *)state->ListComp_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -9726,6 +10061,22 @@ ast2obj_expr(struct ast_state *state, void* _o) goto failed; Py_DECREF(value); break; + case FrozenSetComp_kind: + tp = (PyTypeObject *)state->FrozenSetComp_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(state, o->v.FrozenSetComp.elt); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->elt, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(state, (asdl_seq*)o->v.FrozenSetComp.generators, + ast2obj_comprehension); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->generators, value) == -1) + goto failed; + Py_DECREF(value); + break; case DictComp_kind: tp = (PyTypeObject *)state->DictComp_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -9747,6 +10098,27 @@ ast2obj_expr(struct ast_state *state, void* _o) goto failed; Py_DECREF(value); break; + case FrozenDictComp_kind: + tp = (PyTypeObject *)state->FrozenDictComp_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(state, o->v.FrozenDictComp.key); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->key, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_expr(state, o->v.FrozenDictComp.value); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->value, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_list(state, (asdl_seq*)o->v.FrozenDictComp.generators, + ast2obj_comprehension); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->generators, value) == -1) + goto failed; + Py_DECREF(value); + break; case GeneratorExp_kind: tp = (PyTypeObject *)state->GeneratorExp_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -14369,15 +14741,16 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, const char* if (*out == NULL) goto failed; return 0; } - tp = state->Set_type; + tp = state->FrozenDict_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { return -1; } if (isinstance) { - asdl_expr_seq* elts; + asdl_expr_seq* keys; + asdl_expr_seq* values; - if (PyObject_GetOptionalAttr(obj, state->elts, &tmp) < 0) { + if (PyObject_GetOptionalAttr(obj, state->keys, &tmp) < 0) { return -1; } if (tmp == NULL) { @@ -14391,7 +14764,96 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, const char* Py_ssize_t len; Py_ssize_t i; if (!PyList_Check(tmp)) { - PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %T", tmp); + PyErr_Format(PyExc_TypeError, "FrozenDict field \"keys\" must be a list, not a %T", tmp); + goto failed; + } + len = PyList_GET_SIZE(tmp); + keys = _Py_asdl_expr_seq_new(len, arena); + if (keys == NULL) goto failed; + for (i = 0; i < len; i++) { + expr_ty val; + PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); + if (_Py_EnterRecursiveCall(" while traversing 'FrozenDict' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp2, &val, "keys", arena); + _Py_LeaveRecursiveCall(); + Py_DECREF(tmp2); + if (res != 0) goto failed; + if (len != PyList_GET_SIZE(tmp)) { + PyErr_SetString(PyExc_RuntimeError, "FrozenDict field \"keys\" changed size during iteration"); + goto failed; + } + asdl_seq_SET(keys, i, val); + } + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->values, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + tmp = PyList_New(0); + if (tmp == NULL) { + return -1; + } + } + { + int res; + Py_ssize_t len; + Py_ssize_t i; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "FrozenDict field \"values\" must be a list, not a %T", tmp); + goto failed; + } + len = PyList_GET_SIZE(tmp); + values = _Py_asdl_expr_seq_new(len, arena); + if (values == NULL) goto failed; + for (i = 0; i < len; i++) { + expr_ty val; + PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); + if (_Py_EnterRecursiveCall(" while traversing 'FrozenDict' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp2, &val, "values", arena); + _Py_LeaveRecursiveCall(); + Py_DECREF(tmp2); + if (res != 0) goto failed; + if (len != PyList_GET_SIZE(tmp)) { + PyErr_SetString(PyExc_RuntimeError, "FrozenDict field \"values\" changed size during iteration"); + goto failed; + } + asdl_seq_SET(values, i, val); + } + Py_CLEAR(tmp); + } + *out = _PyAST_FrozenDict(keys, values, lineno, col_offset, end_lineno, + end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } + tp = state->Set_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + asdl_expr_seq* elts; + + if (PyObject_GetOptionalAttr(obj, state->elts, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + tmp = PyList_New(0); + if (tmp == NULL) { + return -1; + } + } + { + int res; + Py_ssize_t len; + Py_ssize_t i; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %T", tmp); goto failed; } len = PyList_GET_SIZE(tmp); @@ -14420,6 +14882,57 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, const char* if (*out == NULL) goto failed; return 0; } + tp = state->FrozenSet_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + asdl_expr_seq* elts; + + if (PyObject_GetOptionalAttr(obj, state->elts, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + tmp = PyList_New(0); + if (tmp == NULL) { + return -1; + } + } + { + int res; + Py_ssize_t len; + Py_ssize_t i; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "FrozenSet field \"elts\" must be a list, not a %T", tmp); + goto failed; + } + len = PyList_GET_SIZE(tmp); + elts = _Py_asdl_expr_seq_new(len, arena); + if (elts == NULL) goto failed; + for (i = 0; i < len; i++) { + expr_ty val; + PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); + if (_Py_EnterRecursiveCall(" while traversing 'FrozenSet' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp2, &val, "elts", arena); + _Py_LeaveRecursiveCall(); + Py_DECREF(tmp2); + if (res != 0) goto failed; + if (len != PyList_GET_SIZE(tmp)) { + PyErr_SetString(PyExc_RuntimeError, "FrozenSet field \"elts\" changed size during iteration"); + goto failed; + } + asdl_seq_SET(elts, i, val); + } + Py_CLEAR(tmp); + } + *out = _PyAST_FrozenSet(elts, lineno, col_offset, end_lineno, + end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->ListComp_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -14558,6 +15071,75 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, const char* if (*out == NULL) goto failed; return 0; } + tp = state->FrozenSetComp_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + expr_ty elt; + asdl_comprehension_seq* generators; + + if (PyObject_GetOptionalAttr(obj, state->elt, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"elt\" missing from FrozenSetComp"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'FrozenSetComp' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &elt, "elt", arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->generators, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + tmp = PyList_New(0); + if (tmp == NULL) { + return -1; + } + } + { + int res; + Py_ssize_t len; + Py_ssize_t i; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "FrozenSetComp field \"generators\" must be a list, not a %T", tmp); + goto failed; + } + len = PyList_GET_SIZE(tmp); + generators = _Py_asdl_comprehension_seq_new(len, arena); + if (generators == NULL) goto failed; + for (i = 0; i < len; i++) { + comprehension_ty val; + PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); + if (_Py_EnterRecursiveCall(" while traversing 'FrozenSetComp' node")) { + goto failed; + } + res = obj2ast_comprehension(state, tmp2, &val, "generators", arena); + _Py_LeaveRecursiveCall(); + Py_DECREF(tmp2); + if (res != 0) goto failed; + if (len != PyList_GET_SIZE(tmp)) { + PyErr_SetString(PyExc_RuntimeError, "FrozenSetComp field \"generators\" changed size during iteration"); + goto failed; + } + asdl_seq_SET(generators, i, val); + } + Py_CLEAR(tmp); + } + *out = _PyAST_FrozenSetComp(elt, generators, lineno, col_offset, + end_lineno, end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->DictComp_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -14645,6 +15227,94 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, const char* if (*out == NULL) goto failed; return 0; } + tp = state->FrozenDictComp_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + expr_ty key; + expr_ty value; + asdl_comprehension_seq* generators; + + if (PyObject_GetOptionalAttr(obj, state->key, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"key\" missing from FrozenDictComp"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'FrozenDictComp' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &key, "key", arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { + return -1; + } + if (tmp == NULL || tmp == Py_None) { + Py_CLEAR(tmp); + value = NULL; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'FrozenDictComp' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &value, "value", arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->generators, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + tmp = PyList_New(0); + if (tmp == NULL) { + return -1; + } + } + { + int res; + Py_ssize_t len; + Py_ssize_t i; + if (!PyList_Check(tmp)) { + PyErr_Format(PyExc_TypeError, "FrozenDictComp field \"generators\" must be a list, not a %T", tmp); + goto failed; + } + len = PyList_GET_SIZE(tmp); + generators = _Py_asdl_comprehension_seq_new(len, arena); + if (generators == NULL) goto failed; + for (i = 0; i < len; i++) { + comprehension_ty val; + PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); + if (_Py_EnterRecursiveCall(" while traversing 'FrozenDictComp' node")) { + goto failed; + } + res = obj2ast_comprehension(state, tmp2, &val, "generators", arena); + _Py_LeaveRecursiveCall(); + Py_DECREF(tmp2); + if (res != 0) goto failed; + if (len != PyList_GET_SIZE(tmp)) { + PyErr_SetString(PyExc_RuntimeError, "FrozenDictComp field \"generators\" changed size during iteration"); + goto failed; + } + asdl_seq_SET(generators, i, val); + } + Py_CLEAR(tmp); + } + *out = _PyAST_FrozenDictComp(key, value, generators, lineno, + col_offset, end_lineno, end_col_offset, + arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->GeneratorExp_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -18251,18 +18921,32 @@ astmodule_exec(PyObject *m) if (PyModule_AddObjectRef(m, "Dict", state->Dict_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "FrozenDict", state->FrozenDict_type) < 0) { + return -1; + } if (PyModule_AddObjectRef(m, "Set", state->Set_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "FrozenSet", state->FrozenSet_type) < 0) { + return -1; + } if (PyModule_AddObjectRef(m, "ListComp", state->ListComp_type) < 0) { return -1; } if (PyModule_AddObjectRef(m, "SetComp", state->SetComp_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "FrozenSetComp", state->FrozenSetComp_type) < + 0) { + return -1; + } if (PyModule_AddObjectRef(m, "DictComp", state->DictComp_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "FrozenDictComp", state->FrozenDictComp_type) + < 0) { + return -1; + } if (PyModule_AddObjectRef(m, "GeneratorExp", state->GeneratorExp_type) < 0) { return -1; diff --git a/Python/ast.c b/Python/ast.c index 4cfa2ff559a5f7d..c365e15f95417aa 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -280,36 +280,51 @@ validate_expr(expr_ty exp, expr_context_ty ctx) validate_expr(exp->v.IfExp.body, Load) && validate_expr(exp->v.IfExp.orelse, Load); break; - case Dict_kind: - if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) { - PyErr_SetString(PyExc_ValueError, - "Dict doesn't have the same number of keys as values"); - return 0; - } - /* null_ok=1 for keys expressions to allow dict unpacking to work in - dict literals, i.e. ``{**{a:b}}`` */ - ret = validate_exprs(exp->v.Dict.keys, Load, /*null_ok=*/ 1) && - validate_exprs(exp->v.Dict.values, Load, /*null_ok=*/ 0); - break; +#define DICT_CASE(NAME) \ + case NAME ## _kind: \ + if (asdl_seq_LEN(exp->v.NAME.keys) != asdl_seq_LEN(exp->v.NAME.values)) { \ + PyErr_SetString(PyExc_ValueError, \ + "NAME doesn't have the same number of keys as values"); \ + return 0; \ + } \ + /* null_ok=1 for keys expressions to allow dict unpacking to work in \ + dict literals, i.e. ``{**{a:b}}`` */ \ + ret = validate_exprs(exp->v.NAME.keys, Load, /*null_ok=*/ 1) && \ + validate_exprs(exp->v.NAME.values, Load, /*null_ok=*/ 0); \ + break; + + DICT_CASE(Dict) + DICT_CASE(FrozenDict) +#undef DICT_CASE case Set_kind: ret = validate_exprs(exp->v.Set.elts, Load, 0); break; + case FrozenSet_kind: + ret = validate_exprs(exp->v.FrozenSet.elts, Load, 0); + break; #define COMP(NAME) \ case NAME ## _kind: \ ret = validate_comprehension(exp->v.NAME.generators) && \ validate_expr(exp->v.NAME.elt, Load); \ break; + COMP(ListComp) COMP(SetComp) + COMP(FrozenSetComp) COMP(GeneratorExp) #undef COMP - case DictComp_kind: - ret = validate_comprehension(exp->v.DictComp.generators) && - validate_expr(exp->v.DictComp.key, Load); - if (ret && exp->v.DictComp.value != NULL){ - ret = validate_expr(exp->v.DictComp.value, Load); - } - break; +#define DICTCOMP(NAME) \ + case NAME ## _kind: \ + ret = validate_comprehension(exp->v.NAME.generators) && \ + validate_expr(exp->v.NAME.key, Load); \ + if (ret && exp->v.NAME.value != NULL) { \ + ret = validate_expr(exp->v.NAME.value, Load); \ + } \ + break; + + DICTCOMP(DictComp) + DICTCOMP(FrozenDictComp) +#undef DICTCOMP case Yield_kind: ret = !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load); break; diff --git a/Python/ast_preprocess.c b/Python/ast_preprocess.c index 54dec3dfe042686..f5b8ed40da8e131 100644 --- a/Python/ast_preprocess.c +++ b/Python/ast_preprocess.c @@ -544,9 +544,16 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTPreprocessState *state) CALL_SEQ(astfold_expr, expr, node_->v.Dict.keys); CALL_SEQ(astfold_expr, expr, node_->v.Dict.values); break; + case FrozenDict_kind: + CALL_SEQ(astfold_expr, expr, node_->v.FrozenDict.keys); + CALL_SEQ(astfold_expr, expr, node_->v.FrozenDict.values); + break; case Set_kind: CALL_SEQ(astfold_expr, expr, node_->v.Set.elts); break; + case FrozenSet_kind: + CALL_SEQ(astfold_expr, expr, node_->v.FrozenSet.elts); + break; case ListComp_kind: CALL(astfold_expr, expr_ty, node_->v.ListComp.elt); CALL_SEQ(astfold_comprehension, comprehension, node_->v.ListComp.generators); @@ -555,6 +562,10 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTPreprocessState *state) CALL(astfold_expr, expr_ty, node_->v.SetComp.elt); CALL_SEQ(astfold_comprehension, comprehension, node_->v.SetComp.generators); break; + case FrozenSetComp_kind: + CALL(astfold_expr, expr_ty, node_->v.FrozenSetComp.elt); + CALL_SEQ(astfold_comprehension, comprehension, node_->v.FrozenSetComp.generators); + break; case DictComp_kind: CALL(astfold_expr, expr_ty, node_->v.DictComp.key); if (node_->v.DictComp.value != NULL){ @@ -562,6 +573,13 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTPreprocessState *state) } CALL_SEQ(astfold_comprehension, comprehension, node_->v.DictComp.generators); break; + case FrozenDictComp_kind: + CALL(astfold_expr, expr_ty, node_->v.FrozenDictComp.key); + if (node_->v.FrozenDictComp.value != NULL){ + CALL(astfold_expr, expr_ty, node_->v.FrozenDictComp.value); + } + CALL_SEQ(astfold_comprehension, comprehension, node_->v.FrozenDictComp.generators); + break; case GeneratorExp_kind: CALL(astfold_expr, expr_ty, node_->v.GeneratorExp.elt); CALL_SEQ(astfold_comprehension, comprehension, node_->v.GeneratorExp.generators); diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index 6050c351cff68f0..5526376aba443fe 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -323,47 +323,52 @@ append_ast_ifexp(PyUnicodeWriter *writer, expr_ty e, int level) return 0; } -static int -append_ast_dict(PyUnicodeWriter *writer, expr_ty e) -{ - Py_ssize_t i, value_count; - expr_ty key_node; - - APPEND_CHAR('{'); - value_count = asdl_seq_LEN(e->v.Dict.values); - - for (i = 0; i < value_count; i++) { - APPEND_STR_IF(i > 0, ", "); - key_node = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i); - if (key_node != NULL) { - APPEND_EXPR(key_node, PR_TEST); - APPEND_STR(": "); - APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_TEST); - } - else { - APPEND_STR("**"); - APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Dict.values, i), PR_EXPR); - } - } - - APPEND_CHAR_FINISH('}'); +#define DICT_LIKE(NAME, START) \ +static int \ +append_ast_ ## NAME(PyUnicodeWriter *writer, expr_ty e) \ +{ \ + Py_ssize_t i, value_count; \ + expr_ty key_node; \ + APPEND_STR(START); \ + value_count = asdl_seq_LEN(e->v.NAME.values); \ + for (i = 0; i < value_count; i++) { \ + APPEND_STR_IF(i > 0, ", "); \ + key_node = (expr_ty)asdl_seq_GET(e->v.NAME.keys, i); \ + if (key_node != NULL) { \ + APPEND_EXPR(key_node, PR_TEST); \ + APPEND_STR(": "); \ + APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.NAME.values, i), PR_TEST); \ + } \ + else { \ + APPEND_STR("**"); \ + APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.NAME.values, i), PR_EXPR); \ + } \ + } \ + APPEND_CHAR_FINISH('}'); \ } -static int -append_ast_set(PyUnicodeWriter *writer, expr_ty e) -{ - Py_ssize_t i, elem_count; - - APPEND_CHAR('{'); - elem_count = asdl_seq_LEN(e->v.Set.elts); - for (i = 0; i < elem_count; i++) { - APPEND_STR_IF(i > 0, ", "); - APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.Set.elts, i), PR_TEST); - } - - APPEND_CHAR_FINISH('}'); +DICT_LIKE(Dict, "{") +DICT_LIKE(FrozenDict, "f{") +#undef DICT_LIKE + +#define SET_LIKE(NAME, START) \ +static int \ +append_ast_ ## NAME(PyUnicodeWriter *writer, expr_ty e) \ +{ \ + Py_ssize_t i, elem_count; \ + APPEND_STR(START); \ + elem_count = asdl_seq_LEN(e->v.NAME.elts); \ + for (i = 0; i < elem_count; i++) { \ + APPEND_STR_IF(i > 0, ", "); \ + APPEND_EXPR((expr_ty)asdl_seq_GET(e->v.NAME.elts, i), PR_TEST); \ + } \ + APPEND_CHAR_FINISH('}'); \ } +SET_LIKE(Set, "{") +SET_LIKE(FrozenSet, "f{") +#undef SET_LIKE + static int append_ast_list(PyUnicodeWriter *writer, expr_ty e) { @@ -451,32 +456,42 @@ append_ast_listcomp(PyUnicodeWriter *writer, expr_ty e) APPEND_CHAR_FINISH(']'); } -static int -append_ast_setcomp(PyUnicodeWriter *writer, expr_ty e) -{ - APPEND_CHAR('{'); - APPEND_EXPR(e->v.SetComp.elt, PR_TEST); - APPEND(comprehensions, e->v.SetComp.generators); - APPEND_CHAR_FINISH('}'); +#define SETCOMP(NAME, START) \ +static int \ +append_ast_ ## NAME(PyUnicodeWriter *writer, expr_ty e) \ +{ \ + APPEND_STR(START); \ + APPEND_EXPR(e->v.NAME.elt, PR_TEST); \ + APPEND(comprehensions, e->v.NAME.generators); \ + APPEND_CHAR_FINISH('}'); \ } -static int -append_ast_dictcomp(PyUnicodeWriter *writer, expr_ty e) -{ - APPEND_CHAR('{'); - if (e->v.DictComp.value) { - APPEND_EXPR(e->v.DictComp.key, PR_TEST); - APPEND_STR(": "); - APPEND_EXPR(e->v.DictComp.value, PR_TEST); - } - else { - APPEND_STR("**"); - APPEND_EXPR(e->v.DictComp.key, PR_TEST); - } - APPEND(comprehensions, e->v.DictComp.generators); - APPEND_CHAR_FINISH('}'); +SETCOMP(SetComp, "{") +SETCOMP(FrozenSetComp, "f{") +#undef SETCOMP + +#define DICTCOMP(NAME, START) \ +static int \ +append_ast_ ## NAME(PyUnicodeWriter *writer, expr_ty e) \ +{ \ + APPEND_STR(START); \ + if (e->v.NAME.value) { \ + APPEND_EXPR(e->v.NAME.key, PR_TEST); \ + APPEND_STR(": "); \ + APPEND_EXPR(e->v.NAME.value, PR_TEST); \ + } \ + else { \ + APPEND_STR("**"); \ + APPEND_EXPR(e->v.NAME.key, PR_TEST); \ + } \ + APPEND(comprehensions, e->v.NAME.generators); \ + APPEND_CHAR_FINISH('}'); \ } +DICTCOMP(DictComp, "{") +DICTCOMP(FrozenDictComp, "f{") +#undef DICTCOMP + static int append_ast_compare(PyUnicodeWriter *writer, expr_ty e, int level) { @@ -951,17 +966,25 @@ append_ast_expr(PyUnicodeWriter *writer, expr_ty e, int level) case IfExp_kind: return append_ast_ifexp(writer, e, level); case Dict_kind: - return append_ast_dict(writer, e); + return append_ast_Dict(writer, e); + case FrozenDict_kind: + return append_ast_FrozenDict(writer, e); case Set_kind: - return append_ast_set(writer, e); + return append_ast_Set(writer, e); + case FrozenSet_kind: + return append_ast_FrozenSet(writer, e); case GeneratorExp_kind: return append_ast_genexp(writer, e); case ListComp_kind: return append_ast_listcomp(writer, e); case SetComp_kind: - return append_ast_setcomp(writer, e); + return append_ast_SetComp(writer, e); + case FrozenSetComp_kind: + return append_ast_FrozenSetComp(writer, e); case DictComp_kind: - return append_ast_dictcomp(writer, e); + return append_ast_DictComp(writer, e); + case FrozenDictComp_kind: + return append_ast_FrozenDictComp(writer, e); case Yield_kind: return append_ast_yield(writer, e); case YieldFrom_kind: diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 753530b0dabff31..cff784f30ffb3f0 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -2560,18 +2560,24 @@ dummy_func( DECREF_INPUTS(); ERROR_IF(true); } + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + DEAD(values); + if (err) { + Py_DECREF(set_o); + ERROR_IF(true); + } - int err = 0; - for (Py_ssize_t i = 0; i < oparg; i++) { - _PyStackRef value = values[i]; - values[i] = PyStackRef_NULL; - if (err == 0) { - err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); - } - else { - PyStackRef_CLOSE(value); - } + INPUTS_DEAD(); + set = PyStackRef_FromPyObjectStealMortal(set_o); + } + + inst(BUILD_FROZENSET, (values[oparg] -- set)) { + PyObject *set_o = PyFrozenSet_New(NULL); + if (set_o == NULL) { + DECREF_INPUTS(); + ERROR_IF(true); } + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); DEAD(values); if (err) { Py_DECREF(set_o); @@ -2583,13 +2589,21 @@ dummy_func( } inst(BUILD_MAP, (values[oparg*2] -- map)) { - PyObject *map_o = _Py_BuildMap_StackRefSteal(values, oparg); DEAD(values); ERROR_IF(map_o == NULL); map = PyStackRef_FromPyObjectStealMortal(map_o); } + inst(BUILD_FROZENDICT, (dict -- map)) { + PyObject *dict_o = PyStackRef_AsPyObjectSteal(dict); + // TODO: use `PyFrozenDict_FromDictSteal` API here: + PyObject *map_o = PyFrozenDict_New(dict_o); + Py_DECREF(dict_o); + ERROR_IF(map_o == NULL); + map = PyStackRef_FromPyObjectStealMortal(map_o); + } + inst(SETUP_ANNOTATIONS, (--)) { if (LOCALS() == NULL) { _PyErr_Format(tstate, PyExc_SystemError, diff --git a/Python/ceval.c b/Python/ceval.c index f3f03b28112137a..dbfe275cb967e6a 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -958,6 +958,26 @@ _Py_BuildMap_StackRefSteal( return res; } +int +_Py_BuildSet_StackRefSteal( + PyObject *set_o, + _PyStackRef *values, + int oparg) +{ + int err = 0; + for (Py_ssize_t i = 0; i < oparg; i++) { + _PyStackRef value = values[i]; + values[i] = PyStackRef_NULL; + if (err == 0) { + err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); + } + else { + PyStackRef_CLOSE(value); + } + } + return err; +} + _PyStackRef _Py_LoadAttr_StackRefSteal( PyThreadState *tstate, _PyStackRef owner, diff --git a/Python/codegen.c b/Python/codegen.c index fa8c4ce88956557..9a0d3ffa24a3051 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -37,10 +37,12 @@ #include -#define COMP_GENEXP 0 -#define COMP_LISTCOMP 1 -#define COMP_SETCOMP 2 -#define COMP_DICTCOMP 3 +#define COMP_GENEXP 0 +#define COMP_LISTCOMP 1 +#define COMP_SETCOMP 2 +#define COMP_DICTCOMP 3 +#define COMP_FROZENSETCOMP 4 +#define COMP_FROZENDICTCOMP 5 #undef SUCCESS #undef ERROR @@ -3591,7 +3593,17 @@ codegen_set(compiler *c, expr_ty e) } static int -codegen_subdict(compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end) +codegen_frozenset(compiler *c, expr_ty e) +{ + location loc = LOC(e); + return starunpack_helper(c, loc, e->v.FrozenSet.elts, 0, + BUILD_FROZENSET, SET_ADD, SET_UPDATE, 0); +} + +static int +codegen_subdict(compiler *c, expr_ty e, + asdl_expr_seq *keys, asdl_expr_seq *values, + Py_ssize_t begin, Py_ssize_t end) { Py_ssize_t i, n = end - begin; int big = n*2 > _PY_STACK_USE_GUIDELINE; @@ -3600,8 +3612,8 @@ codegen_subdict(compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end) ADDOP_I(c, loc, BUILD_MAP, 0); } for (i = begin; i < end; i++) { - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.keys, i)); - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(keys, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(values, i)); if (big) { ADDOP_I(c, loc, MAP_ADD, 1); } @@ -3613,20 +3625,22 @@ codegen_subdict(compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end) } static int -codegen_dict(compiler *c, expr_ty e) +dict_codegen_impl(compiler *c, expr_ty e, + asdl_expr_seq *keys, asdl_expr_seq *values, + int is_frozen) { location loc = LOC(e); Py_ssize_t i, n, elements; int have_dict; int is_unpacking = 0; - n = asdl_seq_LEN(e->v.Dict.values); + n = asdl_seq_LEN(values); have_dict = 0; elements = 0; for (i = 0; i < n; i++) { - is_unpacking = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i) == NULL; + is_unpacking = (expr_ty)asdl_seq_GET(keys, i) == NULL; if (is_unpacking) { if (elements) { - RETURN_IF_ERROR(codegen_subdict(c, e, i - elements, i)); + RETURN_IF_ERROR(codegen_subdict(c, e, keys, values, i - elements, i)); if (have_dict) { ADDOP_I(c, loc, DICT_UPDATE, 1); } @@ -3637,12 +3651,12 @@ codegen_dict(compiler *c, expr_ty e) ADDOP_I(c, loc, BUILD_MAP, 0); have_dict = 1; } - VISIT(c, expr, (expr_ty)asdl_seq_GET(e->v.Dict.values, i)); + VISIT(c, expr, (expr_ty)asdl_seq_GET(values, i)); ADDOP_I(c, loc, DICT_UPDATE, 1); } else { if (elements*2 > _PY_STACK_USE_GUIDELINE) { - RETURN_IF_ERROR(codegen_subdict(c, e, i - elements, i + 1)); + RETURN_IF_ERROR(codegen_subdict(c, e, keys, values, i - elements, i + 1)); if (have_dict) { ADDOP_I(c, loc, DICT_UPDATE, 1); } @@ -3655,7 +3669,7 @@ codegen_dict(compiler *c, expr_ty e) } } if (elements) { - RETURN_IF_ERROR(codegen_subdict(c, e, n - elements, n)); + RETURN_IF_ERROR(codegen_subdict(c, e, keys, values, n - elements, n)); if (have_dict) { ADDOP_I(c, loc, DICT_UPDATE, 1); } @@ -3664,9 +3678,26 @@ codegen_dict(compiler *c, expr_ty e) if (!have_dict) { ADDOP_I(c, loc, BUILD_MAP, 0); } + if (is_frozen) { + ADDOP(c, loc, BUILD_FROZENDICT); + } return SUCCESS; } +static int +codegen_dict(compiler *c, expr_ty e) +{ + return dict_codegen_impl(c, e, e->v.Dict.keys, e->v.Dict.values, 0); +} + +static int +codegen_frozendict(compiler *c, expr_ty e) +{ + return dict_codegen_impl(c, e, + e->v.FrozenDict.keys, + e->v.FrozenDict.values, /* is_frozen */ 1); +} + static int codegen_compare(compiler *c, expr_ty e) { @@ -4675,6 +4706,7 @@ codegen_sync_comprehension_generator(compiler *c, location loc, ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); } break; + case COMP_FROZENSETCOMP: _Py_FALLTHROUGH; case COMP_SETCOMP: if (elt->kind == Starred_kind) { VISIT(c, expr, elt->v.Starred.value); @@ -4685,6 +4717,7 @@ codegen_sync_comprehension_generator(compiler *c, location loc, ADDOP_I(c, elt_loc, SET_ADD, depth + 1); } break; + case COMP_FROZENDICTCOMP: _Py_FALLTHROUGH; case COMP_DICTCOMP: if (val == NULL) { /* unpacking (**) case */ @@ -4818,6 +4851,7 @@ codegen_async_comprehension_generator(compiler *c, location loc, ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); } break; + case COMP_FROZENSETCOMP: _Py_FALLTHROUGH; case COMP_SETCOMP: if (elt->kind == Starred_kind) { VISIT(c, expr, elt->v.Starred.value); @@ -4828,6 +4862,7 @@ codegen_async_comprehension_generator(compiler *c, location loc, ADDOP_I(c, elt_loc, SET_ADD, depth + 1); } break; + case COMP_FROZENDICTCOMP: _Py_FALLTHROUGH; case COMP_DICTCOMP: if (val == NULL) { /* unpacking (**) case */ @@ -5067,9 +5102,15 @@ codegen_comprehension(compiler *c, expr_ty e, int type, case COMP_SETCOMP: op = BUILD_SET; break; + case COMP_FROZENSETCOMP: + op = BUILD_FROZENSET; + break; case COMP_DICTCOMP: op = BUILD_MAP; break; + case COMP_FROZENDICTCOMP: + op = BUILD_MAP; + break; default: PyErr_Format(PyExc_SystemError, "unknown comprehension type %d", type); @@ -5086,6 +5127,10 @@ codegen_comprehension(compiler *c, expr_ty e, int type, goto error_in_scope; } + if (type == COMP_FROZENDICTCOMP) { + ADDOP(c, LOC(e), BUILD_FROZENDICT); + } + if (is_inlined) { if (pop_inlined_comprehension_state(c, loc, &inline_state)) { goto error; @@ -5168,6 +5213,15 @@ codegen_setcomp(compiler *c, expr_ty e) e->v.SetComp.elt, NULL); } +static int +codegen_frozensetcomp(compiler *c, expr_ty e) +{ + assert(e->kind == FrozenSetComp_kind); + _Py_DECLARE_STR(anon_frozensetcomp, ""); + return codegen_comprehension(c, e, COMP_FROZENSETCOMP, &_Py_STR(anon_frozensetcomp), + e->v.FrozenSetComp.generators, + e->v.FrozenSetComp.elt, NULL); +} static int codegen_dictcomp(compiler *c, expr_ty e) @@ -5179,6 +5233,16 @@ codegen_dictcomp(compiler *c, expr_ty e) e->v.DictComp.key, e->v.DictComp.value); } +static int +codegen_frozendictcomp(compiler *c, expr_ty e) +{ + assert(e->kind == FrozenDictComp_kind); + _Py_DECLARE_STR(anon_frozendictcomp, ""); + return codegen_comprehension(c, e, COMP_FROZENDICTCOMP, &_Py_STR(anon_frozendictcomp), + e->v.FrozenDictComp.generators, + e->v.FrozenDictComp.key, e->v.FrozenDictComp.value); +} + static int codegen_visit_keyword(compiler *c, keyword_ty k) @@ -5462,16 +5526,24 @@ codegen_visit_expr(compiler *c, expr_ty e) return codegen_ifexp(c, e); case Dict_kind: return codegen_dict(c, e); + case FrozenDict_kind: + return codegen_frozendict(c, e); case Set_kind: return codegen_set(c, e); + case FrozenSet_kind: + return codegen_frozenset(c, e); case GeneratorExp_kind: return codegen_genexp(c, e); case ListComp_kind: return codegen_listcomp(c, e); case SetComp_kind: return codegen_setcomp(c, e); + case FrozenSetComp_kind: + return codegen_frozensetcomp(c, e); case DictComp_kind: return codegen_dictcomp(c, e); + case FrozenDictComp_kind: + return codegen_frozendictcomp(c, e); case Yield_kind: if (!_PyST_IsFunctionLike(SYMTABLE_ENTRY(c))) { return _PyCompile_Error(c, loc, "'yield' outside function"); diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 96dea2d2a6d5bc1..bbf9bad5df97578 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -11002,23 +11002,61 @@ SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - int err = 0; - for (Py_ssize_t i = 0; i < oparg; i++) { - _PyStackRef value = values[i]; - values[i] = PyStackRef_NULL; - if (err == 0) { - assert(stack_pointer == _PyFrame_GetStackPointer(frame)); - _PyFrame_StackPointerValidate(frame); - err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); - _PyFrame_StackPointerInvalidate(frame); - } - else { - assert(stack_pointer == _PyFrame_GetStackPointer(frame)); - _PyFrame_StackPointerValidate(frame); - PyStackRef_CLOSE(value); - _PyFrame_StackPointerInvalidate(frame); + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + _PyFrame_StackPointerInvalidate(frame); + if (err) { + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + Py_DECREF(set_o); + _PyFrame_StackPointerInvalidate(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + set = PyStackRef_FromPyObjectStealMortal(set_o); + _tos_cache0 = set; + _tos_cache1 = PyStackRef_ZERO_BITS; + _tos_cache2 = PyStackRef_ZERO_BITS; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__); + break; + } + + case _BUILD_FROZENSET_r01: { + CHECK_CURRENT_CACHED_VALUES(0); + ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__); + _PyStackRef *values; + _PyStackRef set; + oparg = CURRENT_OPARG(); + values = &stack_pointer[-oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + PyObject *set_o = PyFrozenSet_New(NULL); + _PyFrame_StackPointerInvalidate(frame); + if (set_o == NULL) { + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + _PyStackRef tmp; + for (int _i = oparg; --_i >= 0;) { + tmp = values[_i]; + values[_i] = PyStackRef_NULL; + PyStackRef_CLOSE(tmp); } + _PyFrame_StackPointerInvalidate(frame); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + _PyFrame_StackPointerInvalidate(frame); if (err) { stack_pointer += -oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); @@ -11068,6 +11106,35 @@ break; } + case _BUILD_FROZENDICT_r11: { + CHECK_CURRENT_CACHED_VALUES(1); + ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__); + _PyStackRef dict; + _PyStackRef map; + _PyStackRef _stack_item_0 = _tos_cache0; + dict = _stack_item_0; + PyObject *dict_o = PyStackRef_AsPyObjectSteal(dict); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + PyObject *map_o = PyFrozenDict_New(dict_o); + _PyFrame_StackPointerInvalidate(frame); + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + Py_DECREF(dict_o); + _PyFrame_StackPointerInvalidate(frame); + if (map_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + map = PyStackRef_FromPyObjectStealMortal(map_o); + _tos_cache0 = map; + _tos_cache1 = PyStackRef_ZERO_BITS; + _tos_cache2 = PyStackRef_ZERO_BITS; + SET_CURRENT_CACHED_VALUES(1); + ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__); + break; + } + case _SETUP_ANNOTATIONS_r00: { CHECK_CURRENT_CACHED_VALUES(0); ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 88678f14a99585f..ea514128445b532 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1498,6 +1498,87 @@ DISPATCH(); } + TARGET(BUILD_FROZENDICT) { + #if _Py_TAIL_CALL_INTERP + int opcode = BUILD_FROZENDICT; + (void)(opcode); + #endif + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_FROZENDICT); + _PyStackRef dict; + _PyStackRef map; + dict = stack_pointer[-1]; + PyObject *dict_o = PyStackRef_AsPyObjectSteal(dict); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + PyObject *map_o = PyFrozenDict_New(dict_o); + _PyFrame_StackPointerInvalidate(frame); + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + Py_DECREF(dict_o); + _PyFrame_StackPointerInvalidate(frame); + if (map_o == NULL) { + JUMP_TO_LABEL(error); + } + map = PyStackRef_FromPyObjectStealMortal(map_o); + stack_pointer[0] = map; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + DISPATCH(); + } + + TARGET(BUILD_FROZENSET) { + #if _Py_TAIL_CALL_INTERP + int opcode = BUILD_FROZENSET; + (void)(opcode); + #endif + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_FROZENSET); + _PyStackRef *values; + _PyStackRef set; + values = &stack_pointer[-oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + PyObject *set_o = PyFrozenSet_New(NULL); + _PyFrame_StackPointerInvalidate(frame); + if (set_o == NULL) { + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + _PyStackRef tmp; + for (int _i = oparg; --_i >= 0;) { + tmp = values[_i]; + values[_i] = PyStackRef_NULL; + PyStackRef_CLOSE(tmp); + } + _PyFrame_StackPointerInvalidate(frame); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_LABEL(error); + } + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + _PyFrame_StackPointerInvalidate(frame); + if (err) { + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyFrame_StackPointerValidate(frame); + Py_DECREF(set_o); + _PyFrame_StackPointerInvalidate(frame); + JUMP_TO_LABEL(error); + } + set = PyStackRef_FromPyObjectStealMortal(set_o); + stack_pointer[-oparg] = set; + stack_pointer += 1 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + DISPATCH(); + } + TARGET(BUILD_INTERPOLATION) { #if _Py_TAIL_CALL_INTERP int opcode = BUILD_INTERPOLATION; @@ -1641,23 +1722,10 @@ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); JUMP_TO_LABEL(error); } - int err = 0; - for (Py_ssize_t i = 0; i < oparg; i++) { - _PyStackRef value = values[i]; - values[i] = PyStackRef_NULL; - if (err == 0) { - assert(stack_pointer == _PyFrame_GetStackPointer(frame)); - _PyFrame_StackPointerValidate(frame); - err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); - _PyFrame_StackPointerInvalidate(frame); - } - else { - assert(stack_pointer == _PyFrame_GetStackPointer(frame)); - _PyFrame_StackPointerValidate(frame); - PyStackRef_CLOSE(value); - _PyFrame_StackPointerInvalidate(frame); - } - } + assert(stack_pointer == _PyFrame_GetStackPointer(frame)); + _PyFrame_StackPointerValidate(frame); + int err = _Py_BuildSet_StackRefSteal(set_o, values, oparg); + _PyFrame_StackPointerInvalidate(frame); if (err) { stack_pointer += -oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 9133af142723484..3eae2191e470fe0 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -2,8 +2,9 @@ static void *opcode_targets_table[256] = { &&TARGET_CACHE, &&TARGET_BINARY_SLICE, - &&TARGET_BUILD_TEMPLATE, + &&TARGET_BUILD_FROZENDICT, &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, + &&TARGET_BUILD_TEMPLATE, &&TARGET_CALL_FUNCTION_EX, &&TARGET_CHECK_EG_MATCH, &&TARGET_CHECK_EXC_MATCH, @@ -16,8 +17,8 @@ static void *opcode_targets_table[256] = { &&TARGET_FORMAT_WITH_SPEC, &&TARGET_GET_AITER, &&TARGET_GET_ANEXT, - &&TARGET_GET_LEN, &&TARGET_RESERVED, + &&TARGET_GET_LEN, &&TARGET_INTERPRETER_EXIT, &&TARGET_LOAD_BUILD_CLASS, &&TARGET_LOAD_LOCALS, @@ -43,6 +44,7 @@ static void *opcode_targets_table[256] = { &&TARGET_UNARY_NOT, &&TARGET_WITH_EXCEPT_START, &&TARGET_BINARY_OP, + &&TARGET_BUILD_FROZENSET, &&TARGET_BUILD_INTERPOLATION, &&TARGET_BUILD_LIST, &&TARGET_BUILD_MAP, @@ -126,8 +128,6 @@ static void *opcode_targets_table[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, @@ -377,8 +377,8 @@ static void *opcode_tracing_targets_table[256] = { &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, &&TARGET_TRACE_RECORD, - &&_unknown_opcode, - &&_unknown_opcode, + &&TARGET_TRACE_RECORD, + &&TARGET_TRACE_RECORD, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, @@ -549,6 +549,8 @@ static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_OP_SUBSCR_USTR_INT(TAIL_C static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_OP_SUBTRACT_FLOAT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_OP_SUBTRACT_INT(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BINARY_SLICE(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_FROZENDICT(TAIL_CALL_PARAMS); +static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_FROZENSET(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_INTERPOLATION(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_LIST(TAIL_CALL_PARAMS); static PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_BUILD_MAP(TAIL_CALL_PARAMS); @@ -793,6 +795,8 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [BINARY_OP_SUBTRACT_FLOAT] = _TAIL_CALL_BINARY_OP_SUBTRACT_FLOAT, [BINARY_OP_SUBTRACT_INT] = _TAIL_CALL_BINARY_OP_SUBTRACT_INT, [BINARY_SLICE] = _TAIL_CALL_BINARY_SLICE, + [BUILD_FROZENDICT] = _TAIL_CALL_BUILD_FROZENDICT, + [BUILD_FROZENSET] = _TAIL_CALL_BUILD_FROZENSET, [BUILD_INTERPOLATION] = _TAIL_CALL_BUILD_INTERPOLATION, [BUILD_LIST] = _TAIL_CALL_BUILD_LIST, [BUILD_MAP] = _TAIL_CALL_BUILD_MAP, @@ -1007,8 +1011,6 @@ static py_tail_call_funcptr instruction_funcptr_handler_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_UNPACK_SEQUENCE_TWO_TUPLE, [WITH_EXCEPT_START] = _TAIL_CALL_WITH_EXCEPT_START, [YIELD_VALUE] = _TAIL_CALL_YIELD_VALUE, - [118] = _TAIL_CALL_UNKNOWN_OPCODE, - [119] = _TAIL_CALL_UNKNOWN_OPCODE, [120] = _TAIL_CALL_UNKNOWN_OPCODE, [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, @@ -1051,6 +1053,8 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [BINARY_OP_SUBTRACT_FLOAT] = _TAIL_CALL_TRACE_RECORD, [BINARY_OP_SUBTRACT_INT] = _TAIL_CALL_TRACE_RECORD, [BINARY_SLICE] = _TAIL_CALL_TRACE_RECORD, + [BUILD_FROZENDICT] = _TAIL_CALL_TRACE_RECORD, + [BUILD_FROZENSET] = _TAIL_CALL_TRACE_RECORD, [BUILD_INTERPOLATION] = _TAIL_CALL_TRACE_RECORD, [BUILD_LIST] = _TAIL_CALL_TRACE_RECORD, [BUILD_MAP] = _TAIL_CALL_TRACE_RECORD, @@ -1265,8 +1269,6 @@ static py_tail_call_funcptr instruction_funcptr_tracing_table[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = _TAIL_CALL_TRACE_RECORD, [WITH_EXCEPT_START] = _TAIL_CALL_TRACE_RECORD, [YIELD_VALUE] = _TAIL_CALL_TRACE_RECORD, - [118] = _TAIL_CALL_UNKNOWN_OPCODE, - [119] = _TAIL_CALL_UNKNOWN_OPCODE, [120] = _TAIL_CALL_UNKNOWN_OPCODE, [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 2bc589e86fee279..320638a6a22099c 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -2461,6 +2461,16 @@ break; } + case _BUILD_FROZENSET: { + JitOptRef set; + set = sym_new_not_null(ctx); + CHECK_STACK_BOUNDS(1 - oparg); + stack_pointer[-oparg] = set; + stack_pointer += 1 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + break; + } + case _BUILD_MAP: { JitOptRef map; map = sym_new_type(ctx, &PyDict_Type); @@ -2471,6 +2481,13 @@ break; } + case _BUILD_FROZENDICT: { + JitOptRef map; + map = sym_new_not_null(ctx); + stack_pointer[-1] = map; + break; + } + case _SETUP_ANNOTATIONS: { break; } diff --git a/Python/symtable.c b/Python/symtable.c index e3e89ab403a607e..c553c4083aeb5e5 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -262,7 +262,9 @@ static int symtable_visit_type_param(struct symtable *st, type_param_ty s); static int symtable_visit_genexp(struct symtable *st, expr_ty s); static int symtable_visit_listcomp(struct symtable *st, expr_ty s); static int symtable_visit_setcomp(struct symtable *st, expr_ty s); +static int symtable_visit_frozensetcomp(struct symtable *st, expr_ty s); static int symtable_visit_dictcomp(struct symtable *st, expr_ty s); +static int symtable_visit_frozendictcomp(struct symtable *st, expr_ty s); static int symtable_visit_arguments(struct symtable *st, arguments_ty); static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty); static int symtable_visit_alias(struct symtable *st, alias_ty); @@ -300,7 +302,9 @@ static void _dump_symtable(PySTEntryObject* ste, PyObject* prefix) switch (ste->ste_comprehension) { case ListComprehension: comptype = " ListComprehension"; break; case DictComprehension: comptype = " DictComprehension"; break; + case FrozenDictComprehension: comptype = " FrozenDictComprehension"; break; case SetComprehension: comptype = " SetComprehension"; break; + case FrozenSetComprehension: comptype = " FrozenSetComprehension"; break; case GeneratorExpression: comptype = " GeneratorExpression"; break; case NoComprehension: break; } @@ -2527,9 +2531,16 @@ symtable_visit_expr(struct symtable *st, expr_ty e) VISIT_SEQ_WITH_NULL(st, expr, e->v.Dict.keys); VISIT_SEQ(st, expr, e->v.Dict.values); break; + case FrozenDict_kind: + VISIT_SEQ_WITH_NULL(st, expr, e->v.FrozenDict.keys); + VISIT_SEQ(st, expr, e->v.FrozenDict.values); + break; case Set_kind: VISIT_SEQ(st, expr, e->v.Set.elts); break; + case FrozenSet_kind: + VISIT_SEQ(st, expr, e->v.FrozenSet.elts); + break; case GeneratorExp_kind: if (!symtable_visit_genexp(st, e)) return 0; @@ -2542,10 +2553,18 @@ symtable_visit_expr(struct symtable *st, expr_ty e) if (!symtable_visit_setcomp(st, e)) return 0; break; + case FrozenSetComp_kind: + if (!symtable_visit_frozensetcomp(st, e)) + return 0; + break; case DictComp_kind: if (!symtable_visit_dictcomp(st, e)) return 0; break; + case FrozenDictComp_kind: + if (!symtable_visit_frozendictcomp(st, e)) + return 0; + break; case Yield_kind: if (!symtable_raise_if_annotation_block(st, "yield expression", e)) { return 0; @@ -3105,9 +3124,15 @@ symtable_handle_comprehension(struct symtable *st, expr_ty e, case SetComp_kind: st->st_cur->ste_comprehension = SetComprehension; break; + case FrozenSetComp_kind: + st->st_cur->ste_comprehension = FrozenSetComprehension; + break; case DictComp_kind: st->st_cur->ste_comprehension = DictComprehension; break; + case FrozenDictComp_kind: + st->st_cur->ste_comprehension = FrozenDictComprehension; + break; default: st->st_cur->ste_comprehension = GeneratorExpression; break; @@ -3176,6 +3201,14 @@ symtable_visit_setcomp(struct symtable *st, expr_ty e) e->v.SetComp.elt, NULL); } +static int +symtable_visit_frozensetcomp(struct symtable *st, expr_ty e) +{ + return symtable_handle_comprehension(st, e, &_Py_STR(anon_frozensetcomp), + e->v.FrozenSetComp.generators, + e->v.FrozenSetComp.elt, NULL); +} + static int symtable_visit_dictcomp(struct symtable *st, expr_ty e) { @@ -3185,6 +3218,15 @@ symtable_visit_dictcomp(struct symtable *st, expr_ty e) e->v.DictComp.value); } +static int +symtable_visit_frozendictcomp(struct symtable *st, expr_ty e) +{ + return symtable_handle_comprehension(st, e, &_Py_STR(anon_frozendictcomp), + e->v.FrozenDictComp.generators, + e->v.FrozenDictComp.key, + e->v.FrozenDictComp.value); +} + static int symtable_raise_if_annotation_block(struct symtable *st, const char *name, expr_ty e) { @@ -3219,7 +3261,9 @@ symtable_raise_if_comprehension_block(struct symtable *st, expr_ty e) { PyErr_SetString(PyExc_SyntaxError, (type == ListComprehension) ? "'yield' inside list comprehension" : (type == SetComprehension) ? "'yield' inside set comprehension" : + (type == FrozenSetComprehension) ? "'yield' inside frozenset comprehension" : (type == DictComprehension) ? "'yield' inside dict comprehension" : + (type == FrozenDictComprehension) ? "'yield' inside frozendict comprehension" : "'yield' inside generator expression"); SET_ERROR_LOCATION(st->st_filename, LOCATION(e)); return 0;