From 92482876a68f2ce359ad0b74ad7ceee949b4c97c Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 1 Oct 2024 14:34:25 +0200 Subject: [PATCH 01/88] Implement next version of PEP 750 Still buggy --- Doc/library/token-list.inc | 2 + Grammar/Tokens | 1 + Grammar/python.gram | 13 +- Include/internal/pycore_ast.h | 24 +- Include/internal/pycore_ast_state.h | 3 + Include/internal/pycore_interpolation.h | 31 + Include/internal/pycore_magic_number.h | 3 +- Include/internal/pycore_opcode_metadata.h | 18 +- Include/internal/pycore_template.h | 28 + Include/internal/pycore_token.h | 13 +- Include/internal/pycore_uop_ids.h | 2 + Include/internal/pycore_uop_metadata.h | 8 + Include/opcode_ids.h | 148 +- Lib/_opcode_metadata.py | 148 +- Lib/token.py | 15 +- Makefile.pre.in | 4 + Objects/interpolationobject.c | 144 + Objects/templateobject.c | 96 + Parser/Python.asdl | 2 + Parser/action_helpers.c | 175 +- Parser/lexer/lexer.c | 27 +- Parser/lexer/state.h | 2 + Parser/parser.c | 3009 ++++++++++++--------- Parser/pegen.h | 7 +- Parser/token.c | 1 + Python/Python-ast.c | 357 +++ Python/ast.c | 13 + Python/ast_opt.c | 7 + Python/ast_unparse.c | 96 +- Python/bytecodes.c | 19 + Python/ceval.c | 2 + Python/codegen.c | 82 +- Python/executor_cases.c.h | 43 + Python/generated_cases.c.h | 59 + Python/opcode_targets.h | 4 +- Python/optimizer_cases.c.h | 18 + Python/pylifecycle.c | 14 + Python/symtable.c | 8 + 38 files changed, 3042 insertions(+), 1604 deletions(-) create mode 100644 Include/internal/pycore_interpolation.h create mode 100644 Include/internal/pycore_template.h create mode 100644 Objects/interpolationobject.c create mode 100644 Objects/templateobject.c diff --git a/Doc/library/token-list.inc b/Doc/library/token-list.inc index 39df2927a0b7f2..f5281639627702 100644 --- a/Doc/library/token-list.inc +++ b/Doc/library/token-list.inc @@ -215,6 +215,8 @@ .. data:: FSTRING_START +.. data:: TSTRING_START + .. data:: FSTRING_MIDDLE .. data:: FSTRING_END diff --git a/Grammar/Tokens b/Grammar/Tokens index 20bb803b7d58a6..fdbce45d1e6e71 100644 --- a/Grammar/Tokens +++ b/Grammar/Tokens @@ -60,6 +60,7 @@ TYPE_IGNORE TYPE_COMMENT SOFT_KEYWORD FSTRING_START +TSTRING_START FSTRING_MIDDLE FSTRING_END COMMENT diff --git a/Grammar/python.gram b/Grammar/python.gram index b47028460b94f4..45dbd8b3642edb 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -500,7 +500,7 @@ literal_pattern[pattern_ty]: literal_expr[expr_ty]: | signed_number !('+' | '-') | complex_number - | strings + | &(STRING|FSTRING_START) strings | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) } | 'True' { _PyAST_Constant(Py_True, NULL, EXTRA) } | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) } @@ -841,6 +841,7 @@ atom[expr_ty]: | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) } | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) } | &(STRING|FSTRING_START) strings + | &TSTRING_START tstring | NUMBER | &'(' (tuple | group | genexp) | &'[' (list | listcomp) @@ -927,6 +928,16 @@ fstring_format_spec[expr_ty]: fstring[expr_ty]: | a=FSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_joined_str(p, a, (asdl_expr_seq*)b, c) } +tstring_middle[expr_ty]: + | tstring_replacement_field + | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } +tstring_replacement_field[expr_ty]: + | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { + _PyPegen_interpolation(p, a, debug_expr, conversion, format, rbrace, EXTRA) } + | invalid_replacement_field +tstring[expr_ty]: + | a=TSTRING_START b=tstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } + string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) } strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string)+ { _PyPegen_concatenate_strings(p, a, EXTRA) } diff --git a/Include/internal/pycore_ast.h b/Include/internal/pycore_ast.h index f5bf1205a82be9..92b4842ce31588 100644 --- a/Include/internal/pycore_ast.h +++ b/Include/internal/pycore_ast.h @@ -361,9 +361,10 @@ enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, 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, JoinedStr_kind=19, Constant_kind=20, - Attribute_kind=21, Subscript_kind=22, Starred_kind=23, - Name_kind=24, List_kind=25, Tuple_kind=26, Slice_kind=27}; + 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}; struct _expr { enum _expr_kind kind; union { @@ -459,10 +460,21 @@ struct _expr { expr_ty format_spec; } FormattedValue; + struct { + expr_ty value; + constant str; + constant conversion; + expr_ty format_spec; + } Interpolation; + struct { asdl_expr_seq *values; } JoinedStr; + struct { + asdl_expr_seq *values; + } TemplateStr; + struct { constant value; string kind; @@ -820,8 +832,14 @@ expr_ty _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * expr_ty _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Interpolation(expr_ty value, constant str, constant conversion, + expr_ty format_spec, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena + *arena); expr_ty _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_TemplateStr(asdl_expr_seq * values, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_Constant(constant value, string kind, 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 09ae95465495c0..90fd1b63c326ca 100644 --- a/Include/internal/pycore_ast_state.h +++ b/Include/internal/pycore_ast_state.h @@ -75,6 +75,7 @@ struct ast_state { PyObject *In_singleton; PyObject *In_type; PyObject *Interactive_type; + PyObject *Interpolation_type; PyObject *Invert_singleton; PyObject *Invert_type; PyObject *IsNot_singleton; @@ -137,6 +138,7 @@ struct ast_state { PyObject *Sub_singleton; PyObject *Sub_type; PyObject *Subscript_type; + PyObject *TemplateStr_type; PyObject *TryStar_type; PyObject *Try_type; PyObject *Tuple_type; @@ -242,6 +244,7 @@ struct ast_state { PyObject *slice; PyObject *step; PyObject *stmt_type; + PyObject *str; PyObject *subject; PyObject *tag; PyObject *target; diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h new file mode 100644 index 00000000000000..0545ba42b48de4 --- /dev/null +++ b/Include/internal/pycore_interpolation.h @@ -0,0 +1,31 @@ +#ifndef Py_INTERNAL_INTERPOLATION_H +#define Py_INTERNAL_INTERPOLATION_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + PyObject_HEAD + PyObject *value; + PyObject *expr; + PyObject *conv; + PyObject *format_spec; +} PyInterpolationObject; + +extern PyTypeObject PyInterpolation_Type; + +PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values, Py_ssize_t n); + +extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *); +extern void _PyInterpolation_FiniTypes(PyInterpreterState *); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Include/internal/pycore_magic_number.h b/Include/internal/pycore_magic_number.h index a88ff2deeba941..b471ee3c521139 100644 --- a/Include/internal/pycore_magic_number.h +++ b/Include/internal/pycore_magic_number.h @@ -260,6 +260,7 @@ Known values: Python 3.14a1 3606 (Specialize CALL_KW) Python 3.14a1 3607 (Add pseudo instructions JUMP_IF_TRUE/FALSE) Python 3.14a1 3608 (Add support for slices) + Python 3.14a1 3609 (Add BUILD_INTERPOLATION & BUILD_TEMPLATE opcodes) Python 3.15 will start with 3650 @@ -272,7 +273,7 @@ PC/launcher.c must also be updated. */ -#define PYC_MAGIC_NUMBER 3608 +#define PYC_MAGIC_NUMBER 3609 /* 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 c18423476d3962..519bd26ab2c619 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -67,6 +67,8 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return 2; case BINARY_SUBSCR_TUPLE_INT: return 2; + case BUILD_INTERPOLATION: + return (2 + ((oparg >> 1) & 1) + (oparg & 1)); case BUILD_LIST: return oparg; case BUILD_MAP: @@ -77,6 +79,8 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return 2 + ((oparg == 3) ? 1 : 0); case BUILD_STRING: return oparg; + case BUILD_TEMPLATE: + return oparg; case BUILD_TUPLE: return oparg; case CACHE: @@ -526,6 +530,8 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 1; case BINARY_SUBSCR_TUPLE_INT: return 1; + case BUILD_INTERPOLATION: + return 1; case BUILD_LIST: return 1; case BUILD_MAP: @@ -536,6 +542,8 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 1; case BUILD_STRING: return 1; + case BUILD_TEMPLATE: + return 1; case BUILD_TUPLE: return 1; case CACHE: @@ -1030,11 +1038,13 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_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 }, [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, @@ -1267,11 +1277,13 @@ _PyOpcode_macro_expansion[256] = { [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT, 0, 0 } } }, [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_STR_INT, 0, 0 } } }, [BINARY_SUBSCR_TUPLE_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT, 0, 0 } } }, + [BUILD_INTERPOLATION] = { .nuops = 1, .uops = { { _BUILD_INTERPOLATION, 0, 0 } } }, [BUILD_LIST] = { .nuops = 1, .uops = { { _BUILD_LIST, 0, 0 } } }, [BUILD_MAP] = { .nuops = 1, .uops = { { _BUILD_MAP, 0, 0 } } }, [BUILD_SET] = { .nuops = 1, .uops = { { _BUILD_SET, 0, 0 } } }, [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, 0, 0 } } }, [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, 0, 0 } } }, + [BUILD_TEMPLATE] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE, 0, 0 } } }, [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, 0, 0 } } }, [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 4, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_AND_ALLOCATE_OBJECT, 2, 1 }, { _CREATE_INIT_FRAME, 0, 0 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_FUNCTION_EXACT_ARGS, 0, 0 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, @@ -1448,11 +1460,13 @@ const char *_PyOpcode_OpName[266] = { [BINARY_SUBSCR_LIST_INT] = "BINARY_SUBSCR_LIST_INT", [BINARY_SUBSCR_STR_INT] = "BINARY_SUBSCR_STR_INT", [BINARY_SUBSCR_TUPLE_INT] = "BINARY_SUBSCR_TUPLE_INT", + [BUILD_INTERPOLATION] = "BUILD_INTERPOLATION", [BUILD_LIST] = "BUILD_LIST", [BUILD_MAP] = "BUILD_MAP", [BUILD_SET] = "BUILD_SET", [BUILD_SLICE] = "BUILD_SLICE", [BUILD_STRING] = "BUILD_STRING", + [BUILD_TEMPLATE] = "BUILD_TEMPLATE", [BUILD_TUPLE] = "BUILD_TUPLE", [CACHE] = "CACHE", [CALL] = "CALL", @@ -1704,11 +1718,13 @@ const uint8_t _PyOpcode_Deopt[256] = { [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, + [BUILD_INTERPOLATION] = BUILD_INTERPOLATION, [BUILD_LIST] = BUILD_LIST, [BUILD_MAP] = BUILD_MAP, [BUILD_SET] = BUILD_SET, [BUILD_SLICE] = BUILD_SLICE, [BUILD_STRING] = BUILD_STRING, + [BUILD_TEMPLATE] = BUILD_TEMPLATE, [BUILD_TUPLE] = BUILD_TUPLE, [CACHE] = CACHE, [CALL] = CALL, @@ -1907,8 +1923,6 @@ const uint8_t _PyOpcode_Deopt[256] = { #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ - case 116: \ - case 117: \ case 118: \ case 119: \ case 120: \ diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h new file mode 100644 index 00000000000000..119aa2f53e9726 --- /dev/null +++ b/Include/internal/pycore_template.h @@ -0,0 +1,28 @@ +#ifndef Py_INTERNAL_TEMPLATE_H +#define Py_INTERNAL_TEMPLATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + PyObject_HEAD + PyObject *args; +} PyTemplateObject; + +extern PyTypeObject PyTemplate_Type; + +PyAPI_FUNC(PyObject *) _PyTemplate_Create(PyObject **values, Py_ssize_t n); + +extern PyStatus _PyTemplate_InitTypes(PyInterpreterState *); +extern void _PyTemplate_FiniTypes(PyInterpreterState *); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Include/internal/pycore_token.h b/Include/internal/pycore_token.h index 571cd6249f2812..d8e1de1f324db4 100644 --- a/Include/internal/pycore_token.h +++ b/Include/internal/pycore_token.h @@ -73,12 +73,13 @@ extern "C" { #define TYPE_COMMENT 57 #define SOFT_KEYWORD 58 #define FSTRING_START 59 -#define FSTRING_MIDDLE 60 -#define FSTRING_END 61 -#define COMMENT 62 -#define NL 63 -#define ERRORTOKEN 64 -#define N_TOKENS 66 +#define TSTRING_START 60 +#define FSTRING_MIDDLE 61 +#define FSTRING_END 62 +#define COMMENT 63 +#define NL 64 +#define ERRORTOKEN 65 +#define N_TOKENS 67 #define NT_OFFSET 256 /* Special definitions for cooperation with parser */ diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 1951c65a2871cf..38c1fce14c1bb4 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -28,11 +28,13 @@ extern "C" { #define _BINARY_SUBSCR_LIST_INT BINARY_SUBSCR_LIST_INT #define _BINARY_SUBSCR_STR_INT BINARY_SUBSCR_STR_INT #define _BINARY_SUBSCR_TUPLE_INT BINARY_SUBSCR_TUPLE_INT +#define _BUILD_INTERPOLATION BUILD_INTERPOLATION #define _BUILD_LIST BUILD_LIST #define _BUILD_MAP BUILD_MAP #define _BUILD_SET BUILD_SET #define _BUILD_SLICE BUILD_SLICE #define _BUILD_STRING BUILD_STRING +#define _BUILD_TEMPLATE BUILD_TEMPLATE #define _BUILD_TUPLE BUILD_TUPLE #define _CALL_BUILTIN_CLASS 315 #define _CALL_BUILTIN_FAST 316 diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 2f0a7fb2f6e549..9bb8d721c082f4 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -128,6 +128,8 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_BUILD_INTERPOLATION] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -311,11 +313,13 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BINARY_SUBSCR_LIST_INT] = "_BINARY_SUBSCR_LIST_INT", [_BINARY_SUBSCR_STR_INT] = "_BINARY_SUBSCR_STR_INT", [_BINARY_SUBSCR_TUPLE_INT] = "_BINARY_SUBSCR_TUPLE_INT", + [_BUILD_INTERPOLATION] = "_BUILD_INTERPOLATION", [_BUILD_LIST] = "_BUILD_LIST", [_BUILD_MAP] = "_BUILD_MAP", [_BUILD_SET] = "_BUILD_SET", [_BUILD_SLICE] = "_BUILD_SLICE", [_BUILD_STRING] = "_BUILD_STRING", + [_BUILD_TEMPLATE] = "_BUILD_TEMPLATE", [_BUILD_TUPLE] = "_BUILD_TUPLE", [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", @@ -782,6 +786,10 @@ int _PyUop_num_popped(int opcode, int oparg) return 0; case _BUILD_STRING: return oparg; + case _BUILD_INTERPOLATION: + return (2 + ((oparg >> 1) & 1) + (oparg & 1)); + case _BUILD_TEMPLATE: + return oparg; case _BUILD_TUPLE: return oparg; case _BUILD_LIST: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 327bdb792464a0..d4dca9ef0c7d9a 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -53,79 +53,81 @@ extern "C" { #define UNARY_NOT 40 #define WITH_EXCEPT_START 41 #define BINARY_OP 42 -#define BUILD_LIST 43 -#define BUILD_MAP 44 -#define BUILD_SET 45 -#define BUILD_SLICE 46 -#define BUILD_STRING 47 -#define BUILD_TUPLE 48 -#define CALL 49 -#define CALL_FUNCTION_EX 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 DELETE_GLOBAL 62 -#define DELETE_NAME 63 -#define DICT_MERGE 64 -#define DICT_UPDATE 65 -#define EXTENDED_ARG 66 -#define FOR_ITER 67 -#define GET_AWAITABLE 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_CHECK 83 -#define LOAD_FAST_LOAD_FAST 84 -#define LOAD_FROM_DICT_OR_DEREF 85 -#define LOAD_FROM_DICT_OR_GLOBALS 86 -#define LOAD_GLOBAL 87 -#define LOAD_NAME 88 -#define LOAD_SPECIAL 89 -#define LOAD_SUPER_ATTR 90 -#define MAKE_CELL 91 -#define MAP_ADD 92 -#define MATCH_CLASS 93 -#define POP_JUMP_IF_FALSE 94 -#define POP_JUMP_IF_NONE 95 -#define POP_JUMP_IF_NOT_NONE 96 -#define POP_JUMP_IF_TRUE 97 -#define RAISE_VARARGS 98 -#define RERAISE 99 -#define RETURN_CONST 100 -#define SEND 101 -#define SET_ADD 102 -#define SET_FUNCTION_ATTRIBUTE 103 -#define SET_UPDATE 104 -#define STORE_ATTR 105 -#define STORE_DEREF 106 -#define STORE_FAST 107 -#define STORE_FAST_LOAD_FAST 108 -#define STORE_FAST_STORE_FAST 109 -#define STORE_GLOBAL 110 -#define STORE_NAME 111 -#define SWAP 112 -#define UNPACK_EX 113 -#define UNPACK_SEQUENCE 114 -#define YIELD_VALUE 115 +#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_TEMPLATE 49 +#define BUILD_TUPLE 50 +#define CALL 51 +#define CALL_FUNCTION_EX 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 DELETE_GLOBAL 64 +#define DELETE_NAME 65 +#define DICT_MERGE 66 +#define DICT_UPDATE 67 +#define EXTENDED_ARG 68 +#define FOR_ITER 69 +#define GET_AWAITABLE 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_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_SPECIAL 91 +#define LOAD_SUPER_ATTR 92 +#define MAKE_CELL 93 +#define MAP_ADD 94 +#define MATCH_CLASS 95 +#define POP_JUMP_IF_FALSE 96 +#define POP_JUMP_IF_NONE 97 +#define POP_JUMP_IF_NOT_NONE 98 +#define POP_JUMP_IF_TRUE 99 +#define RAISE_VARARGS 100 +#define RERAISE 101 +#define RETURN_CONST 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 RESUME 149 #define BINARY_OP_ADD_FLOAT 150 #define BINARY_OP_ADD_INT 151 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 9a793717cf082b..d9dd491e111389 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -242,79 +242,81 @@ 'UNARY_NOT': 40, 'WITH_EXCEPT_START': 41, 'BINARY_OP': 42, - 'BUILD_LIST': 43, - 'BUILD_MAP': 44, - 'BUILD_SET': 45, - 'BUILD_SLICE': 46, - 'BUILD_STRING': 47, - 'BUILD_TUPLE': 48, - 'CALL': 49, - 'CALL_FUNCTION_EX': 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, - 'DELETE_GLOBAL': 62, - 'DELETE_NAME': 63, - 'DICT_MERGE': 64, - 'DICT_UPDATE': 65, - 'EXTENDED_ARG': 66, - 'FOR_ITER': 67, - 'GET_AWAITABLE': 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_CHECK': 83, - 'LOAD_FAST_LOAD_FAST': 84, - 'LOAD_FROM_DICT_OR_DEREF': 85, - 'LOAD_FROM_DICT_OR_GLOBALS': 86, - 'LOAD_GLOBAL': 87, - 'LOAD_NAME': 88, - 'LOAD_SPECIAL': 89, - 'LOAD_SUPER_ATTR': 90, - 'MAKE_CELL': 91, - 'MAP_ADD': 92, - 'MATCH_CLASS': 93, - 'POP_JUMP_IF_FALSE': 94, - 'POP_JUMP_IF_NONE': 95, - 'POP_JUMP_IF_NOT_NONE': 96, - 'POP_JUMP_IF_TRUE': 97, - 'RAISE_VARARGS': 98, - 'RERAISE': 99, - 'RETURN_CONST': 100, - 'SEND': 101, - 'SET_ADD': 102, - 'SET_FUNCTION_ATTRIBUTE': 103, - 'SET_UPDATE': 104, - 'STORE_ATTR': 105, - 'STORE_DEREF': 106, - 'STORE_FAST': 107, - 'STORE_FAST_LOAD_FAST': 108, - 'STORE_FAST_STORE_FAST': 109, - 'STORE_GLOBAL': 110, - 'STORE_NAME': 111, - 'SWAP': 112, - 'UNPACK_EX': 113, - 'UNPACK_SEQUENCE': 114, - 'YIELD_VALUE': 115, + 'BUILD_INTERPOLATION': 43, + 'BUILD_LIST': 44, + 'BUILD_MAP': 45, + 'BUILD_SET': 46, + 'BUILD_SLICE': 47, + 'BUILD_STRING': 48, + 'BUILD_TEMPLATE': 49, + 'BUILD_TUPLE': 50, + 'CALL': 51, + 'CALL_FUNCTION_EX': 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, + 'DELETE_GLOBAL': 64, + 'DELETE_NAME': 65, + 'DICT_MERGE': 66, + 'DICT_UPDATE': 67, + 'EXTENDED_ARG': 68, + 'FOR_ITER': 69, + 'GET_AWAITABLE': 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_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_SPECIAL': 91, + 'LOAD_SUPER_ATTR': 92, + 'MAKE_CELL': 93, + 'MAP_ADD': 94, + 'MATCH_CLASS': 95, + 'POP_JUMP_IF_FALSE': 96, + 'POP_JUMP_IF_NONE': 97, + 'POP_JUMP_IF_NOT_NONE': 98, + 'POP_JUMP_IF_TRUE': 99, + 'RAISE_VARARGS': 100, + 'RERAISE': 101, + 'RETURN_CONST': 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, 'INSTRUMENTED_END_FOR': 236, 'INSTRUMENTED_END_SEND': 237, 'INSTRUMENTED_LOAD_SUPER_ATTR': 238, diff --git a/Lib/token.py b/Lib/token.py index b620317106e173..553830552efdfe 100644 --- a/Lib/token.py +++ b/Lib/token.py @@ -63,14 +63,15 @@ TYPE_COMMENT = 57 SOFT_KEYWORD = 58 FSTRING_START = 59 -FSTRING_MIDDLE = 60 -FSTRING_END = 61 -COMMENT = 62 -NL = 63 +TSTRING_START = 60 +FSTRING_MIDDLE = 61 +FSTRING_END = 62 +COMMENT = 63 +NL = 64 # These aren't used by the C tokenizer but are needed for tokenize.py -ERRORTOKEN = 64 -ENCODING = 65 -N_TOKENS = 66 +ERRORTOKEN = 65 +ENCODING = 66 +N_TOKENS = 67 # Special definitions for cooperation with parser NT_OFFSET = 256 diff --git a/Makefile.pre.in b/Makefile.pre.in index fb6f22d57397db..9f6304d99665be 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -554,6 +554,8 @@ OBJECT_OBJS= \ Objects/unicodectype.o \ Objects/unionobject.o \ Objects/weakrefobject.o \ + Objects/interpolationobject.o \ + Objects/templateobject.o \ @PERF_TRAMPOLINE_OBJ@ ########################################################################## @@ -1225,6 +1227,7 @@ PYTHON_HEADERS= \ $(srcdir)/Include/internal/pycore_instruments.h \ $(srcdir)/Include/internal/pycore_instruction_sequence.h \ $(srcdir)/Include/internal/pycore_interp.h \ + $(srcdir)/Include/internal/pycore_interpolation.h \ $(srcdir)/Include/internal/pycore_intrinsics.h \ $(srcdir)/Include/internal/pycore_jit.h \ $(srcdir)/Include/internal/pycore_list.h \ @@ -1276,6 +1279,7 @@ PYTHON_HEADERS= \ $(srcdir)/Include/internal/pycore_symtable.h \ $(srcdir)/Include/internal/pycore_sysmodule.h \ $(srcdir)/Include/internal/pycore_stackref.h \ + $(srcdir)/Include/internal/pycore_template.h \ $(srcdir)/Include/internal/pycore_time.h \ $(srcdir)/Include/internal/pycore_token.h \ $(srcdir)/Include/internal/pycore_traceback.h \ diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c new file mode 100644 index 00000000000000..d04b1e78bf5657 --- /dev/null +++ b/Objects/interpolationobject.c @@ -0,0 +1,144 @@ +/* Interpolation object implementation */ +#include "Python.h" +#include + +#include "pycore_initconfig.h" // _PyStatus_OK +#include "pycore_typeobject.h" // _PyStaticType_InitBuiltin +#include "pycore_stackref.h" // _PyStackRef +#include "pycore_global_objects.h" // _Py_STR +#include "pycore_runtime.h" // _Py_STR +#include "pycore_object.h" // _PyObject_GC_TRACK + +#include "pycore_interpolation.h" + +static PyInterpolationObject * +interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyInterpolationObject *self = (PyInterpolationObject *) type->tp_alloc(type, 0); + if (!self) { + return NULL; + } + + static char *kwlist[] = {"value", "expr", "conv", "format_spec", NULL}; + + PyObject *value, *expr; + PyObject *conv = NULL; + PyObject *format_spec = NULL; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, + &value, &expr, + &conv, &format_spec) < 0) { + Py_DECREF(self); + return NULL; + } + + Py_XSETREF(self->value, Py_NewRef(value)); + Py_XSETREF(self->expr, Py_NewRef(expr)); + Py_XSETREF(self->conv, Py_NewRef(conv ? conv : Py_None)); + Py_XSETREF(self->format_spec, format_spec ? Py_NewRef(format_spec) : &_Py_STR(empty)); + return self; +} + +static void +interpolation_dealloc(PyInterpolationObject *self) +{ + Py_CLEAR(self->value); + Py_CLEAR(self->expr); + Py_CLEAR(self->conv); + Py_CLEAR(self->format_spec); + Py_TYPE(self)->tp_free(self); +} + +static PyObject * +interpolation_repr(PyInterpolationObject *self) +{ + return PyUnicode_FromFormat("%s(%R, %R, %R, %R)", + _PyType_Name(Py_TYPE(self)), + self->value, self->expr, + self->conv, self->format_spec); +} + +static PyMemberDef interpolation_members[] = { + {"value", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, value), Py_READONLY, "Value"}, + {"expr", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, expr), Py_READONLY, "Expr"}, + {"conv", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, conv), Py_READONLY, "Conversion"}, + {"format_spec", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, format_spec), Py_READONLY, "Format specifier"}, + {NULL} +}; + +PyTypeObject PyInterpolation_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "Interpolation", + .tp_doc = PyDoc_STR("Interpolation object"), + .tp_basicsize = sizeof(PyInterpolationObject), + .tp_itemsize = 0, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, + .tp_new = (newfunc) interpolation_new, + .tp_dealloc = (destructor) interpolation_dealloc, + .tp_repr = (reprfunc) interpolation_repr, + .tp_members = interpolation_members, +}; + +PyStatus +_PyInterpolation_InitTypes(PyInterpreterState *interp) +{ + if (_PyStaticType_InitBuiltin(interp, &PyInterpolation_Type) < 0) { + return _PyStatus_ERR("Can't initialize builtin type"); + } + return _PyStatus_OK(); +} + +void +_PyInterpolation_FiniTypes(PyInterpreterState *interp) +{ + _PyStaticType_FiniBuiltin(interp, &PyInterpolation_Type); +} + +PyObject * +_PyInterpolation_FromStackRefSteal(_PyStackRef *values, Py_ssize_t oparg) +{ + Py_ssize_t index = 2; + + PyObject *args = PyTuple_New(oparg + ((oparg >> 1) & 1) + (oparg & 1)); + if (!args) { + goto error; + } + + PyTuple_SET_ITEM(args, 0, PyStackRef_AsPyObjectSteal(values[0])); + PyTuple_SET_ITEM(args, 1, PyStackRef_AsPyObjectSteal(values[1])); + + if ((oparg >> 1) & 1) { + PyTuple_SET_ITEM(args, 2, PyStackRef_AsPyObjectSteal(values[index])); + index++; + } + else { + PyTuple_SET_ITEM(args, 2, Py_NewRef(Py_None)); + } + + if (oparg & 1) { + PyTuple_SET_ITEM(args, 3, PyStackRef_AsPyObjectSteal(values[index])); + } + else { + PyTuple_SET_ITEM(args, 3, &_Py_STR(empty)); + } + + PyObject *interpolation = PyObject_CallObject((PyObject *) &PyInterpolation_Type, args); + if (!interpolation) { + Py_DECREF(args); + goto error; + } + return interpolation; + +error: + PyStackRef_CLOSE(values[0]); + PyStackRef_CLOSE(values[1]); + index = 2; + if ((oparg >> 1) & 1) { + PyStackRef_XCLOSE(values[index]); + index++; + } + if (oparg & 1) { + PyStackRef_XCLOSE(values[index]); + } + return NULL; +} diff --git a/Objects/templateobject.c b/Objects/templateobject.c new file mode 100644 index 00000000000000..e8765e78954b08 --- /dev/null +++ b/Objects/templateobject.c @@ -0,0 +1,96 @@ +/* Interpolation object implementation */ +#include "Python.h" +#include + +#include "pycore_initconfig.h" // _PyStatus_OK +#include "pycore_typeobject.h" // _PyStaticType_InitBuiltin +#include "pycore_stackref.h" // _PyStackRef +#include "pycore_object.h" // _PyObject_GC_TRACK + +#include "pycore_template.h" + +static PyTemplateObject * +template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyTemplateObject *self = (PyTemplateObject *) type->tp_alloc(type, 0); + if (!self) { + return NULL; + } + + static char *kwlist[] = {"args", NULL}; + PyObject *selfargs; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, + &selfargs) < 0) { + Py_DECREF(self); + return NULL; + } + + Py_XSETREF(self->args, Py_NewRef(selfargs)); + return self; +} + +static void +template_dealloc(PyTemplateObject *self) +{ + Py_CLEAR(self->args); + Py_TYPE(self)->tp_free(self); +} + +static PyObject * +template_repr(PyTemplateObject *self) +{ + return PyUnicode_FromFormat("%s(%R)", + _PyType_Name(Py_TYPE(self)), + self->args); +} + +static PyMemberDef template_members[] = { + {"args", Py_T_OBJECT_EX, offsetof(PyTemplateObject, args), Py_READONLY, "Args"}, + {NULL} +}; + +PyTypeObject PyTemplate_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "Template", + .tp_doc = PyDoc_STR("Template object"), + .tp_basicsize = sizeof(PyTemplateObject), + .tp_itemsize = 0, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, + .tp_new = (newfunc) template_new, + .tp_dealloc = (destructor) template_dealloc, + .tp_repr = (reprfunc) template_repr, + .tp_members = template_members, +}; + +PyStatus +_PyTemplate_InitTypes(PyInterpreterState *interp) +{ + if (_PyStaticType_InitBuiltin(interp, &PyTemplate_Type) < 0) { + return _PyStatus_ERR("Can't initialize builtin type"); + } + return _PyStatus_OK(); +} + +void +_PyTemplate_FiniTypes(PyInterpreterState *interp) +{ + _PyStaticType_FiniBuiltin(interp, &PyTemplate_Type); +} + +PyObject * +_PyTemplate_Create(PyObject **values, Py_ssize_t oparg) +{ + PyObject *tuple = PyTuple_New(oparg); + if (!tuple) { + return NULL; + } + + for (Py_ssize_t i = 0; i < oparg; i++) { + PyTuple_SET_ITEM(tuple, i, Py_NewRef(values[i])); + } + + PyObject *template = PyObject_CallOneArg((PyObject *) &PyTemplate_Type, tuple); + Py_DECREF(tuple); + return template; +} diff --git a/Parser/Python.asdl b/Parser/Python.asdl index 80776ffe449393..0be4efc6687b90 100644 --- a/Parser/Python.asdl +++ b/Parser/Python.asdl @@ -78,7 +78,9 @@ module Python | Compare(expr left, cmpop* ops, expr* comparators) | Call(expr func, expr* args, keyword* keywords) | FormattedValue(expr value, int conversion, expr? format_spec) + | Interpolation(expr value, constant str, constant? conversion, expr? format_spec) | JoinedStr(expr* values) + | TemplateStr(expr* values) | Constant(constant value, string? kind) -- the following expression can appear in assignment context diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index cb21777f566189..44a50317805573 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -966,6 +966,16 @@ _PyPegen_check_fstring_conversion(Parser *p, Token* conv_token, expr_ty conv) "f-string: conversion type must come right after the exclamanation mark" ); } + + Py_UCS4 first = PyUnicode_READ_CHAR(conv->v.Name.id, 0); + if (PyUnicode_GET_LENGTH(conv->v.Name.id) > 1 || + !(first == 's' || first == 'r' || first == 'a')) { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION(conv, + "f-string: invalid conversion character %R: expected 's', 'r', or 'a'", + conv->v.Name.id); + return NULL; + } + return result_token_with_metadata(p, conv, conv_token->metadata); } @@ -1070,6 +1080,9 @@ _PyPegen_get_expr_name(expr_ty e) case JoinedStr_kind: case FormattedValue_kind: return "f-string expression"; + case TemplateStr_kind: + case Interpolation_kind: + return "t-string expression"; case Constant_kind: { PyObject *value = e->v.Constant.value; if (value == Py_None) { @@ -1316,9 +1329,9 @@ unpack_top_level_joined_strs(Parser *p, asdl_expr_seq *raw_expressions) return expressions; } -expr_ty -_PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* raw_expressions, Token*b) { - +static asdl_expr_seq * +_get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b) +{ asdl_expr_seq *expr = unpack_top_level_joined_strs(p, raw_expressions); Py_ssize_t n_items = asdl_seq_LEN(expr); @@ -1366,7 +1379,22 @@ _PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* raw_expressions, Token*b else { resized_exprs = seq; } + return resized_exprs; +} + +expr_ty +_PyPegen_template_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b) { + + asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b); + return _PyAST_TemplateStr(resized_exprs, a->lineno, a->col_offset, + b->end_lineno, b->end_col_offset, + p->arena); +} + +expr_ty +_PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* raw_expressions, Token*b) { + asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b); return _PyAST_JoinedStr(resized_exprs, a->lineno, a->col_offset, b->end_lineno, b->end_col_offset, p->arena); @@ -1433,29 +1461,87 @@ expr_ty _PyPegen_constant_from_string(Parser* p, Token* tok) { return _PyAST_Constant(s, kind, tok->lineno, tok->col_offset, tok->end_lineno, tok->end_col_offset, p->arena); } -expr_ty _PyPegen_formatted_value(Parser *p, expr_ty expression, Token *debug, ResultTokenWithMetadata *conversion, - ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset, - int end_lineno, int end_col_offset, PyArena *arena) { - int conversion_val = -1; +static int +_get_interpolation_conversion(Parser *p, Token *debug, ResultTokenWithMetadata *conversion, + ResultTokenWithMetadata *format) +{ if (conversion != NULL) { expr_ty conversion_expr = (expr_ty) conversion->result; assert(conversion_expr->kind == Name_kind); Py_UCS4 first = PyUnicode_READ_CHAR(conversion_expr->v.Name.id, 0); + return Py_SAFE_DOWNCAST(first, Py_UCS4, int); + } + else if (debug && !format) { + /* If no conversion is specified, use !r for debug expressions */ + return (int)'r'; + } + return -1; +} - if (PyUnicode_GET_LENGTH(conversion_expr->v.Name.id) > 1 || - !(first == 's' || first == 'r' || first == 'a')) { - RAISE_SYNTAX_ERROR_KNOWN_LOCATION(conversion_expr, - "f-string: invalid conversion character %R: expected 's', 'r', or 'a'", - conversion_expr->v.Name.id); +expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, ResultTokenWithMetadata *conversion, + ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena) { + + constant exprstr = _PyAST_ExprAsUnicode(expression); + if (exprstr == NULL) { + return NULL; + } + + constant convstr = NULL; + int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); + if (conversion_val >= 0) { + expr_ty conv = (expr_ty) conversion->result; + constant convstr = PyUnicode_FromObject(conv->v.Name.id); + if (convstr == NULL) { return NULL; } + } - conversion_val = Py_SAFE_DOWNCAST(first, Py_UCS4, int); + expr_ty interpolation = _PyAST_Interpolation( + expression, exprstr, convstr, format ? (expr_ty) format->result : NULL, + lineno, col_offset, end_lineno, + end_col_offset, arena + ); + + if (!debug) { + return interpolation; } - else if (debug && !format) { - /* If no conversion is specified, use !r for debug expressions */ - conversion_val = (int)'r'; + + /* Find the non whitespace token after the "=" */ + int debug_end_line, debug_end_offset; + PyObject *debug_metadata; + + if (conversion) { + debug_end_line = ((expr_ty) conversion->result)->lineno; + debug_end_offset = ((expr_ty) conversion->result)->col_offset; + debug_metadata = conversion->metadata; + } + else if (format) { + debug_end_line = ((expr_ty) format->result)->lineno; + debug_end_offset = ((expr_ty) format->result)->col_offset + 1; + debug_metadata = format->metadata; + } + else { + debug_end_line = end_lineno; + debug_end_offset = end_col_offset; + debug_metadata = closing_brace->metadata; } + expr_ty debug_text = _PyAST_Constant(debug_metadata, NULL, lineno, col_offset + 1, debug_end_line, + debug_end_offset - 1, p->arena); + if (!debug_text) { + return NULL; + } + + asdl_expr_seq *values = _Py_asdl_expr_seq_new(2, arena); + asdl_seq_SET(values, 0, debug_text); + asdl_seq_SET(values, 1, interpolation); + return _PyAST_JoinedStr(values, lineno, col_offset, debug_end_line, debug_end_offset, p->arena); +} + +expr_ty _PyPegen_formatted_value(Parser *p, expr_ty expression, Token *debug, ResultTokenWithMetadata *conversion, + ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena) { + int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); expr_ty formatted_value = _PyAST_FormattedValue( expression, conversion_val, format ? (expr_ty) format->result : NULL, @@ -1463,40 +1549,39 @@ expr_ty _PyPegen_formatted_value(Parser *p, expr_ty expression, Token *debug, Re end_col_offset, arena ); - if (debug) { - /* Find the non whitespace token after the "=" */ - int debug_end_line, debug_end_offset; - PyObject *debug_metadata; + if (!debug) { + return formatted_value; + } - if (conversion) { - debug_end_line = ((expr_ty) conversion->result)->lineno; - debug_end_offset = ((expr_ty) conversion->result)->col_offset; - debug_metadata = conversion->metadata; - } - else if (format) { - debug_end_line = ((expr_ty) format->result)->lineno; - debug_end_offset = ((expr_ty) format->result)->col_offset + 1; - debug_metadata = format->metadata; - } - else { - debug_end_line = end_lineno; - debug_end_offset = end_col_offset; - debug_metadata = closing_brace->metadata; - } - expr_ty debug_text = _PyAST_Constant(debug_metadata, NULL, lineno, col_offset + 1, debug_end_line, - debug_end_offset - 1, p->arena); - if (!debug_text) { - return NULL; - } + /* Find the non whitespace token after the "=" */ + int debug_end_line, debug_end_offset; + PyObject *debug_metadata; - asdl_expr_seq *values = _Py_asdl_expr_seq_new(2, arena); - asdl_seq_SET(values, 0, debug_text); - asdl_seq_SET(values, 1, formatted_value); - return _PyAST_JoinedStr(values, lineno, col_offset, debug_end_line, debug_end_offset, p->arena); + if (conversion) { + debug_end_line = ((expr_ty) conversion->result)->lineno; + debug_end_offset = ((expr_ty) conversion->result)->col_offset; + debug_metadata = conversion->metadata; + } + else if (format) { + debug_end_line = ((expr_ty) format->result)->lineno; + debug_end_offset = ((expr_ty) format->result)->col_offset + 1; + debug_metadata = format->metadata; } else { - return formatted_value; + debug_end_line = end_lineno; + debug_end_offset = end_col_offset; + debug_metadata = closing_brace->metadata; + } + expr_ty debug_text = _PyAST_Constant(debug_metadata, NULL, lineno, col_offset + 1, debug_end_line, + debug_end_offset - 1, p->arena); + if (!debug_text) { + return NULL; } + + asdl_expr_seq *values = _Py_asdl_expr_seq_new(2, arena); + asdl_seq_SET(values, 0, debug_text); + asdl_seq_SET(values, 1, formatted_value); + return _PyAST_JoinedStr(values, lineno, col_offset, debug_end_line, debug_end_offset, p->arena); } expr_ty diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index 8c868593f944c8..18d104045f9a96 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -647,13 +647,13 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t nonascii = 0; if (is_potential_identifier_start(c)) { /* Process the various legal combinations of b"", r"", u"", and f"". */ - int saw_b = 0, saw_r = 0, saw_u = 0, saw_f = 0; + int saw_b = 0, saw_r = 0, saw_u = 0, saw_f = 0, saw_t = 0; while (1) { - if (!(saw_b || saw_u || saw_f) && (c == 'b' || c == 'B')) + if (!(saw_b || saw_u || saw_f || saw_t) && (c == 'b' || c == 'B')) saw_b = 1; /* Since this is a backwards compatibility support literal we don't want to support it in arbitrary order like byte literals. */ - else if (!(saw_b || saw_u || saw_r || saw_f) + else if (!(saw_b || saw_u || saw_r || saw_f || saw_t) && (c == 'u'|| c == 'U')) { saw_u = 1; } @@ -661,15 +661,18 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t else if (!(saw_r || saw_u) && (c == 'r' || c == 'R')) { saw_r = 1; } - else if (!(saw_f || saw_b || saw_u) && (c == 'f' || c == 'F')) { + else if (!(saw_f || saw_b || saw_u || saw_t) && (c == 'f' || c == 'F')) { saw_f = 1; } + else if (!(saw_t || saw_b || saw_u || saw_f) && (c == 't' || c == 'T')) { + saw_t = 1; + } else { break; } c = tok_nextc(tok); if (c == '"' || c == '\'') { - if (saw_f) { + if (saw_f || saw_t) { goto f_string_quote; } goto letter_quote; @@ -943,7 +946,9 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t } f_string_quote: - if (((Py_TOLOWER(*tok->start) == 'f' || Py_TOLOWER(*tok->start) == 'r') && (c == '\'' || c == '"'))) { + if (((Py_TOLOWER(*tok->start) == 'f' || Py_TOLOWER(*tok->start) == 'r' || Py_TOLOWER(*tok->start) == 't') + && (c == '\'' || c == '"'))) { + int quote = c; int quote_size = 1; /* 1 or 3 */ @@ -992,7 +997,13 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t the_current_tok->in_format_spec = 0; the_current_tok->f_string_debug = 0; + int tstring = 0; switch (*tok->start) { + case 'T': + case 't': + the_current_tok->f_string_raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; + tstring = 1; + break; case 'F': case 'f': the_current_tok->f_string_raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; @@ -1000,14 +1011,16 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t case 'R': case 'r': the_current_tok->f_string_raw = 1; + tstring = Py_TOLOWER(*(tok->start + 1)) == 't'; break; default: Py_UNREACHABLE(); } + the_current_tok->tstring = tstring; the_current_tok->curly_bracket_depth = 0; the_current_tok->curly_bracket_expr_start_depth = -1; - return MAKE_TOKEN(FSTRING_START); + return tstring ? MAKE_TOKEN(TSTRING_START) : MAKE_TOKEN(FSTRING_START); } letter_quote: diff --git a/Parser/lexer/state.h b/Parser/lexer/state.h index 9ed3babfdbfbf1..022dcef9dd5e07 100644 --- a/Parser/lexer/state.h +++ b/Parser/lexer/state.h @@ -59,6 +59,8 @@ typedef struct _tokenizer_mode { char* last_expr_buffer; int f_string_debug; int in_format_spec; + + int tstring; } tokenizer_mode; /* Tokenizer state */ diff --git a/Parser/parser.c b/Parser/parser.c index 9ff58ab7e7bfd5..3d73c51e8ba427 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -243,269 +243,273 @@ static char *soft_keywords[] = { #define fstring_full_format_spec_type 1156 #define fstring_format_spec_type 1157 #define fstring_type 1158 -#define string_type 1159 -#define strings_type 1160 -#define list_type 1161 -#define tuple_type 1162 -#define set_type 1163 -#define dict_type 1164 -#define double_starred_kvpairs_type 1165 -#define double_starred_kvpair_type 1166 -#define kvpair_type 1167 -#define for_if_clauses_type 1168 -#define for_if_clause_type 1169 -#define listcomp_type 1170 -#define setcomp_type 1171 -#define genexp_type 1172 -#define dictcomp_type 1173 -#define arguments_type 1174 -#define args_type 1175 -#define kwargs_type 1176 -#define starred_expression_type 1177 -#define kwarg_or_starred_type 1178 -#define kwarg_or_double_starred_type 1179 -#define star_targets_type 1180 -#define star_targets_list_seq_type 1181 -#define star_targets_tuple_seq_type 1182 -#define star_target_type 1183 -#define target_with_star_atom_type 1184 -#define star_atom_type 1185 -#define single_target_type 1186 -#define single_subscript_attribute_target_type 1187 -#define t_primary_type 1188 // Left-recursive -#define t_lookahead_type 1189 -#define del_targets_type 1190 -#define del_target_type 1191 -#define del_t_atom_type 1192 -#define type_expressions_type 1193 -#define func_type_comment_type 1194 -#define invalid_arguments_type 1195 -#define invalid_kwarg_type 1196 -#define expression_without_invalid_type 1197 -#define invalid_legacy_expression_type 1198 -#define invalid_type_param_type 1199 -#define invalid_expression_type 1200 -#define invalid_named_expression_type 1201 -#define invalid_assignment_type 1202 -#define invalid_ann_assign_target_type 1203 -#define invalid_del_stmt_type 1204 -#define invalid_block_type 1205 -#define invalid_comprehension_type 1206 -#define invalid_dict_comprehension_type 1207 -#define invalid_parameters_type 1208 -#define invalid_default_type 1209 -#define invalid_star_etc_type 1210 -#define invalid_kwds_type 1211 -#define invalid_parameters_helper_type 1212 -#define invalid_lambda_parameters_type 1213 -#define invalid_lambda_parameters_helper_type 1214 -#define invalid_lambda_star_etc_type 1215 -#define invalid_lambda_kwds_type 1216 -#define invalid_double_type_comments_type 1217 -#define invalid_with_item_type 1218 -#define invalid_for_if_clause_type 1219 -#define invalid_for_target_type 1220 -#define invalid_group_type 1221 -#define invalid_import_type 1222 -#define invalid_import_from_targets_type 1223 -#define invalid_with_stmt_type 1224 -#define invalid_with_stmt_indent_type 1225 -#define invalid_try_stmt_type 1226 -#define invalid_except_stmt_type 1227 -#define invalid_except_star_stmt_type 1228 -#define invalid_finally_stmt_type 1229 -#define invalid_except_stmt_indent_type 1230 -#define invalid_except_star_stmt_indent_type 1231 -#define invalid_match_stmt_type 1232 -#define invalid_case_block_type 1233 -#define invalid_as_pattern_type 1234 -#define invalid_class_pattern_type 1235 -#define invalid_class_argument_pattern_type 1236 -#define invalid_if_stmt_type 1237 -#define invalid_elif_stmt_type 1238 -#define invalid_else_stmt_type 1239 -#define invalid_while_stmt_type 1240 -#define invalid_for_stmt_type 1241 -#define invalid_def_raw_type 1242 -#define invalid_class_def_raw_type 1243 -#define invalid_double_starred_kvpairs_type 1244 -#define invalid_kvpair_type 1245 -#define invalid_starred_expression_unpacking_type 1246 -#define invalid_starred_expression_type 1247 -#define invalid_replacement_field_type 1248 -#define invalid_conversion_character_type 1249 -#define invalid_arithmetic_type 1250 -#define invalid_factor_type 1251 -#define invalid_type_params_type 1252 -#define _loop0_1_type 1253 -#define _loop1_2_type 1254 -#define _loop0_3_type 1255 -#define _gather_4_type 1256 -#define _tmp_5_type 1257 -#define _tmp_6_type 1258 -#define _tmp_7_type 1259 -#define _tmp_8_type 1260 -#define _tmp_9_type 1261 -#define _tmp_10_type 1262 -#define _tmp_11_type 1263 -#define _loop1_12_type 1264 -#define _tmp_13_type 1265 -#define _loop0_14_type 1266 -#define _gather_15_type 1267 -#define _tmp_16_type 1268 -#define _tmp_17_type 1269 -#define _loop0_18_type 1270 -#define _loop1_19_type 1271 -#define _loop0_20_type 1272 -#define _gather_21_type 1273 -#define _tmp_22_type 1274 -#define _loop0_23_type 1275 -#define _gather_24_type 1276 -#define _loop1_25_type 1277 -#define _tmp_26_type 1278 -#define _tmp_27_type 1279 -#define _loop0_28_type 1280 -#define _loop0_29_type 1281 -#define _loop1_30_type 1282 -#define _loop1_31_type 1283 -#define _loop0_32_type 1284 -#define _loop1_33_type 1285 -#define _loop0_34_type 1286 -#define _gather_35_type 1287 -#define _tmp_36_type 1288 -#define _loop1_37_type 1289 -#define _loop1_38_type 1290 -#define _loop1_39_type 1291 -#define _loop0_40_type 1292 -#define _gather_41_type 1293 -#define _tmp_42_type 1294 -#define _tmp_43_type 1295 -#define _loop0_44_type 1296 -#define _gather_45_type 1297 -#define _loop0_46_type 1298 -#define _gather_47_type 1299 -#define _tmp_48_type 1300 -#define _loop0_49_type 1301 -#define _gather_50_type 1302 -#define _loop0_51_type 1303 -#define _gather_52_type 1304 -#define _loop0_53_type 1305 -#define _gather_54_type 1306 -#define _loop1_55_type 1307 -#define _loop1_56_type 1308 -#define _loop0_57_type 1309 -#define _gather_58_type 1310 -#define _loop1_59_type 1311 -#define _loop1_60_type 1312 -#define _loop1_61_type 1313 -#define _tmp_62_type 1314 -#define _loop0_63_type 1315 -#define _gather_64_type 1316 -#define _tmp_65_type 1317 -#define _tmp_66_type 1318 -#define _tmp_67_type 1319 -#define _tmp_68_type 1320 -#define _tmp_69_type 1321 -#define _tmp_70_type 1322 -#define _loop0_71_type 1323 -#define _loop0_72_type 1324 -#define _loop1_73_type 1325 -#define _loop1_74_type 1326 -#define _loop0_75_type 1327 -#define _loop1_76_type 1328 -#define _loop0_77_type 1329 -#define _loop0_78_type 1330 -#define _loop1_79_type 1331 -#define _tmp_80_type 1332 -#define _loop0_81_type 1333 -#define _gather_82_type 1334 -#define _loop1_83_type 1335 -#define _loop0_84_type 1336 -#define _tmp_85_type 1337 -#define _loop0_86_type 1338 -#define _gather_87_type 1339 -#define _tmp_88_type 1340 -#define _loop0_89_type 1341 -#define _gather_90_type 1342 -#define _loop0_91_type 1343 -#define _gather_92_type 1344 -#define _loop0_93_type 1345 -#define _loop0_94_type 1346 -#define _gather_95_type 1347 -#define _loop1_96_type 1348 -#define _tmp_97_type 1349 -#define _loop0_98_type 1350 -#define _gather_99_type 1351 -#define _loop0_100_type 1352 -#define _gather_101_type 1353 -#define _tmp_102_type 1354 -#define _tmp_103_type 1355 -#define _loop0_104_type 1356 -#define _gather_105_type 1357 -#define _tmp_106_type 1358 -#define _tmp_107_type 1359 -#define _tmp_108_type 1360 -#define _tmp_109_type 1361 -#define _tmp_110_type 1362 -#define _tmp_111_type 1363 -#define _tmp_112_type 1364 -#define _tmp_113_type 1365 -#define _tmp_114_type 1366 -#define _loop0_115_type 1367 -#define _loop0_116_type 1368 -#define _tmp_117_type 1369 -#define _tmp_118_type 1370 -#define _tmp_119_type 1371 -#define _tmp_120_type 1372 -#define _tmp_121_type 1373 -#define _tmp_122_type 1374 -#define _tmp_123_type 1375 -#define _tmp_124_type 1376 -#define _tmp_125_type 1377 -#define _loop0_126_type 1378 -#define _gather_127_type 1379 -#define _tmp_128_type 1380 -#define _tmp_129_type 1381 -#define _tmp_130_type 1382 -#define _tmp_131_type 1383 -#define _loop0_132_type 1384 -#define _gather_133_type 1385 -#define _loop0_134_type 1386 -#define _gather_135_type 1387 -#define _loop0_136_type 1388 -#define _gather_137_type 1389 -#define _tmp_138_type 1390 -#define _loop0_139_type 1391 -#define _tmp_140_type 1392 -#define _tmp_141_type 1393 -#define _tmp_142_type 1394 -#define _tmp_143_type 1395 -#define _tmp_144_type 1396 -#define _tmp_145_type 1397 -#define _tmp_146_type 1398 -#define _tmp_147_type 1399 -#define _tmp_148_type 1400 -#define _tmp_149_type 1401 -#define _tmp_150_type 1402 -#define _tmp_151_type 1403 -#define _tmp_152_type 1404 -#define _tmp_153_type 1405 -#define _tmp_154_type 1406 -#define _tmp_155_type 1407 -#define _tmp_156_type 1408 -#define _tmp_157_type 1409 -#define _tmp_158_type 1410 -#define _tmp_159_type 1411 -#define _tmp_160_type 1412 -#define _tmp_161_type 1413 -#define _tmp_162_type 1414 -#define _tmp_163_type 1415 -#define _tmp_164_type 1416 -#define _loop0_165_type 1417 -#define _tmp_166_type 1418 -#define _tmp_167_type 1419 -#define _tmp_168_type 1420 -#define _tmp_169_type 1421 +#define tstring_middle_type 1159 +#define tstring_replacement_field_type 1160 +#define tstring_type 1161 +#define string_type 1162 +#define strings_type 1163 +#define list_type 1164 +#define tuple_type 1165 +#define set_type 1166 +#define dict_type 1167 +#define double_starred_kvpairs_type 1168 +#define double_starred_kvpair_type 1169 +#define kvpair_type 1170 +#define for_if_clauses_type 1171 +#define for_if_clause_type 1172 +#define listcomp_type 1173 +#define setcomp_type 1174 +#define genexp_type 1175 +#define dictcomp_type 1176 +#define arguments_type 1177 +#define args_type 1178 +#define kwargs_type 1179 +#define starred_expression_type 1180 +#define kwarg_or_starred_type 1181 +#define kwarg_or_double_starred_type 1182 +#define star_targets_type 1183 +#define star_targets_list_seq_type 1184 +#define star_targets_tuple_seq_type 1185 +#define star_target_type 1186 +#define target_with_star_atom_type 1187 +#define star_atom_type 1188 +#define single_target_type 1189 +#define single_subscript_attribute_target_type 1190 +#define t_primary_type 1191 // Left-recursive +#define t_lookahead_type 1192 +#define del_targets_type 1193 +#define del_target_type 1194 +#define del_t_atom_type 1195 +#define type_expressions_type 1196 +#define func_type_comment_type 1197 +#define invalid_arguments_type 1198 +#define invalid_kwarg_type 1199 +#define expression_without_invalid_type 1200 +#define invalid_legacy_expression_type 1201 +#define invalid_type_param_type 1202 +#define invalid_expression_type 1203 +#define invalid_named_expression_type 1204 +#define invalid_assignment_type 1205 +#define invalid_ann_assign_target_type 1206 +#define invalid_del_stmt_type 1207 +#define invalid_block_type 1208 +#define invalid_comprehension_type 1209 +#define invalid_dict_comprehension_type 1210 +#define invalid_parameters_type 1211 +#define invalid_default_type 1212 +#define invalid_star_etc_type 1213 +#define invalid_kwds_type 1214 +#define invalid_parameters_helper_type 1215 +#define invalid_lambda_parameters_type 1216 +#define invalid_lambda_parameters_helper_type 1217 +#define invalid_lambda_star_etc_type 1218 +#define invalid_lambda_kwds_type 1219 +#define invalid_double_type_comments_type 1220 +#define invalid_with_item_type 1221 +#define invalid_for_if_clause_type 1222 +#define invalid_for_target_type 1223 +#define invalid_group_type 1224 +#define invalid_import_type 1225 +#define invalid_import_from_targets_type 1226 +#define invalid_with_stmt_type 1227 +#define invalid_with_stmt_indent_type 1228 +#define invalid_try_stmt_type 1229 +#define invalid_except_stmt_type 1230 +#define invalid_except_star_stmt_type 1231 +#define invalid_finally_stmt_type 1232 +#define invalid_except_stmt_indent_type 1233 +#define invalid_except_star_stmt_indent_type 1234 +#define invalid_match_stmt_type 1235 +#define invalid_case_block_type 1236 +#define invalid_as_pattern_type 1237 +#define invalid_class_pattern_type 1238 +#define invalid_class_argument_pattern_type 1239 +#define invalid_if_stmt_type 1240 +#define invalid_elif_stmt_type 1241 +#define invalid_else_stmt_type 1242 +#define invalid_while_stmt_type 1243 +#define invalid_for_stmt_type 1244 +#define invalid_def_raw_type 1245 +#define invalid_class_def_raw_type 1246 +#define invalid_double_starred_kvpairs_type 1247 +#define invalid_kvpair_type 1248 +#define invalid_starred_expression_unpacking_type 1249 +#define invalid_starred_expression_type 1250 +#define invalid_replacement_field_type 1251 +#define invalid_conversion_character_type 1252 +#define invalid_arithmetic_type 1253 +#define invalid_factor_type 1254 +#define invalid_type_params_type 1255 +#define _loop0_1_type 1256 +#define _loop1_2_type 1257 +#define _loop0_3_type 1258 +#define _gather_4_type 1259 +#define _tmp_5_type 1260 +#define _tmp_6_type 1261 +#define _tmp_7_type 1262 +#define _tmp_8_type 1263 +#define _tmp_9_type 1264 +#define _tmp_10_type 1265 +#define _tmp_11_type 1266 +#define _loop1_12_type 1267 +#define _tmp_13_type 1268 +#define _loop0_14_type 1269 +#define _gather_15_type 1270 +#define _tmp_16_type 1271 +#define _tmp_17_type 1272 +#define _loop0_18_type 1273 +#define _loop1_19_type 1274 +#define _loop0_20_type 1275 +#define _gather_21_type 1276 +#define _tmp_22_type 1277 +#define _loop0_23_type 1278 +#define _gather_24_type 1279 +#define _loop1_25_type 1280 +#define _tmp_26_type 1281 +#define _tmp_27_type 1282 +#define _loop0_28_type 1283 +#define _loop0_29_type 1284 +#define _loop1_30_type 1285 +#define _loop1_31_type 1286 +#define _loop0_32_type 1287 +#define _loop1_33_type 1288 +#define _loop0_34_type 1289 +#define _gather_35_type 1290 +#define _tmp_36_type 1291 +#define _loop1_37_type 1292 +#define _loop1_38_type 1293 +#define _loop1_39_type 1294 +#define _loop0_40_type 1295 +#define _gather_41_type 1296 +#define _tmp_42_type 1297 +#define _tmp_43_type 1298 +#define _tmp_44_type 1299 +#define _loop0_45_type 1300 +#define _gather_46_type 1301 +#define _loop0_47_type 1302 +#define _gather_48_type 1303 +#define _tmp_49_type 1304 +#define _loop0_50_type 1305 +#define _gather_51_type 1306 +#define _loop0_52_type 1307 +#define _gather_53_type 1308 +#define _loop0_54_type 1309 +#define _gather_55_type 1310 +#define _loop1_56_type 1311 +#define _loop1_57_type 1312 +#define _loop0_58_type 1313 +#define _gather_59_type 1314 +#define _loop1_60_type 1315 +#define _loop1_61_type 1316 +#define _loop1_62_type 1317 +#define _tmp_63_type 1318 +#define _loop0_64_type 1319 +#define _gather_65_type 1320 +#define _tmp_66_type 1321 +#define _tmp_67_type 1322 +#define _tmp_68_type 1323 +#define _tmp_69_type 1324 +#define _tmp_70_type 1325 +#define _loop0_71_type 1326 +#define _loop0_72_type 1327 +#define _loop1_73_type 1328 +#define _loop1_74_type 1329 +#define _loop0_75_type 1330 +#define _loop1_76_type 1331 +#define _loop0_77_type 1332 +#define _loop0_78_type 1333 +#define _loop0_79_type 1334 +#define _loop1_80_type 1335 +#define _tmp_81_type 1336 +#define _loop0_82_type 1337 +#define _gather_83_type 1338 +#define _loop1_84_type 1339 +#define _loop0_85_type 1340 +#define _tmp_86_type 1341 +#define _loop0_87_type 1342 +#define _gather_88_type 1343 +#define _tmp_89_type 1344 +#define _loop0_90_type 1345 +#define _gather_91_type 1346 +#define _loop0_92_type 1347 +#define _gather_93_type 1348 +#define _loop0_94_type 1349 +#define _loop0_95_type 1350 +#define _gather_96_type 1351 +#define _loop1_97_type 1352 +#define _tmp_98_type 1353 +#define _loop0_99_type 1354 +#define _gather_100_type 1355 +#define _loop0_101_type 1356 +#define _gather_102_type 1357 +#define _tmp_103_type 1358 +#define _tmp_104_type 1359 +#define _loop0_105_type 1360 +#define _gather_106_type 1361 +#define _tmp_107_type 1362 +#define _tmp_108_type 1363 +#define _tmp_109_type 1364 +#define _tmp_110_type 1365 +#define _tmp_111_type 1366 +#define _tmp_112_type 1367 +#define _tmp_113_type 1368 +#define _tmp_114_type 1369 +#define _tmp_115_type 1370 +#define _loop0_116_type 1371 +#define _loop0_117_type 1372 +#define _tmp_118_type 1373 +#define _tmp_119_type 1374 +#define _tmp_120_type 1375 +#define _tmp_121_type 1376 +#define _tmp_122_type 1377 +#define _tmp_123_type 1378 +#define _tmp_124_type 1379 +#define _tmp_125_type 1380 +#define _tmp_126_type 1381 +#define _loop0_127_type 1382 +#define _gather_128_type 1383 +#define _tmp_129_type 1384 +#define _tmp_130_type 1385 +#define _tmp_131_type 1386 +#define _tmp_132_type 1387 +#define _loop0_133_type 1388 +#define _gather_134_type 1389 +#define _loop0_135_type 1390 +#define _gather_136_type 1391 +#define _loop0_137_type 1392 +#define _gather_138_type 1393 +#define _tmp_139_type 1394 +#define _loop0_140_type 1395 +#define _tmp_141_type 1396 +#define _tmp_142_type 1397 +#define _tmp_143_type 1398 +#define _tmp_144_type 1399 +#define _tmp_145_type 1400 +#define _tmp_146_type 1401 +#define _tmp_147_type 1402 +#define _tmp_148_type 1403 +#define _tmp_149_type 1404 +#define _tmp_150_type 1405 +#define _tmp_151_type 1406 +#define _tmp_152_type 1407 +#define _tmp_153_type 1408 +#define _tmp_154_type 1409 +#define _tmp_155_type 1410 +#define _tmp_156_type 1411 +#define _tmp_157_type 1412 +#define _tmp_158_type 1413 +#define _tmp_159_type 1414 +#define _tmp_160_type 1415 +#define _tmp_161_type 1416 +#define _tmp_162_type 1417 +#define _tmp_163_type 1418 +#define _tmp_164_type 1419 +#define _tmp_165_type 1420 +#define _loop0_166_type 1421 +#define _tmp_167_type 1422 +#define _tmp_168_type 1423 +#define _tmp_169_type 1424 +#define _tmp_170_type 1425 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -666,6 +670,9 @@ static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p); static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p); static expr_ty fstring_format_spec_rule(Parser *p); static expr_ty fstring_rule(Parser *p); +static expr_ty tstring_middle_rule(Parser *p); +static expr_ty tstring_replacement_field_rule(Parser *p); +static expr_ty tstring_rule(Parser *p); static expr_ty string_rule(Parser *p); static expr_ty strings_rule(Parser *p); static expr_ty list_rule(Parser *p); @@ -803,28 +810,28 @@ static asdl_seq *_loop0_40_rule(Parser *p); static asdl_seq *_gather_41_rule(Parser *p); static void *_tmp_42_rule(Parser *p); static void *_tmp_43_rule(Parser *p); -static asdl_seq *_loop0_44_rule(Parser *p); -static asdl_seq *_gather_45_rule(Parser *p); -static asdl_seq *_loop0_46_rule(Parser *p); -static asdl_seq *_gather_47_rule(Parser *p); -static void *_tmp_48_rule(Parser *p); -static asdl_seq *_loop0_49_rule(Parser *p); -static asdl_seq *_gather_50_rule(Parser *p); -static asdl_seq *_loop0_51_rule(Parser *p); -static asdl_seq *_gather_52_rule(Parser *p); -static asdl_seq *_loop0_53_rule(Parser *p); -static asdl_seq *_gather_54_rule(Parser *p); -static asdl_seq *_loop1_55_rule(Parser *p); +static void *_tmp_44_rule(Parser *p); +static asdl_seq *_loop0_45_rule(Parser *p); +static asdl_seq *_gather_46_rule(Parser *p); +static asdl_seq *_loop0_47_rule(Parser *p); +static asdl_seq *_gather_48_rule(Parser *p); +static void *_tmp_49_rule(Parser *p); +static asdl_seq *_loop0_50_rule(Parser *p); +static asdl_seq *_gather_51_rule(Parser *p); +static asdl_seq *_loop0_52_rule(Parser *p); +static asdl_seq *_gather_53_rule(Parser *p); +static asdl_seq *_loop0_54_rule(Parser *p); +static asdl_seq *_gather_55_rule(Parser *p); static asdl_seq *_loop1_56_rule(Parser *p); -static asdl_seq *_loop0_57_rule(Parser *p); -static asdl_seq *_gather_58_rule(Parser *p); -static asdl_seq *_loop1_59_rule(Parser *p); +static asdl_seq *_loop1_57_rule(Parser *p); +static asdl_seq *_loop0_58_rule(Parser *p); +static asdl_seq *_gather_59_rule(Parser *p); static asdl_seq *_loop1_60_rule(Parser *p); static asdl_seq *_loop1_61_rule(Parser *p); -static void *_tmp_62_rule(Parser *p); -static asdl_seq *_loop0_63_rule(Parser *p); -static asdl_seq *_gather_64_rule(Parser *p); -static void *_tmp_65_rule(Parser *p); +static asdl_seq *_loop1_62_rule(Parser *p); +static void *_tmp_63_rule(Parser *p); +static asdl_seq *_loop0_64_rule(Parser *p); +static asdl_seq *_gather_65_rule(Parser *p); static void *_tmp_66_rule(Parser *p); static void *_tmp_67_rule(Parser *p); static void *_tmp_68_rule(Parser *p); @@ -838,34 +845,34 @@ static asdl_seq *_loop0_75_rule(Parser *p); static asdl_seq *_loop1_76_rule(Parser *p); static asdl_seq *_loop0_77_rule(Parser *p); static asdl_seq *_loop0_78_rule(Parser *p); -static asdl_seq *_loop1_79_rule(Parser *p); -static void *_tmp_80_rule(Parser *p); -static asdl_seq *_loop0_81_rule(Parser *p); -static asdl_seq *_gather_82_rule(Parser *p); -static asdl_seq *_loop1_83_rule(Parser *p); -static asdl_seq *_loop0_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 void *_tmp_88_rule(Parser *p); -static asdl_seq *_loop0_89_rule(Parser *p); -static asdl_seq *_gather_90_rule(Parser *p); -static asdl_seq *_loop0_91_rule(Parser *p); -static asdl_seq *_gather_92_rule(Parser *p); -static asdl_seq *_loop0_93_rule(Parser *p); +static asdl_seq *_loop0_79_rule(Parser *p); +static asdl_seq *_loop1_80_rule(Parser *p); +static void *_tmp_81_rule(Parser *p); +static asdl_seq *_loop0_82_rule(Parser *p); +static asdl_seq *_gather_83_rule(Parser *p); +static asdl_seq *_loop1_84_rule(Parser *p); +static asdl_seq *_loop0_85_rule(Parser *p); +static void *_tmp_86_rule(Parser *p); +static asdl_seq *_loop0_87_rule(Parser *p); +static asdl_seq *_gather_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 asdl_seq *_loop0_92_rule(Parser *p); +static asdl_seq *_gather_93_rule(Parser *p); static asdl_seq *_loop0_94_rule(Parser *p); -static asdl_seq *_gather_95_rule(Parser *p); -static asdl_seq *_loop1_96_rule(Parser *p); -static void *_tmp_97_rule(Parser *p); -static asdl_seq *_loop0_98_rule(Parser *p); -static asdl_seq *_gather_99_rule(Parser *p); -static asdl_seq *_loop0_100_rule(Parser *p); -static asdl_seq *_gather_101_rule(Parser *p); -static void *_tmp_102_rule(Parser *p); +static asdl_seq *_loop0_95_rule(Parser *p); +static asdl_seq *_gather_96_rule(Parser *p); +static asdl_seq *_loop1_97_rule(Parser *p); +static void *_tmp_98_rule(Parser *p); +static asdl_seq *_loop0_99_rule(Parser *p); +static asdl_seq *_gather_100_rule(Parser *p); +static asdl_seq *_loop0_101_rule(Parser *p); +static asdl_seq *_gather_102_rule(Parser *p); static void *_tmp_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 void *_tmp_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 void *_tmp_108_rule(Parser *p); static void *_tmp_109_rule(Parser *p); @@ -874,9 +881,9 @@ 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 *_loop0_115_rule(Parser *p); +static void *_tmp_115_rule(Parser *p); static asdl_seq *_loop0_116_rule(Parser *p); -static void *_tmp_117_rule(Parser *p); +static asdl_seq *_loop0_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); @@ -885,21 +892,21 @@ static void *_tmp_122_rule(Parser *p); static void *_tmp_123_rule(Parser *p); static void *_tmp_124_rule(Parser *p); static void *_tmp_125_rule(Parser *p); -static asdl_seq *_loop0_126_rule(Parser *p); -static asdl_seq *_gather_127_rule(Parser *p); -static void *_tmp_128_rule(Parser *p); +static void *_tmp_126_rule(Parser *p); +static asdl_seq *_loop0_127_rule(Parser *p); +static asdl_seq *_gather_128_rule(Parser *p); static void *_tmp_129_rule(Parser *p); static void *_tmp_130_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 asdl_seq *_loop0_134_rule(Parser *p); -static asdl_seq *_gather_135_rule(Parser *p); -static asdl_seq *_loop0_136_rule(Parser *p); -static asdl_seq *_gather_137_rule(Parser *p); -static void *_tmp_138_rule(Parser *p); -static asdl_seq *_loop0_139_rule(Parser *p); -static void *_tmp_140_rule(Parser *p); +static void *_tmp_132_rule(Parser *p); +static asdl_seq *_loop0_133_rule(Parser *p); +static asdl_seq *_gather_134_rule(Parser *p); +static asdl_seq *_loop0_135_rule(Parser *p); +static asdl_seq *_gather_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 void *_tmp_141_rule(Parser *p); static void *_tmp_142_rule(Parser *p); static void *_tmp_143_rule(Parser *p); @@ -924,11 +931,12 @@ static void *_tmp_161_rule(Parser *p); static void *_tmp_162_rule(Parser *p); static void *_tmp_163_rule(Parser *p); static void *_tmp_164_rule(Parser *p); -static asdl_seq *_loop0_165_rule(Parser *p); -static void *_tmp_166_rule(Parser *p); +static void *_tmp_165_rule(Parser *p); +static asdl_seq *_loop0_166_rule(Parser *p); static void *_tmp_167_rule(Parser *p); static void *_tmp_168_rule(Parser *p); static void *_tmp_169_rule(Parser *p); +static void *_tmp_170_rule(Parser *p); // file: statements? $ @@ -8190,7 +8198,7 @@ literal_pattern_rule(Parser *p) // literal_expr: // | signed_number !('+' | '-') // | complex_number -// | strings +// | &(STRING | FSTRING_START) strings // | 'None' // | 'True' // | 'False' @@ -8255,24 +8263,26 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); } - { // strings + { // &(STRING | FSTRING_START) strings if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); expr_ty strings_var; if ( + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_43_rule, p) + && (strings_var = strings_rule(p)) // strings ) { - D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings")); + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); _res = strings_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START) strings")); } { // 'None' if (p->error_indicator) { @@ -8825,7 +8835,7 @@ pattern_capture_target_rule(Parser *p) && (name = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_43_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_44_rule, p) ) { D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); @@ -8940,7 +8950,7 @@ value_pattern_rule(Parser *p) if ( (attr = attr_rule(p)) // attr && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_43_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_44_rule, p) ) { D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')")); @@ -9359,7 +9369,7 @@ maybe_sequence_pattern_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * patterns; if ( - (patterns = _gather_45_rule(p)) // ','.maybe_star_pattern+ + (patterns = _gather_46_rule(p)) // ','.maybe_star_pattern+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -9767,13 +9777,13 @@ items_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+")); - asdl_seq * _gather_47_var; + asdl_seq * _gather_48_var; if ( - (_gather_47_var = _gather_47_rule(p)) // ','.key_value_pattern+ + (_gather_48_var = _gather_48_rule(p)) // ','.key_value_pattern+ ) { D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+")); - _res = _gather_47_var; + _res = _gather_48_var; goto done; } p->mark = _mark; @@ -9809,7 +9819,7 @@ key_value_pattern_rule(Parser *p) void *key; pattern_ty pattern; if ( - (key = _tmp_48_rule(p)) // literal_expr | attr + (key = _tmp_49_rule(p)) // literal_expr | attr && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -10137,7 +10147,7 @@ positional_patterns_rule(Parser *p) D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pattern+")); asdl_pattern_seq* args; if ( - (args = (asdl_pattern_seq*)_gather_50_rule(p)) // ','.pattern+ + (args = (asdl_pattern_seq*)_gather_51_rule(p)) // ','.pattern+ ) { D(fprintf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.pattern+")); @@ -10178,13 +10188,13 @@ keyword_patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+")); - asdl_seq * _gather_52_var; + asdl_seq * _gather_53_var; if ( - (_gather_52_var = _gather_52_rule(p)) // ','.keyword_pattern+ + (_gather_53_var = _gather_53_rule(p)) // ','.keyword_pattern+ ) { D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+")); - _res = _gather_52_var; + _res = _gather_53_var; goto done; } p->mark = _mark; @@ -10410,7 +10420,7 @@ type_param_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_type_param_seq* a; if ( - (a = (asdl_type_param_seq*)_gather_54_rule(p)) // ','.type_param+ + (a = (asdl_type_param_seq*)_gather_55_rule(p)) // ','.type_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -10780,7 +10790,7 @@ expressions_rule(Parser *p) if ( (a = expression_rule(p)) // expression && - (b = _loop1_55_rule(p)) // ((',' expression))+ + (b = _loop1_56_rule(p)) // ((',' expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -11168,7 +11178,7 @@ star_expressions_rule(Parser *p) if ( (a = star_expression_rule(p)) // star_expression && - (b = _loop1_56_rule(p)) // ((',' star_expression))+ + (b = _loop1_57_rule(p)) // ((',' star_expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -11367,7 +11377,7 @@ star_named_expressions_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_58_rule(p)) // ','.star_named_expression+ + (a = (asdl_expr_seq*)_gather_59_rule(p)) // ','.star_named_expression+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -11663,7 +11673,7 @@ disjunction_rule(Parser *p) if ( (a = conjunction_rule(p)) // conjunction && - (b = _loop1_59_rule(p)) // (('or' conjunction))+ + (b = _loop1_60_rule(p)) // (('or' conjunction))+ ) { D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+")); @@ -11751,7 +11761,7 @@ conjunction_rule(Parser *p) if ( (a = inversion_rule(p)) // inversion && - (b = _loop1_60_rule(p)) // (('and' inversion))+ + (b = _loop1_61_rule(p)) // (('and' inversion))+ ) { D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+")); @@ -11923,7 +11933,7 @@ comparison_rule(Parser *p) if ( (a = bitwise_or_rule(p)) // bitwise_or && - (b = _loop1_61_rule(p)) // compare_op_bitwise_or_pair+ + (b = _loop1_62_rule(p)) // compare_op_bitwise_or_pair+ ) { D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); @@ -12257,10 +12267,10 @@ noteq_bitwise_or_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or")); - void *_tmp_62_var; + void *_tmp_63_var; expr_ty a; if ( - (_tmp_62_var = _tmp_62_rule(p)) // '!=' + (_tmp_63_var = _tmp_63_rule(p)) // '!=' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -14308,7 +14318,7 @@ slices_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_64_rule(p)) // ','.(slice | starred_expression)+ + (a = (asdl_expr_seq*)_gather_65_rule(p)) // ','.(slice | starred_expression)+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -14380,7 +14390,7 @@ slice_rule(Parser *p) && (b = expression_rule(p), !p->error_indicator) // expression? && - (c = _tmp_65_rule(p), !p->error_indicator) // [':' expression?] + (c = _tmp_66_rule(p), !p->error_indicator) // [':' expression?] ) { D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]")); @@ -14441,6 +14451,7 @@ slice_rule(Parser *p) // | 'False' // | 'None' // | &(STRING | FSTRING_START) strings +// | &TSTRING_START tstring // | NUMBER // | &'(' (tuple | group | genexp) // | &'[' (list | listcomp) @@ -14593,7 +14604,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); expr_ty strings_var; if ( - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_66_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_43_rule, p) && (strings_var = strings_rule(p)) // strings ) @@ -14606,6 +14617,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, "&(STRING | FSTRING_START) strings")); } + { // &TSTRING_START tstring + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&TSTRING_START tstring")); + expr_ty tstring_var; + if ( + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, TSTRING_START) // token=TSTRING_START + && + (tstring_var = tstring_rule(p)) // tstring + ) + { + D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&TSTRING_START tstring")); + _res = tstring_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, "&TSTRING_START tstring")); + } { // NUMBER if (p->error_indicator) { p->level--; @@ -16122,6 +16154,214 @@ fstring_rule(Parser *p) return _res; } +// tstring_middle: tstring_replacement_field | FSTRING_MIDDLE +static expr_ty +tstring_middle_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + { // tstring_replacement_field + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_replacement_field")); + expr_ty tstring_replacement_field_var; + if ( + (tstring_replacement_field_var = tstring_replacement_field_rule(p)) // tstring_replacement_field + ) + { + D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring_replacement_field")); + _res = tstring_replacement_field_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_replacement_field")); + } + { // FSTRING_MIDDLE + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + Token * t; + if ( + (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' + ) + { + D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + _res = _PyPegen_constant_from_token ( p , t ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// tstring_replacement_field: +// | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' +// | invalid_replacement_field +static expr_ty +tstring_replacement_field_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _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 + { // '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + Token * _literal; + expr_ty a; + void *conversion; + void *debug_expr; + void *format; + Token * rbrace; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = annotated_rhs_rule(p)) // annotated_rhs + && + (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (conversion = fstring_conversion_rule(p), !p->error_indicator) // fstring_conversion? + && + (format = fstring_full_format_spec_rule(p), !p->error_indicator) // fstring_full_format_spec? + && + (rbrace = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + 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 = _PyPegen_interpolation ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + } + if (p->call_invalid_rules) { // invalid_replacement_field + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); + void *invalid_replacement_field_var; + if ( + (invalid_replacement_field_var = invalid_replacement_field_rule(p)) // invalid_replacement_field + ) + { + D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); + _res = invalid_replacement_field_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_replacement_field")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// tstring: TSTRING_START tstring_middle* FSTRING_END +static expr_ty +tstring_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + { // TSTRING_START tstring_middle* FSTRING_END + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + Token * a; + asdl_seq * b; + Token * c; + if ( + (a = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' + && + (b = _loop0_79_rule(p)) // tstring_middle* + && + (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' + ) + { + D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + _res = _PyPegen_template_str ( p , a , ( asdl_expr_seq* ) b , c ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // string: STRING static expr_ty string_rule(Parser *p) @@ -16199,7 +16439,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_79_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_80_rule(p)) // ((fstring | string))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); @@ -16332,7 +16572,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_80_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_81_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -16547,7 +16787,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_82_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_83_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -16706,7 +16946,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_83_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_84_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+")); @@ -16771,7 +17011,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_84_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_85_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))*")); @@ -16814,7 +17054,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_84_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_85_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))*")); @@ -17093,7 +17333,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_85_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_86_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -17342,9 +17582,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_87_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_88_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_89_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]")); @@ -17434,11 +17674,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_90_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_91_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_92_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_93_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+")); @@ -17460,13 +17700,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_90_var; + asdl_seq * _gather_91_var; if ( - (_gather_90_var = _gather_90_rule(p)) // ','.kwarg_or_starred+ + (_gather_91_var = _gather_91_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_90_var; + _res = _gather_91_var; goto done; } p->mark = _mark; @@ -17479,13 +17719,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_92_var; + asdl_seq * _gather_93_var; if ( - (_gather_92_var = _gather_92_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_93_var = _gather_93_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_92_var; + _res = _gather_93_var; goto done; } p->mark = _mark; @@ -17896,7 +18136,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_93_rule(p)) // ((',' star_target))* + (b = _loop0_94_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -17952,7 +18192,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_95_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_96_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18002,7 +18242,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_96_rule(p)) // ((',' star_target))+ + (b = _loop1_97_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18090,7 +18330,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_97_rule(p)) // !'*' star_target + (a = _tmp_98_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); @@ -19013,7 +19253,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_99_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_100_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19371,7 +19611,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_101_rule(p)) // ','.expression+ + (a = _gather_102_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19410,7 +19650,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_101_rule(p)) // ','.expression+ + (a = _gather_102_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19443,7 +19683,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_101_rule(p)) // ','.expression+ + (a = _gather_102_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19563,7 +19803,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_101_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_102_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); @@ -19614,7 +19854,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_102_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_103_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -19700,15 +19940,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_105_var; - void *_tmp_103_var; + asdl_seq * _gather_106_var; + void *_tmp_104_var; Token * a; if ( - (_tmp_103_var = _tmp_103_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs + (_tmp_104_var = _tmp_104_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs && (a = _PyPegen_expect_token(p, 12)) // token=',' && - (_gather_105_var = _gather_105_rule(p)) // ','.(starred_expression !'=')+ + (_gather_106_var = _gather_106_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 !'=')+")); @@ -19742,7 +19982,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_106_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_107_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]")); @@ -19802,13 +20042,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_107_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_108_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_108_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_109_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); @@ -19946,7 +20186,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_109_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_110_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -20006,7 +20246,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_110_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) && (a = expression_rule(p)) // expression && @@ -20347,7 +20587,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -20383,7 +20623,7 @@ invalid_expression_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); @@ -20504,7 +20744,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); @@ -20530,7 +20770,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_115_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -20538,7 +20778,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_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 !('=' | ':=')")); @@ -20618,7 +20858,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_115_var; + asdl_seq * _loop0_116_var; expr_ty a; expr_ty expression_var; if ( @@ -20626,7 +20866,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_115_var = _loop0_115_rule(p)) // star_named_expressions* + (_loop0_116_var = _loop0_116_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -20683,10 +20923,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_116_var; + asdl_seq * _loop0_117_var; expr_ty a; if ( - (_loop0_116_var = _loop0_116_rule(p)) // ((star_targets '='))* + (_loop0_117_var = _loop0_117_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -20713,10 +20953,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_116_var; + asdl_seq * _loop0_117_var; expr_ty a; if ( - (_loop0_116_var = _loop0_116_rule(p)) // ((star_targets '='))* + (_loop0_117_var = _loop0_117_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -20972,11 +21212,11 @@ invalid_comprehension_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); - void *_tmp_117_var; + void *_tmp_118_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_117_var = _tmp_117_rule(p)) // '[' | '(' | '{' + (_tmp_118_var = _tmp_118_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -21003,12 +21243,12 @@ invalid_comprehension_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); Token * _literal; - void *_tmp_118_var; + void *_tmp_119_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_118_var = _tmp_118_rule(p)) // '[' | '{' + (_tmp_119_var = _tmp_119_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21038,12 +21278,12 @@ invalid_comprehension_rule(Parser *p) 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_118_var; + void *_tmp_119_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_118_var = _tmp_118_rule(p)) // '[' | '{' + (_tmp_119_var = _tmp_119_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21179,10 +21419,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_32_var; - void *_tmp_119_var; + void *_tmp_120_var; Token * a; if ( - (_tmp_119_var = _tmp_119_rule(p)) // slash_no_default | slash_with_default + (_tmp_120_var = _tmp_120_rule(p)) // slash_no_default | slash_with_default && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && @@ -21284,16 +21524,16 @@ invalid_parameters_rule(Parser *p) asdl_seq * _loop0_32_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_120_var; + void *_tmp_121_var; Token * a; if ( - (_opt_var = _tmp_119_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_120_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_120_var = _tmp_120_rule(p)) // ',' | param_no_default + (_tmp_121_var = _tmp_121_rule(p)) // ',' | param_no_default && (_loop0_32_var_1 = _loop0_32_rule(p)) // param_maybe_default* && @@ -21372,7 +21612,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_121_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_122_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); @@ -21417,12 +21657,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_122_var; + void *_tmp_123_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_122_var = _tmp_122_rule(p)) // ')' | ',' (')' | '**') + (_tmp_123_var = _tmp_123_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); @@ -21506,19 +21746,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_32_var; - void *_tmp_123_var; - void *_tmp_123_var_1; + void *_tmp_124_var; + void *_tmp_124_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_123_var = _tmp_123_rule(p)) // param_no_default | ',' + (_tmp_124_var = _tmp_124_rule(p)) // param_no_default | ',' && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_123_var_1 = _tmp_123_rule(p)) // param_no_default | ',' + (_tmp_124_var_1 = _tmp_124_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 | ',')")); @@ -21633,7 +21873,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_124_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_125_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); @@ -21770,10 +22010,10 @@ 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* '/'")); asdl_seq * _loop0_75_var; - void *_tmp_125_var; + void *_tmp_126_var; Token * a; if ( - (_tmp_125_var = _tmp_125_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_126_var = _tmp_126_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -21833,7 +22073,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_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_127_var; + asdl_seq * _gather_128_var; asdl_seq * _loop0_71_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -21844,7 +22084,7 @@ invalid_lambda_parameters_rule(Parser *p) && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_127_var = _gather_127_rule(p)) // ','.lambda_param+ + (_gather_128_var = _gather_128_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -21875,16 +22115,16 @@ invalid_lambda_parameters_rule(Parser *p) asdl_seq * _loop0_75_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_128_var; + void *_tmp_129_var; Token * a; if ( - (_opt_var = _tmp_125_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_126_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_128_var = _tmp_128_rule(p)) // ',' | lambda_param_no_default + (_tmp_129_var = _tmp_129_rule(p)) // ',' | lambda_param_no_default && (_loop0_75_var_1 = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -22027,11 +22267,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_129_var; + void *_tmp_130_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_129_var = _tmp_129_rule(p)) // ':' | ',' (':' | '**') + (_tmp_130_var = _tmp_130_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); @@ -22085,19 +22325,19 @@ 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_75_var; - void *_tmp_130_var; - void *_tmp_130_var_1; + void *_tmp_131_var; + void *_tmp_131_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_130_var = _tmp_130_rule(p)) // lambda_param_no_default | ',' + (_tmp_131_var = _tmp_131_rule(p)) // lambda_param_no_default | ',' && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_130_var_1 = _tmp_130_rule(p)) // lambda_param_no_default | ',' + (_tmp_131_var_1 = _tmp_131_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 | ',')")); @@ -22215,7 +22455,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_124_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_125_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -22365,13 +22605,13 @@ invalid_for_if_clause_rule(Parser *p) Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_131_var; + void *_tmp_132_var; if ( (_opt_var = _PyPegen_expect_token(p, 682), !p->error_indicator) // 'async'? && (_keyword = _PyPegen_expect_token(p, 678)) // token='for' && - (_tmp_131_var = _tmp_131_rule(p)) // bitwise_or ((',' bitwise_or))* ','? + (_tmp_132_var = _tmp_132_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 679) // token='in' ) @@ -22546,14 +22786,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_133_var; + asdl_seq * _gather_134_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( (a = _PyPegen_expect_token(p, 622)) // token='import' && - (_gather_133_var = _gather_133_rule(p)) // ','.dotted_name+ + (_gather_134_var = _gather_134_rule(p)) // ','.dotted_name+ && (_keyword = _PyPegen_expect_token(p, 621)) // token='from' && @@ -22700,7 +22940,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_135_var; + asdl_seq * _gather_136_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22710,7 +22950,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 633)) // token='with' && - (_gather_135_var = _gather_135_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_136_var = _gather_136_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -22734,7 +22974,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_137_var; + asdl_seq * _gather_138_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -22750,7 +22990,7 @@ invalid_with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_137_var = _gather_137_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_138_var = _gather_138_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -22799,7 +23039,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_135_var; + asdl_seq * _gather_136_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22810,7 +23050,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (a = _PyPegen_expect_token(p, 633)) // token='with' && - (_gather_135_var = _gather_135_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_136_var = _gather_136_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -22838,7 +23078,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_137_var; + asdl_seq * _gather_138_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -22855,7 +23095,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_137_var = _gather_137_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_138_var = _gather_138_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -22952,7 +23192,7 @@ invalid_try_stmt_rule(Parser *p) && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_138_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_139_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); @@ -22977,7 +23217,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_139_var; + asdl_seq * _loop0_140_var; asdl_seq * _loop1_37_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22989,7 +23229,7 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_139_var = _loop0_139_rule(p)) // block* + (_loop0_140_var = _loop0_140_rule(p)) // block* && (_loop1_37_var = _loop1_37_rule(p)) // except_block+ && @@ -23026,7 +23266,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_139_var; + asdl_seq * _loop0_140_var; asdl_seq * _loop1_38_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23036,13 +23276,13 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_139_var = _loop0_139_rule(p)) // block* + (_loop0_140_var = _loop0_140_rule(p)) // block* && (_loop1_38_var = _loop1_38_rule(p)) // except_star_block+ && (a = _PyPegen_expect_token(p, 663)) // token='except' && - (_opt_var = _tmp_140_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_141_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -23327,14 +23567,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_141_var; + void *_tmp_142_var; Token * a; if ( (a = _PyPegen_expect_token(p, 663)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_141_var = _tmp_141_rule(p)) // NEWLINE | ':' + (_tmp_142_var = _tmp_142_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_star_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); @@ -23931,7 +24171,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_142_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_143_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -24630,11 +24870,11 @@ 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")); - asdl_seq * _gather_82_var; + asdl_seq * _gather_83_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_82_var = _gather_82_rule(p)) // ','.double_starred_kvpair+ + (_gather_83_var = _gather_83_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24642,7 +24882,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); - _res = _PyPegen_dummy_name(p, _gather_82_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_83_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -24695,7 +24935,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_143_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_144_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -24805,7 +25045,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_143_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_144_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -25093,7 +25333,7 @@ invalid_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_144_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_145_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); @@ -25125,7 +25365,7 @@ invalid_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_145_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_146_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); @@ -25189,9 +25429,9 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_147_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_148_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); @@ -25228,7 +25468,7 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25269,7 +25509,7 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -25316,7 +25556,7 @@ invalid_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_147_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_148_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); @@ -25383,14 +25623,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_148_var; + void *_tmp_149_var; Token * a; expr_ty b; expr_ty sum_var; if ( (sum_var = sum_rule(p)) // sum && - (_tmp_148_var = _tmp_148_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' + (_tmp_149_var = _tmp_149_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && (a = _PyPegen_expect_token(p, 687)) // token='not' && @@ -25435,11 +25675,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_149_var; + void *_tmp_150_var; Token * a; expr_ty b; if ( - (_tmp_149_var = _tmp_149_rule(p)) // '+' | '-' | '~' + (_tmp_150_var = _tmp_150_rule(p)) // '+' | '-' | '~' && (a = _PyPegen_expect_token(p, 687)) // token='not' && @@ -26213,12 +26453,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_150_var; + void *_tmp_151_var; while ( - (_tmp_150_var = _tmp_150_rule(p)) // star_targets '=' + (_tmp_151_var = _tmp_151_rule(p)) // star_targets '=' ) { - _res = _tmp_150_var; + _res = _tmp_151_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26551,12 +26791,12 @@ _loop0_18_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_151_var; + void *_tmp_152_var; while ( - (_tmp_151_var = _tmp_151_rule(p)) // '.' | '...' + (_tmp_152_var = _tmp_152_rule(p)) // '.' | '...' ) { - _res = _tmp_151_var; + _res = _tmp_152_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26618,12 +26858,12 @@ _loop1_19_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_151_var; + void *_tmp_152_var; while ( - (_tmp_151_var = _tmp_151_rule(p)) // '.' | '...' + (_tmp_152_var = _tmp_152_rule(p)) // '.' | '...' ) { - _res = _tmp_151_var; + _res = _tmp_152_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26970,12 +27210,12 @@ _loop1_25_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); - void *_tmp_152_var; + void *_tmp_153_var; while ( - (_tmp_152_var = _tmp_152_rule(p)) // '@' named_expression NEWLINE + (_tmp_153_var = _tmp_153_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_152_var; + _res = _tmp_153_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -28109,9 +28349,66 @@ _tmp_42_rule(Parser *p) return _res; } -// _tmp_43: '.' | '(' | '=' +// _tmp_43: STRING | FSTRING_START static void * _tmp_43_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // STRING + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING")); + expr_ty string_var; + if ( + (string_var = _PyPegen_string_token(p)) // STRING + ) + { + D(fprintf(stderr, "%*c+ _tmp_43[%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_43[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING")); + } + { // FSTRING_START + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_START")); + Token * fstring_start_var; + if ( + (fstring_start_var = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START' + ) + { + D(fprintf(stderr, "%*c+ _tmp_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_START")); + _res = fstring_start_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_44: '.' | '(' | '=' +static void * +_tmp_44_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28127,18 +28424,18 @@ _tmp_43_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c> _tmp_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_44[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_44[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } { // '(' @@ -28146,18 +28443,18 @@ _tmp_43_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c> _tmp_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c+ _tmp_44[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_44[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); } { // '=' @@ -28165,18 +28462,18 @@ _tmp_43_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_44[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_44[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } _res = NULL; @@ -28185,9 +28482,9 @@ _tmp_43_rule(Parser *p) return _res; } -// _loop0_44: ',' maybe_star_pattern +// _loop0_45: ',' maybe_star_pattern static asdl_seq * -_loop0_44_rule(Parser *p) +_loop0_45_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28212,7 +28509,7 @@ _loop0_44_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pattern")); + D(fprintf(stderr, "%*c> _loop0_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pattern")); Token * _literal; pattern_ty elem; while ( @@ -28244,7 +28541,7 @@ _loop0_44_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_45[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' maybe_star_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -28261,9 +28558,9 @@ _loop0_44_rule(Parser *p) return _seq; } -// _gather_45: maybe_star_pattern _loop0_44 +// _gather_46: maybe_star_pattern _loop0_45 static asdl_seq * -_gather_45_rule(Parser *p) +_gather_46_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28274,27 +28571,27 @@ _gather_45_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // maybe_star_pattern _loop0_44 + { // maybe_star_pattern _loop0_45 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_44")); + D(fprintf(stderr, "%*c> _gather_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_45")); pattern_ty elem; asdl_seq * seq; if ( (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern && - (seq = _loop0_44_rule(p)) // _loop0_44 + (seq = _loop0_45_rule(p)) // _loop0_45 ) { - D(fprintf(stderr, "%*c+ _gather_45[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_44")); + D(fprintf(stderr, "%*c+ _gather_46[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_45")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_45[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_44")); + D(fprintf(stderr, "%*c%s _gather_46[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_45")); } _res = NULL; done: @@ -28302,9 +28599,9 @@ _gather_45_rule(Parser *p) return _res; } -// _loop0_46: ',' key_value_pattern +// _loop0_47: ',' key_value_pattern static asdl_seq * -_loop0_46_rule(Parser *p) +_loop0_47_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28329,7 +28626,7 @@ _loop0_46_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pattern")); + D(fprintf(stderr, "%*c> _loop0_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pattern")); Token * _literal; KeyPatternPair* elem; while ( @@ -28361,7 +28658,7 @@ _loop0_46_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_47[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' key_value_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -28378,9 +28675,9 @@ _loop0_46_rule(Parser *p) return _seq; } -// _gather_47: key_value_pattern _loop0_46 +// _gather_48: key_value_pattern _loop0_47 static asdl_seq * -_gather_47_rule(Parser *p) +_gather_48_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28391,27 +28688,27 @@ _gather_47_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // key_value_pattern _loop0_46 + { // key_value_pattern _loop0_47 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_46")); + D(fprintf(stderr, "%*c> _gather_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_47")); KeyPatternPair* elem; asdl_seq * seq; if ( (elem = key_value_pattern_rule(p)) // key_value_pattern && - (seq = _loop0_46_rule(p)) // _loop0_46 + (seq = _loop0_47_rule(p)) // _loop0_47 ) { - D(fprintf(stderr, "%*c+ _gather_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_46")); + D(fprintf(stderr, "%*c+ _gather_48[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_47")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_47[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "key_value_pattern _loop0_46")); + D(fprintf(stderr, "%*c%s _gather_48[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "key_value_pattern _loop0_47")); } _res = NULL; done: @@ -28419,9 +28716,9 @@ _gather_47_rule(Parser *p) return _res; } -// _tmp_48: literal_expr | attr +// _tmp_49: literal_expr | attr static void * -_tmp_48_rule(Parser *p) +_tmp_49_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28437,18 +28734,18 @@ _tmp_48_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr")); + D(fprintf(stderr, "%*c> _tmp_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr")); expr_ty literal_expr_var; if ( (literal_expr_var = literal_expr_rule(p)) // literal_expr ) { - D(fprintf(stderr, "%*c+ _tmp_48[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_expr")); + D(fprintf(stderr, "%*c+ _tmp_49[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_expr")); _res = literal_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_48[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_49[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr")); } { // attr @@ -28456,18 +28753,18 @@ _tmp_48_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); + D(fprintf(stderr, "%*c> _tmp_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); expr_ty attr_var; if ( (attr_var = attr_rule(p)) // attr ) { - D(fprintf(stderr, "%*c+ _tmp_48[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr")); + D(fprintf(stderr, "%*c+ _tmp_49[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr")); _res = attr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_48[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_49[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); } _res = NULL; @@ -28476,9 +28773,9 @@ _tmp_48_rule(Parser *p) return _res; } -// _loop0_49: ',' pattern +// _loop0_50: ',' pattern static asdl_seq * -_loop0_49_rule(Parser *p) +_loop0_50_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28503,7 +28800,7 @@ _loop0_49_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern")); + D(fprintf(stderr, "%*c> _loop0_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern")); Token * _literal; pattern_ty elem; while ( @@ -28535,7 +28832,7 @@ _loop0_49_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_49[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_50[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -28552,9 +28849,9 @@ _loop0_49_rule(Parser *p) return _seq; } -// _gather_50: pattern _loop0_49 +// _gather_51: pattern _loop0_50 static asdl_seq * -_gather_50_rule(Parser *p) +_gather_51_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28565,27 +28862,27 @@ _gather_50_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // pattern _loop0_49 + { // pattern _loop0_50 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_49")); + D(fprintf(stderr, "%*c> _gather_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_50")); pattern_ty elem; asdl_seq * seq; if ( (elem = pattern_rule(p)) // pattern && - (seq = _loop0_49_rule(p)) // _loop0_49 + (seq = _loop0_50_rule(p)) // _loop0_50 ) { - D(fprintf(stderr, "%*c+ _gather_50[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern _loop0_49")); + D(fprintf(stderr, "%*c+ _gather_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern _loop0_50")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_50[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern _loop0_49")); + D(fprintf(stderr, "%*c%s _gather_51[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern _loop0_50")); } _res = NULL; done: @@ -28593,9 +28890,9 @@ _gather_50_rule(Parser *p) return _res; } -// _loop0_51: ',' keyword_pattern +// _loop0_52: ',' keyword_pattern static asdl_seq * -_loop0_51_rule(Parser *p) +_loop0_52_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28620,7 +28917,7 @@ _loop0_51_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_pattern")); + D(fprintf(stderr, "%*c> _loop0_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_pattern")); Token * _literal; KeyPatternPair* elem; while ( @@ -28652,7 +28949,7 @@ _loop0_51_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_51[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_52[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' keyword_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -28669,9 +28966,9 @@ _loop0_51_rule(Parser *p) return _seq; } -// _gather_52: keyword_pattern _loop0_51 +// _gather_53: keyword_pattern _loop0_52 static asdl_seq * -_gather_52_rule(Parser *p) +_gather_53_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28682,27 +28979,27 @@ _gather_52_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // keyword_pattern _loop0_51 + { // keyword_pattern _loop0_52 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_51")); + D(fprintf(stderr, "%*c> _gather_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_52")); KeyPatternPair* elem; asdl_seq * seq; if ( (elem = keyword_pattern_rule(p)) // keyword_pattern && - (seq = _loop0_51_rule(p)) // _loop0_51 + (seq = _loop0_52_rule(p)) // _loop0_52 ) { - D(fprintf(stderr, "%*c+ _gather_52[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_51")); + D(fprintf(stderr, "%*c+ _gather_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_52")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_52[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "keyword_pattern _loop0_51")); + D(fprintf(stderr, "%*c%s _gather_53[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "keyword_pattern _loop0_52")); } _res = NULL; done: @@ -28710,9 +29007,9 @@ _gather_52_rule(Parser *p) return _res; } -// _loop0_53: ',' type_param +// _loop0_54: ',' type_param static asdl_seq * -_loop0_53_rule(Parser *p) +_loop0_54_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28737,7 +29034,7 @@ _loop0_53_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' type_param")); + D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' type_param")); Token * _literal; type_param_ty elem; while ( @@ -28769,7 +29066,7 @@ _loop0_53_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_53[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_54[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' type_param")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -28786,9 +29083,9 @@ _loop0_53_rule(Parser *p) return _seq; } -// _gather_54: type_param _loop0_53 +// _gather_55: type_param _loop0_54 static asdl_seq * -_gather_54_rule(Parser *p) +_gather_55_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28799,27 +29096,27 @@ _gather_54_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // type_param _loop0_53 + { // type_param _loop0_54 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "type_param _loop0_53")); + D(fprintf(stderr, "%*c> _gather_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "type_param _loop0_54")); type_param_ty elem; asdl_seq * seq; if ( (elem = type_param_rule(p)) // type_param && - (seq = _loop0_53_rule(p)) // _loop0_53 + (seq = _loop0_54_rule(p)) // _loop0_54 ) { - D(fprintf(stderr, "%*c+ _gather_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "type_param _loop0_53")); + D(fprintf(stderr, "%*c+ _gather_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "type_param _loop0_54")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_54[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "type_param _loop0_53")); + D(fprintf(stderr, "%*c%s _gather_55[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "type_param _loop0_54")); } _res = NULL; done: @@ -28827,9 +29124,9 @@ _gather_54_rule(Parser *p) return _res; } -// _loop1_55: (',' expression) +// _loop1_56: (',' expression) static asdl_seq * -_loop1_55_rule(Parser *p) +_loop1_56_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28854,7 +29151,7 @@ _loop1_55_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)")); + D(fprintf(stderr, "%*c> _loop1_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)")); void *_tmp_17_var; while ( (_tmp_17_var = _tmp_17_rule(p)) // ',' expression @@ -28877,7 +29174,7 @@ _loop1_55_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_55[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_56[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)")); } if (_n == 0 || p->error_indicator) { @@ -28899,9 +29196,9 @@ _loop1_55_rule(Parser *p) return _seq; } -// _loop1_56: (',' star_expression) +// _loop1_57: (',' star_expression) static asdl_seq * -_loop1_56_rule(Parser *p) +_loop1_57_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28926,13 +29223,13 @@ _loop1_56_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); - void *_tmp_153_var; + D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); + void *_tmp_154_var; while ( - (_tmp_153_var = _tmp_153_rule(p)) // ',' star_expression + (_tmp_154_var = _tmp_154_rule(p)) // ',' star_expression ) { - _res = _tmp_153_var; + _res = _tmp_154_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -28949,7 +29246,7 @@ _loop1_56_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_56[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_57[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)")); } if (_n == 0 || p->error_indicator) { @@ -28971,9 +29268,9 @@ _loop1_56_rule(Parser *p) return _seq; } -// _loop0_57: ',' star_named_expression +// _loop0_58: ',' star_named_expression static asdl_seq * -_loop0_57_rule(Parser *p) +_loop0_58_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -28998,7 +29295,7 @@ _loop0_57_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression")); + D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression")); Token * _literal; expr_ty elem; while ( @@ -29030,7 +29327,7 @@ _loop0_57_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_57[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -29047,9 +29344,9 @@ _loop0_57_rule(Parser *p) return _seq; } -// _gather_58: star_named_expression _loop0_57 +// _gather_59: star_named_expression _loop0_58 static asdl_seq * -_gather_58_rule(Parser *p) +_gather_59_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29060,27 +29357,27 @@ _gather_58_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_named_expression _loop0_57 + { // star_named_expression _loop0_58 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_57")); + D(fprintf(stderr, "%*c> _gather_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_58")); expr_ty elem; asdl_seq * seq; if ( (elem = star_named_expression_rule(p)) // star_named_expression && - (seq = _loop0_57_rule(p)) // _loop0_57 + (seq = _loop0_58_rule(p)) // _loop0_58 ) { - D(fprintf(stderr, "%*c+ _gather_58[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_57")); + D(fprintf(stderr, "%*c+ _gather_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_58")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_58[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_57")); + D(fprintf(stderr, "%*c%s _gather_59[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_58")); } _res = NULL; done: @@ -29088,9 +29385,9 @@ _gather_58_rule(Parser *p) return _res; } -// _loop1_59: ('or' conjunction) +// _loop1_60: ('or' conjunction) static asdl_seq * -_loop1_59_rule(Parser *p) +_loop1_60_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29115,13 +29412,13 @@ _loop1_59_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); - void *_tmp_154_var; + D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); + void *_tmp_155_var; while ( - (_tmp_154_var = _tmp_154_rule(p)) // 'or' conjunction + (_tmp_155_var = _tmp_155_rule(p)) // 'or' conjunction ) { - _res = _tmp_154_var; + _res = _tmp_155_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29138,7 +29435,7 @@ _loop1_59_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_59[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)")); } if (_n == 0 || p->error_indicator) { @@ -29160,9 +29457,9 @@ _loop1_59_rule(Parser *p) return _seq; } -// _loop1_60: ('and' inversion) +// _loop1_61: ('and' inversion) static asdl_seq * -_loop1_60_rule(Parser *p) +_loop1_61_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29187,13 +29484,13 @@ _loop1_60_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); - void *_tmp_155_var; + D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); + void *_tmp_156_var; while ( - (_tmp_155_var = _tmp_155_rule(p)) // 'and' inversion + (_tmp_156_var = _tmp_156_rule(p)) // 'and' inversion ) { - _res = _tmp_155_var; + _res = _tmp_156_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29210,7 +29507,7 @@ _loop1_60_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)")); } if (_n == 0 || p->error_indicator) { @@ -29232,9 +29529,9 @@ _loop1_60_rule(Parser *p) return _seq; } -// _loop1_61: compare_op_bitwise_or_pair +// _loop1_62: compare_op_bitwise_or_pair static asdl_seq * -_loop1_61_rule(Parser *p) +_loop1_62_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29259,7 +29556,7 @@ _loop1_61_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); + D(fprintf(stderr, "%*c> _loop1_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); CmpopExprPair* compare_op_bitwise_or_pair_var; while ( (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair @@ -29282,7 +29579,7 @@ _loop1_61_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_62[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair")); } if (_n == 0 || p->error_indicator) { @@ -29304,9 +29601,9 @@ _loop1_61_rule(Parser *p) return _seq; } -// _tmp_62: '!=' +// _tmp_63: '!=' static void * -_tmp_62_rule(Parser *p) +_tmp_63_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29322,13 +29619,13 @@ _tmp_62_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); + D(fprintf(stderr, "%*c> _tmp_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); Token * tok; if ( (tok = _PyPegen_expect_token(p, 28)) // token='!=' ) { - D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); + D(fprintf(stderr, "%*c+ _tmp_63[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29338,7 +29635,7 @@ _tmp_62_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_62[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_63[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='")); } _res = NULL; @@ -29347,9 +29644,9 @@ _tmp_62_rule(Parser *p) return _res; } -// _loop0_63: ',' (slice | starred_expression) +// _loop0_64: ',' (slice | starred_expression) static asdl_seq * -_loop0_63_rule(Parser *p) +_loop0_64_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29374,13 +29671,13 @@ _loop0_63_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | starred_expression)")); + D(fprintf(stderr, "%*c> _loop0_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | starred_expression)")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_156_rule(p)) // slice | starred_expression + (elem = _tmp_157_rule(p)) // slice | starred_expression ) { _res = elem; @@ -29406,7 +29703,7 @@ _loop0_63_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_63[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_64[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (slice | starred_expression)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -29423,9 +29720,9 @@ _loop0_63_rule(Parser *p) return _seq; } -// _gather_64: (slice | starred_expression) _loop0_63 +// _gather_65: (slice | starred_expression) _loop0_64 static asdl_seq * -_gather_64_rule(Parser *p) +_gather_65_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29436,27 +29733,27 @@ _gather_64_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (slice | starred_expression) _loop0_63 + { // (slice | starred_expression) _loop0_64 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_63")); + D(fprintf(stderr, "%*c> _gather_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_64")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_156_rule(p)) // slice | starred_expression + (elem = _tmp_157_rule(p)) // slice | starred_expression && - (seq = _loop0_63_rule(p)) // _loop0_63 + (seq = _loop0_64_rule(p)) // _loop0_64 ) { - D(fprintf(stderr, "%*c+ _gather_64[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_63")); + D(fprintf(stderr, "%*c+ _gather_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_64")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_64[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_63")); + D(fprintf(stderr, "%*c%s _gather_65[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_64")); } _res = NULL; done: @@ -29464,9 +29761,9 @@ _gather_64_rule(Parser *p) return _res; } -// _tmp_65: ':' expression? +// _tmp_66: ':' expression? static void * -_tmp_65_rule(Parser *p) +_tmp_66_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -29482,7 +29779,7 @@ _tmp_65_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); + D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); Token * _literal; void *d; if ( @@ -29491,7 +29788,7 @@ _tmp_65_rule(Parser *p) (d = expression_rule(p), !p->error_indicator) // expression? ) { - D(fprintf(stderr, "%*c+ _tmp_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?")); + D(fprintf(stderr, "%*c+ _tmp_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29501,65 +29798,8 @@ _tmp_65_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_65[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_66: STRING | FSTRING_START -static void * -_tmp_66_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void * _res = NULL; - int _mark = p->mark; - { // STRING - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING")); - expr_ty string_var; - if ( - (string_var = _PyPegen_string_token(p)) // STRING - ) - { - D(fprintf(stderr, "%*c+ _tmp_66[%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_66[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING")); - } - { // FSTRING_START - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_START")); - Token * fstring_start_var; - if ( - (fstring_start_var = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START' - ) - { - D(fprintf(stderr, "%*c+ _tmp_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_START")); - _res = fstring_start_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?")); } _res = NULL; done: @@ -30403,9 +30643,76 @@ _loop0_78_rule(Parser *p) return _seq; } -// _loop1_79: (fstring | string) +// _loop0_79: tstring_middle +static asdl_seq * +_loop0_79_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // tstring_middle + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_79[%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 + ) + { + _res = tstring_middle_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_79[%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); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop1_80: (fstring | string) static asdl_seq * -_loop1_79_rule(Parser *p) +_loop1_80_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30430,13 +30737,13 @@ _loop1_79_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); - void *_tmp_157_var; + D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); + void *_tmp_158_var; while ( - (_tmp_157_var = _tmp_157_rule(p)) // fstring | string + (_tmp_158_var = _tmp_158_rule(p)) // fstring | string ) { - _res = _tmp_157_var; + _res = _tmp_158_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30453,7 +30760,7 @@ _loop1_79_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_79[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)")); } if (_n == 0 || p->error_indicator) { @@ -30475,9 +30782,9 @@ _loop1_79_rule(Parser *p) return _seq; } -// _tmp_80: star_named_expression ',' star_named_expressions? +// _tmp_81: star_named_expression ',' star_named_expressions? static void * -_tmp_80_rule(Parser *p) +_tmp_81_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30493,7 +30800,7 @@ _tmp_80_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); Token * _literal; expr_ty y; void *z; @@ -30505,7 +30812,7 @@ _tmp_80_rule(Parser *p) (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? ) { - D(fprintf(stderr, "%*c+ _tmp_80[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c+ _tmp_81[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); _res = _PyPegen_seq_insert_in_front ( p , y , z ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -30515,7 +30822,7 @@ _tmp_80_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_80[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_81[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); } _res = NULL; @@ -30524,9 +30831,9 @@ _tmp_80_rule(Parser *p) return _res; } -// _loop0_81: ',' double_starred_kvpair +// _loop0_82: ',' double_starred_kvpair static asdl_seq * -_loop0_81_rule(Parser *p) +_loop0_82_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30551,7 +30858,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, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -30583,7 +30890,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, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -30600,9 +30907,9 @@ _loop0_81_rule(Parser *p) return _seq; } -// _gather_82: double_starred_kvpair _loop0_81 +// _gather_83: double_starred_kvpair _loop0_82 static asdl_seq * -_gather_82_rule(Parser *p) +_gather_83_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30613,27 +30920,27 @@ _gather_82_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_81 + { // double_starred_kvpair _loop0_82 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_81")); + D(fprintf(stderr, "%*c> _gather_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_81_rule(p)) // _loop0_81 + (seq = _loop0_82_rule(p)) // _loop0_82 ) { - D(fprintf(stderr, "%*c+ _gather_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_81")); + D(fprintf(stderr, "%*c+ _gather_83[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_82[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_81")); + D(fprintf(stderr, "%*c%s _gather_83[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_82")); } _res = NULL; done: @@ -30641,9 +30948,9 @@ _gather_82_rule(Parser *p) return _res; } -// _loop1_83: for_if_clause +// _loop1_84: for_if_clause static asdl_seq * -_loop1_83_rule(Parser *p) +_loop1_84_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30668,7 +30975,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, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_84[%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 @@ -30691,7 +30998,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, "for_if_clause")); } if (_n == 0 || p->error_indicator) { @@ -30713,9 +31020,9 @@ _loop1_83_rule(Parser *p) return _seq; } -// _loop0_84: ('if' disjunction) +// _loop0_85: ('if' disjunction) static asdl_seq * -_loop0_84_rule(Parser *p) +_loop0_85_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30740,13 +31047,13 @@ _loop0_84_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); - void *_tmp_158_var; + D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + void *_tmp_159_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // 'if' disjunction + (_tmp_159_var = _tmp_159_rule(p)) // 'if' disjunction ) { - _res = _tmp_158_var; + _res = _tmp_159_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30763,7 +31070,7 @@ _loop0_84_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_84[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_85[%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); @@ -30780,9 +31087,9 @@ _loop0_84_rule(Parser *p) return _seq; } -// _tmp_85: assignment_expression | expression !':=' +// _tmp_86: assignment_expression | expression !':=' static void * -_tmp_85_rule(Parser *p) +_tmp_86_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30798,18 +31105,18 @@ _tmp_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_86[%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_85[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_86[%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_85[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_86[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } { // expression !':=' @@ -30817,7 +31124,7 @@ _tmp_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -30825,12 +31132,12 @@ _tmp_85_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_85[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_86[%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_85[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_86[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } _res = NULL; @@ -30839,9 +31146,9 @@ _tmp_85_rule(Parser *p) return _res; } -// _loop0_86: ',' (starred_expression | (assignment_expression | expression !':=') !'=') +// _loop0_87: ',' (starred_expression | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_86_rule(Parser *p) +_loop0_87_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30866,13 +31173,13 @@ _loop0_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_87[%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_159_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_160_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -30898,7 +31205,7 @@ _loop0_86_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_86[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_87[%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); @@ -30915,10 +31222,10 @@ _loop0_86_rule(Parser *p) return _seq; } -// _gather_87: -// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86 +// _gather_88: +// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 static asdl_seq * -_gather_87_rule(Parser *p) +_gather_88_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30929,27 +31236,27 @@ _gather_87_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86 + { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); + D(fprintf(stderr, "%*c> _gather_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_159_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_160_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_86_rule(p)) // _loop0_86 + (seq = _loop0_87_rule(p)) // _loop0_87 ) { - D(fprintf(stderr, "%*c+ _gather_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); + D(fprintf(stderr, "%*c+ _gather_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_87[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); + D(fprintf(stderr, "%*c%s _gather_88[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); } _res = NULL; done: @@ -30957,9 +31264,9 @@ _gather_87_rule(Parser *p) return _res; } -// _tmp_88: ',' kwargs +// _tmp_89: ',' kwargs static void * -_tmp_88_rule(Parser *p) +_tmp_89_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30975,7 +31282,7 @@ _tmp_88_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -30984,7 +31291,7 @@ _tmp_88_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); _res = k; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -30994,7 +31301,7 @@ _tmp_88_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_88[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); } _res = NULL; @@ -31003,9 +31310,9 @@ _tmp_88_rule(Parser *p) return _res; } -// _loop0_89: ',' kwarg_or_starred +// _loop0_90: ',' kwarg_or_starred static asdl_seq * -_loop0_89_rule(Parser *p) +_loop0_90_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31030,7 +31337,7 @@ _loop0_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31062,7 +31369,7 @@ _loop0_89_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_89[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_90[%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); @@ -31079,9 +31386,9 @@ _loop0_89_rule(Parser *p) return _seq; } -// _gather_90: kwarg_or_starred _loop0_89 +// _gather_91: kwarg_or_starred _loop0_90 static asdl_seq * -_gather_90_rule(Parser *p) +_gather_91_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31092,27 +31399,27 @@ _gather_90_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_89 + { // kwarg_or_starred _loop0_90 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_89")); + D(fprintf(stderr, "%*c> _gather_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_90")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_89_rule(p)) // _loop0_89 + (seq = _loop0_90_rule(p)) // _loop0_90 ) { - D(fprintf(stderr, "%*c+ _gather_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_89")); + D(fprintf(stderr, "%*c+ _gather_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_90")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_90[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_89")); + D(fprintf(stderr, "%*c%s _gather_91[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_90")); } _res = NULL; done: @@ -31120,9 +31427,9 @@ _gather_90_rule(Parser *p) return _res; } -// _loop0_91: ',' kwarg_or_double_starred +// _loop0_92: ',' kwarg_or_double_starred static asdl_seq * -_loop0_91_rule(Parser *p) +_loop0_92_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31147,7 +31454,7 @@ _loop0_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31179,7 +31486,7 @@ _loop0_91_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_91[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_92[%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); @@ -31196,9 +31503,9 @@ _loop0_91_rule(Parser *p) return _seq; } -// _gather_92: kwarg_or_double_starred _loop0_91 +// _gather_93: kwarg_or_double_starred _loop0_92 static asdl_seq * -_gather_92_rule(Parser *p) +_gather_93_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31209,27 +31516,27 @@ _gather_92_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_91 + { // kwarg_or_double_starred _loop0_92 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_91")); + D(fprintf(stderr, "%*c> _gather_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_91_rule(p)) // _loop0_91 + (seq = _loop0_92_rule(p)) // _loop0_92 ) { - D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_91")); + D(fprintf(stderr, "%*c+ _gather_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_91")); + D(fprintf(stderr, "%*c%s _gather_93[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_92")); } _res = NULL; done: @@ -31237,9 +31544,9 @@ _gather_92_rule(Parser *p) return _res; } -// _loop0_93: (',' star_target) +// _loop0_94: (',' star_target) static asdl_seq * -_loop0_93_rule(Parser *p) +_loop0_94_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31264,13 +31571,13 @@ _loop0_93_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_160_var; + D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_161_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // ',' star_target + (_tmp_161_var = _tmp_161_rule(p)) // ',' star_target ) { - _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 *)); @@ -31287,7 +31594,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, "(',' star_target)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31304,9 +31611,9 @@ _loop0_93_rule(Parser *p) return _seq; } -// _loop0_94: ',' star_target +// _loop0_95: ',' star_target static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_95_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31331,7 +31638,7 @@ _loop0_94_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -31363,7 +31670,7 @@ _loop0_94_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_94[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_95[%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); @@ -31380,9 +31687,9 @@ _loop0_94_rule(Parser *p) return _seq; } -// _gather_95: star_target _loop0_94 +// _gather_96: star_target _loop0_95 static asdl_seq * -_gather_95_rule(Parser *p) +_gather_96_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31393,27 +31700,27 @@ _gather_95_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_94 + { // star_target _loop0_95 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_94")); + D(fprintf(stderr, "%*c> _gather_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_95")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_94_rule(p)) // _loop0_94 + (seq = _loop0_95_rule(p)) // _loop0_95 ) { - D(fprintf(stderr, "%*c+ _gather_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_94")); + D(fprintf(stderr, "%*c+ _gather_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_95")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_95[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_94")); + D(fprintf(stderr, "%*c%s _gather_96[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_95")); } _res = NULL; done: @@ -31421,9 +31728,9 @@ _gather_95_rule(Parser *p) return _res; } -// _loop1_96: (',' star_target) +// _loop1_97: (',' star_target) static asdl_seq * -_loop1_96_rule(Parser *p) +_loop1_97_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31448,13 +31755,13 @@ _loop1_96_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_160_var; + D(fprintf(stderr, "%*c> _loop1_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_161_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // ',' star_target + (_tmp_161_var = _tmp_161_rule(p)) // ',' star_target ) { - _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 *)); @@ -31471,7 +31778,7 @@ _loop1_96_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_96[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_97[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -31493,9 +31800,9 @@ _loop1_96_rule(Parser *p) return _seq; } -// _tmp_97: !'*' star_target +// _tmp_98: !'*' star_target static void * -_tmp_97_rule(Parser *p) +_tmp_98_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31511,7 +31818,7 @@ _tmp_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_98[%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='*' @@ -31519,12 +31826,12 @@ _tmp_97_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_98[%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_97[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_98[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); } _res = NULL; @@ -31533,9 +31840,9 @@ _tmp_97_rule(Parser *p) return _res; } -// _loop0_98: ',' del_target +// _loop0_99: ',' del_target static asdl_seq * -_loop0_98_rule(Parser *p) +_loop0_99_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31560,7 +31867,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, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -31592,7 +31899,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, "',' del_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31609,9 +31916,9 @@ _loop0_98_rule(Parser *p) return _seq; } -// _gather_99: del_target _loop0_98 +// _gather_100: del_target _loop0_99 static asdl_seq * -_gather_99_rule(Parser *p) +_gather_100_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31622,27 +31929,27 @@ _gather_99_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_98 + { // del_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, "del_target _loop0_98")); + D(fprintf(stderr, "%*c> _gather_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_99")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_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, "del_target _loop0_98")); + D(fprintf(stderr, "%*c+ _gather_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_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, "del_target _loop0_98")); + D(fprintf(stderr, "%*c%s _gather_100[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_99")); } _res = NULL; done: @@ -31650,9 +31957,9 @@ _gather_99_rule(Parser *p) return _res; } -// _loop0_100: ',' expression +// _loop0_101: ',' expression static asdl_seq * -_loop0_100_rule(Parser *p) +_loop0_101_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31677,7 +31984,7 @@ _loop0_100_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -31709,7 +32016,7 @@ _loop0_100_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_100[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_101[%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); @@ -31726,9 +32033,9 @@ _loop0_100_rule(Parser *p) return _seq; } -// _gather_101: expression _loop0_100 +// _gather_102: expression _loop0_101 static asdl_seq * -_gather_101_rule(Parser *p) +_gather_102_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31739,27 +32046,27 @@ _gather_101_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_100 + { // expression _loop0_101 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_100")); + D(fprintf(stderr, "%*c> _gather_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_100_rule(p)) // _loop0_100 + (seq = _loop0_101_rule(p)) // _loop0_101 ) { - D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_100")); + D(fprintf(stderr, "%*c+ _gather_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_100")); + D(fprintf(stderr, "%*c%s _gather_102[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_101")); } _res = NULL; done: @@ -31767,9 +32074,9 @@ _gather_101_rule(Parser *p) return _res; } -// _tmp_102: NEWLINE INDENT +// _tmp_103: NEWLINE INDENT static void * -_tmp_102_rule(Parser *p) +_tmp_103_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31785,7 +32092,7 @@ _tmp_102_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -31794,12 +32101,12 @@ _tmp_102_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_103[%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_102[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_103[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); } _res = NULL; @@ -31808,11 +32115,11 @@ _tmp_102_rule(Parser *p) return _res; } -// _tmp_103: +// _tmp_104: // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) // | kwargs static void * -_tmp_103_rule(Parser *p) +_tmp_104_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31828,18 +32135,18 @@ _tmp_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - void *_tmp_161_var; + D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + void *_tmp_162_var; if ( - (_tmp_161_var = _tmp_161_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs + (_tmp_162_var = _tmp_162_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - _res = _tmp_161_var; + D(fprintf(stderr, "%*c+ _tmp_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + _res = _tmp_162_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_103[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } { // kwargs @@ -31847,18 +32154,18 @@ _tmp_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c> _tmp_104[%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_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c+ _tmp_104[%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_103[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); } _res = NULL; @@ -31867,9 +32174,9 @@ _tmp_103_rule(Parser *p) return _res; } -// _loop0_104: ',' (starred_expression !'=') +// _loop0_105: ',' (starred_expression !'=') static asdl_seq * -_loop0_104_rule(Parser *p) +_loop0_105_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31894,13 +32201,13 @@ _loop0_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); + D(fprintf(stderr, "%*c> _loop0_105[%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_162_rule(p)) // starred_expression !'=' + (elem = _tmp_163_rule(p)) // starred_expression !'=' ) { _res = elem; @@ -31926,7 +32233,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, "',' (starred_expression !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31943,9 +32250,9 @@ _loop0_104_rule(Parser *p) return _seq; } -// _gather_105: (starred_expression !'=') _loop0_104 +// _gather_106: (starred_expression !'=') _loop0_105 static asdl_seq * -_gather_105_rule(Parser *p) +_gather_106_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31956,27 +32263,27 @@ _gather_105_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression !'=') _loop0_104 + { // (starred_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, "(starred_expression !'=') _loop0_104")); + D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_105")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_162_rule(p)) // starred_expression !'=' + (elem = _tmp_163_rule(p)) // starred_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, "(starred_expression !'=') _loop0_104")); + D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_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, "(starred_expression !'=') _loop0_104")); + D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_105")); } _res = NULL; done: @@ -31984,9 +32291,9 @@ _gather_105_rule(Parser *p) return _res; } -// _tmp_106: args | expression for_if_clauses +// _tmp_107: args | expression for_if_clauses static void * -_tmp_106_rule(Parser *p) +_tmp_107_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32002,18 +32309,18 @@ _tmp_106_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c> _tmp_107[%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_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c+ _tmp_107[%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_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, "args")); } { // expression for_if_clauses @@ -32021,7 +32328,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, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_107[%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 ( @@ -32030,12 +32337,12 @@ _tmp_106_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_107[%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_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, "expression for_if_clauses")); } _res = NULL; @@ -32044,9 +32351,9 @@ _tmp_106_rule(Parser *p) return _res; } -// _tmp_107: args ',' +// _tmp_108: args ',' static void * -_tmp_107_rule(Parser *p) +_tmp_108_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32062,7 +32369,7 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -32071,12 +32378,12 @@ _tmp_107_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_108[%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_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, "args ','")); } _res = NULL; @@ -32085,9 +32392,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _tmp_108: ',' | ')' +// _tmp_109: ',' | ')' static void * -_tmp_108_rule(Parser *p) +_tmp_109_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32103,18 +32410,18 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -32122,18 +32429,18 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } _res = NULL; @@ -32142,9 +32449,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _tmp_109: 'True' | 'False' | 'None' +// _tmp_110: 'True' | 'False' | 'None' static void * -_tmp_109_rule(Parser *p) +_tmp_110_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32160,18 +32467,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 610)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'False' @@ -32179,18 +32486,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 612)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } { // 'None' @@ -32198,18 +32505,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 611)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } _res = NULL; @@ -32218,9 +32525,9 @@ _tmp_109_rule(Parser *p) return _res; } -// _tmp_110: NAME '=' +// _tmp_111: NAME '=' static void * -_tmp_110_rule(Parser *p) +_tmp_111_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32236,7 +32543,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, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -32245,12 +32552,12 @@ _tmp_110_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_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, "NAME '='")); } _res = NULL; @@ -32259,9 +32566,9 @@ _tmp_110_rule(Parser *p) return _res; } -// _tmp_111: NAME STRING | SOFT_KEYWORD +// _tmp_112: NAME STRING | SOFT_KEYWORD static void * -_tmp_111_rule(Parser *p) +_tmp_112_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32277,7 +32584,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, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -32286,12 +32593,12 @@ _tmp_111_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_112[%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_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, "NAME STRING")); } { // SOFT_KEYWORD @@ -32299,18 +32606,18 @@ _tmp_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_112[%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_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_112[%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_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, "SOFT_KEYWORD")); } _res = NULL; @@ -32319,9 +32626,9 @@ _tmp_111_rule(Parser *p) return _res; } -// _tmp_112: 'else' | ':' +// _tmp_113: 'else' | ':' static void * -_tmp_112_rule(Parser *p) +_tmp_113_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32337,18 +32644,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, "'else'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 671)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); _res = _keyword; 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, "'else'")); } { // ':' @@ -32356,18 +32663,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, 11)) // 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; @@ -32376,9 +32683,9 @@ _tmp_112_rule(Parser *p) return _res; } -// _tmp_113: '=' | ':=' +// _tmp_114: '=' | ':=' static void * -_tmp_113_rule(Parser *p) +_tmp_114_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32394,18 +32701,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, "'='")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; 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, "'='")); } { // ':=' @@ -32413,18 +32720,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, "':='")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); _res = _literal; 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, "':='")); } _res = NULL; @@ -32433,9 +32740,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_115: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_114_rule(Parser *p) +_tmp_115_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32451,18 +32758,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c> _tmp_115[%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_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c+ _tmp_115[%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_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, "list")); } { // tuple @@ -32470,18 +32777,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c> _tmp_115[%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_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_115[%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_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, "tuple")); } { // genexp @@ -32489,18 +32796,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c> _tmp_115[%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_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_115[%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_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, "genexp")); } { // 'True' @@ -32508,18 +32815,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 610)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; 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, "'True'")); } { // 'None' @@ -32527,18 +32834,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 611)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; 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, "'None'")); } { // 'False' @@ -32546,18 +32853,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 612)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; 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, "'False'")); } _res = NULL; @@ -32566,9 +32873,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _loop0_115: star_named_expressions +// _loop0_116: star_named_expressions static asdl_seq * -_loop0_115_rule(Parser *p) +_loop0_116_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32593,7 +32900,7 @@ _loop0_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_116[%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 @@ -32616,7 +32923,7 @@ _loop0_115_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_116[%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); @@ -32633,9 +32940,9 @@ _loop0_115_rule(Parser *p) return _seq; } -// _loop0_116: (star_targets '=') +// _loop0_117: (star_targets '=') static asdl_seq * -_loop0_116_rule(Parser *p) +_loop0_117_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32660,13 +32967,13 @@ _loop0_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_150_var; + D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); + void *_tmp_151_var; while ( - (_tmp_150_var = _tmp_150_rule(p)) // star_targets '=' + (_tmp_151_var = _tmp_151_rule(p)) // star_targets '=' ) { - _res = _tmp_150_var; + _res = _tmp_151_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32683,7 +32990,7 @@ _loop0_116_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_117[%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); @@ -32700,9 +33007,9 @@ _loop0_116_rule(Parser *p) return _seq; } -// _tmp_117: '[' | '(' | '{' +// _tmp_118: '[' | '(' | '{' static void * -_tmp_117_rule(Parser *p) +_tmp_118_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32718,18 +33025,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, 9)) // 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, "'['")); } { // '(' @@ -32737,18 +33044,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, 7)) // 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, "'('")); } { // '{' @@ -32756,18 +33063,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, 25)) // 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; @@ -32776,9 +33083,9 @@ _tmp_117_rule(Parser *p) return _res; } -// _tmp_118: '[' | '{' +// _tmp_119: '[' | '{' static void * -_tmp_118_rule(Parser *p) +_tmp_119_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32794,18 +33101,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, "'['")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; 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, "'['")); } { // '{' @@ -32813,18 +33120,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, "'{'")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; 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, "'{'")); } _res = NULL; @@ -32833,9 +33140,9 @@ _tmp_118_rule(Parser *p) return _res; } -// _tmp_119: slash_no_default | slash_with_default +// _tmp_120: slash_no_default | slash_with_default static void * -_tmp_119_rule(Parser *p) +_tmp_120_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32851,18 +33158,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, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_120[%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_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_120[%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_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, "slash_no_default")); } { // slash_with_default @@ -32870,18 +33177,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, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_120[%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_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_120[%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_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, "slash_with_default")); } _res = NULL; @@ -32890,9 +33197,9 @@ _tmp_119_rule(Parser *p) return _res; } -// _tmp_120: ',' | param_no_default +// _tmp_121: ',' | param_no_default static void * -_tmp_120_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32908,18 +33215,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, "','")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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, "','")); } { // param_no_default @@ -32927,18 +33234,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_121[%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_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_121[%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_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, "param_no_default")); } _res = NULL; @@ -32947,9 +33254,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _tmp_121: ')' | ',' +// _tmp_122: ')' | ',' static void * -_tmp_121_rule(Parser *p) +_tmp_122_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32965,18 +33272,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' @@ -32984,18 +33291,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -33004,9 +33311,9 @@ _tmp_121_rule(Parser *p) return _res; } -// _tmp_122: ')' | ',' (')' | '**') +// _tmp_123: ')' | ',' (')' | '**') static void * -_tmp_122_rule(Parser *p) +_tmp_123_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33022,18 +33329,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' (')' | '**') @@ -33041,21 +33348,21 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); Token * _literal; - void *_tmp_163_var; + void *_tmp_164_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_163_var = _tmp_163_rule(p)) // ')' | '**' + (_tmp_164_var = _tmp_164_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_163_var); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_164_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); } _res = NULL; @@ -33064,9 +33371,9 @@ _tmp_122_rule(Parser *p) return _res; } -// _tmp_123: param_no_default | ',' +// _tmp_124: param_no_default | ',' static void * -_tmp_123_rule(Parser *p) +_tmp_124_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33082,18 +33389,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_124[%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_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_124[%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_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, "param_no_default")); } { // ',' @@ -33101,18 +33408,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, 12)) // 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, "','")); } _res = NULL; @@ -33121,9 +33428,9 @@ _tmp_123_rule(Parser *p) return _res; } -// _tmp_124: '*' | '**' | '/' +// _tmp_125: '*' | '**' | '/' static void * -_tmp_124_rule(Parser *p) +_tmp_125_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33139,18 +33446,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, "'*'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _literal; 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, "'*'")); } { // '**' @@ -33158,18 +33465,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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } { // '/' @@ -33177,18 +33484,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, "'/'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _literal; 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, "'/'")); } _res = NULL; @@ -33197,9 +33504,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _tmp_125: lambda_slash_no_default | lambda_slash_with_default +// _tmp_126: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_125_rule(Parser *p) +_tmp_126_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33215,18 +33522,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, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_126[%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_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_126[%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_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, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -33234,18 +33541,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, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_126[%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_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_126[%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_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, "lambda_slash_with_default")); } _res = NULL; @@ -33254,9 +33561,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _loop0_126: ',' lambda_param +// _loop0_127: ',' lambda_param static asdl_seq * -_loop0_126_rule(Parser *p) +_loop0_127_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33281,7 +33588,7 @@ _loop0_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -33313,7 +33620,7 @@ _loop0_126_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_126[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_127[%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); @@ -33330,9 +33637,9 @@ _loop0_126_rule(Parser *p) return _seq; } -// _gather_127: lambda_param _loop0_126 +// _gather_128: lambda_param _loop0_127 static asdl_seq * -_gather_127_rule(Parser *p) +_gather_128_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33343,27 +33650,27 @@ _gather_127_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_126 + { // lambda_param _loop0_127 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_126")); + D(fprintf(stderr, "%*c> _gather_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_127")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_126_rule(p)) // _loop0_126 + (seq = _loop0_127_rule(p)) // _loop0_127 ) { - D(fprintf(stderr, "%*c+ _gather_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_126")); + D(fprintf(stderr, "%*c+ _gather_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_127")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_127[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_126")); + D(fprintf(stderr, "%*c%s _gather_128[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_127")); } _res = NULL; done: @@ -33371,9 +33678,9 @@ _gather_127_rule(Parser *p) return _res; } -// _tmp_128: ',' | lambda_param_no_default +// _tmp_129: ',' | lambda_param_no_default static void * -_tmp_128_rule(Parser *p) +_tmp_129_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33389,18 +33696,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, "','")); } { // lambda_param_no_default @@ -33408,18 +33715,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, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_129[%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_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_129[%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_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, "lambda_param_no_default")); } _res = NULL; @@ -33428,9 +33735,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) { _Pypegen_stack_overflow(p); @@ -33446,18 +33753,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, 11)) // 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, "':'")); } { // ',' (':' | '**') @@ -33465,21 +33772,21 @@ _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; - void *_tmp_164_var; + void *_tmp_165_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_164_var = _tmp_164_rule(p)) // ':' | '**' + (_tmp_165_var = _tmp_165_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_164_var); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_165_var); 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; @@ -33488,9 +33795,9 @@ _tmp_129_rule(Parser *p) return _res; } -// _tmp_130: lambda_param_no_default | ',' +// _tmp_131: lambda_param_no_default | ',' static void * -_tmp_130_rule(Parser *p) +_tmp_131_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33506,18 +33813,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_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_131[%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_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_131[%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_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_param_no_default")); } { // ',' @@ -33525,18 +33832,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, "','")); + D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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, "','")); } _res = NULL; @@ -33545,9 +33852,9 @@ _tmp_130_rule(Parser *p) return _res; } -// _tmp_131: bitwise_or ((',' bitwise_or))* ','? +// _tmp_132: bitwise_or ((',' bitwise_or))* ','? static void * -_tmp_131_rule(Parser *p) +_tmp_132_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33563,25 +33870,25 @@ _tmp_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - asdl_seq * _loop0_165_var; + D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + asdl_seq * _loop0_166_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_165_var = _loop0_165_rule(p)) // ((',' bitwise_or))* + (_loop0_166_var = _loop0_166_rule(p)) // ((',' bitwise_or))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) { - D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_165_var, _opt_var); + D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_166_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); } _res = NULL; @@ -33590,9 +33897,9 @@ _tmp_131_rule(Parser *p) return _res; } -// _loop0_132: ',' dotted_name +// _loop0_133: ',' dotted_name static asdl_seq * -_loop0_132_rule(Parser *p) +_loop0_133_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33617,7 +33924,7 @@ _loop0_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -33649,7 +33956,7 @@ _loop0_132_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_132[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_133[%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); @@ -33666,9 +33973,9 @@ _loop0_132_rule(Parser *p) return _seq; } -// _gather_133: dotted_name _loop0_132 +// _gather_134: dotted_name _loop0_133 static asdl_seq * -_gather_133_rule(Parser *p) +_gather_134_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33679,27 +33986,27 @@ _gather_133_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_132 + { // dotted_name _loop0_133 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_132")); + D(fprintf(stderr, "%*c> _gather_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_133")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_132_rule(p)) // _loop0_132 + (seq = _loop0_133_rule(p)) // _loop0_133 ) { - D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_132")); + D(fprintf(stderr, "%*c+ _gather_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_133")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_133[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_132")); + D(fprintf(stderr, "%*c%s _gather_134[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_133")); } _res = NULL; done: @@ -33707,9 +34014,9 @@ _gather_133_rule(Parser *p) return _res; } -// _loop0_134: ',' (expression ['as' star_target]) +// _loop0_135: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_134_rule(Parser *p) +_loop0_135_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33734,13 +34041,13 @@ _loop0_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_135[%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_166_rule(p)) // expression ['as' star_target] + (elem = _tmp_167_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -33766,7 +34073,7 @@ _loop0_134_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_134[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_135[%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); @@ -33783,9 +34090,9 @@ _loop0_134_rule(Parser *p) return _seq; } -// _gather_135: (expression ['as' star_target]) _loop0_134 +// _gather_136: (expression ['as' star_target]) _loop0_135 static asdl_seq * -_gather_135_rule(Parser *p) +_gather_136_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33796,27 +34103,27 @@ _gather_135_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_134 + { // (expression ['as' star_target]) _loop0_135 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); + D(fprintf(stderr, "%*c> _gather_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_166_rule(p)) // expression ['as' star_target] + (elem = _tmp_167_rule(p)) // expression ['as' star_target] && - (seq = _loop0_134_rule(p)) // _loop0_134 + (seq = _loop0_135_rule(p)) // _loop0_135 ) { - D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); + D(fprintf(stderr, "%*c+ _gather_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); + D(fprintf(stderr, "%*c%s _gather_136[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); } _res = NULL; done: @@ -33824,9 +34131,9 @@ _gather_135_rule(Parser *p) return _res; } -// _loop0_136: ',' (expressions ['as' star_target]) +// _loop0_137: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_136_rule(Parser *p) +_loop0_137_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33851,13 +34158,13 @@ _loop0_136_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_137[%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_167_rule(p)) // expressions ['as' star_target] + (elem = _tmp_168_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -33883,7 +34190,7 @@ _loop0_136_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_137[%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); @@ -33900,9 +34207,9 @@ _loop0_136_rule(Parser *p) return _seq; } -// _gather_137: (expressions ['as' star_target]) _loop0_136 +// _gather_138: (expressions ['as' star_target]) _loop0_137 static asdl_seq * -_gather_137_rule(Parser *p) +_gather_138_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33913,27 +34220,27 @@ _gather_137_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_136 + { // (expressions ['as' star_target]) _loop0_137 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); + D(fprintf(stderr, "%*c> _gather_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_167_rule(p)) // expressions ['as' star_target] + (elem = _tmp_168_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_136_rule(p)) // _loop0_136 + (seq = _loop0_137_rule(p)) // _loop0_137 ) { - D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); + D(fprintf(stderr, "%*c+ _gather_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); + D(fprintf(stderr, "%*c%s _gather_138[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); } _res = NULL; done: @@ -33941,9 +34248,9 @@ _gather_137_rule(Parser *p) return _res; } -// _tmp_138: 'except' | 'finally' +// _tmp_139: 'except' | 'finally' static void * -_tmp_138_rule(Parser *p) +_tmp_139_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33959,18 +34266,18 @@ _tmp_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 663)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } { // 'finally' @@ -33978,18 +34285,18 @@ _tmp_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 659)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } _res = NULL; @@ -33998,9 +34305,9 @@ _tmp_138_rule(Parser *p) return _res; } -// _loop0_139: block +// _loop0_140: block static asdl_seq * -_loop0_139_rule(Parser *p) +_loop0_140_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34025,7 +34332,7 @@ _loop0_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); + D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -34048,7 +34355,7 @@ _loop0_139_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_139[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_140[%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); @@ -34065,9 +34372,9 @@ _loop0_139_rule(Parser *p) return _seq; } -// _tmp_140: expression ['as' NAME] +// _tmp_141: expression ['as' NAME] static void * -_tmp_140_rule(Parser *p) +_tmp_141_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34083,7 +34390,7 @@ _tmp_140_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_141[%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; @@ -34093,12 +34400,12 @@ _tmp_140_rule(Parser *p) (_opt_var = _tmp_22_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_141[%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_140[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]")); } _res = NULL; @@ -34107,9 +34414,9 @@ _tmp_140_rule(Parser *p) return _res; } -// _tmp_141: NEWLINE | ':' +// _tmp_142: NEWLINE | ':' static void * -_tmp_141_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34125,18 +34432,18 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_142[%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_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_142[%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_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } { // ':' @@ -34144,18 +34451,18 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -34164,9 +34471,9 @@ _tmp_141_rule(Parser *p) return _res; } -// _tmp_142: positional_patterns ',' +// _tmp_143: positional_patterns ',' static void * -_tmp_142_rule(Parser *p) +_tmp_143_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34182,7 +34489,7 @@ _tmp_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -34191,12 +34498,12 @@ _tmp_142_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_143[%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_142[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); } _res = NULL; @@ -34205,9 +34512,9 @@ _tmp_142_rule(Parser *p) return _res; } -// _tmp_143: '}' | ',' +// _tmp_144: '}' | ',' static void * -_tmp_143_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34223,18 +34530,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } { // ',' @@ -34242,18 +34549,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -34262,9 +34569,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: '=' | '!' | ':' | '}' +// _tmp_145: '=' | '!' | ':' | '}' static void * -_tmp_144_rule(Parser *p) +_tmp_145_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34280,18 +34587,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, "'='")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; 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, "'='")); } { // '!' @@ -34299,18 +34606,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, "'!'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; 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, "'!'")); } { // ':' @@ -34318,18 +34625,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } { // '}' @@ -34337,18 +34644,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; 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, "'}'")); } _res = NULL; @@ -34357,9 +34664,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _tmp_145: '!' | ':' | '}' +// _tmp_146: '!' | ':' | '}' static void * -_tmp_145_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34375,18 +34682,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -34394,18 +34701,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -34413,18 +34720,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -34433,9 +34740,9 @@ _tmp_145_rule(Parser *p) return _res; } -// _tmp_146: '!' NAME +// _tmp_147: '!' NAME static void * -_tmp_146_rule(Parser *p) +_tmp_147_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34451,7 +34758,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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -34460,12 +34767,12 @@ _tmp_146_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_147[%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_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, "'!' NAME")); } _res = NULL; @@ -34474,9 +34781,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: ':' | '}' +// _tmp_148: ':' | '}' static void * -_tmp_147_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34492,18 +34799,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, "':'")); } { // '}' @@ -34511,18 +34818,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, 26)) // 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; @@ -34531,9 +34838,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: '+' | '-' | '*' | '/' | '%' | '//' | '@' +// _tmp_149: '+' | '-' | '*' | '/' | '%' | '//' | '@' static void * -_tmp_148_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34549,18 +34856,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _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, "'+'")); } { // '-' @@ -34568,18 +34875,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _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, "'-'")); } { // '*' @@ -34587,18 +34894,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _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, "'*'")); } { // '/' @@ -34606,18 +34913,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _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, "'/'")); } { // '%' @@ -34625,18 +34932,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 24)) // token='%' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); _res = _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, "'%'")); } { // '//' @@ -34644,18 +34951,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 47)) // token='//' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); _res = _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, "'//'")); } { // '@' @@ -34663,18 +34970,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); _res = _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, "'@'")); } _res = NULL; @@ -34683,9 +34990,9 @@ _tmp_148_rule(Parser *p) return _res; } -// _tmp_149: '+' | '-' | '~' +// _tmp_150: '+' | '-' | '~' static void * -_tmp_149_rule(Parser *p) +_tmp_150_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34701,18 +35008,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _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, "'+'")); } { // '-' @@ -34720,18 +35027,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _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, "'-'")); } { // '~' @@ -34739,18 +35046,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 31)) // token='~' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); _res = _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, "'~'")); } _res = NULL; @@ -34759,9 +35066,9 @@ _tmp_149_rule(Parser *p) return _res; } -// _tmp_150: star_targets '=' +// _tmp_151: star_targets '=' static void * -_tmp_150_rule(Parser *p) +_tmp_151_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34777,7 +35084,7 @@ _tmp_150_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -34786,7 +35093,7 @@ _tmp_150_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -34796,7 +35103,7 @@ _tmp_150_rule(Parser *p) 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, "star_targets '='")); } _res = NULL; @@ -34805,9 +35112,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) { _Pypegen_stack_overflow(p); @@ -34823,18 +35130,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, 23)) // 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, "'.'")); } { // '...' @@ -34842,18 +35149,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, 52)) // 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; @@ -34862,9 +35169,9 @@ _tmp_151_rule(Parser *p) return _res; } -// _tmp_152: '@' named_expression NEWLINE +// _tmp_153: '@' named_expression NEWLINE static void * -_tmp_152_rule(Parser *p) +_tmp_153_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34880,7 +35187,7 @@ _tmp_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -34892,7 +35199,7 @@ _tmp_152_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); _res = f; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -34902,7 +35209,7 @@ _tmp_152_rule(Parser *p) 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, "'@' named_expression NEWLINE")); } _res = NULL; @@ -34911,9 +35218,9 @@ _tmp_152_rule(Parser *p) return _res; } -// _tmp_153: ',' star_expression +// _tmp_154: ',' star_expression static void * -_tmp_153_rule(Parser *p) +_tmp_154_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34929,7 +35236,7 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -34938,7 +35245,7 @@ _tmp_153_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -34948,7 +35255,7 @@ _tmp_153_rule(Parser *p) 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, "',' star_expression")); } _res = NULL; @@ -34957,9 +35264,9 @@ _tmp_153_rule(Parser *p) return _res; } -// _tmp_154: 'or' conjunction +// _tmp_155: 'or' conjunction static void * -_tmp_154_rule(Parser *p) +_tmp_155_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34975,7 +35282,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, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -34984,7 +35291,7 @@ _tmp_154_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -34994,7 +35301,7 @@ _tmp_154_rule(Parser *p) 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, "'or' conjunction")); } _res = NULL; @@ -35003,9 +35310,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _tmp_155: 'and' inversion +// _tmp_156: 'and' inversion static void * -_tmp_155_rule(Parser *p) +_tmp_156_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35021,7 +35328,7 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -35030,7 +35337,7 @@ _tmp_155_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35040,7 +35347,7 @@ _tmp_155_rule(Parser *p) 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, "'and' inversion")); } _res = NULL; @@ -35049,9 +35356,9 @@ _tmp_155_rule(Parser *p) return _res; } -// _tmp_156: slice | starred_expression +// _tmp_157: slice | starred_expression static void * -_tmp_156_rule(Parser *p) +_tmp_157_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35067,18 +35374,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, "slice")); + D(fprintf(stderr, "%*c> _tmp_157[%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_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c+ _tmp_157[%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_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, "slice")); } { // starred_expression @@ -35086,18 +35393,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, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_157[%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_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_157[%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_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, "starred_expression")); } _res = NULL; @@ -35106,9 +35413,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: fstring | string +// _tmp_158: fstring | string static void * -_tmp_157_rule(Parser *p) +_tmp_158_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35124,18 +35431,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, "fstring")); + D(fprintf(stderr, "%*c> _tmp_158[%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_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_158[%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_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, "fstring")); } { // string @@ -35143,18 +35450,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, "string")); + D(fprintf(stderr, "%*c> _tmp_158[%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_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c+ _tmp_158[%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_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, "string")); } _res = NULL; @@ -35163,9 +35470,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: 'if' disjunction +// _tmp_159: 'if' disjunction static void * -_tmp_158_rule(Parser *p) +_tmp_159_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35181,7 +35488,7 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -35190,7 +35497,7 @@ _tmp_158_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35200,7 +35507,7 @@ _tmp_158_rule(Parser *p) 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, "'if' disjunction")); } _res = NULL; @@ -35209,9 +35516,9 @@ _tmp_158_rule(Parser *p) return _res; } -// _tmp_159: starred_expression | (assignment_expression | expression !':=') !'=' +// _tmp_160: starred_expression | (assignment_expression | expression !':=') !'=' static void * -_tmp_159_rule(Parser *p) +_tmp_160_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35227,18 +35534,18 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_160[%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_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_160[%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_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, "starred_expression")); } { // (assignment_expression | expression !':=') !'=' @@ -35246,20 +35553,20 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - void *_tmp_85_var; + D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + void *_tmp_86_var; if ( - (_tmp_85_var = _tmp_85_rule(p)) // assignment_expression | expression !':=' + (_tmp_86_var = _tmp_86_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_85_var; + D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_86_var; 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, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -35268,9 +35575,9 @@ _tmp_159_rule(Parser *p) return _res; } -// _tmp_160: ',' star_target +// _tmp_161: ',' star_target static void * -_tmp_160_rule(Parser *p) +_tmp_161_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35286,7 +35593,7 @@ _tmp_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -35295,7 +35602,7 @@ _tmp_160_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35305,7 +35612,7 @@ _tmp_160_rule(Parser *p) 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, "',' star_target")); } _res = NULL; @@ -35314,10 +35621,10 @@ _tmp_160_rule(Parser *p) return _res; } -// _tmp_161: +// _tmp_162: // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs static void * -_tmp_161_rule(Parser *p) +_tmp_162_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35333,24 +35640,24 @@ _tmp_161_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - asdl_seq * _gather_87_var; + D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + asdl_seq * _gather_88_var; Token * _literal; asdl_seq* kwargs_var; if ( - (_gather_87_var = _gather_87_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (_gather_88_var = _gather_88_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_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - _res = _PyPegen_dummy_name(p, _gather_87_var, _literal, kwargs_var); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + _res = _PyPegen_dummy_name(p, _gather_88_var, _literal, kwargs_var); 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, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); } _res = NULL; @@ -35359,9 +35666,9 @@ _tmp_161_rule(Parser *p) return _res; } -// _tmp_162: starred_expression !'=' +// _tmp_163: starred_expression !'=' static void * -_tmp_162_rule(Parser *p) +_tmp_163_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35377,7 +35684,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, "starred_expression !'='")); + D(fprintf(stderr, "%*c> _tmp_163[%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 @@ -35385,12 +35692,12 @@ _tmp_162_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c+ _tmp_163[%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_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, "starred_expression !'='")); } _res = NULL; @@ -35399,9 +35706,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: ')' | '**' +// _tmp_164: ')' | '**' static void * -_tmp_163_rule(Parser *p) +_tmp_164_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35417,18 +35724,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; 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, "')'")); } { // '**' @@ -35436,18 +35743,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } _res = NULL; @@ -35456,9 +35763,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: ':' | '**' +// _tmp_165: ':' | '**' static void * -_tmp_164_rule(Parser *p) +_tmp_165_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35474,18 +35781,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } { // '**' @@ -35493,18 +35800,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } _res = NULL; @@ -35513,9 +35820,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _loop0_165: (',' bitwise_or) +// _loop0_166: (',' bitwise_or) static asdl_seq * -_loop0_165_rule(Parser *p) +_loop0_166_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35540,13 +35847,13 @@ _loop0_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); - void *_tmp_168_var; + D(fprintf(stderr, "%*c> _loop0_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); + void *_tmp_169_var; while ( - (_tmp_168_var = _tmp_168_rule(p)) // ',' bitwise_or + (_tmp_169_var = _tmp_169_rule(p)) // ',' bitwise_or ) { - _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 *)); @@ -35563,7 +35870,7 @@ _loop0_165_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_165[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_166[%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); @@ -35580,9 +35887,9 @@ _loop0_165_rule(Parser *p) return _seq; } -// _tmp_166: expression ['as' star_target] +// _tmp_167: expression ['as' star_target] static void * -_tmp_166_rule(Parser *p) +_tmp_167_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35598,22 +35905,22 @@ _tmp_166_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_167[%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_169_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_170_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_167[%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_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, "expression ['as' star_target]")); } _res = NULL; @@ -35622,9 +35929,9 @@ _tmp_166_rule(Parser *p) return _res; } -// _tmp_167: expressions ['as' star_target] +// _tmp_168: expressions ['as' star_target] static void * -_tmp_167_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35640,22 +35947,22 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_168[%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_169_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_170_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_168[%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_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, "expressions ['as' star_target]")); } _res = NULL; @@ -35664,9 +35971,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _tmp_168: ',' bitwise_or +// _tmp_169: ',' bitwise_or static void * -_tmp_168_rule(Parser *p) +_tmp_169_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35682,7 +35989,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, "',' bitwise_or")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); Token * _literal; expr_ty bitwise_or_var; if ( @@ -35691,12 +35998,12 @@ _tmp_168_rule(Parser *p) (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c+ _tmp_169[%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_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, "',' bitwise_or")); } _res = NULL; @@ -35705,9 +36012,9 @@ _tmp_168_rule(Parser *p) return _res; } -// _tmp_169: 'as' star_target +// _tmp_170: 'as' star_target static void * -_tmp_169_rule(Parser *p) +_tmp_170_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35723,7 +36030,7 @@ _tmp_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( @@ -35732,12 +36039,12 @@ _tmp_169_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_170[%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_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, "'as' star_target")); } _res = NULL; diff --git a/Parser/pegen.h b/Parser/pegen.h index 32c64e7774b878..b16b37a5fec48d 100644 --- a/Parser/pegen.h +++ b/Parser/pegen.h @@ -318,6 +318,10 @@ StarEtc *_PyPegen_star_etc(Parser *, arg_ty, asdl_seq *, arg_ty); arguments_ty _PyPegen_make_arguments(Parser *, asdl_arg_seq *, SlashWithDefault *, asdl_arg_seq *, asdl_seq *, StarEtc *); arguments_ty _PyPegen_empty_arguments(Parser *); +expr_ty _PyPegen_template_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b); +expr_ty _PyPegen_joined_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b); +expr_ty _PyPegen_interpolation(Parser *, expr_ty, Token *, ResultTokenWithMetadata *, ResultTokenWithMetadata *, Token *, + int, int, int, int, PyArena *); expr_ty _PyPegen_formatted_value(Parser *, expr_ty, Token *, ResultTokenWithMetadata *, ResultTokenWithMetadata *, Token *, int, int, int, int, PyArena *); AugOperator *_PyPegen_augoperator(Parser*, operator_ty type); @@ -358,9 +362,6 @@ void *_PyPegen_run_parser(Parser *); mod_ty _PyPegen_run_parser_from_string(const char *, int, PyObject *, PyCompilerFlags *, PyArena *); asdl_stmt_seq *_PyPegen_interactive_exit(Parser *); -// TODO: move to the correct place in this file -expr_ty _PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* expr, Token*b); - // Generated function in parse.c - function definition in python.gram void *_PyPegen_parse(Parser *); diff --git a/Parser/token.c b/Parser/token.c index 4f163f21609a0a..5c76730f6aa4f1 100644 --- a/Parser/token.c +++ b/Parser/token.c @@ -66,6 +66,7 @@ const char * const _PyParser_TokenNames[] = { "TYPE_COMMENT", "SOFT_KEYWORD", "FSTRING_START", + "TSTRING_START", "FSTRING_MIDDLE", "FSTRING_END", "COMMENT", diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 38d74b48d232f8..eaa35bb628ae3b 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -96,6 +96,7 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->In_singleton); Py_CLEAR(state->In_type); Py_CLEAR(state->Interactive_type); + Py_CLEAR(state->Interpolation_type); Py_CLEAR(state->Invert_singleton); Py_CLEAR(state->Invert_type); Py_CLEAR(state->IsNot_singleton); @@ -158,6 +159,7 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->Sub_singleton); Py_CLEAR(state->Sub_type); Py_CLEAR(state->Subscript_type); + Py_CLEAR(state->TemplateStr_type); Py_CLEAR(state->TryStar_type); Py_CLEAR(state->Try_type); Py_CLEAR(state->Tuple_type); @@ -263,6 +265,7 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->slice); Py_CLEAR(state->step); Py_CLEAR(state->stmt_type); + Py_CLEAR(state->str); Py_CLEAR(state->subject); Py_CLEAR(state->tag); Py_CLEAR(state->target); @@ -361,6 +364,7 @@ static int init_identifiers(struct ast_state *state) if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return -1; if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return -1; if ((state->step = PyUnicode_InternFromString("step")) == NULL) return -1; + if ((state->str = PyUnicode_InternFromString("str")) == NULL) return -1; if ((state->subject = PyUnicode_InternFromString("subject")) == NULL) return -1; if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return -1; if ((state->target = PyUnicode_InternFromString("target")) == NULL) return -1; @@ -626,9 +630,18 @@ static const char * const FormattedValue_fields[]={ "conversion", "format_spec", }; +static const char * const Interpolation_fields[]={ + "value", + "str", + "conversion", + "format_spec", +}; static const char * const JoinedStr_fields[]={ "values", }; +static const char * const TemplateStr_fields[]={ + "values", +}; static const char * const Constant_fields[]={ "value", "kind", @@ -3197,6 +3210,75 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(FormattedValue_annotations); + PyObject *Interpolation_annotations = PyDict_New(); + if (!Interpolation_annotations) return 0; + { + PyObject *type = state->expr_type; + Py_INCREF(type); + cond = PyDict_SetItemString(Interpolation_annotations, "value", type) + == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + } + { + PyObject *type = (PyObject *)&PyBaseObject_Type; + Py_INCREF(type); + cond = PyDict_SetItemString(Interpolation_annotations, "str", type) == + 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + } + { + PyObject *type = (PyObject *)&PyBaseObject_Type; + type = _Py_union_type_or(type, Py_None); + cond = type != NULL; + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + cond = PyDict_SetItemString(Interpolation_annotations, "conversion", + type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + } + { + PyObject *type = state->expr_type; + type = _Py_union_type_or(type, Py_None); + cond = type != NULL; + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + cond = PyDict_SetItemString(Interpolation_annotations, "format_spec", + type) == 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->Interpolation_type, "_field_types", + Interpolation_annotations) == 0; + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->Interpolation_type, "__annotations__", + Interpolation_annotations) == 0; + if (!cond) { + Py_DECREF(Interpolation_annotations); + return 0; + } + Py_DECREF(Interpolation_annotations); PyObject *JoinedStr_annotations = PyDict_New(); if (!JoinedStr_annotations) return 0; { @@ -3227,6 +3309,37 @@ add_ast_annotations(struct ast_state *state) return 0; } Py_DECREF(JoinedStr_annotations); + PyObject *TemplateStr_annotations = PyDict_New(); + if (!TemplateStr_annotations) return 0; + { + PyObject *type = state->expr_type; + type = Py_GenericAlias((PyObject *)&PyList_Type, type); + cond = type != NULL; + if (!cond) { + Py_DECREF(TemplateStr_annotations); + return 0; + } + cond = PyDict_SetItemString(TemplateStr_annotations, "values", type) == + 0; + Py_DECREF(type); + if (!cond) { + Py_DECREF(TemplateStr_annotations); + return 0; + } + } + cond = PyObject_SetAttrString(state->TemplateStr_type, "_field_types", + TemplateStr_annotations) == 0; + if (!cond) { + Py_DECREF(TemplateStr_annotations); + return 0; + } + cond = PyObject_SetAttrString(state->TemplateStr_type, "__annotations__", + TemplateStr_annotations) == 0; + if (!cond) { + Py_DECREF(TemplateStr_annotations); + return 0; + } + Py_DECREF(TemplateStr_annotations); PyObject *Constant_annotations = PyDict_New(); if (!Constant_annotations) return 0; { @@ -6287,7 +6400,9 @@ init_types(void *arg) " | Compare(expr left, cmpop* ops, expr* comparators)\n" " | Call(expr func, expr* args, keyword* keywords)\n" " | FormattedValue(expr value, int conversion, expr? format_spec)\n" + " | Interpolation(expr value, constant str, constant? conversion, expr? format_spec)\n" " | JoinedStr(expr* values)\n" + " | TemplateStr(expr* values)\n" " | Constant(constant value, string? kind)\n" " | Attribute(expr value, identifier attr, expr_context ctx)\n" " | Subscript(expr value, expr slice, expr_context ctx)\n" @@ -6382,10 +6497,25 @@ init_types(void *arg) if (PyObject_SetAttr(state->FormattedValue_type, state->format_spec, Py_None) == -1) return -1; + state->Interpolation_type = make_type(state, "Interpolation", + state->expr_type, + Interpolation_fields, 4, + "Interpolation(expr value, constant str, constant? conversion, expr? format_spec)"); + if (!state->Interpolation_type) return -1; + if (PyObject_SetAttr(state->Interpolation_type, state->conversion, Py_None) + == -1) + return -1; + if (PyObject_SetAttr(state->Interpolation_type, state->format_spec, + Py_None) == -1) + return -1; state->JoinedStr_type = make_type(state, "JoinedStr", state->expr_type, JoinedStr_fields, 1, "JoinedStr(expr* values)"); if (!state->JoinedStr_type) return -1; + state->TemplateStr_type = make_type(state, "TemplateStr", state->expr_type, + TemplateStr_fields, 1, + "TemplateStr(expr* values)"); + if (!state->TemplateStr_type) return -1; state->Constant_type = make_type(state, "Constant", state->expr_type, Constant_fields, 2, "Constant(constant value, string? kind)"); @@ -8059,6 +8189,37 @@ _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int return p; } +expr_ty +_PyAST_Interpolation(expr_ty value, constant str, constant conversion, expr_ty + format_spec, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + expr_ty p; + if (!value) { + PyErr_SetString(PyExc_ValueError, + "field 'value' is required for Interpolation"); + return NULL; + } + if (!str) { + PyErr_SetString(PyExc_ValueError, + "field 'str' is required for Interpolation"); + return NULL; + } + p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = Interpolation_kind; + p->v.Interpolation.value = value; + p->v.Interpolation.str = str; + p->v.Interpolation.conversion = conversion; + p->v.Interpolation.format_spec = format_spec; + 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_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) @@ -8076,6 +8237,23 @@ _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, int return p; } +expr_ty +_PyAST_TemplateStr(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 = TemplateStr_kind; + p->v.TemplateStr.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_Constant(constant value, string kind, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) @@ -9727,6 +9905,31 @@ ast2obj_expr(struct ast_state *state, struct validator *vstate, void* _o) goto failed; Py_DECREF(value); break; + case Interpolation_kind: + tp = (PyTypeObject *)state->Interpolation_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_expr(state, vstate, o->v.Interpolation.value); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->value, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_constant(state, vstate, o->v.Interpolation.str); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->str, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_constant(state, vstate, o->v.Interpolation.conversion); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->conversion, value) == -1) + goto failed; + Py_DECREF(value); + value = ast2obj_expr(state, vstate, o->v.Interpolation.format_spec); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->format_spec, value) == -1) + goto failed; + Py_DECREF(value); + break; case JoinedStr_kind: tp = (PyTypeObject *)state->JoinedStr_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -9738,6 +9941,17 @@ ast2obj_expr(struct ast_state *state, struct validator *vstate, void* _o) goto failed; Py_DECREF(value); break; + case TemplateStr_kind: + tp = (PyTypeObject *)state->TemplateStr_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_list(state, vstate, (asdl_seq*)o->v.TemplateStr.values, + ast2obj_expr); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->values, value) == -1) + goto failed; + Py_DECREF(value); + break; case Constant_kind: tp = (PyTypeObject *)state->Constant_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -14883,6 +15097,91 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (*out == NULL) goto failed; return 0; } + tp = state->Interpolation_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + expr_ty value; + constant str; + constant conversion; + expr_ty format_spec; + + if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Interpolation"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'Interpolation' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &value, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->str, &tmp) < 0) { + return -1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"str\" missing from Interpolation"); + return -1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'Interpolation' node")) { + goto failed; + } + res = obj2ast_constant(state, tmp, &str, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->conversion, &tmp) < 0) { + return -1; + } + if (tmp == NULL || tmp == Py_None) { + Py_CLEAR(tmp); + conversion = NULL; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'Interpolation' node")) { + goto failed; + } + res = obj2ast_constant(state, tmp, &conversion, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + if (PyObject_GetOptionalAttr(obj, state->format_spec, &tmp) < 0) { + return -1; + } + if (tmp == NULL || tmp == Py_None) { + Py_CLEAR(tmp); + format_spec = NULL; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'Interpolation' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp, &format_spec, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + *out = _PyAST_Interpolation(value, str, conversion, format_spec, + lineno, col_offset, end_lineno, + end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->JoinedStr_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -14934,6 +15233,57 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (*out == NULL) goto failed; return 0; } + tp = state->TemplateStr_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return -1; + } + if (isinstance) { + asdl_expr_seq* values; + + 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, "TemplateStr field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(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 'TemplateStr' node")) { + goto failed; + } + res = obj2ast_expr(state, tmp2, &val, arena); + _Py_LeaveRecursiveCall(); + Py_DECREF(tmp2); + if (res != 0) goto failed; + if (len != PyList_GET_SIZE(tmp)) { + PyErr_SetString(PyExc_RuntimeError, "TemplateStr field \"values\" changed size during iteration"); + goto failed; + } + asdl_seq_SET(values, i, val); + } + Py_CLEAR(tmp); + } + *out = _PyAST_TemplateStr(values, lineno, col_offset, end_lineno, + end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->Constant_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -17884,9 +18234,16 @@ astmodule_exec(PyObject *m) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "Interpolation", state->Interpolation_type) < + 0) { + return -1; + } if (PyModule_AddObjectRef(m, "JoinedStr", state->JoinedStr_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "TemplateStr", state->TemplateStr_type) < 0) { + return -1; + } if (PyModule_AddObjectRef(m, "Constant", state->Constant_type) < 0) { return -1; } diff --git a/Python/ast.c b/Python/ast.c index bf1ff5f3ec18ba..e10cdaf6be60e0 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -356,6 +356,9 @@ validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx) case JoinedStr_kind: ret = validate_exprs(state, exp->v.JoinedStr.values, Load, 0); break; + case TemplateStr_kind: + ret = validate_exprs(state, exp->v.TemplateStr.values, Load, 0); + break; case FormattedValue_kind: if (validate_expr(state, exp->v.FormattedValue.value, Load) == 0) return 0; @@ -365,6 +368,15 @@ validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx) } ret = 1; break; + case Interpolation_kind: + if (validate_expr(state, exp->v.Interpolation.value, Load) == 0) + return 0; + if (exp->v.FormattedValue.format_spec) { + ret = validate_expr(state, exp->v.Interpolation.format_spec, Load); + break; + } + ret = 1; + break; case Attribute_kind: ret = validate_expr(state, exp->v.Attribute.value, Load); break; @@ -523,6 +535,7 @@ validate_pattern_match_value(struct validator *state, expr_ty exp) } break; case JoinedStr_kind: + case TemplateStr_kind: // Handled in the later stages return 1; default: diff --git a/Python/ast_opt.c b/Python/ast_opt.c index 01e208b88eca8b..0494c94dfffdf6 100644 --- a/Python/ast_opt.c +++ b/Python/ast_opt.c @@ -813,9 +813,16 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state) CALL(astfold_expr, expr_ty, node_->v.FormattedValue.value); CALL_OPT(astfold_expr, expr_ty, node_->v.FormattedValue.format_spec); break; + case Interpolation_kind: + CALL(astfold_expr, expr_ty, node_->v.Interpolation.value); + CALL_OPT(astfold_expr, expr_ty, node_->v.Interpolation.format_spec); + break; case JoinedStr_kind: CALL_SEQ(astfold_expr, expr, node_->v.JoinedStr.values); break; + case TemplateStr_kind: + CALL_SEQ(astfold_expr, expr, node_->v.TemplateStr.values); + break; case Attribute_kind: CALL(astfold_expr, expr_ty, node_->v.Attribute.value); break; diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index 8017cfc7fcf268..d2fca69824151a 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -18,8 +18,12 @@ expr_as_unicode(expr_ty e, int level); static int append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level); static int +append_templatestr(_PyUnicodeWriter *writer, expr_ty e); +static int append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec); static int +append_interpolation(_PyUnicodeWriter *writer, expr_ty e); +static int append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e); static int append_ast_slice(_PyUnicodeWriter *writer, expr_ty e); @@ -605,8 +609,12 @@ append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec) return append_fstring_unicode(writer, e->v.Constant.value); case JoinedStr_kind: return append_joinedstr(writer, e, is_format_spec); + case TemplateStr_kind: + return append_templatestr(writer, e); case FormattedValue_kind: return append_formattedvalue(writer, e); + case Interpolation_kind: + return append_interpolation(writer, e); default: PyErr_SetString(PyExc_SystemError, "unknown expression kind inside f-string"); @@ -617,7 +625,7 @@ append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec) /* Build body separately to enable wrapping the entire stream of Strs, Constants and FormattedValues in one opening and one closing quote. */ static PyObject * -build_fstring_body(asdl_expr_seq *values, bool is_format_spec) +build_ftstring_body(asdl_expr_seq *values, bool is_format_spec) { Py_ssize_t i, value_count; _PyUnicodeWriter body_writer; @@ -639,11 +647,29 @@ build_fstring_body(asdl_expr_seq *values, bool is_format_spec) return _PyUnicodeWriter_Finish(&body_writer); } +static int +append_templatestr(_PyUnicodeWriter *writer, expr_ty e) +{ + int result = -1; + PyObject *body = build_ftstring_body(e->v.TemplateStr.values, 0); + if (!body) { + return -1; + } + + if (-1 != append_charp(writer, "t") && + -1 != append_repr(writer, body)) + { + result = 0; + } + Py_DECREF(body); + return result; +} + static int append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec) { int result = -1; - PyObject *body = build_fstring_body(e->v.JoinedStr.values, is_format_spec); + PyObject *body = build_ftstring_body(e->v.JoinedStr.values, is_format_spec); if (!body) { return -1; } @@ -663,13 +689,12 @@ append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec) } static int -append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e) +append_interpolation_value(_PyUnicodeWriter *writer, expr_ty e) { - const char *conversion; const char *outer_brace = "{"; /* Grammar allows PR_TUPLE, but use >PR_TEST for adding parenthesis around a lambda with ':' */ - PyObject *temp_fv_str = expr_as_unicode(e->v.FormattedValue.value, PR_TEST + 1); + PyObject *temp_fv_str = expr_as_unicode(e, PR_TEST + 1); if (!temp_fv_str) { return -1; } @@ -687,6 +712,51 @@ append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e) return -1; } Py_DECREF(temp_fv_str); + return 0; +} + +static int +append_interpolation_format_spec(_PyUnicodeWriter *writer, expr_ty e) +{ + if (e) { + if (-1 == _PyUnicodeWriter_WriteASCIIString(writer, ":", 1) || + -1 == append_fstring_element(writer, e, true)) + { + return -1; + } + } + return 0; +} + +static int +append_interpolation(_PyUnicodeWriter *writer, expr_ty e) +{ + if (-1 == append_interpolation_value(writer, e->v.Interpolation.value)) { + return -1; + } + + if (e->v.Interpolation.conversion) { + APPEND_STR("!"); + if (-1 == _PyUnicodeWriter_WriteStr(writer, e->v.Interpolation.conversion)) { + return -1; + } + } + + if (-1 == append_interpolation_format_spec(writer, e->v.Interpolation.format_spec)) { + return -1; + } + + APPEND_STR_FINISH("}"); +} + +static int +append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e) +{ + const char *conversion; + + if (-1 == append_interpolation_value(writer, e->v.FormattedValue.value)) { + return -1; + } if (e->v.FormattedValue.conversion > 0) { switch (e->v.FormattedValue.conversion) { @@ -706,15 +776,9 @@ append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e) } APPEND_STR(conversion); } - if (e->v.FormattedValue.format_spec) { - if (-1 == _PyUnicodeWriter_WriteASCIIString(writer, ":", 1) || - -1 == append_fstring_element(writer, - e->v.FormattedValue.format_spec, - true - )) - { - return -1; - } + + if (-1 == append_interpolation_format_spec(writer, e->v.FormattedValue.format_spec)) { + return -1; } APPEND_STR_FINISH("}"); @@ -887,8 +951,12 @@ append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, int level) return append_ast_constant(writer, e->v.Constant.value); case JoinedStr_kind: return append_joinedstr(writer, e, false); + case TemplateStr_kind: + return append_templatestr(writer, e); case FormattedValue_kind: return append_formattedvalue(writer, e); + case Interpolation_kind: + return append_interpolation(writer, e); /* The following exprs can be assignment targets. */ case Attribute_kind: return append_ast_attribute(writer, e); diff --git a/Python/bytecodes.c b/Python/bytecodes.c index c59a35c3e828ca..96758178d99615 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1726,6 +1726,25 @@ dummy_func( str = PyStackRef_FromPyObjectSteal(str_o); } + inst(BUILD_INTERPOLATION, (values[2 + ((oparg >> 1) & 1) + (oparg & 1)] -- interpolation)) { + PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values, oparg); + ERROR_IF(interpolation_o == NULL, error); + interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); + } + + inst(BUILD_TEMPLATE, (pieces[oparg] -- template)) { + STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o); + if (CONVERSION_FAILED(pieces_o)) { + DECREF_INPUTS(); + ERROR_IF(true, error); + } + PyObject *template_o = _PyTemplate_Create(pieces_o, oparg); + STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); + DECREF_INPUTS(); + ERROR_IF(template_o == NULL, error); + template = PyStackRef_FromPyObjectSteal(template_o); + } + inst(BUILD_TUPLE, (values[oparg] -- tup)) { PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); INPUTS_DEAD(); diff --git a/Python/ceval.c b/Python/ceval.c index 55e5eba25eaa21..e6fff3f755fff9 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -40,6 +40,8 @@ #include "pydtrace.h" #include "setobject.h" #include "pycore_stackref.h" +#include "pycore_template.h" +#include "pycore_interpolation.h" #include // bool diff --git a/Python/codegen.c b/Python/codegen.c index 689d2b5124e9d3..22bb99797d4d9c 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -3494,7 +3494,9 @@ infer_type(expr_ty e) case Lambda_kind: return &PyFunction_Type; case JoinedStr_kind: + case TemplateStr_kind: case FormattedValue_kind: + case Interpolation_kind: return &PyUnicode_Type; case Constant_kind: return Py_TYPE(e->v.Constant.value); @@ -3517,7 +3519,9 @@ check_caller(compiler *c, expr_ty e) case SetComp_kind: case GeneratorExp_kind: case JoinedStr_kind: - case FormattedValue_kind: { + case TemplateStr_kind: + case FormattedValue_kind: + case Interpolation_kind: { location loc = LOC(e); return _PyCompile_Warn(c, loc, "'%.200s' object is not callable; " "perhaps you missed a comma?", @@ -3580,7 +3584,9 @@ check_index(compiler *c, expr_ty e, expr_ty s) case List_kind: case ListComp_kind: case JoinedStr_kind: - case FormattedValue_kind: { + case TemplateStr_kind: + case FormattedValue_kind: + case Interpolation_kind: { location loc = LOC(e); return _PyCompile_Warn(c, loc, "%.200s indices must be integers " "or slices, not %.200s; " @@ -3840,6 +3846,35 @@ codegen_call(compiler *c, expr_ty e) e->v.Call.keywords); } +static int +codegen_template_str(compiler *c, expr_ty e) +{ + location loc = LOC(e); + Py_ssize_t value_count = asdl_seq_LEN(e->v.TemplateStr.values); + if (value_count > STACK_USE_GUIDELINE) { + _Py_DECLARE_STR(empty, ""); + ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); + ADDOP_NAME(c, loc, LOAD_METHOD, &_Py_ID(join), names); + ADDOP_I(c, loc, BUILD_LIST, 0); + for (Py_ssize_t i = 0; i < asdl_seq_LEN(e->v.TemplateStr.values); i++) { + VISIT(c, expr, asdl_seq_GET(e->v.TemplateStr.values, i)); + ADDOP_I(c, loc, LIST_APPEND, 1); + } + ADDOP_I(c, loc, CALL, 1); + } + else { + VISIT_SEQ(c, expr, e->v.TemplateStr.values); + if (value_count > 1) { + ADDOP_I(c, loc, BUILD_TEMPLATE, value_count); + } + else if (value_count == 0) { + _Py_DECLARE_STR(empty, ""); + ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); + } + } + return SUCCESS; +} + static int codegen_joined_str(compiler *c, expr_ty e) { @@ -3869,24 +3904,35 @@ codegen_joined_str(compiler *c, expr_ty e) return SUCCESS; } -/* Used to implement f-strings. Format a single value. */ static int -codegen_formatted_value(compiler *c, expr_ty e) +codegen_interpolation(compiler *c, expr_ty e) { - /* Our oparg encodes 2 pieces of information: the conversion - character, and whether or not a format_spec was provided. - - Convert the conversion char to 3 bits: - : 000 0x0 FVC_NONE The default if nothing specified. - !s : 001 0x1 FVC_STR - !r : 010 0x2 FVC_REPR - !a : 011 0x3 FVC_ASCII - - next bit is whether or not we have a format spec: - yes : 100 0x4 - no : 000 0x0 + /* The oparg encodes which values are there: + - (oparg >> 2) & 1 == 1, always true, value and str are always there + - (oparg >> 1) & 1 == 1, if conversion is not NULL + - oparg & 1 == 1, if format_spec is not NULL */ + int oparg = 0b100; + location loc = LOC(e); + VISIT(c, expr, e->v.Interpolation.value); + ADDOP_LOAD_CONST(c, loc, e->v.Interpolation.str); + if (e->v.Interpolation.conversion) { + ADDOP_LOAD_CONST(c, loc, e->v.Interpolation.conversion); + oparg |= 0b10; + } + if (e->v.Interpolation.format_spec) { + VISIT(c, expr, e->v.Interpolation.format_spec); + oparg |= 1; + } + ADDOP_I(c, loc, BUILD_INTERPOLATION, oparg); + return SUCCESS; +} + +/* Used to implement f-strings. Format a single value. */ +static int +codegen_formatted_value(compiler *c, expr_ty e) +{ int conversion = e->v.FormattedValue.conversion; int oparg; @@ -4958,8 +5004,12 @@ codegen_visit_expr(compiler *c, expr_ty e) break; case JoinedStr_kind: return codegen_joined_str(c, e); + case TemplateStr_kind: + return codegen_template_str(c, e); case FormattedValue_kind: return codegen_formatted_value(c, e); + case Interpolation_kind: + return codegen_interpolation(c, e); /* The following exprs can be assignment targets. */ case Attribute_kind: if (e->v.Attribute.ctx == Load) { diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 15a6c7bc1a7966..dffcf05fb3e6b1 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2035,6 +2035,49 @@ break; } + case _BUILD_INTERPOLATION: { + _PyStackRef *values; + _PyStackRef interpolation; + oparg = CURRENT_OPARG(); + values = &stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (interpolation_o == NULL) JUMP_TO_ERROR(); + interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); + stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))] = interpolation; + stack_pointer += 1 - (2 + ((oparg >> 1) & 1) + (oparg & 1)); + assert(WITHIN_STACK_BOUNDS()); + break; + } + + case _BUILD_TEMPLATE: { + _PyStackRef *pieces; + _PyStackRef template; + oparg = CURRENT_OPARG(); + pieces = &stack_pointer[-oparg]; + STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o); + if (CONVERSION_FAILED(pieces_o)) { + for (int _i = oparg; --_i >= 0;) { + PyStackRef_CLOSE(pieces[_i]); + } + if (true) JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *template_o = _PyTemplate_Create(pieces_o, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); + for (int _i = oparg; --_i >= 0;) { + PyStackRef_CLOSE(pieces[_i]); + } + if (template_o == NULL) JUMP_TO_ERROR(); + template = PyStackRef_FromPyObjectSteal(template_o); + stack_pointer[-oparg] = template; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + break; + } + case _BUILD_TUPLE: { _PyStackRef *values; _PyStackRef tup; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index a9290986c24f45..3cf98669b65db5 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -657,6 +657,28 @@ DISPATCH(); } + TARGET(BUILD_INTERPOLATION) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_INTERPOLATION); + _PyStackRef *values; + _PyStackRef interpolation; + values = &stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (interpolation_o == NULL) { + stack_pointer += -(2 + ((oparg >> 1) & 1) + (oparg & 1)); + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); + stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))] = interpolation; + stack_pointer += 1 - (2 + ((oparg >> 1) & 1) + (oparg & 1)); + assert(WITHIN_STACK_BOUNDS()); + DISPATCH(); + } + TARGET(BUILD_LIST) { frame->instr_ptr = next_instr; next_instr += 1; @@ -826,6 +848,43 @@ DISPATCH(); } + TARGET(BUILD_TEMPLATE) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_TEMPLATE); + _PyStackRef *pieces; + _PyStackRef template; + pieces = &stack_pointer[-oparg]; + STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o); + if (CONVERSION_FAILED(pieces_o)) { + for (int _i = oparg; --_i >= 0;) { + PyStackRef_CLOSE(pieces[_i]); + } + if (true) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *template_o = _PyTemplate_Create(pieces_o, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); + for (int _i = oparg; --_i >= 0;) { + PyStackRef_CLOSE(pieces[_i]); + } + if (template_o == NULL) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + template = PyStackRef_FromPyObjectSteal(template_o); + stack_pointer[-oparg] = template; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + DISPATCH(); + } + TARGET(BUILD_TUPLE) { frame->instr_ptr = next_instr; next_instr += 1; diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 3fc9d3118d59ad..5798e24ff30743 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -42,11 +42,13 @@ static void *opcode_targets[256] = { &&TARGET_UNARY_NOT, &&TARGET_WITH_EXCEPT_START, &&TARGET_BINARY_OP, + &&TARGET_BUILD_INTERPOLATION, &&TARGET_BUILD_LIST, &&TARGET_BUILD_MAP, &&TARGET_BUILD_SET, &&TARGET_BUILD_SLICE, &&TARGET_BUILD_STRING, + &&TARGET_BUILD_TEMPLATE, &&TARGET_BUILD_TUPLE, &&TARGET_CALL, &&TARGET_CALL_FUNCTION_EX, @@ -146,8 +148,6 @@ static void *opcode_targets[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 6ec9e69d1dbc44..1bdfdc3188ad97 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -937,6 +937,24 @@ break; } + case _BUILD_INTERPOLATION: { + _Py_UopsSymbol *interpolation; + interpolation = sym_new_not_null(ctx); + stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))] = interpolation; + stack_pointer += 1 - (2 + ((oparg >> 1) & 1) + (oparg & 1)); + assert(WITHIN_STACK_BOUNDS()); + break; + } + + case _BUILD_TEMPLATE: { + _Py_UopsSymbol *template; + template = sym_new_not_null(ctx); + stack_pointer[-oparg] = template; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + break; + } + case _BUILD_TUPLE: { _Py_UopsSymbol *tup; tup = sym_new_not_null(ctx); diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index b8f424854ecb86..bd62c98075fd16 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -35,6 +35,8 @@ #include "pycore_unicodeobject.h" // _PyUnicode_InitTypes() #include "pycore_weakref.h" // _PyWeakref_GET_REF() #include "pycore_obmalloc.h" // _PyMem_init_obmalloc() +#include "pycore_template.h" // _PyTemplate_InitTypes() +#include "pycore_interpolation.h" // _PyInterpolation_InitTypes() #include "opcode.h" @@ -772,6 +774,16 @@ pycore_init_types(PyInterpreterState *interp) return status; } + status = _PyInterpolation_InitTypes(interp); + if (_PyStatus_EXCEPTION(status)) { + return status; + } + + status = _PyTemplate_InitTypes(interp); + if (_PyStatus_EXCEPTION(status)) { + return status; + } + return _PyStatus_OK(); } @@ -1830,6 +1842,8 @@ finalize_interp_types(PyInterpreterState *interp) _PyFloat_FiniType(interp); _PyLong_FiniTypes(interp); _PyThread_FiniType(interp); + _PyInterpolation_FiniTypes(interp); + _PyTemplate_FiniTypes(interp); // XXX fini collections module static types (_PyStaticType_Dealloc()) // XXX fini IO module static types (_PyStaticType_Dealloc()) _PyErr_FiniTypes(interp); diff --git a/Python/symtable.c b/Python/symtable.c index 709918b27afcc8..d0ed4eb61b4131 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -2454,9 +2454,17 @@ symtable_visit_expr(struct symtable *st, expr_ty e) if (e->v.FormattedValue.format_spec) VISIT(st, expr, e->v.FormattedValue.format_spec); break; + case Interpolation_kind: + VISIT(st, expr, e->v.Interpolation.value); + if (e->v.Interpolation.format_spec) + VISIT(st, expr, e->v.Interpolation.format_spec); + break; case JoinedStr_kind: VISIT_SEQ(st, expr, e->v.JoinedStr.values); break; + case TemplateStr_kind: + VISIT_SEQ(st, expr, e->v.TemplateStr.values); + break; case Constant_kind: /* Nothing to do here. */ break; From 450d771615168ae5d24b4a0f49c51bcd69fcd926 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 18 Oct 2024 17:50:03 +0200 Subject: [PATCH 02/88] First fixes; conv and format_spec still not working --- Parser/action_helpers.c | 2 +- Python/ast.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 44a50317805573..0c7357be4bb7c3 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1491,7 +1491,7 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); if (conversion_val >= 0) { expr_ty conv = (expr_ty) conversion->result; - constant convstr = PyUnicode_FromObject(conv->v.Name.id); + convstr = PyUnicode_FromObject(conv->v.Name.id); if (convstr == NULL) { return NULL; } diff --git a/Python/ast.c b/Python/ast.c index e10cdaf6be60e0..c923af8de89c64 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -371,7 +371,7 @@ validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx) case Interpolation_kind: if (validate_expr(state, exp->v.Interpolation.value, Load) == 0) return 0; - if (exp->v.FormattedValue.format_spec) { + if (exp->v.Interpolation.format_spec) { ret = validate_expr(state, exp->v.Interpolation.format_spec, Load); break; } From a095a9bcbf7c7fce0b360a3f68222d0e26188ba0 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 18 Oct 2024 20:00:17 +0200 Subject: [PATCH 03/88] Change BUILD_INTERPOLATION opcode to simplify --- Include/internal/pycore_interpolation.h | 2 +- Include/internal/pycore_opcode_metadata.h | 4 +- Include/internal/pycore_uop_metadata.h | 4 +- Include/opcode_ids.h | 80 +++++++++++------------ Lib/_opcode_metadata.py | 80 +++++++++++------------ Objects/interpolationobject.c | 33 +++------- Parser/action_helpers.c | 2 +- Python/bytecodes.c | 4 +- Python/codegen.c | 14 ++-- Python/executor_cases.c.h | 9 ++- Python/generated_cases.c.h | 14 ++-- Python/opcode_targets.h | 4 +- Python/optimizer_cases.c.h | 4 +- 13 files changed, 119 insertions(+), 135 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 0545ba42b48de4..4f9c31453494de 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -19,7 +19,7 @@ typedef struct { extern PyTypeObject PyInterpolation_Type; -PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values, Py_ssize_t n); +PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *); extern void _PyInterpolation_FiniTypes(PyInterpreterState *); diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 519bd26ab2c619..51146cad722964 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -68,7 +68,7 @@ int _PyOpcode_num_popped(int opcode, int oparg) { case BINARY_SUBSCR_TUPLE_INT: return 2; case BUILD_INTERPOLATION: - return (2 + ((oparg >> 1) & 1) + (oparg & 1)); + return 4; case BUILD_LIST: return oparg; case BUILD_MAP: @@ -1038,7 +1038,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BUILD_INTERPOLATION] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_INTERPOLATION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 9bb8d721c082f4..3aea0ae6cd0900 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -128,7 +128,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_BUILD_INTERPOLATION] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, @@ -787,7 +787,7 @@ int _PyUop_num_popped(int opcode, int oparg) case _BUILD_STRING: return oparg; case _BUILD_INTERPOLATION: - return (2 + ((oparg >> 1) & 1) + (oparg & 1)); + return 4; case _BUILD_TEMPLATE: return oparg; case _BUILD_TUPLE: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index d4dca9ef0c7d9a..89f3832bbc3ae8 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -14,46 +14,46 @@ extern "C" { #define BINARY_SLICE 1 #define BINARY_SUBSCR 2 #define BINARY_OP_INPLACE_ADD_UNICODE 3 -#define CHECK_EG_MATCH 4 -#define CHECK_EXC_MATCH 5 -#define CLEANUP_THROW 6 -#define DELETE_SUBSCR 7 -#define END_ASYNC_FOR 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_ITER 16 +#define BUILD_INTERPOLATION 4 +#define CHECK_EG_MATCH 5 +#define CHECK_EXC_MATCH 6 +#define CLEANUP_THROW 7 +#define DELETE_SUBSCR 8 +#define END_ASYNC_FOR 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 GET_LEN 18 -#define GET_YIELD_FROM_ITER 19 -#define INTERPRETER_EXIT 20 -#define LOAD_BUILD_CLASS 21 -#define LOAD_LOCALS 22 -#define MAKE_FUNCTION 23 -#define MATCH_KEYS 24 -#define MATCH_MAPPING 25 -#define MATCH_SEQUENCE 26 -#define NOP 27 -#define POP_EXCEPT 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 GET_ITER 18 +#define GET_LEN 19 +#define GET_YIELD_FROM_ITER 20 +#define INTERPRETER_EXIT 21 +#define LOAD_BUILD_CLASS 22 +#define LOAD_LOCALS 23 +#define MAKE_FUNCTION 24 +#define MATCH_KEYS 25 +#define MATCH_MAPPING 26 +#define MATCH_SEQUENCE 27 +#define NOP 28 +#define POP_EXCEPT 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_LIST 44 #define BUILD_MAP 45 #define BUILD_SET 46 @@ -237,7 +237,7 @@ extern "C" { #define SETUP_WITH 264 #define STORE_FAST_MAYBE_NULL 265 -#define HAVE_ARGUMENT 41 +#define HAVE_ARGUMENT 42 #define MIN_SPECIALIZED_OPCODE 150 #define MIN_INSTRUMENTED_OPCODE 236 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index d9dd491e111389..d3c67e5679a1aa 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -204,45 +204,45 @@ 'ENTER_EXECUTOR': 255, 'BINARY_SLICE': 1, 'BINARY_SUBSCR': 2, - 'CHECK_EG_MATCH': 4, - 'CHECK_EXC_MATCH': 5, - 'CLEANUP_THROW': 6, - 'DELETE_SUBSCR': 7, - 'END_ASYNC_FOR': 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_ITER': 16, - 'GET_LEN': 18, - 'GET_YIELD_FROM_ITER': 19, - 'INTERPRETER_EXIT': 20, - 'LOAD_BUILD_CLASS': 21, - 'LOAD_LOCALS': 22, - 'MAKE_FUNCTION': 23, - 'MATCH_KEYS': 24, - 'MATCH_MAPPING': 25, - 'MATCH_SEQUENCE': 26, - 'NOP': 27, - 'POP_EXCEPT': 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_INTERPOLATION': 4, + 'CHECK_EG_MATCH': 5, + 'CHECK_EXC_MATCH': 6, + 'CLEANUP_THROW': 7, + 'DELETE_SUBSCR': 8, + 'END_ASYNC_FOR': 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_ITER': 18, + 'GET_LEN': 19, + 'GET_YIELD_FROM_ITER': 20, + 'INTERPRETER_EXIT': 21, + 'LOAD_BUILD_CLASS': 22, + 'LOAD_LOCALS': 23, + 'MAKE_FUNCTION': 24, + 'MATCH_KEYS': 25, + 'MATCH_MAPPING': 26, + 'MATCH_SEQUENCE': 27, + 'NOP': 28, + 'POP_EXCEPT': 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_LIST': 44, 'BUILD_MAP': 45, 'BUILD_SET': 46, @@ -347,5 +347,5 @@ 'STORE_FAST_MAYBE_NULL': 265, } -HAVE_ARGUMENT = 41 +HAVE_ARGUMENT = 42 MIN_INSTRUMENTED_OPCODE = 236 diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index d04b1e78bf5657..6e34289f965b3e 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -95,11 +95,9 @@ _PyInterpolation_FiniTypes(PyInterpreterState *interp) } PyObject * -_PyInterpolation_FromStackRefSteal(_PyStackRef *values, Py_ssize_t oparg) +_PyInterpolation_FromStackRefSteal(_PyStackRef *values) { - Py_ssize_t index = 2; - - PyObject *args = PyTuple_New(oparg + ((oparg >> 1) & 1) + (oparg & 1)); + PyObject *args = PyTuple_New(4); if (!args) { goto error; } @@ -107,20 +105,11 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values, Py_ssize_t oparg) PyTuple_SET_ITEM(args, 0, PyStackRef_AsPyObjectSteal(values[0])); PyTuple_SET_ITEM(args, 1, PyStackRef_AsPyObjectSteal(values[1])); - if ((oparg >> 1) & 1) { - PyTuple_SET_ITEM(args, 2, PyStackRef_AsPyObjectSteal(values[index])); - index++; - } - else { - PyTuple_SET_ITEM(args, 2, Py_NewRef(Py_None)); - } + PyObject *conv = PyStackRef_AsPyObjectSteal(values[2]); + PyTuple_SET_ITEM(args, 2, conv ? conv : Py_NewRef(Py_None)); - if (oparg & 1) { - PyTuple_SET_ITEM(args, 3, PyStackRef_AsPyObjectSteal(values[index])); - } - else { - PyTuple_SET_ITEM(args, 3, &_Py_STR(empty)); - } + PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]); + PyTuple_SET_ITEM(args, 3, format_spec ? format_spec : &_Py_STR(empty)); PyObject *interpolation = PyObject_CallObject((PyObject *) &PyInterpolation_Type, args); if (!interpolation) { @@ -132,13 +121,7 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values, Py_ssize_t oparg) error: PyStackRef_CLOSE(values[0]); PyStackRef_CLOSE(values[1]); - index = 2; - if ((oparg >> 1) & 1) { - PyStackRef_XCLOSE(values[index]); - index++; - } - if (oparg & 1) { - PyStackRef_XCLOSE(values[index]); - } + PyStackRef_XCLOSE(values[2]); + PyStackRef_XCLOSE(values[3]); return NULL; } diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 0c7357be4bb7c3..e617b2d0e46f8c 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1491,7 +1491,7 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); if (conversion_val >= 0) { expr_ty conv = (expr_ty) conversion->result; - convstr = PyUnicode_FromObject(conv->v.Name.id); + convstr = _PyUnicode_Copy(conv->v.Name.id); if (convstr == NULL) { return NULL; } diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 96758178d99615..f79d52815984b1 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1726,8 +1726,8 @@ dummy_func( str = PyStackRef_FromPyObjectSteal(str_o); } - inst(BUILD_INTERPOLATION, (values[2 + ((oparg >> 1) & 1) + (oparg & 1)] -- interpolation)) { - PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values, oparg); + inst(BUILD_INTERPOLATION, (values[4] -- interpolation)) { + PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); ERROR_IF(interpolation_o == NULL, error); interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); } diff --git a/Python/codegen.c b/Python/codegen.c index 22bb99797d4d9c..8aa90f28b7b582 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -3912,20 +3912,26 @@ codegen_interpolation(compiler *c, expr_ty e) - (oparg >> 1) & 1 == 1, if conversion is not NULL - oparg & 1 == 1, if format_spec is not NULL */ - int oparg = 0b100; location loc = LOC(e); VISIT(c, expr, e->v.Interpolation.value); ADDOP_LOAD_CONST(c, loc, e->v.Interpolation.str); + if (e->v.Interpolation.conversion) { ADDOP_LOAD_CONST(c, loc, e->v.Interpolation.conversion); - oparg |= 0b10; } + else { + ADDOP(c, loc, PUSH_NULL); + } + if (e->v.Interpolation.format_spec) { VISIT(c, expr, e->v.Interpolation.format_spec); - oparg |= 1; } - ADDOP_I(c, loc, BUILD_INTERPOLATION, oparg); + else { + ADDOP(c, loc, PUSH_NULL); + } + + ADDOP(c, loc, BUILD_INTERPOLATION); return SUCCESS; } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index dffcf05fb3e6b1..ee5f2bcbf84382 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2038,15 +2038,14 @@ case _BUILD_INTERPOLATION: { _PyStackRef *values; _PyStackRef interpolation; - oparg = CURRENT_OPARG(); - values = &stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))]; + values = &stack_pointer[-4]; _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values, oparg); + PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); stack_pointer = _PyFrame_GetStackPointer(frame); if (interpolation_o == NULL) JUMP_TO_ERROR(); interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); - stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))] = interpolation; - stack_pointer += 1 - (2 + ((oparg >> 1) & 1) + (oparg & 1)); + stack_pointer[-4] = interpolation; + stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 3cf98669b65db5..72c7ecdb9309e6 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -663,18 +663,14 @@ INSTRUCTION_STATS(BUILD_INTERPOLATION); _PyStackRef *values; _PyStackRef interpolation; - values = &stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))]; + values = &stack_pointer[-4]; _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values, oparg); + PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); stack_pointer = _PyFrame_GetStackPointer(frame); - if (interpolation_o == NULL) { - stack_pointer += -(2 + ((oparg >> 1) & 1) + (oparg & 1)); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (interpolation_o == NULL) goto pop_4_error; interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); - stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))] = interpolation; - stack_pointer += 1 - (2 + ((oparg >> 1) & 1) + (oparg & 1)); + stack_pointer[-4] = interpolation; + stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 5798e24ff30743..8088bc7450c35a 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -3,6 +3,7 @@ static void *opcode_targets[256] = { &&TARGET_BINARY_SLICE, &&TARGET_BINARY_SUBSCR, &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, + &&TARGET_BUILD_INTERPOLATION, &&TARGET_CHECK_EG_MATCH, &&TARGET_CHECK_EXC_MATCH, &&TARGET_CLEANUP_THROW, @@ -15,8 +16,8 @@ static void *opcode_targets[256] = { &&TARGET_FORMAT_WITH_SPEC, &&TARGET_GET_AITER, &&TARGET_GET_ANEXT, - &&TARGET_GET_ITER, &&TARGET_RESERVED, + &&TARGET_GET_ITER, &&TARGET_GET_LEN, &&TARGET_GET_YIELD_FROM_ITER, &&TARGET_INTERPRETER_EXIT, @@ -42,7 +43,6 @@ static void *opcode_targets[256] = { &&TARGET_UNARY_NOT, &&TARGET_WITH_EXCEPT_START, &&TARGET_BINARY_OP, - &&TARGET_BUILD_INTERPOLATION, &&TARGET_BUILD_LIST, &&TARGET_BUILD_MAP, &&TARGET_BUILD_SET, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 1bdfdc3188ad97..c3b5e26ca26341 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -940,8 +940,8 @@ case _BUILD_INTERPOLATION: { _Py_UopsSymbol *interpolation; interpolation = sym_new_not_null(ctx); - stack_pointer[-(2 + ((oparg >> 1) & 1) + (oparg & 1))] = interpolation; - stack_pointer += 1 - (2 + ((oparg >> 1) & 1) + (oparg & 1)); + stack_pointer[-4] = interpolation; + stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); break; } From 499d70caaa9ee94a6462a3740fbfe9322c285699 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Oct 2024 00:23:17 +0200 Subject: [PATCH 04/88] Add templatelib module & clean-up types/objects etc. --- Include/internal/pycore_interpolation.h | 13 +------ Include/internal/pycore_template.h | 10 +---- Lib/templatelib.py | 3 ++ Modules/Setup.bootstrap.in | 1 + Modules/_templatelibmodule.c | 49 +++++++++++++++++++++++++ Objects/interpolationobject.c | 47 ++++++++++-------------- Objects/object.c | 4 ++ Objects/templateobject.c | 38 +++++++------------ Python/pylifecycle.c | 12 ------ 9 files changed, 94 insertions(+), 83 deletions(-) create mode 100644 Lib/templatelib.py create mode 100644 Modules/_templatelibmodule.c diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 4f9c31453494de..43eb5661d0a900 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -9,21 +9,12 @@ extern "C" { # error "this header requires Py_BUILD_CORE define" #endif -typedef struct { - PyObject_HEAD - PyObject *value; - PyObject *expr; - PyObject *conv; - PyObject *format_spec; -} PyInterpolationObject; +#include "pycore_stackref.h" // _PyStackRef -extern PyTypeObject PyInterpolation_Type; +extern PyTypeObject _PyInterpolation_Type; PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); -extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *); -extern void _PyInterpolation_FiniTypes(PyInterpreterState *); - #ifdef __cplusplus } #endif diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 119aa2f53e9726..5e9f9d793f6a2e 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -9,18 +9,10 @@ extern "C" { # error "this header requires Py_BUILD_CORE define" #endif -typedef struct { - PyObject_HEAD - PyObject *args; -} PyTemplateObject; - -extern PyTypeObject PyTemplate_Type; +extern PyTypeObject _PyTemplate_Type; PyAPI_FUNC(PyObject *) _PyTemplate_Create(PyObject **values, Py_ssize_t n); -extern PyStatus _PyTemplate_InitTypes(PyInterpreterState *); -extern void _PyTemplate_FiniTypes(PyInterpreterState *); - #ifdef __cplusplus } #endif diff --git a/Lib/templatelib.py b/Lib/templatelib.py new file mode 100644 index 00000000000000..89199aebb9d09d --- /dev/null +++ b/Lib/templatelib.py @@ -0,0 +1,3 @@ +from _templatelib import Template, Interpolation + +__all__ = ['Template', 'Interpolation'] diff --git a/Modules/Setup.bootstrap.in b/Modules/Setup.bootstrap.in index 4dcc0f55176d0e..c1c65016e50e14 100644 --- a/Modules/Setup.bootstrap.in +++ b/Modules/Setup.bootstrap.in @@ -25,6 +25,7 @@ _thread _threadmodule.c time timemodule.c _typing _typingmodule.c _weakref _weakref.c +_templatelib _templatelibmodule.c # commonly used core modules _abc _abc.c diff --git a/Modules/_templatelibmodule.c b/Modules/_templatelibmodule.c new file mode 100644 index 00000000000000..94c57c4443c4dc --- /dev/null +++ b/Modules/_templatelibmodule.c @@ -0,0 +1,49 @@ +/* interpreter-internal types for templatelib */ + +#ifndef Py_BUILD_CORE +#define Py_BUILD_CORE +#endif + +#include "Python.h" +#include "pycore_template.h" +#include "pycore_interpolation.h" + +static int +_templatelib_exec(PyObject *m) +{ + if (PyModule_AddObjectRef(m, "Template", (PyObject *)&_PyTemplate_Type) < 0) { + return -1; + } + if (PyModule_AddObjectRef(m, "Interpolation", (PyObject *)&_PyInterpolation_Type) < 0) { + return -1; + } + return 0; +} + +PyDoc_STRVAR(_templatelib_doc, +"Interpreter-internal types for t-string templates.\n"); + +static struct PyModuleDef_Slot _templatelib_slots[] = { + {Py_mod_exec, _templatelib_exec}, + {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, + {Py_mod_gil, Py_MOD_GIL_NOT_USED}, + {0, NULL} +}; + +static struct PyModuleDef _templatemodule = { + PyModuleDef_HEAD_INIT, + "_templatelib", + _templatelib_doc, + 0, + NULL, + _templatelib_slots, + NULL, + NULL, + NULL +}; + +PyMODINIT_FUNC +PyInit__templatelib(void) +{ + return PyModuleDef_Init(&_templatemodule); +} diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 6e34289f965b3e..27b197a5e8ae0f 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -11,10 +11,18 @@ #include "pycore_interpolation.h" -static PyInterpolationObject * +typedef struct { + PyObject_HEAD + PyObject *value; + PyObject *expr; + PyObject *conv; + PyObject *format_spec; +} interpolationobject; + +static interpolationobject * interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - PyInterpolationObject *self = (PyInterpolationObject *) type->tp_alloc(type, 0); + interpolationobject *self = (interpolationobject *) type->tp_alloc(type, 0); if (!self) { return NULL; } @@ -40,7 +48,7 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } static void -interpolation_dealloc(PyInterpolationObject *self) +interpolation_dealloc(interpolationobject *self) { Py_CLEAR(self->value); Py_CLEAR(self->expr); @@ -50,7 +58,7 @@ interpolation_dealloc(PyInterpolationObject *self) } static PyObject * -interpolation_repr(PyInterpolationObject *self) +interpolation_repr(interpolationobject *self) { return PyUnicode_FromFormat("%s(%R, %R, %R, %R)", _PyType_Name(Py_TYPE(self)), @@ -59,18 +67,18 @@ interpolation_repr(PyInterpolationObject *self) } static PyMemberDef interpolation_members[] = { - {"value", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, value), Py_READONLY, "Value"}, - {"expr", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, expr), Py_READONLY, "Expr"}, - {"conv", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, conv), Py_READONLY, "Conversion"}, - {"format_spec", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, format_spec), Py_READONLY, "Format specifier"}, + {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"}, + {"expr", Py_T_OBJECT_EX, offsetof(interpolationobject, expr), Py_READONLY, "Expr"}, + {"conv", Py_T_OBJECT_EX, offsetof(interpolationobject, conv), Py_READONLY, "Conversion"}, + {"format_spec", Py_T_OBJECT_EX, offsetof(interpolationobject, format_spec), Py_READONLY, "Format specifier"}, {NULL} }; -PyTypeObject PyInterpolation_Type = { +PyTypeObject _PyInterpolation_Type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "Interpolation", + .tp_name = "templatelib.Interpolation", .tp_doc = PyDoc_STR("Interpolation object"), - .tp_basicsize = sizeof(PyInterpolationObject), + .tp_basicsize = sizeof(interpolationobject), .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, .tp_new = (newfunc) interpolation_new, @@ -79,21 +87,6 @@ PyTypeObject PyInterpolation_Type = { .tp_members = interpolation_members, }; -PyStatus -_PyInterpolation_InitTypes(PyInterpreterState *interp) -{ - if (_PyStaticType_InitBuiltin(interp, &PyInterpolation_Type) < 0) { - return _PyStatus_ERR("Can't initialize builtin type"); - } - return _PyStatus_OK(); -} - -void -_PyInterpolation_FiniTypes(PyInterpreterState *interp) -{ - _PyStaticType_FiniBuiltin(interp, &PyInterpolation_Type); -} - PyObject * _PyInterpolation_FromStackRefSteal(_PyStackRef *values) { @@ -111,7 +104,7 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values) PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]); PyTuple_SET_ITEM(args, 3, format_spec ? format_spec : &_Py_STR(empty)); - PyObject *interpolation = PyObject_CallObject((PyObject *) &PyInterpolation_Type, args); + PyObject *interpolation = PyObject_CallObject((PyObject *) &_PyInterpolation_Type, args); if (!interpolation) { Py_DECREF(args); goto error; diff --git a/Objects/object.c b/Objects/object.c index 1a15b70d3dc63f..94294eac5bdd89 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -13,6 +13,7 @@ #include "pycore_freelist.h" // _PyObject_ClearFreeLists() #include "pycore_initconfig.h" // _PyStatus_EXCEPTION() #include "pycore_instruction_sequence.h" // _PyInstructionSequence_Type +#include "pycore_interpolation.h" // _PyInterpolation_Type #include "pycore_hashtable.h" // _Py_hashtable_new() #include "pycore_memoryobject.h" // _PyManagedBuffer_Type #include "pycore_namespace.h" // _PyNamespace_Type @@ -24,6 +25,7 @@ #include "pycore_pymem.h" // _PyMem_IsPtrFreed() #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_symtable.h" // PySTEntry_Type +#include "pycore_template.h" // _PyTemplate_Type #include "pycore_typeobject.h" // _PyBufferWrapper_Type #include "pycore_typevarobject.h" // _PyTypeAlias_Type, _Py_initialize_generic #include "pycore_unionobject.h" // _PyUnion_Type @@ -2345,6 +2347,8 @@ static PyTypeObject* static_types[] = { &_PyWeakref_RefType, &_PyTypeAlias_Type, &_PyNoDefault_Type, + &_PyInterpolation_Type, + &_PyTemplate_Type, // subclasses: _PyTypes_FiniTypes() deallocates them before their base // class diff --git a/Objects/templateobject.c b/Objects/templateobject.c index e8765e78954b08..2c11991a9a650f 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -9,10 +9,15 @@ #include "pycore_template.h" -static PyTemplateObject * +typedef struct { + PyObject_HEAD + PyObject *args; +} templateobject; + +static templateobject * template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { - PyTemplateObject *self = (PyTemplateObject *) type->tp_alloc(type, 0); + templateobject *self = (templateobject *) type->tp_alloc(type, 0); if (!self) { return NULL; } @@ -31,14 +36,14 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } static void -template_dealloc(PyTemplateObject *self) +template_dealloc(templateobject *self) { Py_CLEAR(self->args); Py_TYPE(self)->tp_free(self); } static PyObject * -template_repr(PyTemplateObject *self) +template_repr(templateobject *self) { return PyUnicode_FromFormat("%s(%R)", _PyType_Name(Py_TYPE(self)), @@ -46,15 +51,15 @@ template_repr(PyTemplateObject *self) } static PyMemberDef template_members[] = { - {"args", Py_T_OBJECT_EX, offsetof(PyTemplateObject, args), Py_READONLY, "Args"}, + {"args", Py_T_OBJECT_EX, offsetof(templateobject, args), Py_READONLY, "Args"}, {NULL} }; -PyTypeObject PyTemplate_Type = { +PyTypeObject _PyTemplate_Type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "Template", + .tp_name = "templatelib.Template", .tp_doc = PyDoc_STR("Template object"), - .tp_basicsize = sizeof(PyTemplateObject), + .tp_basicsize = sizeof(templateobject), .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, .tp_new = (newfunc) template_new, @@ -63,21 +68,6 @@ PyTypeObject PyTemplate_Type = { .tp_members = template_members, }; -PyStatus -_PyTemplate_InitTypes(PyInterpreterState *interp) -{ - if (_PyStaticType_InitBuiltin(interp, &PyTemplate_Type) < 0) { - return _PyStatus_ERR("Can't initialize builtin type"); - } - return _PyStatus_OK(); -} - -void -_PyTemplate_FiniTypes(PyInterpreterState *interp) -{ - _PyStaticType_FiniBuiltin(interp, &PyTemplate_Type); -} - PyObject * _PyTemplate_Create(PyObject **values, Py_ssize_t oparg) { @@ -90,7 +80,7 @@ _PyTemplate_Create(PyObject **values, Py_ssize_t oparg) PyTuple_SET_ITEM(tuple, i, Py_NewRef(values[i])); } - PyObject *template = PyObject_CallOneArg((PyObject *) &PyTemplate_Type, tuple); + PyObject *template = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple); Py_DECREF(tuple); return template; } diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index bd62c98075fd16..9eab6efc609296 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -774,16 +774,6 @@ pycore_init_types(PyInterpreterState *interp) return status; } - status = _PyInterpolation_InitTypes(interp); - if (_PyStatus_EXCEPTION(status)) { - return status; - } - - status = _PyTemplate_InitTypes(interp); - if (_PyStatus_EXCEPTION(status)) { - return status; - } - return _PyStatus_OK(); } @@ -1842,8 +1832,6 @@ finalize_interp_types(PyInterpreterState *interp) _PyFloat_FiniType(interp); _PyLong_FiniTypes(interp); _PyThread_FiniType(interp); - _PyInterpolation_FiniTypes(interp); - _PyTemplate_FiniTypes(interp); // XXX fini collections module static types (_PyStaticType_Dealloc()) // XXX fini IO module static types (_PyStaticType_Dealloc()) _PyErr_FiniTypes(interp); From f742d4554d56cea2935bbe3406a036fb6ae16e94 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Oct 2024 15:16:55 +0200 Subject: [PATCH 05/88] Support explicit concatenation of template and str --- Objects/templateobject.c | 74 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 2c11991a9a650f..53dfbd07bbd1d4 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -50,11 +50,84 @@ template_repr(templateobject *self) self->args); } +static PyObject * +template_add_template_str(templateobject *template, PyUnicodeObject *str, int templateleft) +{ + Py_ssize_t templatesize = PyTuple_GET_SIZE(template->args); + + PyObject *tuple = PyTuple_New(templatesize + 1); + if (!tuple) { + return NULL; + } + + Py_ssize_t i = 0; + Py_ssize_t j = 0; + if (!templateleft) { + PyTuple_SET_ITEM(tuple, i++, Py_NewRef(str)); + } + for (j = 0; j < templatesize; j++) { + PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(PyTuple_GET_ITEM(template->args, j))); + } + if (templateleft) { + PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(str)); + } + + PyObject *newtemplate = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple); + Py_DECREF(tuple); + return newtemplate; +} + +static PyObject * +template_add_templates(templateobject *self, templateobject *other) +{ + Py_ssize_t selfsize = PyTuple_GET_SIZE(self->args); + Py_ssize_t othersize = PyTuple_GET_SIZE(other->args); + + PyObject *tuple = PyTuple_New(selfsize + othersize); + if (!tuple) { + return NULL; + } + + Py_ssize_t i; + for (i = 0; i < selfsize; i++) { + PyTuple_SET_ITEM(tuple, i, Py_NewRef(PyTuple_GET_ITEM(self->args, i))); + } + for (Py_ssize_t j = 0; j < othersize; j++) { + PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(PyTuple_GET_ITEM(other->args, j))); + } + + PyObject *newtemplate = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple); + Py_DECREF(tuple); + return newtemplate; +} + +static PyObject * +template_add(PyObject *self, PyObject *other) +{ + if (PyObject_TypeCheck(self, &_PyTemplate_Type) && + PyObject_TypeCheck(other, &_PyTemplate_Type)) { + return template_add_templates((templateobject *) self, (templateobject *) other); + } + else if (PyObject_TypeCheck(self, &_PyTemplate_Type) && PyUnicode_Check(other)) { + return template_add_template_str((templateobject *) self, (PyUnicodeObject *) other, 1); + } + else if (PyUnicode_Check(self) && PyObject_TypeCheck(other, &_PyTemplate_Type)) { + return template_add_template_str((templateobject *) other, (PyUnicodeObject *) self, 0); + } + else { + Py_RETURN_NOTIMPLEMENTED; + } +} + static PyMemberDef template_members[] = { {"args", Py_T_OBJECT_EX, offsetof(templateobject, args), Py_READONLY, "Args"}, {NULL} }; +static PyNumberMethods template_as_number = { + .nb_add = template_add +}; + PyTypeObject _PyTemplate_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "templatelib.Template", @@ -62,6 +135,7 @@ PyTypeObject _PyTemplate_Type = { .tp_basicsize = sizeof(templateobject), .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, + .tp_as_number = &template_as_number, .tp_new = (newfunc) template_new, .tp_dealloc = (destructor) template_dealloc, .tp_repr = (reprfunc) template_repr, From 0dda3f95bb07ee9c254b0794dabe48bd9174afbe Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Oct 2024 22:52:12 +0200 Subject: [PATCH 06/88] Avoid folding one node template into its content --- Python/codegen.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/Python/codegen.c b/Python/codegen.c index 8aa90f28b7b582..4bb69ee8b214fb 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -3864,13 +3864,7 @@ codegen_template_str(compiler *c, expr_ty e) } else { VISIT_SEQ(c, expr, e->v.TemplateStr.values); - if (value_count > 1) { - ADDOP_I(c, loc, BUILD_TEMPLATE, value_count); - } - else if (value_count == 0) { - _Py_DECLARE_STR(empty, ""); - ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); - } + ADDOP_I(c, loc, BUILD_TEMPLATE, value_count); } return SUCCESS; } From 17014e722ea3d49f29f617f22ca763eda200a8c9 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 09:54:31 +0200 Subject: [PATCH 07/88] Implement __eq__ for template and interpolation --- Objects/interpolationobject.c | 35 +++++++++++++++++++++++++++++++++++ Objects/templateobject.c | 17 ++++++++++++++++- 2 files changed, 51 insertions(+), 1 deletion(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 27b197a5e8ae0f..b579eb09381013 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -66,6 +66,40 @@ interpolation_repr(interpolationobject *self) self->conv, self->format_spec); } +static PyObject * +interpolation_compare(interpolationobject *self, PyObject *other, int op) +{ + if (op == Py_LT || op == Py_LE || op == Py_GT || op == Py_GE) { + Py_RETURN_NOTIMPLEMENTED; + } + + if (!PyObject_TypeCheck(other, &_PyInterpolation_Type)) { + return (op == Py_EQ) ? Py_False : Py_True; + } + + interpolationobject *other_i = (interpolationobject *) other; + + int valueeq = PyObject_RichCompareBool(self->value, other_i->value, Py_EQ); + if (valueeq == -1) { + return NULL; + } + int expreq = PyUnicode_Compare(self->expr, other_i->expr); + if (expreq == -1 && PyErr_Occurred()) { + return NULL; + } + int conveq = PyObject_RichCompareBool(self->conv, other_i->conv, Py_EQ); // conv might be Py_None + if (conveq == -1) { + return NULL; + } + int formatspeceq = PyUnicode_Compare(self->format_spec, other_i->format_spec); + if (formatspeceq == -1 && PyErr_Occurred()) { + return NULL; + } + + int eq = valueeq && expreq == 0 && conveq && formatspeceq == 0; + return PyBool_FromLong(op == Py_EQ ? eq : !eq); +} + static PyMemberDef interpolation_members[] = { {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"}, {"expr", Py_T_OBJECT_EX, offsetof(interpolationobject, expr), Py_READONLY, "Expr"}, @@ -84,6 +118,7 @@ PyTypeObject _PyInterpolation_Type = { .tp_new = (newfunc) interpolation_new, .tp_dealloc = (destructor) interpolation_dealloc, .tp_repr = (reprfunc) interpolation_repr, + .tp_richcompare = (richcmpfunc) interpolation_compare, .tp_members = interpolation_members, }; diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 53dfbd07bbd1d4..6ae06f18f9226e 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -50,6 +50,20 @@ template_repr(templateobject *self) self->args); } +static PyObject * +template_compare(templateobject *self, PyObject *other, int op) +{ + if (op == Py_LT || op == Py_LE || op == Py_GT || op == Py_GE) { + Py_RETURN_NOTIMPLEMENTED; + } + + if (!PyObject_TypeCheck(other, &_PyTemplate_Type)) { + return (op == Py_EQ) ? Py_False : Py_True; + } + + return PyObject_RichCompare(self->args, ((templateobject *) other)->args, op); +} + static PyObject * template_add_template_str(templateobject *template, PyUnicodeObject *str, int templateleft) { @@ -125,7 +139,7 @@ static PyMemberDef template_members[] = { }; static PyNumberMethods template_as_number = { - .nb_add = template_add + .nb_add = template_add, }; PyTypeObject _PyTemplate_Type = { @@ -139,6 +153,7 @@ PyTypeObject _PyTemplate_Type = { .tp_new = (newfunc) template_new, .tp_dealloc = (destructor) template_dealloc, .tp_repr = (reprfunc) template_repr, + .tp_richcompare = (richcmpfunc) template_compare, .tp_members = template_members, }; From 94371bd98578f7de90d4f8e120d9fe98f7a710a2 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 10:01:37 +0200 Subject: [PATCH 08/88] Fix debug specifier segfault --- Parser/action_helpers.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index e617b2d0e46f8c..999387d8477fdc 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1490,8 +1490,9 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu constant convstr = NULL; int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); if (conversion_val >= 0) { - expr_ty conv = (expr_ty) conversion->result; - convstr = _PyUnicode_Copy(conv->v.Name.id); + char buf[1]; + buf[0] = conversion_val; + convstr = PyUnicode_FromStringAndSize(buf, 1); if (convstr == NULL) { return NULL; } From 99184ccc53ab204ddaae64f6d4018e130c3d44bf Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 10:47:16 +0200 Subject: [PATCH 09/88] Add __match_args__ to Interpolation --- Include/internal/pycore_interpolation.h | 2 + Objects/interpolationobject.c | 61 ++++++++++++++++++++++++- Objects/templateobject.c | 5 -- Python/pylifecycle.c | 6 ++- 4 files changed, 66 insertions(+), 8 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 43eb5661d0a900..cf089ddc8f7063 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -15,6 +15,8 @@ extern PyTypeObject _PyInterpolation_Type; PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); +extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *); + #ifdef __cplusplus } #endif diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index b579eb09381013..d77cf68adc6fca 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -3,11 +3,9 @@ #include #include "pycore_initconfig.h" // _PyStatus_OK -#include "pycore_typeobject.h" // _PyStaticType_InitBuiltin #include "pycore_stackref.h" // _PyStackRef #include "pycore_global_objects.h" // _Py_STR #include "pycore_runtime.h" // _Py_STR -#include "pycore_object.h" // _PyObject_GC_TRACK #include "pycore_interpolation.h" @@ -122,6 +120,65 @@ PyTypeObject _PyInterpolation_Type = { .tp_members = interpolation_members, }; +static PyObject * +_get_match_args(void) +{ + PyObject *value = NULL, *expr = NULL, *conv = NULL, *format_spec = NULL; + + value = PyUnicode_FromString("value"); + if (!value) { + goto error; + } + expr = PyUnicode_FromString("expr"); + if (!expr) { + goto error; + } + conv = PyUnicode_FromString("conv"); + if (!conv) { + goto error; + } + format_spec = PyUnicode_FromString("format_spec"); + if (!format_spec) { + goto error; + } + + PyObject *tuple = PyTuple_Pack(4, value, expr, conv, format_spec); + if (!tuple) { + goto error; + } + return tuple; + +error: + Py_XDECREF(value); + Py_XDECREF(expr); + Py_XDECREF(conv); + Py_XDECREF(format_spec); + return NULL; + +} + +PyStatus +_PyInterpolation_InitTypes(PyInterpreterState *interp) +{ + PyObject *tuple = _get_match_args(); + if (!tuple) { + goto error; + } + + int status = PyDict_SetItemString(_PyType_GetDict(&_PyInterpolation_Type), + "__match_args__", + tuple); + Py_DECREF(tuple); + + if (status < 0) { + goto error; + } + return _PyStatus_OK(); + +error: + return _PyStatus_ERR("Can't initialize interpolation types"); +} + PyObject * _PyInterpolation_FromStackRefSteal(_PyStackRef *values) { diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 6ae06f18f9226e..7b5ee99bc4d152 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -2,11 +2,6 @@ #include "Python.h" #include -#include "pycore_initconfig.h" // _PyStatus_OK -#include "pycore_typeobject.h" // _PyStaticType_InitBuiltin -#include "pycore_stackref.h" // _PyStackRef -#include "pycore_object.h" // _PyObject_GC_TRACK - #include "pycore_template.h" typedef struct { diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index 9eab6efc609296..6a41f9d07c57ac 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -35,7 +35,6 @@ #include "pycore_unicodeobject.h" // _PyUnicode_InitTypes() #include "pycore_weakref.h" // _PyWeakref_GET_REF() #include "pycore_obmalloc.h" // _PyMem_init_obmalloc() -#include "pycore_template.h" // _PyTemplate_InitTypes() #include "pycore_interpolation.h" // _PyInterpolation_InitTypes() #include "opcode.h" @@ -774,6 +773,11 @@ pycore_init_types(PyInterpreterState *interp) return status; } + status = _PyInterpolation_InitTypes(interp); + if (_PyStatus_EXCEPTION(status)) { + return status; + } + return _PyStatus_OK(); } From 4e89c873413b1d0589540fe689d85d24952ce9d1 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 11:52:21 +0200 Subject: [PATCH 10/88] Fix syntax error prefix in t-strings --- Grammar/python.gram | 51 +- Parser/action_helpers.c | 6 +- Parser/lexer/lexer.c | 29 +- Parser/parser.c | 2507 ++++++++++++++++++--------------------- Parser/pegen.h | 4 + Python/ast_unparse.c | 2 +- 6 files changed, 1195 insertions(+), 1404 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 45dbd8b3642edb..11bf97a1410606 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -916,7 +916,8 @@ fstring_middle[expr_ty]: | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } fstring_replacement_field[expr_ty]: | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { - _PyPegen_formatted_value(p, a, debug_expr, conversion, format, rbrace, EXTRA) } + (TOK_GET_MODE(p->tok)->tstring ? _PyPegen_interpolation : _PyPegen_formatted_value)( + p, a, debug_expr, conversion, format, rbrace, EXTRA) } | invalid_replacement_field fstring_conversion[ResultTokenWithMetadata*]: | conv_token="!" conv=NAME { _PyPegen_check_fstring_conversion(p, conv_token, conv) } @@ -928,15 +929,8 @@ fstring_format_spec[expr_ty]: fstring[expr_ty]: | a=FSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_joined_str(p, a, (asdl_expr_seq*)b, c) } -tstring_middle[expr_ty]: - | tstring_replacement_field - | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } -tstring_replacement_field[expr_ty]: - | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { - _PyPegen_interpolation(p, a, debug_expr, conversion, format, rbrace, EXTRA) } - | invalid_replacement_field -tstring[expr_ty]: - | a=TSTRING_START b=tstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } +tstring[expr_ty] (memo): + | a=TSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) } strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string)+ { _PyPegen_concatenate_strings(p, a, EXTRA) } @@ -1196,7 +1190,8 @@ invalid_expression: RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid syntax. Perhaps you forgot a comma?") } | a=disjunction 'if' b=disjunction !('else'|':') { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "expected 'else' after 'if' expression") } | a='lambda' [lambda_params] b=':' &FSTRING_MIDDLE { - RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "f-string: lambda expressions are not allowed without parentheses") } + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "%c-string: lambda expressions are not allowed without parentheses", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } invalid_named_expression(memo): | a=expression ':=' expression { @@ -1439,26 +1434,36 @@ invalid_starred_expression: | '*' { RAISE_SYNTAX_ERROR("Invalid star expression") } invalid_replacement_field: - | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '='") } - | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '!'") } - | '{' a=':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before ':'") } - | '{' a='}' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '}'") } - | '{' !annotated_rhs { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting a valid expression after '{'")} + | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before '='", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before '!'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + | '{' a=':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before ':'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + | '{' a='}' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before '}'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + | '{' !annotated_rhs { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting a valid expression after '{'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f')} | '{' annotated_rhs !('=' | '!' | ':' | '}') { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '=', or '!', or ':', or '}'") } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '=', or '!', or ':', or '}'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } | '{' annotated_rhs '=' !('!' | ':' | '}') { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '!', or ':', or '}'") } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '!', or ':', or '}'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } | '{' annotated_rhs '='? invalid_conversion_character | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting ':' or '}'") } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting ':' or '}'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '}', or format specs") } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '}', or format specs", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } | '{' annotated_rhs '='? ['!' NAME] !'}' { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '}'") } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '}'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } invalid_conversion_character: - | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: missing conversion character") } - | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: invalid conversion character") } + | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: missing conversion character") } + | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: invalid conversion character") } invalid_arithmetic: | sum ('+'|'-'|'*'|'/'|'%'|'//'|'@') a='not' b=inversion { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "'not' after an operator must be parenthesized") } diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 999387d8477fdc..016df531a784bd 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -963,7 +963,8 @@ _PyPegen_check_fstring_conversion(Parser *p, Token* conv_token, expr_ty conv) if (conv_token->lineno != conv->lineno || conv_token->end_col_offset != conv->col_offset) { return RAISE_SYNTAX_ERROR_KNOWN_RANGE( conv_token, conv, - "f-string: conversion type must come right after the exclamanation mark" + "%c-string: conversion type must come right after the exclamanation mark", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f' ); } @@ -971,7 +972,8 @@ _PyPegen_check_fstring_conversion(Parser *p, Token* conv_token, expr_ty conv) if (PyUnicode_GET_LENGTH(conv->v.Name.id) > 1 || !(first == 's' || first == 'r' || first == 'a')) { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(conv, - "f-string: invalid conversion character %R: expected 's', 'r', or 'a'", + "%c-string: invalid conversion character %R: expected 's', 'r', or 'a'", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f', conv->v.Name.id); return NULL; } diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index 18d104045f9a96..a44ce8e2f18c40 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -980,7 +980,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t p_start = tok->start; p_end = tok->cur; if (tok->tok_mode_stack_index + 1 >= MAXFSTRINGLEVEL) { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "too many nested f-strings")); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "too many nested f-strings or t-strings")); } tokenizer_mode *the_current_tok = TOK_NEXT_MODE(tok); the_current_tok->kind = TOK_FSTRING_MODE; @@ -1082,7 +1082,8 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t tokenizer_mode *the_current_tok = TOK_GET_MODE(tok); if (the_current_tok->f_string_quote == quote && the_current_tok->f_string_quote_size == quote_size) { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "f-string: expecting '}'", start)); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, + "%c-string: expecting '}'", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); } } @@ -1211,7 +1212,8 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t case ']': case '}': if (INSIDE_FSTRING(tok) && !current_tok->curly_bracket_depth && c == '}') { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "f-string: single '}' is not allowed")); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, + "%c-string: single '}' is not allowed", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); } if (!tok->tok_extra_tokens && !tok->level) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "unmatched '%c'", c)); @@ -1231,7 +1233,8 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t assert(current_tok->curly_bracket_depth >= 0); int previous_bracket = current_tok->curly_bracket_depth - 1; if (previous_bracket == current_tok->curly_bracket_expr_start_depth) { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "f-string: unmatched '%c'", c)); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, + "%c-string: unmatched '%c'", TOK_GET_MODE(tok)->tstring ? 't' : 'f', c)); } } if (tok->parenlinenostack[tok->level] != tok->lineno) { @@ -1252,7 +1255,8 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t if (INSIDE_FSTRING(tok)) { current_tok->curly_bracket_depth--; if (current_tok->curly_bracket_depth < 0) { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "f-string: unmatched '%c'", c)); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "%c-string: unmatched '%c'", + TOK_GET_MODE(tok)->tstring ? 't' : 'f', c)); } if (c == '}' && current_tok->curly_bracket_depth == current_tok->curly_bracket_expr_start_depth) { current_tok->curly_bracket_expr_start_depth--; @@ -1302,7 +1306,8 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct if (peek1 != '{') { current_tok->curly_bracket_expr_start_depth++; if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "f-string: expressions nested too deeply")); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, + "%c-string: expressions nested too deeply", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); } TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE; return tok_get_normal_mode(tok, current_tok, token); @@ -1380,8 +1385,9 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct if (current_tok->f_string_quote_size == 3) { _PyTokenizer_syntaxerror(tok, - "unterminated triple-quoted f-string literal" - " (detected at line %d)", start); + "unterminated triple-quoted %c-string literal" + " (detected at line %d)", + TOK_GET_MODE(tok)->tstring ? 't' : 'f', start); if (c != '\n') { tok->done = E_EOFS; } @@ -1389,8 +1395,8 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct } else { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, - "unterminated f-string literal (detected at" - " line %d)", start)); + "unterminated %c-string literal (detected at" + " line %d)", TOK_GET_MODE(tok)->tstring ? 't' : 'f', start)); } } @@ -1411,7 +1417,8 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct tok_backup(tok, c); current_tok->curly_bracket_expr_start_depth++; if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) { - return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "f-string: expressions nested too deeply")); + return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, + "%c-string: expressions nested too deeply", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); } TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE; current_tok->in_format_spec = 0; diff --git a/Parser/parser.c b/Parser/parser.c index 3d73c51e8ba427..9f256f446e15ff 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -243,273 +243,270 @@ static char *soft_keywords[] = { #define fstring_full_format_spec_type 1156 #define fstring_format_spec_type 1157 #define fstring_type 1158 -#define tstring_middle_type 1159 -#define tstring_replacement_field_type 1160 -#define tstring_type 1161 -#define string_type 1162 -#define strings_type 1163 -#define list_type 1164 -#define tuple_type 1165 -#define set_type 1166 -#define dict_type 1167 -#define double_starred_kvpairs_type 1168 -#define double_starred_kvpair_type 1169 -#define kvpair_type 1170 -#define for_if_clauses_type 1171 -#define for_if_clause_type 1172 -#define listcomp_type 1173 -#define setcomp_type 1174 -#define genexp_type 1175 -#define dictcomp_type 1176 -#define arguments_type 1177 -#define args_type 1178 -#define kwargs_type 1179 -#define starred_expression_type 1180 -#define kwarg_or_starred_type 1181 -#define kwarg_or_double_starred_type 1182 -#define star_targets_type 1183 -#define star_targets_list_seq_type 1184 -#define star_targets_tuple_seq_type 1185 -#define star_target_type 1186 -#define target_with_star_atom_type 1187 -#define star_atom_type 1188 -#define single_target_type 1189 -#define single_subscript_attribute_target_type 1190 -#define t_primary_type 1191 // Left-recursive -#define t_lookahead_type 1192 -#define del_targets_type 1193 -#define del_target_type 1194 -#define del_t_atom_type 1195 -#define type_expressions_type 1196 -#define func_type_comment_type 1197 -#define invalid_arguments_type 1198 -#define invalid_kwarg_type 1199 -#define expression_without_invalid_type 1200 -#define invalid_legacy_expression_type 1201 -#define invalid_type_param_type 1202 -#define invalid_expression_type 1203 -#define invalid_named_expression_type 1204 -#define invalid_assignment_type 1205 -#define invalid_ann_assign_target_type 1206 -#define invalid_del_stmt_type 1207 -#define invalid_block_type 1208 -#define invalid_comprehension_type 1209 -#define invalid_dict_comprehension_type 1210 -#define invalid_parameters_type 1211 -#define invalid_default_type 1212 -#define invalid_star_etc_type 1213 -#define invalid_kwds_type 1214 -#define invalid_parameters_helper_type 1215 -#define invalid_lambda_parameters_type 1216 -#define invalid_lambda_parameters_helper_type 1217 -#define invalid_lambda_star_etc_type 1218 -#define invalid_lambda_kwds_type 1219 -#define invalid_double_type_comments_type 1220 -#define invalid_with_item_type 1221 -#define invalid_for_if_clause_type 1222 -#define invalid_for_target_type 1223 -#define invalid_group_type 1224 -#define invalid_import_type 1225 -#define invalid_import_from_targets_type 1226 -#define invalid_with_stmt_type 1227 -#define invalid_with_stmt_indent_type 1228 -#define invalid_try_stmt_type 1229 -#define invalid_except_stmt_type 1230 -#define invalid_except_star_stmt_type 1231 -#define invalid_finally_stmt_type 1232 -#define invalid_except_stmt_indent_type 1233 -#define invalid_except_star_stmt_indent_type 1234 -#define invalid_match_stmt_type 1235 -#define invalid_case_block_type 1236 -#define invalid_as_pattern_type 1237 -#define invalid_class_pattern_type 1238 -#define invalid_class_argument_pattern_type 1239 -#define invalid_if_stmt_type 1240 -#define invalid_elif_stmt_type 1241 -#define invalid_else_stmt_type 1242 -#define invalid_while_stmt_type 1243 -#define invalid_for_stmt_type 1244 -#define invalid_def_raw_type 1245 -#define invalid_class_def_raw_type 1246 -#define invalid_double_starred_kvpairs_type 1247 -#define invalid_kvpair_type 1248 -#define invalid_starred_expression_unpacking_type 1249 -#define invalid_starred_expression_type 1250 -#define invalid_replacement_field_type 1251 -#define invalid_conversion_character_type 1252 -#define invalid_arithmetic_type 1253 -#define invalid_factor_type 1254 -#define invalid_type_params_type 1255 -#define _loop0_1_type 1256 -#define _loop1_2_type 1257 -#define _loop0_3_type 1258 -#define _gather_4_type 1259 -#define _tmp_5_type 1260 -#define _tmp_6_type 1261 -#define _tmp_7_type 1262 -#define _tmp_8_type 1263 -#define _tmp_9_type 1264 -#define _tmp_10_type 1265 -#define _tmp_11_type 1266 -#define _loop1_12_type 1267 -#define _tmp_13_type 1268 -#define _loop0_14_type 1269 -#define _gather_15_type 1270 -#define _tmp_16_type 1271 -#define _tmp_17_type 1272 -#define _loop0_18_type 1273 -#define _loop1_19_type 1274 -#define _loop0_20_type 1275 -#define _gather_21_type 1276 -#define _tmp_22_type 1277 -#define _loop0_23_type 1278 -#define _gather_24_type 1279 -#define _loop1_25_type 1280 -#define _tmp_26_type 1281 -#define _tmp_27_type 1282 -#define _loop0_28_type 1283 -#define _loop0_29_type 1284 -#define _loop1_30_type 1285 -#define _loop1_31_type 1286 -#define _loop0_32_type 1287 -#define _loop1_33_type 1288 -#define _loop0_34_type 1289 -#define _gather_35_type 1290 -#define _tmp_36_type 1291 -#define _loop1_37_type 1292 -#define _loop1_38_type 1293 -#define _loop1_39_type 1294 -#define _loop0_40_type 1295 -#define _gather_41_type 1296 -#define _tmp_42_type 1297 -#define _tmp_43_type 1298 -#define _tmp_44_type 1299 -#define _loop0_45_type 1300 -#define _gather_46_type 1301 -#define _loop0_47_type 1302 -#define _gather_48_type 1303 -#define _tmp_49_type 1304 -#define _loop0_50_type 1305 -#define _gather_51_type 1306 -#define _loop0_52_type 1307 -#define _gather_53_type 1308 -#define _loop0_54_type 1309 -#define _gather_55_type 1310 -#define _loop1_56_type 1311 -#define _loop1_57_type 1312 -#define _loop0_58_type 1313 -#define _gather_59_type 1314 -#define _loop1_60_type 1315 -#define _loop1_61_type 1316 -#define _loop1_62_type 1317 -#define _tmp_63_type 1318 -#define _loop0_64_type 1319 -#define _gather_65_type 1320 -#define _tmp_66_type 1321 -#define _tmp_67_type 1322 -#define _tmp_68_type 1323 -#define _tmp_69_type 1324 -#define _tmp_70_type 1325 -#define _loop0_71_type 1326 -#define _loop0_72_type 1327 -#define _loop1_73_type 1328 -#define _loop1_74_type 1329 -#define _loop0_75_type 1330 -#define _loop1_76_type 1331 -#define _loop0_77_type 1332 -#define _loop0_78_type 1333 -#define _loop0_79_type 1334 -#define _loop1_80_type 1335 -#define _tmp_81_type 1336 -#define _loop0_82_type 1337 -#define _gather_83_type 1338 -#define _loop1_84_type 1339 -#define _loop0_85_type 1340 -#define _tmp_86_type 1341 -#define _loop0_87_type 1342 -#define _gather_88_type 1343 -#define _tmp_89_type 1344 -#define _loop0_90_type 1345 -#define _gather_91_type 1346 -#define _loop0_92_type 1347 -#define _gather_93_type 1348 -#define _loop0_94_type 1349 -#define _loop0_95_type 1350 -#define _gather_96_type 1351 -#define _loop1_97_type 1352 -#define _tmp_98_type 1353 -#define _loop0_99_type 1354 -#define _gather_100_type 1355 -#define _loop0_101_type 1356 -#define _gather_102_type 1357 -#define _tmp_103_type 1358 -#define _tmp_104_type 1359 -#define _loop0_105_type 1360 -#define _gather_106_type 1361 -#define _tmp_107_type 1362 -#define _tmp_108_type 1363 -#define _tmp_109_type 1364 -#define _tmp_110_type 1365 -#define _tmp_111_type 1366 -#define _tmp_112_type 1367 -#define _tmp_113_type 1368 -#define _tmp_114_type 1369 -#define _tmp_115_type 1370 -#define _loop0_116_type 1371 -#define _loop0_117_type 1372 -#define _tmp_118_type 1373 -#define _tmp_119_type 1374 -#define _tmp_120_type 1375 -#define _tmp_121_type 1376 -#define _tmp_122_type 1377 -#define _tmp_123_type 1378 -#define _tmp_124_type 1379 -#define _tmp_125_type 1380 -#define _tmp_126_type 1381 -#define _loop0_127_type 1382 -#define _gather_128_type 1383 -#define _tmp_129_type 1384 -#define _tmp_130_type 1385 -#define _tmp_131_type 1386 -#define _tmp_132_type 1387 -#define _loop0_133_type 1388 -#define _gather_134_type 1389 -#define _loop0_135_type 1390 -#define _gather_136_type 1391 -#define _loop0_137_type 1392 -#define _gather_138_type 1393 -#define _tmp_139_type 1394 -#define _loop0_140_type 1395 -#define _tmp_141_type 1396 -#define _tmp_142_type 1397 -#define _tmp_143_type 1398 -#define _tmp_144_type 1399 -#define _tmp_145_type 1400 -#define _tmp_146_type 1401 -#define _tmp_147_type 1402 -#define _tmp_148_type 1403 -#define _tmp_149_type 1404 -#define _tmp_150_type 1405 -#define _tmp_151_type 1406 -#define _tmp_152_type 1407 -#define _tmp_153_type 1408 -#define _tmp_154_type 1409 -#define _tmp_155_type 1410 -#define _tmp_156_type 1411 -#define _tmp_157_type 1412 -#define _tmp_158_type 1413 -#define _tmp_159_type 1414 -#define _tmp_160_type 1415 -#define _tmp_161_type 1416 -#define _tmp_162_type 1417 -#define _tmp_163_type 1418 -#define _tmp_164_type 1419 -#define _tmp_165_type 1420 -#define _loop0_166_type 1421 -#define _tmp_167_type 1422 -#define _tmp_168_type 1423 -#define _tmp_169_type 1424 -#define _tmp_170_type 1425 +#define tstring_type 1159 +#define string_type 1160 +#define strings_type 1161 +#define list_type 1162 +#define tuple_type 1163 +#define set_type 1164 +#define dict_type 1165 +#define double_starred_kvpairs_type 1166 +#define double_starred_kvpair_type 1167 +#define kvpair_type 1168 +#define for_if_clauses_type 1169 +#define for_if_clause_type 1170 +#define listcomp_type 1171 +#define setcomp_type 1172 +#define genexp_type 1173 +#define dictcomp_type 1174 +#define arguments_type 1175 +#define args_type 1176 +#define kwargs_type 1177 +#define starred_expression_type 1178 +#define kwarg_or_starred_type 1179 +#define kwarg_or_double_starred_type 1180 +#define star_targets_type 1181 +#define star_targets_list_seq_type 1182 +#define star_targets_tuple_seq_type 1183 +#define star_target_type 1184 +#define target_with_star_atom_type 1185 +#define star_atom_type 1186 +#define single_target_type 1187 +#define single_subscript_attribute_target_type 1188 +#define t_primary_type 1189 // Left-recursive +#define t_lookahead_type 1190 +#define del_targets_type 1191 +#define del_target_type 1192 +#define del_t_atom_type 1193 +#define type_expressions_type 1194 +#define func_type_comment_type 1195 +#define invalid_arguments_type 1196 +#define invalid_kwarg_type 1197 +#define expression_without_invalid_type 1198 +#define invalid_legacy_expression_type 1199 +#define invalid_type_param_type 1200 +#define invalid_expression_type 1201 +#define invalid_named_expression_type 1202 +#define invalid_assignment_type 1203 +#define invalid_ann_assign_target_type 1204 +#define invalid_del_stmt_type 1205 +#define invalid_block_type 1206 +#define invalid_comprehension_type 1207 +#define invalid_dict_comprehension_type 1208 +#define invalid_parameters_type 1209 +#define invalid_default_type 1210 +#define invalid_star_etc_type 1211 +#define invalid_kwds_type 1212 +#define invalid_parameters_helper_type 1213 +#define invalid_lambda_parameters_type 1214 +#define invalid_lambda_parameters_helper_type 1215 +#define invalid_lambda_star_etc_type 1216 +#define invalid_lambda_kwds_type 1217 +#define invalid_double_type_comments_type 1218 +#define invalid_with_item_type 1219 +#define invalid_for_if_clause_type 1220 +#define invalid_for_target_type 1221 +#define invalid_group_type 1222 +#define invalid_import_type 1223 +#define invalid_import_from_targets_type 1224 +#define invalid_with_stmt_type 1225 +#define invalid_with_stmt_indent_type 1226 +#define invalid_try_stmt_type 1227 +#define invalid_except_stmt_type 1228 +#define invalid_except_star_stmt_type 1229 +#define invalid_finally_stmt_type 1230 +#define invalid_except_stmt_indent_type 1231 +#define invalid_except_star_stmt_indent_type 1232 +#define invalid_match_stmt_type 1233 +#define invalid_case_block_type 1234 +#define invalid_as_pattern_type 1235 +#define invalid_class_pattern_type 1236 +#define invalid_class_argument_pattern_type 1237 +#define invalid_if_stmt_type 1238 +#define invalid_elif_stmt_type 1239 +#define invalid_else_stmt_type 1240 +#define invalid_while_stmt_type 1241 +#define invalid_for_stmt_type 1242 +#define invalid_def_raw_type 1243 +#define invalid_class_def_raw_type 1244 +#define invalid_double_starred_kvpairs_type 1245 +#define invalid_kvpair_type 1246 +#define invalid_starred_expression_unpacking_type 1247 +#define invalid_starred_expression_type 1248 +#define invalid_replacement_field_type 1249 +#define invalid_conversion_character_type 1250 +#define invalid_arithmetic_type 1251 +#define invalid_factor_type 1252 +#define invalid_type_params_type 1253 +#define _loop0_1_type 1254 +#define _loop1_2_type 1255 +#define _loop0_3_type 1256 +#define _gather_4_type 1257 +#define _tmp_5_type 1258 +#define _tmp_6_type 1259 +#define _tmp_7_type 1260 +#define _tmp_8_type 1261 +#define _tmp_9_type 1262 +#define _tmp_10_type 1263 +#define _tmp_11_type 1264 +#define _loop1_12_type 1265 +#define _tmp_13_type 1266 +#define _loop0_14_type 1267 +#define _gather_15_type 1268 +#define _tmp_16_type 1269 +#define _tmp_17_type 1270 +#define _loop0_18_type 1271 +#define _loop1_19_type 1272 +#define _loop0_20_type 1273 +#define _gather_21_type 1274 +#define _tmp_22_type 1275 +#define _loop0_23_type 1276 +#define _gather_24_type 1277 +#define _loop1_25_type 1278 +#define _tmp_26_type 1279 +#define _tmp_27_type 1280 +#define _loop0_28_type 1281 +#define _loop0_29_type 1282 +#define _loop1_30_type 1283 +#define _loop1_31_type 1284 +#define _loop0_32_type 1285 +#define _loop1_33_type 1286 +#define _loop0_34_type 1287 +#define _gather_35_type 1288 +#define _tmp_36_type 1289 +#define _loop1_37_type 1290 +#define _loop1_38_type 1291 +#define _loop1_39_type 1292 +#define _loop0_40_type 1293 +#define _gather_41_type 1294 +#define _tmp_42_type 1295 +#define _tmp_43_type 1296 +#define _tmp_44_type 1297 +#define _loop0_45_type 1298 +#define _gather_46_type 1299 +#define _loop0_47_type 1300 +#define _gather_48_type 1301 +#define _tmp_49_type 1302 +#define _loop0_50_type 1303 +#define _gather_51_type 1304 +#define _loop0_52_type 1305 +#define _gather_53_type 1306 +#define _loop0_54_type 1307 +#define _gather_55_type 1308 +#define _loop1_56_type 1309 +#define _loop1_57_type 1310 +#define _loop0_58_type 1311 +#define _gather_59_type 1312 +#define _loop1_60_type 1313 +#define _loop1_61_type 1314 +#define _loop1_62_type 1315 +#define _tmp_63_type 1316 +#define _loop0_64_type 1317 +#define _gather_65_type 1318 +#define _tmp_66_type 1319 +#define _tmp_67_type 1320 +#define _tmp_68_type 1321 +#define _tmp_69_type 1322 +#define _tmp_70_type 1323 +#define _loop0_71_type 1324 +#define _loop0_72_type 1325 +#define _loop1_73_type 1326 +#define _loop1_74_type 1327 +#define _loop0_75_type 1328 +#define _loop1_76_type 1329 +#define _loop0_77_type 1330 +#define _loop0_78_type 1331 +#define _loop1_79_type 1332 +#define _tmp_80_type 1333 +#define _loop0_81_type 1334 +#define _gather_82_type 1335 +#define _loop1_83_type 1336 +#define _loop0_84_type 1337 +#define _tmp_85_type 1338 +#define _loop0_86_type 1339 +#define _gather_87_type 1340 +#define _tmp_88_type 1341 +#define _loop0_89_type 1342 +#define _gather_90_type 1343 +#define _loop0_91_type 1344 +#define _gather_92_type 1345 +#define _loop0_93_type 1346 +#define _loop0_94_type 1347 +#define _gather_95_type 1348 +#define _loop1_96_type 1349 +#define _tmp_97_type 1350 +#define _loop0_98_type 1351 +#define _gather_99_type 1352 +#define _loop0_100_type 1353 +#define _gather_101_type 1354 +#define _tmp_102_type 1355 +#define _tmp_103_type 1356 +#define _loop0_104_type 1357 +#define _gather_105_type 1358 +#define _tmp_106_type 1359 +#define _tmp_107_type 1360 +#define _tmp_108_type 1361 +#define _tmp_109_type 1362 +#define _tmp_110_type 1363 +#define _tmp_111_type 1364 +#define _tmp_112_type 1365 +#define _tmp_113_type 1366 +#define _tmp_114_type 1367 +#define _loop0_115_type 1368 +#define _loop0_116_type 1369 +#define _tmp_117_type 1370 +#define _tmp_118_type 1371 +#define _tmp_119_type 1372 +#define _tmp_120_type 1373 +#define _tmp_121_type 1374 +#define _tmp_122_type 1375 +#define _tmp_123_type 1376 +#define _tmp_124_type 1377 +#define _tmp_125_type 1378 +#define _loop0_126_type 1379 +#define _gather_127_type 1380 +#define _tmp_128_type 1381 +#define _tmp_129_type 1382 +#define _tmp_130_type 1383 +#define _tmp_131_type 1384 +#define _loop0_132_type 1385 +#define _gather_133_type 1386 +#define _loop0_134_type 1387 +#define _gather_135_type 1388 +#define _loop0_136_type 1389 +#define _gather_137_type 1390 +#define _tmp_138_type 1391 +#define _loop0_139_type 1392 +#define _tmp_140_type 1393 +#define _tmp_141_type 1394 +#define _tmp_142_type 1395 +#define _tmp_143_type 1396 +#define _tmp_144_type 1397 +#define _tmp_145_type 1398 +#define _tmp_146_type 1399 +#define _tmp_147_type 1400 +#define _tmp_148_type 1401 +#define _tmp_149_type 1402 +#define _tmp_150_type 1403 +#define _tmp_151_type 1404 +#define _tmp_152_type 1405 +#define _tmp_153_type 1406 +#define _tmp_154_type 1407 +#define _tmp_155_type 1408 +#define _tmp_156_type 1409 +#define _tmp_157_type 1410 +#define _tmp_158_type 1411 +#define _tmp_159_type 1412 +#define _tmp_160_type 1413 +#define _tmp_161_type 1414 +#define _tmp_162_type 1415 +#define _tmp_163_type 1416 +#define _tmp_164_type 1417 +#define _loop0_165_type 1418 +#define _tmp_166_type 1419 +#define _tmp_167_type 1420 +#define _tmp_168_type 1421 +#define _tmp_169_type 1422 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -670,8 +667,6 @@ static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p); static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p); static expr_ty fstring_format_spec_rule(Parser *p); static expr_ty fstring_rule(Parser *p); -static expr_ty tstring_middle_rule(Parser *p); -static expr_ty tstring_replacement_field_rule(Parser *p); static expr_ty tstring_rule(Parser *p); static expr_ty string_rule(Parser *p); static expr_ty strings_rule(Parser *p); @@ -845,34 +840,34 @@ static asdl_seq *_loop0_75_rule(Parser *p); static asdl_seq *_loop1_76_rule(Parser *p); static asdl_seq *_loop0_77_rule(Parser *p); static asdl_seq *_loop0_78_rule(Parser *p); -static asdl_seq *_loop0_79_rule(Parser *p); -static asdl_seq *_loop1_80_rule(Parser *p); -static void *_tmp_81_rule(Parser *p); -static asdl_seq *_loop0_82_rule(Parser *p); -static asdl_seq *_gather_83_rule(Parser *p); -static asdl_seq *_loop1_84_rule(Parser *p); -static asdl_seq *_loop0_85_rule(Parser *p); -static void *_tmp_86_rule(Parser *p); -static asdl_seq *_loop0_87_rule(Parser *p); -static asdl_seq *_gather_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 asdl_seq *_loop0_92_rule(Parser *p); -static asdl_seq *_gather_93_rule(Parser *p); +static asdl_seq *_loop1_79_rule(Parser *p); +static void *_tmp_80_rule(Parser *p); +static asdl_seq *_loop0_81_rule(Parser *p); +static asdl_seq *_gather_82_rule(Parser *p); +static asdl_seq *_loop1_83_rule(Parser *p); +static asdl_seq *_loop0_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 void *_tmp_88_rule(Parser *p); +static asdl_seq *_loop0_89_rule(Parser *p); +static asdl_seq *_gather_90_rule(Parser *p); +static asdl_seq *_loop0_91_rule(Parser *p); +static asdl_seq *_gather_92_rule(Parser *p); +static asdl_seq *_loop0_93_rule(Parser *p); static asdl_seq *_loop0_94_rule(Parser *p); -static asdl_seq *_loop0_95_rule(Parser *p); -static asdl_seq *_gather_96_rule(Parser *p); -static asdl_seq *_loop1_97_rule(Parser *p); -static void *_tmp_98_rule(Parser *p); -static asdl_seq *_loop0_99_rule(Parser *p); -static asdl_seq *_gather_100_rule(Parser *p); -static asdl_seq *_loop0_101_rule(Parser *p); -static asdl_seq *_gather_102_rule(Parser *p); +static asdl_seq *_gather_95_rule(Parser *p); +static asdl_seq *_loop1_96_rule(Parser *p); +static void *_tmp_97_rule(Parser *p); +static asdl_seq *_loop0_98_rule(Parser *p); +static asdl_seq *_gather_99_rule(Parser *p); +static asdl_seq *_loop0_100_rule(Parser *p); +static asdl_seq *_gather_101_rule(Parser *p); +static void *_tmp_102_rule(Parser *p); static void *_tmp_103_rule(Parser *p); -static void *_tmp_104_rule(Parser *p); -static asdl_seq *_loop0_105_rule(Parser *p); -static asdl_seq *_gather_106_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 void *_tmp_107_rule(Parser *p); static void *_tmp_108_rule(Parser *p); static void *_tmp_109_rule(Parser *p); @@ -881,9 +876,9 @@ 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 void *_tmp_115_rule(Parser *p); +static asdl_seq *_loop0_115_rule(Parser *p); static asdl_seq *_loop0_116_rule(Parser *p); -static asdl_seq *_loop0_117_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); @@ -892,21 +887,21 @@ static void *_tmp_122_rule(Parser *p); static void *_tmp_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); -static asdl_seq *_loop0_127_rule(Parser *p); -static asdl_seq *_gather_128_rule(Parser *p); +static asdl_seq *_loop0_126_rule(Parser *p); +static asdl_seq *_gather_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 void *_tmp_131_rule(Parser *p); -static void *_tmp_132_rule(Parser *p); -static asdl_seq *_loop0_133_rule(Parser *p); -static asdl_seq *_gather_134_rule(Parser *p); -static asdl_seq *_loop0_135_rule(Parser *p); -static asdl_seq *_gather_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 *_loop0_132_rule(Parser *p); +static asdl_seq *_gather_133_rule(Parser *p); +static asdl_seq *_loop0_134_rule(Parser *p); +static asdl_seq *_gather_135_rule(Parser *p); +static asdl_seq *_loop0_136_rule(Parser *p); +static asdl_seq *_gather_137_rule(Parser *p); +static void *_tmp_138_rule(Parser *p); +static asdl_seq *_loop0_139_rule(Parser *p); +static void *_tmp_140_rule(Parser *p); static void *_tmp_141_rule(Parser *p); static void *_tmp_142_rule(Parser *p); static void *_tmp_143_rule(Parser *p); @@ -931,12 +926,11 @@ static void *_tmp_161_rule(Parser *p); static void *_tmp_162_rule(Parser *p); static void *_tmp_163_rule(Parser *p); static void *_tmp_164_rule(Parser *p); -static void *_tmp_165_rule(Parser *p); -static asdl_seq *_loop0_166_rule(Parser *p); +static asdl_seq *_loop0_165_rule(Parser *p); +static void *_tmp_166_rule(Parser *p); static void *_tmp_167_rule(Parser *p); static void *_tmp_168_rule(Parser *p); static void *_tmp_169_rule(Parser *p); -static void *_tmp_170_rule(Parser *p); // file: statements? $ @@ -15896,7 +15890,7 @@ fstring_replacement_field_rule(Parser *p) 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 = _PyPegen_formatted_value ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); + _res = ( TOK_GET_MODE ( p -> tok ) -> tstring ? _PyPegen_interpolation : _PyPegen_formatted_value ) ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -16154,73 +16148,9 @@ fstring_rule(Parser *p) return _res; } -// tstring_middle: tstring_replacement_field | FSTRING_MIDDLE +// tstring: TSTRING_START fstring_middle* FSTRING_END static expr_ty -tstring_middle_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - expr_ty _res = NULL; - int _mark = p->mark; - { // tstring_replacement_field - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_replacement_field")); - expr_ty tstring_replacement_field_var; - if ( - (tstring_replacement_field_var = tstring_replacement_field_rule(p)) // tstring_replacement_field - ) - { - D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring_replacement_field")); - _res = tstring_replacement_field_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_replacement_field")); - } - { // FSTRING_MIDDLE - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); - Token * t; - if ( - (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' - ) - { - D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); - _res = _PyPegen_constant_from_token ( p , t ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// tstring_replacement_field: -// | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' -// | invalid_replacement_field -static expr_ty -tstring_replacement_field_rule(Parser *p) +tstring_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -16230,120 +16160,29 @@ tstring_replacement_field_rule(Parser *p) 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 - { // '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); - Token * _literal; - expr_ty a; - void *conversion; - void *debug_expr; - void *format; - Token * rbrace; - if ( - (_literal = _PyPegen_expect_token(p, 25)) // token='{' - && - (a = annotated_rhs_rule(p)) // annotated_rhs - && - (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? - && - (conversion = fstring_conversion_rule(p), !p->error_indicator) // fstring_conversion? - && - (format = fstring_full_format_spec_rule(p), !p->error_indicator) // fstring_full_format_spec? - && - (rbrace = _PyPegen_expect_token(p, 26)) // token='}' - ) - { - D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); - 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 = _PyPegen_interpolation ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); - } - if (p->call_invalid_rules) { // invalid_replacement_field - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); - void *invalid_replacement_field_var; - if ( - (invalid_replacement_field_var = invalid_replacement_field_rule(p)) // invalid_replacement_field - ) - { - D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); - _res = invalid_replacement_field_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_replacement_field")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// tstring: TSTRING_START tstring_middle* FSTRING_END -static expr_ty -tstring_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { + if (_PyPegen_is_memoized(p, tstring_type, &_res)) { p->level--; - return NULL; + return _res; } - expr_ty _res = NULL; int _mark = p->mark; - { // TSTRING_START tstring_middle* FSTRING_END + { // TSTRING_START fstring_middle* FSTRING_END if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START fstring_middle* FSTRING_END")); Token * a; asdl_seq * b; Token * c; if ( (a = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' && - (b = _loop0_79_rule(p)) // tstring_middle* + (b = _loop0_78_rule(p)) // fstring_middle* && (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' ) { - D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START fstring_middle* FSTRING_END")); _res = _PyPegen_template_str ( p , a , ( asdl_expr_seq* ) b , c ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -16354,10 +16193,11 @@ tstring_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START fstring_middle* FSTRING_END")); } _res = NULL; done: + _PyPegen_insert_memo(p, _mark, tstring_type, _res); p->level--; return _res; } @@ -16439,7 +16279,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_80_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_79_rule(p)) // ((fstring | string))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); @@ -16572,7 +16412,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_81_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_80_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -16787,7 +16627,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_83_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_82_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -16946,7 +16786,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_84_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_83_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+")); @@ -17011,7 +16851,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_85_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_84_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))*")); @@ -17054,7 +16894,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_85_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_84_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))*")); @@ -17333,7 +17173,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_86_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_85_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -17582,9 +17422,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_87_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_89_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_88_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]")); @@ -17674,11 +17514,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_91_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_90_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_93_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_92_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+")); @@ -17700,13 +17540,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_91_var; + asdl_seq * _gather_90_var; if ( - (_gather_91_var = _gather_91_rule(p)) // ','.kwarg_or_starred+ + (_gather_90_var = _gather_90_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_91_var; + _res = _gather_90_var; goto done; } p->mark = _mark; @@ -17719,13 +17559,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_93_var; + asdl_seq * _gather_92_var; if ( - (_gather_93_var = _gather_93_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_92_var = _gather_92_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_93_var; + _res = _gather_92_var; goto done; } p->mark = _mark; @@ -18136,7 +17976,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_94_rule(p)) // ((',' star_target))* + (b = _loop0_93_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18192,7 +18032,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_96_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_95_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18242,7 +18082,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_97_rule(p)) // ((',' star_target))+ + (b = _loop1_96_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18330,7 +18170,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_98_rule(p)) // !'*' star_target + (a = _tmp_97_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); @@ -19253,7 +19093,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_100_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_99_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19611,7 +19451,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_102_rule(p)) // ','.expression+ + (a = _gather_101_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19650,7 +19490,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_102_rule(p)) // ','.expression+ + (a = _gather_101_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19683,7 +19523,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_102_rule(p)) // ','.expression+ + (a = _gather_101_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19803,7 +19643,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_102_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_101_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); @@ -19854,7 +19694,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_103_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_102_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -19940,15 +19780,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_106_var; - void *_tmp_104_var; + asdl_seq * _gather_105_var; + void *_tmp_103_var; Token * a; if ( - (_tmp_104_var = _tmp_104_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs + (_tmp_103_var = _tmp_103_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs && (a = _PyPegen_expect_token(p, 12)) // token=',' && - (_gather_106_var = _gather_106_rule(p)) // ','.(starred_expression !'=')+ + (_gather_105_var = _gather_105_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 !'=')+")); @@ -19982,7 +19822,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_107_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_106_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]")); @@ -20042,13 +19882,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_108_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_107_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_109_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_108_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); @@ -20186,7 +20026,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_110_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_109_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -20246,7 +20086,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_110_rule, p) && (a = expression_rule(p)) // expression && @@ -20587,7 +20427,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -20623,7 +20463,7 @@ invalid_expression_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); @@ -20660,7 +20500,7 @@ invalid_expression_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE")); - _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "f-string: lambda expressions are not allowed without parentheses" ); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "%c-string: lambda expressions are not allowed without parentheses" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20744,7 +20584,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); @@ -20770,7 +20610,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_115_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -20778,7 +20618,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_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 !('=' | ':=')")); @@ -20858,7 +20698,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_116_var; + asdl_seq * _loop0_115_var; expr_ty a; expr_ty expression_var; if ( @@ -20866,7 +20706,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_116_var = _loop0_116_rule(p)) // star_named_expressions* + (_loop0_115_var = _loop0_115_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -20923,10 +20763,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_117_var; + asdl_seq * _loop0_116_var; expr_ty a; if ( - (_loop0_117_var = _loop0_117_rule(p)) // ((star_targets '='))* + (_loop0_116_var = _loop0_116_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -20953,10 +20793,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_117_var; + asdl_seq * _loop0_116_var; expr_ty a; if ( - (_loop0_117_var = _loop0_117_rule(p)) // ((star_targets '='))* + (_loop0_116_var = _loop0_116_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -21212,11 +21052,11 @@ invalid_comprehension_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); - void *_tmp_118_var; + void *_tmp_117_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_118_var = _tmp_118_rule(p)) // '[' | '(' | '{' + (_tmp_117_var = _tmp_117_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -21243,12 +21083,12 @@ invalid_comprehension_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); Token * _literal; - void *_tmp_119_var; + void *_tmp_118_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_119_var = _tmp_119_rule(p)) // '[' | '{' + (_tmp_118_var = _tmp_118_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21278,12 +21118,12 @@ invalid_comprehension_rule(Parser *p) 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_119_var; + void *_tmp_118_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_119_var = _tmp_119_rule(p)) // '[' | '{' + (_tmp_118_var = _tmp_118_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21419,10 +21259,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_32_var; - void *_tmp_120_var; + void *_tmp_119_var; Token * a; if ( - (_tmp_120_var = _tmp_120_rule(p)) // slash_no_default | slash_with_default + (_tmp_119_var = _tmp_119_rule(p)) // slash_no_default | slash_with_default && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && @@ -21524,16 +21364,16 @@ invalid_parameters_rule(Parser *p) asdl_seq * _loop0_32_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_121_var; + void *_tmp_120_var; Token * a; if ( - (_opt_var = _tmp_120_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_119_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_121_var = _tmp_121_rule(p)) // ',' | param_no_default + (_tmp_120_var = _tmp_120_rule(p)) // ',' | param_no_default && (_loop0_32_var_1 = _loop0_32_rule(p)) // param_maybe_default* && @@ -21612,7 +21452,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_122_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_121_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); @@ -21657,12 +21497,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_123_var; + void *_tmp_122_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_123_var = _tmp_123_rule(p)) // ')' | ',' (')' | '**') + (_tmp_122_var = _tmp_122_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); @@ -21746,19 +21586,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_32_var; - void *_tmp_124_var; - void *_tmp_124_var_1; + void *_tmp_123_var; + void *_tmp_123_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_124_var = _tmp_124_rule(p)) // param_no_default | ',' + (_tmp_123_var = _tmp_123_rule(p)) // param_no_default | ',' && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_124_var_1 = _tmp_124_rule(p)) // param_no_default | ',' + (_tmp_123_var_1 = _tmp_123_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 | ',')")); @@ -21873,7 +21713,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_125_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_124_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); @@ -22010,10 +21850,10 @@ 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* '/'")); asdl_seq * _loop0_75_var; - void *_tmp_126_var; + void *_tmp_125_var; Token * a; if ( - (_tmp_126_var = _tmp_126_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_125_var = _tmp_125_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -22073,7 +21913,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_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_128_var; + asdl_seq * _gather_127_var; asdl_seq * _loop0_71_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22084,7 +21924,7 @@ invalid_lambda_parameters_rule(Parser *p) && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_128_var = _gather_128_rule(p)) // ','.lambda_param+ + (_gather_127_var = _gather_127_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -22115,16 +21955,16 @@ invalid_lambda_parameters_rule(Parser *p) asdl_seq * _loop0_75_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_129_var; + void *_tmp_128_var; Token * a; if ( - (_opt_var = _tmp_126_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_125_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_129_var = _tmp_129_rule(p)) // ',' | lambda_param_no_default + (_tmp_128_var = _tmp_128_rule(p)) // ',' | lambda_param_no_default && (_loop0_75_var_1 = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -22267,11 +22107,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_130_var; + void *_tmp_129_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_130_var = _tmp_130_rule(p)) // ':' | ',' (':' | '**') + (_tmp_129_var = _tmp_129_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); @@ -22325,19 +22165,19 @@ 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_75_var; - void *_tmp_131_var; - void *_tmp_131_var_1; + void *_tmp_130_var; + void *_tmp_130_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_131_var = _tmp_131_rule(p)) // lambda_param_no_default | ',' + (_tmp_130_var = _tmp_130_rule(p)) // lambda_param_no_default | ',' && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_131_var_1 = _tmp_131_rule(p)) // lambda_param_no_default | ',' + (_tmp_130_var_1 = _tmp_130_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 | ',')")); @@ -22455,7 +22295,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_125_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_124_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -22605,13 +22445,13 @@ invalid_for_if_clause_rule(Parser *p) Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_132_var; + void *_tmp_131_var; if ( (_opt_var = _PyPegen_expect_token(p, 682), !p->error_indicator) // 'async'? && (_keyword = _PyPegen_expect_token(p, 678)) // token='for' && - (_tmp_132_var = _tmp_132_rule(p)) // bitwise_or ((',' bitwise_or))* ','? + (_tmp_131_var = _tmp_131_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 679) // token='in' ) @@ -22786,14 +22626,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_134_var; + asdl_seq * _gather_133_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( (a = _PyPegen_expect_token(p, 622)) // token='import' && - (_gather_134_var = _gather_134_rule(p)) // ','.dotted_name+ + (_gather_133_var = _gather_133_rule(p)) // ','.dotted_name+ && (_keyword = _PyPegen_expect_token(p, 621)) // token='from' && @@ -22940,7 +22780,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_136_var; + asdl_seq * _gather_135_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22950,7 +22790,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 633)) // token='with' && - (_gather_136_var = _gather_136_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_135_var = _gather_135_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -22974,7 +22814,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_138_var; + asdl_seq * _gather_137_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -22990,7 +22830,7 @@ invalid_with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_138_var = _gather_138_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_137_var = _gather_137_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23039,7 +22879,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_136_var; + asdl_seq * _gather_135_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23050,7 +22890,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (a = _PyPegen_expect_token(p, 633)) // token='with' && - (_gather_136_var = _gather_136_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_135_var = _gather_135_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -23078,7 +22918,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_138_var; + asdl_seq * _gather_137_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -23095,7 +22935,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_138_var = _gather_138_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_137_var = _gather_137_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23192,7 +23032,7 @@ invalid_try_stmt_rule(Parser *p) && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_139_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_138_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); @@ -23217,7 +23057,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_140_var; + asdl_seq * _loop0_139_var; asdl_seq * _loop1_37_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23229,7 +23069,7 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_140_var = _loop0_140_rule(p)) // block* + (_loop0_139_var = _loop0_139_rule(p)) // block* && (_loop1_37_var = _loop1_37_rule(p)) // except_block+ && @@ -23266,7 +23106,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_140_var; + asdl_seq * _loop0_139_var; asdl_seq * _loop1_38_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23276,13 +23116,13 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_140_var = _loop0_140_rule(p)) // block* + (_loop0_139_var = _loop0_139_rule(p)) // block* && (_loop1_38_var = _loop1_38_rule(p)) // except_star_block+ && (a = _PyPegen_expect_token(p, 663)) // token='except' && - (_opt_var = _tmp_141_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_140_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -23567,14 +23407,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_142_var; + void *_tmp_141_var; Token * a; if ( (a = _PyPegen_expect_token(p, 663)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_142_var = _tmp_142_rule(p)) // NEWLINE | ':' + (_tmp_141_var = _tmp_141_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_star_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); @@ -24171,7 +24011,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_143_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_142_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -24870,11 +24710,11 @@ 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")); - asdl_seq * _gather_83_var; + asdl_seq * _gather_82_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_83_var = _gather_83_rule(p)) // ','.double_starred_kvpair+ + (_gather_82_var = _gather_82_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24882,7 +24722,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); - _res = _PyPegen_dummy_name(p, _gather_83_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_82_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -24935,7 +24775,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_144_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_143_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -25045,7 +24885,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_144_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_143_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -25201,7 +25041,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '='")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '='" ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before '='" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25228,7 +25068,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '!'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '!'" ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before '!'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25255,7 +25095,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' ':'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before ':'" ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before ':'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25282,7 +25122,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '}'" ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25308,7 +25148,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting a valid expression after '{'" ); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting a valid expression after '{'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25333,11 +25173,11 @@ invalid_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_145_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_144_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '=', or '!', or ':', or '}'" ); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '=', or '!', or ':', or '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25365,11 +25205,11 @@ invalid_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_146_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_145_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '!', or ':', or '}'" ); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '!', or ':', or '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25429,13 +25269,13 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_148_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_147_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting ':' or '}'" ); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting ':' or '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25468,7 +25308,7 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25478,7 +25318,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '}', or format specs" ); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '}', or format specs" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25509,13 +25349,13 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '}'" ); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25556,11 +25396,11 @@ invalid_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_148_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_147_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: missing conversion character" ); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: missing conversion character" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25586,7 +25426,7 @@ invalid_conversion_character_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: invalid conversion character" ); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: invalid conversion character" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25623,14 +25463,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_149_var; + void *_tmp_148_var; Token * a; expr_ty b; expr_ty sum_var; if ( (sum_var = sum_rule(p)) // sum && - (_tmp_149_var = _tmp_149_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' + (_tmp_148_var = _tmp_148_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && (a = _PyPegen_expect_token(p, 687)) // token='not' && @@ -25675,11 +25515,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_150_var; + void *_tmp_149_var; Token * a; expr_ty b; if ( - (_tmp_150_var = _tmp_150_rule(p)) // '+' | '-' | '~' + (_tmp_149_var = _tmp_149_rule(p)) // '+' | '-' | '~' && (a = _PyPegen_expect_token(p, 687)) // token='not' && @@ -26453,12 +26293,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_151_var; + void *_tmp_150_var; while ( - (_tmp_151_var = _tmp_151_rule(p)) // star_targets '=' + (_tmp_150_var = _tmp_150_rule(p)) // star_targets '=' ) { - _res = _tmp_151_var; + _res = _tmp_150_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26791,12 +26631,12 @@ _loop0_18_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_152_var; + void *_tmp_151_var; while ( - (_tmp_152_var = _tmp_152_rule(p)) // '.' | '...' + (_tmp_151_var = _tmp_151_rule(p)) // '.' | '...' ) { - _res = _tmp_152_var; + _res = _tmp_151_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26858,12 +26698,12 @@ _loop1_19_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_152_var; + void *_tmp_151_var; while ( - (_tmp_152_var = _tmp_152_rule(p)) // '.' | '...' + (_tmp_151_var = _tmp_151_rule(p)) // '.' | '...' ) { - _res = _tmp_152_var; + _res = _tmp_151_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -27210,12 +27050,12 @@ _loop1_25_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); - void *_tmp_153_var; + void *_tmp_152_var; while ( - (_tmp_153_var = _tmp_153_rule(p)) // '@' named_expression NEWLINE + (_tmp_152_var = _tmp_152_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_153_var; + _res = _tmp_152_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29224,12 +29064,12 @@ _loop1_57_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); - void *_tmp_154_var; + void *_tmp_153_var; while ( - (_tmp_154_var = _tmp_154_rule(p)) // ',' star_expression + (_tmp_153_var = _tmp_153_rule(p)) // ',' star_expression ) { - _res = _tmp_154_var; + _res = _tmp_153_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29413,12 +29253,12 @@ _loop1_60_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); - void *_tmp_155_var; + void *_tmp_154_var; while ( - (_tmp_155_var = _tmp_155_rule(p)) // 'or' conjunction + (_tmp_154_var = _tmp_154_rule(p)) // 'or' conjunction ) { - _res = _tmp_155_var; + _res = _tmp_154_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29485,12 +29325,12 @@ _loop1_61_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); - void *_tmp_156_var; + void *_tmp_155_var; while ( - (_tmp_156_var = _tmp_156_rule(p)) // 'and' inversion + (_tmp_155_var = _tmp_155_rule(p)) // 'and' inversion ) { - _res = _tmp_156_var; + _res = _tmp_155_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29677,7 +29517,7 @@ _loop0_64_rule(Parser *p) while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_157_rule(p)) // slice | starred_expression + (elem = _tmp_156_rule(p)) // slice | starred_expression ) { _res = elem; @@ -29742,7 +29582,7 @@ _gather_65_rule(Parser *p) void *elem; asdl_seq * seq; if ( - (elem = _tmp_157_rule(p)) // slice | starred_expression + (elem = _tmp_156_rule(p)) // slice | starred_expression && (seq = _loop0_64_rule(p)) // _loop0_64 ) @@ -30643,76 +30483,9 @@ _loop0_78_rule(Parser *p) return _seq; } -// _loop0_79: tstring_middle -static asdl_seq * -_loop0_79_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void *_res = NULL; - int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // tstring_middle - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _loop0_79[%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 - ) - { - _res = tstring_middle_var; - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_79[%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); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _loop1_80: (fstring | string) +// _loop1_79: (fstring | string) static asdl_seq * -_loop1_80_rule(Parser *p) +_loop1_79_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30737,13 +30510,13 @@ _loop1_80_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); - void *_tmp_158_var; + D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); + void *_tmp_157_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // fstring | string + (_tmp_157_var = _tmp_157_rule(p)) // fstring | string ) { - _res = _tmp_158_var; + _res = _tmp_157_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30760,7 +30533,7 @@ _loop1_80_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_79[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)")); } if (_n == 0 || p->error_indicator) { @@ -30782,9 +30555,9 @@ _loop1_80_rule(Parser *p) return _seq; } -// _tmp_81: star_named_expression ',' star_named_expressions? +// _tmp_80: star_named_expression ',' star_named_expressions? static void * -_tmp_81_rule(Parser *p) +_tmp_80_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30800,7 +30573,7 @@ _tmp_81_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); Token * _literal; expr_ty y; void *z; @@ -30812,7 +30585,7 @@ _tmp_81_rule(Parser *p) (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? ) { - D(fprintf(stderr, "%*c+ _tmp_81[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c+ _tmp_80[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); _res = _PyPegen_seq_insert_in_front ( p , y , z ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -30822,7 +30595,7 @@ _tmp_81_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_81[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_80[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); } _res = NULL; @@ -30831,9 +30604,9 @@ _tmp_81_rule(Parser *p) return _res; } -// _loop0_82: ',' double_starred_kvpair +// _loop0_81: ',' double_starred_kvpair static asdl_seq * -_loop0_82_rule(Parser *p) +_loop0_81_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30858,7 +30631,7 @@ _loop0_82_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -30890,7 +30663,7 @@ _loop0_82_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_82[%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, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -30907,9 +30680,9 @@ _loop0_82_rule(Parser *p) return _seq; } -// _gather_83: double_starred_kvpair _loop0_82 +// _gather_82: double_starred_kvpair _loop0_81 static asdl_seq * -_gather_83_rule(Parser *p) +_gather_82_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30920,27 +30693,27 @@ _gather_83_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_82 + { // double_starred_kvpair _loop0_81 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); + D(fprintf(stderr, "%*c> _gather_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_81")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_82_rule(p)) // _loop0_82 + (seq = _loop0_81_rule(p)) // _loop0_81 ) { - D(fprintf(stderr, "%*c+ _gather_83[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); + D(fprintf(stderr, "%*c+ _gather_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_81")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_83[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_82")); + D(fprintf(stderr, "%*c%s _gather_82[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_81")); } _res = NULL; done: @@ -30948,9 +30721,9 @@ _gather_83_rule(Parser *p) return _res; } -// _loop1_84: for_if_clause +// _loop1_83: for_if_clause static asdl_seq * -_loop1_84_rule(Parser *p) +_loop1_83_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30975,7 +30748,7 @@ _loop1_84_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_83[%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 @@ -30998,7 +30771,7 @@ _loop1_84_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_84[%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, "for_if_clause")); } if (_n == 0 || p->error_indicator) { @@ -31020,9 +30793,9 @@ _loop1_84_rule(Parser *p) return _seq; } -// _loop0_85: ('if' disjunction) +// _loop0_84: ('if' disjunction) static asdl_seq * -_loop0_85_rule(Parser *p) +_loop0_84_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31047,13 +30820,13 @@ _loop0_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); - void *_tmp_159_var; + D(fprintf(stderr, "%*c> _loop0_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + void *_tmp_158_var; while ( - (_tmp_159_var = _tmp_159_rule(p)) // 'if' disjunction + (_tmp_158_var = _tmp_158_rule(p)) // 'if' disjunction ) { - _res = _tmp_159_var; + _res = _tmp_158_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31070,7 +30843,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_84[%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); @@ -31087,9 +30860,9 @@ _loop0_85_rule(Parser *p) return _seq; } -// _tmp_86: assignment_expression | expression !':=' +// _tmp_85: assignment_expression | expression !':=' static void * -_tmp_86_rule(Parser *p) +_tmp_85_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31105,18 +30878,18 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_85[%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_86[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_85[%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_86[%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, "assignment_expression")); } { // expression !':=' @@ -31124,7 +30897,7 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -31132,12 +30905,12 @@ _tmp_86_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_86[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_85[%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_86[%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, "expression !':='")); } _res = NULL; @@ -31146,9 +30919,9 @@ _tmp_86_rule(Parser *p) return _res; } -// _loop0_87: ',' (starred_expression | (assignment_expression | expression !':=') !'=') +// _loop0_86: ',' (starred_expression | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_87_rule(Parser *p) +_loop0_86_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31173,13 +30946,13 @@ _loop0_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_86[%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_160_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_159_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -31205,7 +30978,7 @@ _loop0_87_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_87[%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, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31222,10 +30995,10 @@ _loop0_87_rule(Parser *p) return _seq; } -// _gather_88: -// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 +// _gather_87: +// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86 static asdl_seq * -_gather_88_rule(Parser *p) +_gather_87_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31236,27 +31009,27 @@ _gather_88_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 + { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); + D(fprintf(stderr, "%*c> _gather_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_160_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_159_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_87_rule(p)) // _loop0_87 + (seq = _loop0_86_rule(p)) // _loop0_86 ) { - D(fprintf(stderr, "%*c+ _gather_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); + D(fprintf(stderr, "%*c+ _gather_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_88[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); + D(fprintf(stderr, "%*c%s _gather_87[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); } _res = NULL; done: @@ -31264,9 +31037,9 @@ _gather_88_rule(Parser *p) return _res; } -// _tmp_89: ',' kwargs +// _tmp_88: ',' kwargs static void * -_tmp_89_rule(Parser *p) +_tmp_88_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31282,7 +31055,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, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -31291,7 +31064,7 @@ _tmp_89_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); _res = k; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31301,7 +31074,7 @@ _tmp_89_rule(Parser *p) 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_88[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); } _res = NULL; @@ -31310,9 +31083,9 @@ _tmp_89_rule(Parser *p) return _res; } -// _loop0_90: ',' kwarg_or_starred +// _loop0_89: ',' kwarg_or_starred static asdl_seq * -_loop0_90_rule(Parser *p) +_loop0_89_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31337,7 +31110,7 @@ _loop0_90_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31369,7 +31142,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_89[%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); @@ -31386,9 +31159,9 @@ _loop0_90_rule(Parser *p) return _seq; } -// _gather_91: kwarg_or_starred _loop0_90 +// _gather_90: kwarg_or_starred _loop0_89 static asdl_seq * -_gather_91_rule(Parser *p) +_gather_90_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31399,27 +31172,27 @@ _gather_91_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_90 + { // kwarg_or_starred _loop0_89 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_90")); + D(fprintf(stderr, "%*c> _gather_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_89")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_90_rule(p)) // _loop0_90 + (seq = _loop0_89_rule(p)) // _loop0_89 ) { - D(fprintf(stderr, "%*c+ _gather_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_90")); + D(fprintf(stderr, "%*c+ _gather_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_89")); _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, "kwarg_or_starred _loop0_90")); + D(fprintf(stderr, "%*c%s _gather_90[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_89")); } _res = NULL; done: @@ -31427,9 +31200,9 @@ _gather_91_rule(Parser *p) return _res; } -// _loop0_92: ',' kwarg_or_double_starred +// _loop0_91: ',' kwarg_or_double_starred static asdl_seq * -_loop0_92_rule(Parser *p) +_loop0_91_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31454,7 +31227,7 @@ _loop0_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31486,7 +31259,7 @@ _loop0_92_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_92[%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, "',' kwarg_or_double_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31503,9 +31276,9 @@ _loop0_92_rule(Parser *p) return _seq; } -// _gather_93: kwarg_or_double_starred _loop0_92 +// _gather_92: kwarg_or_double_starred _loop0_91 static asdl_seq * -_gather_93_rule(Parser *p) +_gather_92_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31516,27 +31289,27 @@ _gather_93_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_92 + { // kwarg_or_double_starred _loop0_91 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); + D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_91")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_92_rule(p)) // _loop0_92 + (seq = _loop0_91_rule(p)) // _loop0_91 ) { - D(fprintf(stderr, "%*c+ _gather_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); + D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_91")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_93[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_92")); + D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_91")); } _res = NULL; done: @@ -31544,9 +31317,9 @@ _gather_93_rule(Parser *p) return _res; } -// _loop0_94: (',' star_target) +// _loop0_93: (',' star_target) static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_93_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31571,13 +31344,13 @@ _loop0_94_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_161_var; + D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_160_var; while ( - (_tmp_161_var = _tmp_161_rule(p)) // ',' star_target + (_tmp_160_var = _tmp_160_rule(p)) // ',' star_target ) { - _res = _tmp_161_var; + _res = _tmp_160_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31594,7 +31367,7 @@ _loop0_94_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_94[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_93[%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); @@ -31611,9 +31384,9 @@ _loop0_94_rule(Parser *p) return _seq; } -// _loop0_95: ',' star_target +// _loop0_94: ',' star_target static asdl_seq * -_loop0_95_rule(Parser *p) +_loop0_94_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31638,7 +31411,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, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -31670,7 +31443,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_94[%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); @@ -31687,9 +31460,9 @@ _loop0_95_rule(Parser *p) return _seq; } -// _gather_96: star_target _loop0_95 +// _gather_95: star_target _loop0_94 static asdl_seq * -_gather_96_rule(Parser *p) +_gather_95_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31700,27 +31473,27 @@ _gather_96_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_95 + { // star_target _loop0_94 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_95")); + D(fprintf(stderr, "%*c> _gather_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_94")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_95_rule(p)) // _loop0_95 + (seq = _loop0_94_rule(p)) // _loop0_94 ) { - D(fprintf(stderr, "%*c+ _gather_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_95")); + D(fprintf(stderr, "%*c+ _gather_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_94")); _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, "star_target _loop0_95")); + D(fprintf(stderr, "%*c%s _gather_95[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_94")); } _res = NULL; done: @@ -31728,9 +31501,9 @@ _gather_96_rule(Parser *p) return _res; } -// _loop1_97: (',' star_target) +// _loop1_96: (',' star_target) static asdl_seq * -_loop1_97_rule(Parser *p) +_loop1_96_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31755,13 +31528,13 @@ _loop1_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_161_var; + D(fprintf(stderr, "%*c> _loop1_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_160_var; while ( - (_tmp_161_var = _tmp_161_rule(p)) // ',' star_target + (_tmp_160_var = _tmp_160_rule(p)) // ',' star_target ) { - _res = _tmp_161_var; + _res = _tmp_160_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31778,7 +31551,7 @@ _loop1_97_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_97[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_96[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -31800,9 +31573,9 @@ _loop1_97_rule(Parser *p) return _seq; } -// _tmp_98: !'*' star_target +// _tmp_97: !'*' star_target static void * -_tmp_98_rule(Parser *p) +_tmp_97_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31818,7 +31591,7 @@ _tmp_98_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_97[%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='*' @@ -31826,12 +31599,12 @@ _tmp_98_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_98[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_97[%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_98[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); } _res = NULL; @@ -31840,9 +31613,9 @@ _tmp_98_rule(Parser *p) return _res; } -// _loop0_99: ',' del_target +// _loop0_98: ',' del_target static asdl_seq * -_loop0_99_rule(Parser *p) +_loop0_98_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31867,7 +31640,7 @@ _loop0_99_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -31899,7 +31672,7 @@ _loop0_99_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_99[%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, "',' del_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31916,9 +31689,9 @@ _loop0_99_rule(Parser *p) return _seq; } -// _gather_100: del_target _loop0_99 +// _gather_99: del_target _loop0_98 static asdl_seq * -_gather_100_rule(Parser *p) +_gather_99_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31929,27 +31702,27 @@ _gather_100_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_99 + { // del_target _loop0_98 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_99")); + D(fprintf(stderr, "%*c> _gather_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_98")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_99_rule(p)) // _loop0_99 + (seq = _loop0_98_rule(p)) // _loop0_98 ) { - D(fprintf(stderr, "%*c+ _gather_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_99")); + D(fprintf(stderr, "%*c+ _gather_99[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_98")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_100[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_99")); + D(fprintf(stderr, "%*c%s _gather_99[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_98")); } _res = NULL; done: @@ -31957,9 +31730,9 @@ _gather_100_rule(Parser *p) return _res; } -// _loop0_101: ',' expression +// _loop0_100: ',' expression static asdl_seq * -_loop0_101_rule(Parser *p) +_loop0_100_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31984,7 +31757,7 @@ _loop0_101_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -32016,7 +31789,7 @@ _loop0_101_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_101[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_100[%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); @@ -32033,9 +31806,9 @@ _loop0_101_rule(Parser *p) return _seq; } -// _gather_102: expression _loop0_101 +// _gather_101: expression _loop0_100 static asdl_seq * -_gather_102_rule(Parser *p) +_gather_101_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32046,27 +31819,27 @@ _gather_102_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_101 + { // expression _loop0_100 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); + D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_100")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_101_rule(p)) // _loop0_101 + (seq = _loop0_100_rule(p)) // _loop0_100 ) { - D(fprintf(stderr, "%*c+ _gather_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); + D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_100")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_102[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_101")); + D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_100")); } _res = NULL; done: @@ -32074,9 +31847,9 @@ _gather_102_rule(Parser *p) return _res; } -// _tmp_103: NEWLINE INDENT +// _tmp_102: NEWLINE INDENT static void * -_tmp_103_rule(Parser *p) +_tmp_102_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32092,7 +31865,7 @@ _tmp_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -32101,12 +31874,12 @@ _tmp_103_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_102[%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_103[%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, "NEWLINE INDENT")); } _res = NULL; @@ -32115,11 +31888,11 @@ _tmp_103_rule(Parser *p) return _res; } -// _tmp_104: +// _tmp_103: // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) // | kwargs static void * -_tmp_104_rule(Parser *p) +_tmp_103_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32135,18 +31908,18 @@ _tmp_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - void *_tmp_162_var; + D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + void *_tmp_161_var; if ( - (_tmp_162_var = _tmp_162_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs + (_tmp_161_var = _tmp_161_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - _res = _tmp_162_var; + D(fprintf(stderr, "%*c+ _tmp_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + _res = _tmp_161_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_103[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } { // kwargs @@ -32154,18 +31927,18 @@ _tmp_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c> _tmp_103[%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_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c+ _tmp_103[%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_104[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_103[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); } _res = NULL; @@ -32174,9 +31947,9 @@ _tmp_104_rule(Parser *p) return _res; } -// _loop0_105: ',' (starred_expression !'=') +// _loop0_104: ',' (starred_expression !'=') static asdl_seq * -_loop0_105_rule(Parser *p) +_loop0_104_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32201,13 +31974,13 @@ _loop0_105_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); + D(fprintf(stderr, "%*c> _loop0_104[%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_163_rule(p)) // starred_expression !'=' + (elem = _tmp_162_rule(p)) // starred_expression !'=' ) { _res = elem; @@ -32233,7 +32006,7 @@ _loop0_105_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_104[%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); @@ -32250,9 +32023,9 @@ _loop0_105_rule(Parser *p) return _seq; } -// _gather_106: (starred_expression !'=') _loop0_105 +// _gather_105: (starred_expression !'=') _loop0_104 static asdl_seq * -_gather_106_rule(Parser *p) +_gather_105_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32263,27 +32036,27 @@ _gather_106_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression !'=') _loop0_105 + { // (starred_expression !'=') _loop0_104 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_105")); + D(fprintf(stderr, "%*c> _gather_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_104")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_163_rule(p)) // starred_expression !'=' + (elem = _tmp_162_rule(p)) // starred_expression !'=' && - (seq = _loop0_105_rule(p)) // _loop0_105 + (seq = _loop0_104_rule(p)) // _loop0_104 ) { - D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_105")); + D(fprintf(stderr, "%*c+ _gather_105[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_104")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_105")); + D(fprintf(stderr, "%*c%s _gather_105[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_104")); } _res = NULL; done: @@ -32291,9 +32064,9 @@ _gather_106_rule(Parser *p) return _res; } -// _tmp_107: args | expression for_if_clauses +// _tmp_106: args | expression for_if_clauses static void * -_tmp_107_rule(Parser *p) +_tmp_106_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32309,18 +32082,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, "args")); + D(fprintf(stderr, "%*c> _tmp_106[%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_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c+ _tmp_106[%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_107[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_106[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); } { // expression for_if_clauses @@ -32328,7 +32101,7 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_106[%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 ( @@ -32337,12 +32110,12 @@ _tmp_107_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_106[%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_107[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_106[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses")); } _res = NULL; @@ -32351,9 +32124,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _tmp_108: args ',' +// _tmp_107: args ',' static void * -_tmp_108_rule(Parser *p) +_tmp_107_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32369,7 +32142,7 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -32378,12 +32151,12 @@ _tmp_108_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_107[%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_108[%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, "args ','")); } _res = NULL; @@ -32392,9 +32165,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _tmp_109: ',' | ')' +// _tmp_108: ',' | ')' static void * -_tmp_109_rule(Parser *p) +_tmp_108_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32410,18 +32183,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%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, "','")); } { // ')' @@ -32429,18 +32202,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%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, "')'")); } _res = NULL; @@ -32449,9 +32222,9 @@ _tmp_109_rule(Parser *p) return _res; } -// _tmp_110: 'True' | 'False' | 'None' +// _tmp_109: 'True' | 'False' | 'None' static void * -_tmp_110_rule(Parser *p) +_tmp_109_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32467,18 +32240,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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 610)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; 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_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'False' @@ -32486,18 +32259,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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 612)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; 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_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } { // 'None' @@ -32505,18 +32278,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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 611)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; 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_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } _res = NULL; @@ -32525,9 +32298,9 @@ _tmp_110_rule(Parser *p) return _res; } -// _tmp_111: NAME '=' +// _tmp_110: NAME '=' static void * -_tmp_111_rule(Parser *p) +_tmp_110_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32543,7 +32316,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, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -32552,12 +32325,12 @@ _tmp_111_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_110[%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_111[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='")); } _res = NULL; @@ -32566,9 +32339,9 @@ _tmp_111_rule(Parser *p) return _res; } -// _tmp_112: NAME STRING | SOFT_KEYWORD +// _tmp_111: NAME STRING | SOFT_KEYWORD static void * -_tmp_112_rule(Parser *p) +_tmp_111_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32584,7 +32357,7 @@ _tmp_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -32593,12 +32366,12 @@ _tmp_112_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_112[%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, "NAME STRING")); } { // SOFT_KEYWORD @@ -32606,18 +32379,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, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_111[%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_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_112[%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, "SOFT_KEYWORD")); } _res = NULL; @@ -32626,9 +32399,9 @@ _tmp_112_rule(Parser *p) return _res; } -// _tmp_113: 'else' | ':' +// _tmp_112: 'else' | ':' static void * -_tmp_113_rule(Parser *p) +_tmp_112_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32644,18 +32417,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, "'else'")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 671)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); _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_112[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'")); } { // ':' @@ -32663,18 +32436,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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_112[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -32683,9 +32456,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: '=' | ':=' +// _tmp_113: '=' | ':=' static void * -_tmp_114_rule(Parser *p) +_tmp_113_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32701,18 +32474,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%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, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%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_114[%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, "'='")); } { // ':=' @@ -32720,18 +32493,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%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, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%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_114[%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; @@ -32740,9 +32513,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _tmp_115: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_114: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_115_rule(Parser *p) +_tmp_114_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32758,18 +32531,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c> _tmp_114[%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_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c+ _tmp_114[%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_115[%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, "list")); } { // tuple @@ -32777,18 +32550,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c> _tmp_114[%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_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_114[%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_115[%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, "tuple")); } { // genexp @@ -32796,18 +32569,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c> _tmp_114[%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_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_114[%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_115[%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, "genexp")); } { // 'True' @@ -32815,18 +32588,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%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, 610)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_115[%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_115[%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'")); } { // 'None' @@ -32834,18 +32607,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%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, 611)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_115[%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_115[%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'")); } { // 'False' @@ -32853,18 +32626,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%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, 612)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_115[%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_115[%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'")); } _res = NULL; @@ -32873,9 +32646,9 @@ _tmp_115_rule(Parser *p) return _res; } -// _loop0_116: star_named_expressions +// _loop0_115: star_named_expressions static asdl_seq * -_loop0_116_rule(Parser *p) +_loop0_115_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32900,7 +32673,7 @@ _loop0_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_115[%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 @@ -32923,7 +32696,7 @@ _loop0_116_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_115[%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); @@ -32940,9 +32713,9 @@ _loop0_116_rule(Parser *p) return _seq; } -// _loop0_117: (star_targets '=') +// _loop0_116: (star_targets '=') static asdl_seq * -_loop0_117_rule(Parser *p) +_loop0_116_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32967,13 +32740,13 @@ _loop0_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_151_var; + D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); + void *_tmp_150_var; while ( - (_tmp_151_var = _tmp_151_rule(p)) // star_targets '=' + (_tmp_150_var = _tmp_150_rule(p)) // star_targets '=' ) { - _res = _tmp_151_var; + _res = _tmp_150_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32990,7 +32763,7 @@ _loop0_117_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_117[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_116[%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); @@ -33007,9 +32780,9 @@ _loop0_117_rule(Parser *p) return _seq; } -// _tmp_118: '[' | '(' | '{' +// _tmp_117: '[' | '(' | '{' static void * -_tmp_118_rule(Parser *p) +_tmp_117_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33025,18 +32798,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, "'['")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; 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_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); } { // '(' @@ -33044,18 +32817,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, "'('")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); _res = _literal; 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_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); } { // '{' @@ -33063,18 +32836,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, "'{'")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; 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_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); } _res = NULL; @@ -33083,9 +32856,9 @@ _tmp_118_rule(Parser *p) return _res; } -// _tmp_119: '[' | '{' +// _tmp_118: '[' | '{' static void * -_tmp_119_rule(Parser *p) +_tmp_118_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33101,18 +32874,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_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_119[%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_119[%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, "'['")); } { // '{' @@ -33120,18 +32893,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_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_119[%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_119[%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; @@ -33140,9 +32913,9 @@ _tmp_119_rule(Parser *p) return _res; } -// _tmp_120: slash_no_default | slash_with_default +// _tmp_119: slash_no_default | slash_with_default static void * -_tmp_120_rule(Parser *p) +_tmp_119_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33158,18 +32931,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, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_119[%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_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_119[%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_120[%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, "slash_no_default")); } { // slash_with_default @@ -33177,18 +32950,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, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_119[%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_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_119[%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_120[%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, "slash_with_default")); } _res = NULL; @@ -33197,9 +32970,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _tmp_121: ',' | param_no_default +// _tmp_120: ',' | param_no_default static void * -_tmp_121_rule(Parser *p) +_tmp_120_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33215,18 +32988,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%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, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%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_121[%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, "','")); } { // param_no_default @@ -33234,18 +33007,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_120[%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_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_120[%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_121[%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, "param_no_default")); } _res = NULL; @@ -33254,9 +33027,9 @@ _tmp_121_rule(Parser *p) return _res; } -// _tmp_122: ')' | ',' +// _tmp_121: ')' | ',' static void * -_tmp_122_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33272,18 +33045,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%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, "')'")); } { // ',' @@ -33291,18 +33064,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%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, "','")); } _res = NULL; @@ -33311,9 +33084,9 @@ _tmp_122_rule(Parser *p) return _res; } -// _tmp_123: ')' | ',' (')' | '**') +// _tmp_122: ')' | ',' (')' | '**') static void * -_tmp_123_rule(Parser *p) +_tmp_122_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33329,18 +33102,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_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_122[%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_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' (')' | '**') @@ -33348,21 +33121,21 @@ _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_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); Token * _literal; - void *_tmp_164_var; + void *_tmp_163_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_164_var = _tmp_164_rule(p)) // ')' | '**' + (_tmp_163_var = _tmp_163_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_164_var); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_163_var); 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_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); } _res = NULL; @@ -33371,9 +33144,9 @@ _tmp_123_rule(Parser *p) return _res; } -// _tmp_124: param_no_default | ',' +// _tmp_123: param_no_default | ',' static void * -_tmp_124_rule(Parser *p) +_tmp_123_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33389,18 +33162,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_123[%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_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_123[%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_124[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } { // ',' @@ -33408,18 +33181,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, "','")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -33428,9 +33201,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _tmp_125: '*' | '**' | '/' +// _tmp_124: '*' | '**' | '/' static void * -_tmp_125_rule(Parser *p) +_tmp_124_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33446,18 +33219,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_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%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_125[%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, "'*'")); } { // '**' @@ -33465,18 +33238,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_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%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_125[%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, "'**'")); } { // '/' @@ -33484,18 +33257,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_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%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_125[%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, "'/'")); } _res = NULL; @@ -33504,9 +33277,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _tmp_126: lambda_slash_no_default | lambda_slash_with_default +// _tmp_125: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_126_rule(Parser *p) +_tmp_125_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33522,18 +33295,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, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_125[%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_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_125[%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_126[%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, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -33541,18 +33314,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, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_125[%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_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_125[%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_126[%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, "lambda_slash_with_default")); } _res = NULL; @@ -33561,9 +33334,9 @@ _tmp_126_rule(Parser *p) return _res; } -// _loop0_127: ',' lambda_param +// _loop0_126: ',' lambda_param static asdl_seq * -_loop0_127_rule(Parser *p) +_loop0_126_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33588,7 +33361,7 @@ _loop0_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -33620,7 +33393,7 @@ _loop0_127_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_126[%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); @@ -33637,9 +33410,9 @@ _loop0_127_rule(Parser *p) return _seq; } -// _gather_128: lambda_param _loop0_127 +// _gather_127: lambda_param _loop0_126 static asdl_seq * -_gather_128_rule(Parser *p) +_gather_127_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33650,27 +33423,27 @@ _gather_128_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_127 + { // lambda_param _loop0_126 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_127")); + D(fprintf(stderr, "%*c> _gather_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_126")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_127_rule(p)) // _loop0_127 + (seq = _loop0_126_rule(p)) // _loop0_126 ) { - D(fprintf(stderr, "%*c+ _gather_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_127")); + D(fprintf(stderr, "%*c+ _gather_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_126")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_128[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_127")); + D(fprintf(stderr, "%*c%s _gather_127[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_126")); } _res = NULL; done: @@ -33678,9 +33451,9 @@ _gather_128_rule(Parser *p) return _res; } -// _tmp_129: ',' | lambda_param_no_default +// _tmp_128: ',' | lambda_param_no_default static void * -_tmp_129_rule(Parser *p) +_tmp_128_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33696,18 +33469,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_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_129[%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_129[%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, "','")); } { // lambda_param_no_default @@ -33715,18 +33488,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, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_128[%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_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_128[%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_129[%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, "lambda_param_no_default")); } _res = NULL; @@ -33735,9 +33508,9 @@ _tmp_129_rule(Parser *p) return _res; } -// _tmp_130: ':' | ',' (':' | '**') +// _tmp_129: ':' | ',' (':' | '**') static void * -_tmp_130_rule(Parser *p) +_tmp_129_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33753,18 +33526,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_130[%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_130[%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, "':'")); } { // ',' (':' | '**') @@ -33772,21 +33545,21 @@ _tmp_130_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_130[%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; - void *_tmp_165_var; + void *_tmp_164_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_165_var = _tmp_165_rule(p)) // ':' | '**' + (_tmp_164_var = _tmp_164_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_165_var); + D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_164_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_129[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); } _res = NULL; @@ -33795,9 +33568,9 @@ _tmp_130_rule(Parser *p) return _res; } -// _tmp_131: lambda_param_no_default | ',' +// _tmp_130: lambda_param_no_default | ',' static void * -_tmp_131_rule(Parser *p) +_tmp_130_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33813,18 +33586,18 @@ _tmp_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_130[%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_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_130[%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_131[%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, "lambda_param_no_default")); } { // ',' @@ -33832,18 +33605,18 @@ _tmp_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_131[%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, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_131[%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_131[%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; @@ -33852,9 +33625,9 @@ _tmp_131_rule(Parser *p) return _res; } -// _tmp_132: bitwise_or ((',' bitwise_or))* ','? +// _tmp_131: bitwise_or ((',' bitwise_or))* ','? static void * -_tmp_132_rule(Parser *p) +_tmp_131_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33870,25 +33643,25 @@ _tmp_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - asdl_seq * _loop0_166_var; + D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + asdl_seq * _loop0_165_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_166_var = _loop0_166_rule(p)) // ((',' bitwise_or))* + (_loop0_165_var = _loop0_165_rule(p)) // ((',' bitwise_or))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) { - D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_166_var, _opt_var); + D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_165_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_132[%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, "bitwise_or ((',' bitwise_or))* ','?")); } _res = NULL; @@ -33897,9 +33670,9 @@ _tmp_132_rule(Parser *p) return _res; } -// _loop0_133: ',' dotted_name +// _loop0_132: ',' dotted_name static asdl_seq * -_loop0_133_rule(Parser *p) +_loop0_132_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33924,7 +33697,7 @@ _loop0_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -33956,7 +33729,7 @@ _loop0_133_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_133[%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, "',' dotted_name")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33973,9 +33746,9 @@ _loop0_133_rule(Parser *p) return _seq; } -// _gather_134: dotted_name _loop0_133 +// _gather_133: dotted_name _loop0_132 static asdl_seq * -_gather_134_rule(Parser *p) +_gather_133_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33986,27 +33759,27 @@ _gather_134_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_133 + { // dotted_name _loop0_132 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_133")); + D(fprintf(stderr, "%*c> _gather_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_132")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_133_rule(p)) // _loop0_133 + (seq = _loop0_132_rule(p)) // _loop0_132 ) { - D(fprintf(stderr, "%*c+ _gather_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_133")); + D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_132")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_134[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_133")); + D(fprintf(stderr, "%*c%s _gather_133[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_132")); } _res = NULL; done: @@ -34014,9 +33787,9 @@ _gather_134_rule(Parser *p) return _res; } -// _loop0_135: ',' (expression ['as' star_target]) +// _loop0_134: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_135_rule(Parser *p) +_loop0_134_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34041,13 +33814,13 @@ _loop0_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_134[%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_167_rule(p)) // expression ['as' star_target] + (elem = _tmp_166_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -34073,7 +33846,7 @@ _loop0_135_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_135[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_134[%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); @@ -34090,9 +33863,9 @@ _loop0_135_rule(Parser *p) return _seq; } -// _gather_136: (expression ['as' star_target]) _loop0_135 +// _gather_135: (expression ['as' star_target]) _loop0_134 static asdl_seq * -_gather_136_rule(Parser *p) +_gather_135_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34103,27 +33876,27 @@ _gather_136_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_135 + { // (expression ['as' star_target]) _loop0_134 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); + D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_167_rule(p)) // expression ['as' star_target] + (elem = _tmp_166_rule(p)) // expression ['as' star_target] && - (seq = _loop0_135_rule(p)) // _loop0_135 + (seq = _loop0_134_rule(p)) // _loop0_134 ) { - D(fprintf(stderr, "%*c+ _gather_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); + D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_136[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); + D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); } _res = NULL; done: @@ -34131,9 +33904,9 @@ _gather_136_rule(Parser *p) return _res; } -// _loop0_137: ',' (expressions ['as' star_target]) +// _loop0_136: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_137_rule(Parser *p) +_loop0_136_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34158,13 +33931,13 @@ _loop0_137_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_136[%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_168_rule(p)) // expressions ['as' star_target] + (elem = _tmp_167_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -34190,7 +33963,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_136[%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); @@ -34207,9 +33980,9 @@ _loop0_137_rule(Parser *p) return _seq; } -// _gather_138: (expressions ['as' star_target]) _loop0_137 +// _gather_137: (expressions ['as' star_target]) _loop0_136 static asdl_seq * -_gather_138_rule(Parser *p) +_gather_137_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34220,27 +33993,27 @@ _gather_138_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_137 + { // (expressions ['as' star_target]) _loop0_136 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); + D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_168_rule(p)) // expressions ['as' star_target] + (elem = _tmp_167_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_137_rule(p)) // _loop0_137 + (seq = _loop0_136_rule(p)) // _loop0_136 ) { - D(fprintf(stderr, "%*c+ _gather_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); + D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); _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, "(expressions ['as' star_target]) _loop0_137")); + D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); } _res = NULL; done: @@ -34248,9 +34021,9 @@ _gather_138_rule(Parser *p) return _res; } -// _tmp_139: 'except' | 'finally' +// _tmp_138: 'except' | 'finally' static void * -_tmp_139_rule(Parser *p) +_tmp_138_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34266,18 +34039,18 @@ _tmp_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 663)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); _res = _keyword; 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_138[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } { // 'finally' @@ -34285,18 +34058,18 @@ _tmp_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 659)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); _res = _keyword; 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_138[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } _res = NULL; @@ -34305,9 +34078,9 @@ _tmp_139_rule(Parser *p) return _res; } -// _loop0_140: block +// _loop0_139: block static asdl_seq * -_loop0_140_rule(Parser *p) +_loop0_139_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34332,7 +34105,7 @@ _loop0_140_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); + D(fprintf(stderr, "%*c> _loop0_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -34355,7 +34128,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_139[%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); @@ -34372,9 +34145,9 @@ _loop0_140_rule(Parser *p) return _seq; } -// _tmp_141: expression ['as' NAME] +// _tmp_140: expression ['as' NAME] static void * -_tmp_141_rule(Parser *p) +_tmp_140_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34390,7 +34163,7 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_140[%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; @@ -34400,12 +34173,12 @@ _tmp_141_rule(Parser *p) (_opt_var = _tmp_22_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_140[%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_141[%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, "expression ['as' NAME]")); } _res = NULL; @@ -34414,9 +34187,9 @@ _tmp_141_rule(Parser *p) return _res; } -// _tmp_142: NEWLINE | ':' +// _tmp_141: NEWLINE | ':' static void * -_tmp_142_rule(Parser *p) +_tmp_141_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34432,18 +34205,18 @@ _tmp_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_141[%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_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_141[%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_142[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } { // ':' @@ -34451,18 +34224,18 @@ _tmp_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -34471,9 +34244,9 @@ _tmp_142_rule(Parser *p) return _res; } -// _tmp_143: positional_patterns ',' +// _tmp_142: positional_patterns ',' static void * -_tmp_143_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34489,7 +34262,7 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -34498,12 +34271,12 @@ _tmp_143_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_142[%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_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); } _res = NULL; @@ -34512,9 +34285,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: '}' | ',' +// _tmp_143: '}' | ',' static void * -_tmp_144_rule(Parser *p) +_tmp_143_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34530,18 +34303,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; 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_143[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } { // ',' @@ -34549,18 +34322,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, "','")); + D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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_143[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -34569,9 +34342,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _tmp_145: '=' | '!' | ':' | '}' +// _tmp_144: '=' | '!' | ':' | '}' static void * -_tmp_145_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34587,18 +34360,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } { // '!' @@ -34606,18 +34379,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -34625,18 +34398,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -34644,18 +34417,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -34664,9 +34437,9 @@ _tmp_145_rule(Parser *p) return _res; } -// _tmp_146: '!' | ':' | '}' +// _tmp_145: '!' | ':' | '}' static void * -_tmp_146_rule(Parser *p) +_tmp_145_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34682,18 +34455,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; 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_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -34701,18 +34474,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -34720,18 +34493,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; 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_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -34740,9 +34513,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: '!' NAME +// _tmp_146: '!' NAME static void * -_tmp_147_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34758,7 +34531,7 @@ _tmp_147_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -34767,12 +34540,12 @@ _tmp_147_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_146[%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_147[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME")); } _res = NULL; @@ -34781,9 +34554,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: ':' | '}' +// _tmp_147: ':' | '}' static void * -_tmp_148_rule(Parser *p) +_tmp_147_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34799,18 +34572,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _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_147[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -34818,18 +34591,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _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_147[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -34838,9 +34611,9 @@ _tmp_148_rule(Parser *p) return _res; } -// _tmp_149: '+' | '-' | '*' | '/' | '%' | '//' | '@' +// _tmp_148: '+' | '-' | '*' | '/' | '%' | '//' | '@' static void * -_tmp_149_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34856,18 +34629,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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, "'+'")); } { // '-' @@ -34875,18 +34648,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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, "'-'")); } { // '*' @@ -34894,18 +34667,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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, "'*'")); } { // '/' @@ -34913,18 +34686,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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, "'/'")); } { // '%' @@ -34932,18 +34705,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 24)) // token='%' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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, "'%'")); } { // '//' @@ -34951,18 +34724,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 47)) // token='//' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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, "'//'")); } { // '@' @@ -34970,18 +34743,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%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, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%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_149[%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; @@ -34990,9 +34763,9 @@ _tmp_149_rule(Parser *p) return _res; } -// _tmp_150: '+' | '-' | '~' +// _tmp_149: '+' | '-' | '~' static void * -_tmp_150_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35008,18 +34781,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, "'+'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _literal; 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_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } { // '-' @@ -35027,18 +34800,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, "'-'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _literal; 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_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } { // '~' @@ -35046,18 +34819,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, "'~'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 31)) // token='~' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); _res = _literal; 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_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~'")); } _res = NULL; @@ -35066,9 +34839,9 @@ _tmp_150_rule(Parser *p) return _res; } -// _tmp_151: star_targets '=' +// _tmp_150: star_targets '=' static void * -_tmp_151_rule(Parser *p) +_tmp_150_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35084,7 +34857,7 @@ _tmp_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -35093,7 +34866,7 @@ _tmp_151_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35103,7 +34876,7 @@ _tmp_151_rule(Parser *p) 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_150[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); } _res = NULL; @@ -35112,9 +34885,9 @@ _tmp_151_rule(Parser *p) return _res; } -// _tmp_152: '.' | '...' +// _tmp_151: '.' | '...' static void * -_tmp_152_rule(Parser *p) +_tmp_151_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35130,18 +34903,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_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_151[%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_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } { // '...' @@ -35149,18 +34922,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_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 52)) // token='...' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_151[%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_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); } _res = NULL; @@ -35169,9 +34942,9 @@ _tmp_152_rule(Parser *p) return _res; } -// _tmp_153: '@' named_expression NEWLINE +// _tmp_152: '@' named_expression NEWLINE static void * -_tmp_153_rule(Parser *p) +_tmp_152_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35187,7 +34960,7 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -35199,7 +34972,7 @@ _tmp_153_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); _res = f; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35209,7 +34982,7 @@ _tmp_153_rule(Parser *p) 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_152[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE")); } _res = NULL; @@ -35218,9 +34991,9 @@ _tmp_153_rule(Parser *p) return _res; } -// _tmp_154: ',' star_expression +// _tmp_153: ',' star_expression static void * -_tmp_154_rule(Parser *p) +_tmp_153_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35236,7 +35009,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, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -35245,7 +35018,7 @@ _tmp_154_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35255,7 +35028,7 @@ _tmp_154_rule(Parser *p) 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_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression")); } _res = NULL; @@ -35264,9 +35037,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _tmp_155: 'or' conjunction +// _tmp_154: 'or' conjunction static void * -_tmp_155_rule(Parser *p) +_tmp_154_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35282,7 +35055,7 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -35291,7 +35064,7 @@ _tmp_155_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35301,7 +35074,7 @@ _tmp_155_rule(Parser *p) 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_154[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction")); } _res = NULL; @@ -35310,9 +35083,9 @@ _tmp_155_rule(Parser *p) return _res; } -// _tmp_156: 'and' inversion +// _tmp_155: 'and' inversion static void * -_tmp_156_rule(Parser *p) +_tmp_155_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35328,7 +35101,7 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -35337,7 +35110,7 @@ _tmp_156_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35347,7 +35120,7 @@ _tmp_156_rule(Parser *p) 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_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion")); } _res = NULL; @@ -35356,9 +35129,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: slice | starred_expression +// _tmp_156: slice | starred_expression static void * -_tmp_157_rule(Parser *p) +_tmp_156_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35374,18 +35147,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, "slice")); + D(fprintf(stderr, "%*c> _tmp_156[%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_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c+ _tmp_156[%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_157[%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, "slice")); } { // starred_expression @@ -35393,18 +35166,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, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_156[%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_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_156[%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_157[%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, "starred_expression")); } _res = NULL; @@ -35413,9 +35186,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: fstring | string +// _tmp_157: fstring | string static void * -_tmp_158_rule(Parser *p) +_tmp_157_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35431,18 +35204,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, "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_158[%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_158[%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 @@ -35450,18 +35223,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, "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_158[%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_158[%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; @@ -35470,9 +35243,9 @@ _tmp_158_rule(Parser *p) return _res; } -// _tmp_159: 'if' disjunction +// _tmp_158: 'if' disjunction static void * -_tmp_159_rule(Parser *p) +_tmp_158_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35488,7 +35261,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, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -35497,7 +35270,7 @@ _tmp_159_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35507,7 +35280,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_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); } _res = NULL; @@ -35516,9 +35289,9 @@ _tmp_159_rule(Parser *p) return _res; } -// _tmp_160: starred_expression | (assignment_expression | expression !':=') !'=' +// _tmp_159: starred_expression | (assignment_expression | expression !':=') !'=' static void * -_tmp_160_rule(Parser *p) +_tmp_159_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35534,18 +35307,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, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_159[%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_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_159[%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_160[%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, "starred_expression")); } { // (assignment_expression | expression !':=') !'=' @@ -35553,20 +35326,20 @@ _tmp_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - void *_tmp_86_var; + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + void *_tmp_85_var; if ( - (_tmp_86_var = _tmp_86_rule(p)) // assignment_expression | expression !':=' + (_tmp_85_var = _tmp_85_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_86_var; + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_85_var; 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_159[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -35575,9 +35348,9 @@ _tmp_160_rule(Parser *p) return _res; } -// _tmp_161: ',' star_target +// _tmp_160: ',' star_target static void * -_tmp_161_rule(Parser *p) +_tmp_160_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35593,7 +35366,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, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -35602,7 +35375,7 @@ _tmp_161_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35612,7 +35385,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_160[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); } _res = NULL; @@ -35621,10 +35394,10 @@ _tmp_161_rule(Parser *p) return _res; } -// _tmp_162: +// _tmp_161: // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs static void * -_tmp_162_rule(Parser *p) +_tmp_161_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35640,24 +35413,24 @@ _tmp_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - asdl_seq * _gather_88_var; + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + asdl_seq * _gather_87_var; Token * _literal; asdl_seq* kwargs_var; if ( - (_gather_88_var = _gather_88_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (_gather_87_var = _gather_87_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_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - _res = _PyPegen_dummy_name(p, _gather_88_var, _literal, kwargs_var); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + _res = _PyPegen_dummy_name(p, _gather_87_var, _literal, kwargs_var); 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_161[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); } _res = NULL; @@ -35666,9 +35439,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: starred_expression !'=' +// _tmp_162: starred_expression !'=' static void * -_tmp_163_rule(Parser *p) +_tmp_162_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35684,7 +35457,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, "starred_expression !'='")); + D(fprintf(stderr, "%*c> _tmp_162[%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 @@ -35692,12 +35465,12 @@ _tmp_163_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c+ _tmp_162[%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_163[%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, "starred_expression !'='")); } _res = NULL; @@ -35706,9 +35479,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: ')' | '**' +// _tmp_163: ')' | '**' static void * -_tmp_164_rule(Parser *p) +_tmp_163_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35724,18 +35497,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; 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_163[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // '**' @@ -35743,18 +35516,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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_163[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } _res = NULL; @@ -35763,9 +35536,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _tmp_165: ':' | '**' +// _tmp_164: ':' | '**' static void * -_tmp_165_rule(Parser *p) +_tmp_164_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35781,18 +35554,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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_164[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '**' @@ -35800,18 +35573,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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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_164[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } _res = NULL; @@ -35820,9 +35593,9 @@ _tmp_165_rule(Parser *p) return _res; } -// _loop0_166: (',' bitwise_or) +// _loop0_165: (',' bitwise_or) static asdl_seq * -_loop0_166_rule(Parser *p) +_loop0_165_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35847,13 +35620,13 @@ _loop0_166_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); - void *_tmp_169_var; + D(fprintf(stderr, "%*c> _loop0_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); + void *_tmp_168_var; while ( - (_tmp_169_var = _tmp_169_rule(p)) // ',' bitwise_or + (_tmp_168_var = _tmp_168_rule(p)) // ',' bitwise_or ) { - _res = _tmp_169_var; + _res = _tmp_168_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35870,7 +35643,7 @@ _loop0_166_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_166[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_165[%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); @@ -35887,9 +35660,9 @@ _loop0_166_rule(Parser *p) return _seq; } -// _tmp_167: expression ['as' star_target] +// _tmp_166: expression ['as' star_target] static void * -_tmp_167_rule(Parser *p) +_tmp_166_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35905,22 +35678,22 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_166[%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_170_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_169_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_166[%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_167[%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, "expression ['as' star_target]")); } _res = NULL; @@ -35929,9 +35702,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _tmp_168: expressions ['as' star_target] +// _tmp_167: expressions ['as' star_target] static void * -_tmp_168_rule(Parser *p) +_tmp_167_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35947,22 +35720,22 @@ _tmp_168_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_167[%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_170_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_169_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_167[%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_168[%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, "expressions ['as' star_target]")); } _res = NULL; @@ -35971,9 +35744,9 @@ _tmp_168_rule(Parser *p) return _res; } -// _tmp_169: ',' bitwise_or +// _tmp_168: ',' bitwise_or static void * -_tmp_169_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35989,7 +35762,7 @@ _tmp_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); Token * _literal; expr_ty bitwise_or_var; if ( @@ -35998,12 +35771,12 @@ _tmp_169_rule(Parser *p) (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c+ _tmp_168[%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_169[%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, "',' bitwise_or")); } _res = NULL; @@ -36012,9 +35785,9 @@ _tmp_169_rule(Parser *p) return _res; } -// _tmp_170: 'as' star_target +// _tmp_169: 'as' star_target static void * -_tmp_170_rule(Parser *p) +_tmp_169_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -36030,7 +35803,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, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( @@ -36039,12 +35812,12 @@ _tmp_170_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_169[%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_170[%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, "'as' star_target")); } _res = NULL; diff --git a/Parser/pegen.h b/Parser/pegen.h index b16b37a5fec48d..e167ef92970fd9 100644 --- a/Parser/pegen.h +++ b/Parser/pegen.h @@ -5,6 +5,8 @@ #include #include +#include "lexer/state.h" + #if 0 #define PyPARSE_YIELD_IS_KEYWORD 0x0001 #endif @@ -24,6 +26,8 @@ #define CURRENT_POS (-5) +#define TOK_GET_MODE(tok) (&(tok->tok_mode_stack[tok->tok_mode_stack_index])) + typedef struct _memo { int type; void *node; diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index d2fca69824151a..a02f9fc7367a8f 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -617,7 +617,7 @@ append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec) return append_interpolation(writer, e); default: PyErr_SetString(PyExc_SystemError, - "unknown expression kind inside f-string"); + "unknown expression kind inside f-string or t-string"); return -1; } } From 6bfb09561c8e864feefcf5eb1de7565d6642b154 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 11:57:48 +0200 Subject: [PATCH 11/88] Fix test_dis --- Lib/test/test_dis.py | 352 +++++++++++++++++++++---------------------- 1 file changed, 176 insertions(+), 176 deletions(-) diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py index 1ee0fbe98914be..44fc169fd949ac 100644 --- a/Lib/test/test_dis.py +++ b/Lib/test/test_dis.py @@ -1706,201 +1706,201 @@ def _prepare_test_cases(): Instruction = dis.Instruction expected_opinfo_outer = [ - Instruction(opname='MAKE_CELL', opcode=91, arg=0, argval='a', argrepr='a', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_CELL', opcode=91, arg=1, argval='b', argrepr='b', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=93, arg=0, argval='a', argrepr='a', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=93, arg=1, argval='b', argrepr='b', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=4, start_offset=4, starts_line=True, line_number=1, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=5, argval=(3, 4), argrepr='(3, 4)', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='a', argrepr='a', offset=8, start_offset=8, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=1, argval='b', argrepr='b', offset=10, start_offset=10, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_TUPLE', opcode=48, arg=2, argval=2, argrepr='', offset=12, start_offset=12, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=1, argval=code_object_f, argrepr=repr(code_object_f), offset=14, start_offset=14, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_FUNCTION', opcode=23, arg=None, argval=None, argrepr='', offset=16, start_offset=16, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=103, arg=8, argval=8, argrepr='closure', offset=18, start_offset=18, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=103, arg=1, argval=1, argrepr='defaults', offset=20, start_offset=20, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='STORE_FAST', opcode=107, arg=2, argval='f', argrepr='f', offset=22, start_offset=22, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=1, argval='print', argrepr='print + NULL', offset=24, start_offset=24, starts_line=True, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_DEREF', opcode=80, arg=0, argval='a', argrepr='a', offset=34, start_offset=34, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=1, argval='b', argrepr='b', offset=36, start_offset=36, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=2, argval='', argrepr="''", offset=38, start_offset=38, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=3, argval=1, argrepr='1', offset=40, start_offset=40, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_LIST', opcode=43, arg=0, argval=0, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_MAP', opcode=44, arg=0, argval=0, argrepr='', offset=44, start_offset=44, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=4, argval='Hello world!', argrepr="'Hello world!'", offset=46, start_offset=46, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=7, argval=7, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=2, argval='f', argrepr='f', offset=58, start_offset=58, starts_line=True, line_number=8, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_VALUE', opcode=33, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=5, argval=(3, 4), argrepr='(3, 4)', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='a', argrepr='a', offset=8, start_offset=8, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=1, argval='b', argrepr='b', offset=10, start_offset=10, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_TUPLE', opcode=50, arg=2, argval=2, argrepr='', offset=12, start_offset=12, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=1, argval=code_object_f, argrepr=repr(code_object_f), offset=14, start_offset=14, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_FUNCTION', opcode=24, arg=None, argval=None, argrepr='', offset=16, start_offset=16, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=8, argval=8, argrepr='closure', offset=18, start_offset=18, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=1, argval=1, argrepr='defaults', offset=20, start_offset=20, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='STORE_FAST', opcode=109, arg=2, argval='f', argrepr='f', offset=22, start_offset=22, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='print', argrepr='print + NULL', offset=24, start_offset=24, starts_line=True, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_DEREF', opcode=82, arg=0, argval='a', argrepr='a', offset=34, start_offset=34, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=1, argval='b', argrepr='b', offset=36, start_offset=36, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval='', argrepr="''", offset=38, start_offset=38, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=3, argval=1, argrepr='1', offset=40, start_offset=40, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_LIST', opcode=44, arg=0, argval=0, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_MAP', opcode=45, arg=0, argval=0, argrepr='', offset=44, start_offset=44, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=4, argval='Hello world!', argrepr="'Hello world!'", offset=46, start_offset=46, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=7, argval=7, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=2, argval='f', argrepr='f', offset=58, start_offset=58, starts_line=True, line_number=8, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_VALUE', opcode=34, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), ] expected_opinfo_f = [ - Instruction(opname='COPY_FREE_VARS', opcode=58, arg=2, argval=2, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_CELL', opcode=91, arg=0, argval='c', argrepr='c', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_CELL', opcode=91, arg=1, argval='d', argrepr='d', offset=4, start_offset=4, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='COPY_FREE_VARS', opcode=60, arg=2, argval=2, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=93, arg=0, argval='c', argrepr='c', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=93, arg=1, argval='d', argrepr='d', offset=4, start_offset=4, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=2, argval=(5, 6), argrepr='(5, 6)', offset=8, start_offset=8, starts_line=True, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=3, argval='a', argrepr='a', offset=10, start_offset=10, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=4, argval='b', argrepr='b', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='c', argrepr='c', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=1, argval='d', argrepr='d', offset=16, start_offset=16, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_TUPLE', opcode=48, arg=4, argval=4, argrepr='', offset=18, start_offset=18, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=1, argval=code_object_inner, argrepr=repr(code_object_inner), offset=20, start_offset=20, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_FUNCTION', opcode=23, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=103, arg=8, argval=8, argrepr='closure', offset=24, start_offset=24, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=103, arg=1, argval=1, argrepr='defaults', offset=26, start_offset=26, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='STORE_FAST', opcode=107, arg=2, argval='inner', argrepr='inner', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=1, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_DEREF', opcode=80, arg=3, argval='a', argrepr='a', offset=40, start_offset=40, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=4, argval='b', argrepr='b', offset=42, start_offset=42, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=0, argval='c', argrepr='c', offset=44, start_offset=44, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=1, argval='d', argrepr='d', offset=46, start_offset=46, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=4, argval=4, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=2, argval='inner', argrepr='inner', offset=58, start_offset=58, starts_line=True, line_number=6, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_VALUE', opcode=33, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=6, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval=(5, 6), argrepr='(5, 6)', offset=8, start_offset=8, starts_line=True, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=3, argval='a', argrepr='a', offset=10, start_offset=10, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=4, argval='b', argrepr='b', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='c', argrepr='c', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=1, argval='d', argrepr='d', offset=16, start_offset=16, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_TUPLE', opcode=50, arg=4, argval=4, argrepr='', offset=18, start_offset=18, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=1, argval=code_object_inner, argrepr=repr(code_object_inner), offset=20, start_offset=20, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_FUNCTION', opcode=24, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=8, argval=8, argrepr='closure', offset=24, start_offset=24, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=1, argval=1, argrepr='defaults', offset=26, start_offset=26, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='STORE_FAST', opcode=109, arg=2, argval='inner', argrepr='inner', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_DEREF', opcode=82, arg=3, argval='a', argrepr='a', offset=40, start_offset=40, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=4, argval='b', argrepr='b', offset=42, start_offset=42, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=0, argval='c', argrepr='c', offset=44, start_offset=44, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=1, argval='d', argrepr='d', offset=46, start_offset=46, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=4, argval=4, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=2, argval='inner', argrepr='inner', offset=58, start_offset=58, starts_line=True, line_number=6, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_VALUE', opcode=34, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=6, label=None, positions=None, cache_info=None), ] expected_opinfo_inner = [ - Instruction(opname='COPY_FREE_VARS', opcode=58, arg=4, argval=4, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='COPY_FREE_VARS', opcode=60, arg=4, argval=4, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=1, argval='print', argrepr='print + NULL', offset=4, start_offset=4, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_DEREF', opcode=80, arg=2, argval='a', argrepr='a', offset=14, start_offset=14, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=3, argval='b', argrepr='b', offset=16, start_offset=16, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=4, argval='c', argrepr='c', offset=18, start_offset=18, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=80, arg=5, argval='d', argrepr='d', offset=20, start_offset=20, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST_LOAD_FAST', opcode=84, arg=1, argval=('e', 'f'), argrepr='e, f', offset=22, start_offset=22, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=6, argval=6, argrepr='', offset=24, start_offset=24, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=32, start_offset=32, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_CONST', opcode=100, arg=0, argval=None, argrepr='None', offset=34, start_offset=34, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='print', argrepr='print + NULL', offset=4, start_offset=4, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_DEREF', opcode=82, arg=2, argval='a', argrepr='a', offset=14, start_offset=14, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=3, argval='b', argrepr='b', offset=16, start_offset=16, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=4, argval='c', argrepr='c', offset=18, start_offset=18, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=82, arg=5, argval='d', argrepr='d', offset=20, start_offset=20, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST_LOAD_FAST', opcode=86, arg=1, argval=('e', 'f'), argrepr='e, f', offset=22, start_offset=22, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=6, argval=6, argrepr='', offset=24, start_offset=24, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=32, start_offset=32, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_CONST', opcode=102, arg=0, argval=None, argrepr='None', offset=34, start_offset=34, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), ] expected_opinfo_jumpy = [ Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=1, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=1, argval='range', argrepr='range + NULL', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=1, argval=10, argrepr='10', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='GET_ITER', opcode=16, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='FOR_ITER', opcode=67, arg=30, argval=88, argrepr='to L4', offset=24, start_offset=24, starts_line=False, line_number=3, label=1, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='STORE_FAST', opcode=107, arg=0, argval='i', argrepr='i', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=40, start_offset=40, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=50, start_offset=50, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=52, start_offset=52, starts_line=True, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=2, argval=4, argrepr='4', offset=54, start_offset=54, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=54, arg=18, argval='<', argrepr='bool(<)', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=94, arg=2, argval=68, argrepr='to L2', offset=60, start_offset=60, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=72, arg=22, argval=24, argrepr='to L1', offset=64, start_offset=64, starts_line=True, line_number=6, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=68, start_offset=68, starts_line=True, line_number=7, label=2, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=3, argval=6, argrepr='6', offset=70, start_offset=70, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=54, arg=148, argval='>', argrepr='bool(>)', offset=72, start_offset=72, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_TRUE', opcode=97, arg=2, argval=84, argrepr='to L3', offset=76, start_offset=76, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=72, arg=30, argval=24, argrepr='to L1', offset=80, start_offset=80, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=84, start_offset=84, starts_line=True, line_number=8, label=3, positions=None, cache_info=None), - Instruction(opname='JUMP_FORWARD', opcode=74, arg=13, argval=114, argrepr='to L5', offset=86, start_offset=86, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), - Instruction(opname='END_FOR', opcode=9, arg=None, argval=None, argrepr='', offset=88, start_offset=88, starts_line=True, line_number=3, label=4, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=90, start_offset=90, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=92, start_offset=92, starts_line=True, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=102, start_offset=102, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=104, start_offset=104, starts_line=False, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=112, start_offset=112, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST_CHECK', opcode=83, arg=0, argval='i', argrepr='i', offset=114, start_offset=114, starts_line=True, line_number=11, label=5, positions=None, cache_info=None), - Instruction(opname='TO_BOOL', opcode=37, arg=None, argval=None, argrepr='', offset=116, start_offset=116, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=94, arg=33, argval=194, argrepr='to L8', offset=124, start_offset=124, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=128, start_offset=128, starts_line=True, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=138, start_offset=138, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=140, start_offset=140, starts_line=False, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=148, start_offset=148, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=150, start_offset=150, starts_line=True, line_number=13, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=5, argval=1, argrepr='1', offset=152, start_offset=152, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), - Instruction(opname='BINARY_OP', opcode=42, arg=23, argval=23, argrepr='-=', offset=154, start_offset=154, starts_line=False, line_number=13, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='STORE_FAST', opcode=107, arg=0, argval='i', argrepr='i', offset=158, start_offset=158, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=160, start_offset=160, starts_line=True, line_number=14, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=3, argval=6, argrepr='6', offset=162, start_offset=162, starts_line=False, line_number=14, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=54, arg=148, argval='>', argrepr='bool(>)', offset=164, start_offset=164, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=94, arg=2, argval=176, argrepr='to L6', offset=168, start_offset=168, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=72, arg=31, argval=114, argrepr='to L5', offset=172, start_offset=172, starts_line=True, line_number=15, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=176, start_offset=176, starts_line=True, line_number=16, label=6, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=2, argval=4, argrepr='4', offset=178, start_offset=178, starts_line=False, line_number=16, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=54, arg=18, argval='<', argrepr='bool(<)', offset=180, start_offset=180, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_TRUE', opcode=97, arg=2, argval=192, argrepr='to L7', offset=184, start_offset=184, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=72, arg=39, argval=114, argrepr='to L5', offset=188, start_offset=188, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_FORWARD', opcode=74, arg=11, argval=216, argrepr='to L9', offset=192, start_offset=192, starts_line=True, line_number=17, label=7, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=194, start_offset=194, starts_line=True, line_number=19, label=8, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=6, argval='Who let lolcatz into this test suite?', argrepr="'Who let lolcatz into this test suite?'", offset=204, start_offset=204, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=206, start_offset=206, starts_line=False, line_number=19, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=214, start_offset=214, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), - Instruction(opname='NOP', opcode=27, arg=None, argval=None, argrepr='', offset=216, start_offset=216, starts_line=True, line_number=20, label=9, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=5, argval=1, argrepr='1', offset=218, start_offset=218, starts_line=True, line_number=21, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=7, argval=0, argrepr='0', offset=220, start_offset=220, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), - Instruction(opname='BINARY_OP', opcode=42, arg=11, argval=11, argrepr='/', offset=222, start_offset=222, starts_line=False, line_number=21, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=226, start_offset=226, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=81, arg=0, argval='i', argrepr='i', offset=228, start_offset=228, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=57, arg=1, argval=1, argrepr='', offset=230, start_offset=230, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_SPECIAL', opcode=89, arg=1, argval=1, argrepr='__exit__', offset=232, start_offset=232, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='SWAP', opcode=112, arg=2, argval=2, argrepr='', offset=234, start_offset=234, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='SWAP', opcode=112, arg=3, argval=3, argrepr='', offset=236, start_offset=236, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_SPECIAL', opcode=89, arg=0, argval=0, argrepr='__enter__', offset=238, start_offset=238, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=0, argval=0, argrepr='', offset=240, start_offset=240, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='STORE_FAST', opcode=107, arg=1, argval='dodgy', argrepr='dodgy', offset=248, start_offset=248, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=250, start_offset=250, starts_line=True, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=8, argval='Never reach this', argrepr="'Never reach this'", offset=260, start_offset=260, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=262, start_offset=262, starts_line=False, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=270, start_offset=270, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=0, argval=None, argrepr='None', offset=272, start_offset=272, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=0, argval=None, argrepr='None', offset=274, start_offset=274, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=79, arg=0, argval=None, argrepr='None', offset=276, start_offset=276, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=3, argval=3, argrepr='', offset=278, start_offset=278, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=286, start_offset=286, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=288, start_offset=288, starts_line=True, line_number=28, label=10, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=298, start_offset=298, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=300, start_offset=300, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=308, start_offset=308, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_CONST', opcode=100, arg=0, argval=None, argrepr='None', offset=310, start_offset=310, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='PUSH_EXC_INFO', opcode=30, arg=None, argval=None, argrepr='', offset=312, start_offset=312, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='WITH_EXCEPT_START', opcode=41, arg=None, argval=None, argrepr='', offset=314, start_offset=314, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='TO_BOOL', opcode=37, arg=None, argval=None, argrepr='', offset=316, start_offset=316, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_JUMP_IF_TRUE', opcode=97, arg=1, argval=330, argrepr='to L11', offset=324, start_offset=324, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='RERAISE', opcode=99, arg=2, argval=2, argrepr='', offset=328, start_offset=328, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=330, start_offset=330, starts_line=False, line_number=25, label=11, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=28, arg=None, argval=None, argrepr='', offset=332, start_offset=332, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=334, start_offset=334, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=336, start_offset=336, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=338, start_offset=338, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=73, arg=27, argval=288, argrepr='to L10', offset=340, start_offset=340, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=57, arg=3, argval=3, argrepr='', offset=342, start_offset=342, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=28, arg=None, argval=None, argrepr='', offset=344, start_offset=344, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=99, arg=1, argval=1, argrepr='', offset=346, start_offset=346, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='PUSH_EXC_INFO', opcode=30, arg=None, argval=None, argrepr='', offset=348, start_offset=348, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=4, argval='ZeroDivisionError', argrepr='ZeroDivisionError', offset=350, start_offset=350, starts_line=True, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='CHECK_EXC_MATCH', opcode=5, arg=None, argval=None, argrepr='', offset=360, start_offset=360, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=94, arg=14, argval=394, argrepr='to L12', offset=362, start_offset=362, starts_line=False, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=366, start_offset=366, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=368, start_offset=368, starts_line=True, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=9, argval='Here we go, here we go, here we go...', argrepr="'Here we go, here we go, here we go...'", offset=378, start_offset=378, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=380, start_offset=380, starts_line=False, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=388, start_offset=388, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=28, arg=None, argval=None, argrepr='', offset=390, start_offset=390, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=73, arg=53, argval=288, argrepr='to L10', offset=392, start_offset=392, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=99, arg=0, argval=0, argrepr='', offset=394, start_offset=394, starts_line=True, line_number=22, label=12, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=57, arg=3, argval=3, argrepr='', offset=396, start_offset=396, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=28, arg=None, argval=None, argrepr='', offset=398, start_offset=398, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=99, arg=1, argval=1, argrepr='', offset=400, start_offset=400, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='PUSH_EXC_INFO', opcode=30, arg=None, argval=None, argrepr='', offset=402, start_offset=402, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=87, arg=3, argval='print', argrepr='print + NULL', offset=404, start_offset=404, starts_line=True, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=79, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=414, start_offset=414, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=49, arg=1, argval=1, argrepr='', offset=416, start_offset=416, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=29, arg=None, argval=None, argrepr='', offset=424, start_offset=424, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=99, arg=0, argval=0, argrepr='', offset=426, start_offset=426, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=57, arg=3, argval=3, argrepr='', offset=428, start_offset=428, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=28, arg=None, argval=None, argrepr='', offset=430, start_offset=430, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=99, arg=1, argval=1, argrepr='', offset=432, start_offset=432, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='range', argrepr='range + NULL', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=1, argval=10, argrepr='10', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='GET_ITER', opcode=18, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='FOR_ITER', opcode=69, arg=30, argval=88, argrepr='to L4', offset=24, start_offset=24, starts_line=False, line_number=3, label=1, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='STORE_FAST', opcode=109, arg=0, argval='i', argrepr='i', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=40, start_offset=40, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=50, start_offset=50, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=52, start_offset=52, starts_line=True, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval=4, argrepr='4', offset=54, start_offset=54, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=56, arg=18, argval='<', argrepr='bool(<)', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=2, argval=68, argrepr='to L2', offset=60, start_offset=60, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=74, arg=22, argval=24, argrepr='to L1', offset=64, start_offset=64, starts_line=True, line_number=6, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=68, start_offset=68, starts_line=True, line_number=7, label=2, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=3, argval=6, argrepr='6', offset=70, start_offset=70, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=56, arg=148, argval='>', argrepr='bool(>)', offset=72, start_offset=72, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_TRUE', opcode=99, arg=2, argval=84, argrepr='to L3', offset=76, start_offset=76, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=74, arg=30, argval=24, argrepr='to L1', offset=80, start_offset=80, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=84, start_offset=84, starts_line=True, line_number=8, label=3, positions=None, cache_info=None), + Instruction(opname='JUMP_FORWARD', opcode=76, arg=13, argval=114, argrepr='to L5', offset=86, start_offset=86, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), + Instruction(opname='END_FOR', opcode=10, arg=None, argval=None, argrepr='', offset=88, start_offset=88, starts_line=True, line_number=3, label=4, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=90, start_offset=90, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=92, start_offset=92, starts_line=True, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=102, start_offset=102, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=104, start_offset=104, starts_line=False, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=112, start_offset=112, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST_CHECK', opcode=85, arg=0, argval='i', argrepr='i', offset=114, start_offset=114, starts_line=True, line_number=11, label=5, positions=None, cache_info=None), + Instruction(opname='TO_BOOL', opcode=38, arg=None, argval=None, argrepr='', offset=116, start_offset=116, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=33, argval=194, argrepr='to L8', offset=124, start_offset=124, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=128, start_offset=128, starts_line=True, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=138, start_offset=138, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=140, start_offset=140, starts_line=False, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=148, start_offset=148, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=150, start_offset=150, starts_line=True, line_number=13, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=5, argval=1, argrepr='1', offset=152, start_offset=152, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), + Instruction(opname='BINARY_OP', opcode=43, arg=23, argval=23, argrepr='-=', offset=154, start_offset=154, starts_line=False, line_number=13, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='STORE_FAST', opcode=109, arg=0, argval='i', argrepr='i', offset=158, start_offset=158, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=160, start_offset=160, starts_line=True, line_number=14, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=3, argval=6, argrepr='6', offset=162, start_offset=162, starts_line=False, line_number=14, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=56, arg=148, argval='>', argrepr='bool(>)', offset=164, start_offset=164, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=2, argval=176, argrepr='to L6', offset=168, start_offset=168, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=74, arg=31, argval=114, argrepr='to L5', offset=172, start_offset=172, starts_line=True, line_number=15, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=176, start_offset=176, starts_line=True, line_number=16, label=6, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval=4, argrepr='4', offset=178, start_offset=178, starts_line=False, line_number=16, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=56, arg=18, argval='<', argrepr='bool(<)', offset=180, start_offset=180, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_TRUE', opcode=99, arg=2, argval=192, argrepr='to L7', offset=184, start_offset=184, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=74, arg=39, argval=114, argrepr='to L5', offset=188, start_offset=188, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_FORWARD', opcode=76, arg=11, argval=216, argrepr='to L9', offset=192, start_offset=192, starts_line=True, line_number=17, label=7, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=194, start_offset=194, starts_line=True, line_number=19, label=8, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=6, argval='Who let lolcatz into this test suite?', argrepr="'Who let lolcatz into this test suite?'", offset=204, start_offset=204, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=206, start_offset=206, starts_line=False, line_number=19, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=214, start_offset=214, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), + Instruction(opname='NOP', opcode=28, arg=None, argval=None, argrepr='', offset=216, start_offset=216, starts_line=True, line_number=20, label=9, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=5, argval=1, argrepr='1', offset=218, start_offset=218, starts_line=True, line_number=21, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=7, argval=0, argrepr='0', offset=220, start_offset=220, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), + Instruction(opname='BINARY_OP', opcode=43, arg=11, argval=11, argrepr='/', offset=222, start_offset=222, starts_line=False, line_number=21, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=226, start_offset=226, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=228, start_offset=228, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=59, arg=1, argval=1, argrepr='', offset=230, start_offset=230, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_SPECIAL', opcode=91, arg=1, argval=1, argrepr='__exit__', offset=232, start_offset=232, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='SWAP', opcode=114, arg=2, argval=2, argrepr='', offset=234, start_offset=234, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='SWAP', opcode=114, arg=3, argval=3, argrepr='', offset=236, start_offset=236, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_SPECIAL', opcode=91, arg=0, argval=0, argrepr='__enter__', offset=238, start_offset=238, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=0, argval=0, argrepr='', offset=240, start_offset=240, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='STORE_FAST', opcode=109, arg=1, argval='dodgy', argrepr='dodgy', offset=248, start_offset=248, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=250, start_offset=250, starts_line=True, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=8, argval='Never reach this', argrepr="'Never reach this'", offset=260, start_offset=260, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=262, start_offset=262, starts_line=False, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=270, start_offset=270, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=0, argval=None, argrepr='None', offset=272, start_offset=272, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=0, argval=None, argrepr='None', offset=274, start_offset=274, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=81, arg=0, argval=None, argrepr='None', offset=276, start_offset=276, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=3, argval=3, argrepr='', offset=278, start_offset=278, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=286, start_offset=286, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=288, start_offset=288, starts_line=True, line_number=28, label=10, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=298, start_offset=298, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=300, start_offset=300, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=308, start_offset=308, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_CONST', opcode=102, arg=0, argval=None, argrepr='None', offset=310, start_offset=310, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='PUSH_EXC_INFO', opcode=31, arg=None, argval=None, argrepr='', offset=312, start_offset=312, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='WITH_EXCEPT_START', opcode=42, arg=None, argval=None, argrepr='', offset=314, start_offset=314, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='TO_BOOL', opcode=38, arg=None, argval=None, argrepr='', offset=316, start_offset=316, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_JUMP_IF_TRUE', opcode=99, arg=1, argval=330, argrepr='to L11', offset=324, start_offset=324, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='RERAISE', opcode=101, arg=2, argval=2, argrepr='', offset=328, start_offset=328, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=330, start_offset=330, starts_line=False, line_number=25, label=11, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=332, start_offset=332, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=334, start_offset=334, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=336, start_offset=336, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=338, start_offset=338, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=75, arg=27, argval=288, argrepr='to L10', offset=340, start_offset=340, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=59, arg=3, argval=3, argrepr='', offset=342, start_offset=342, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=344, start_offset=344, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=101, arg=1, argval=1, argrepr='', offset=346, start_offset=346, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='PUSH_EXC_INFO', opcode=31, arg=None, argval=None, argrepr='', offset=348, start_offset=348, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=4, argval='ZeroDivisionError', argrepr='ZeroDivisionError', offset=350, start_offset=350, starts_line=True, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='CHECK_EXC_MATCH', opcode=6, arg=None, argval=None, argrepr='', offset=360, start_offset=360, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=14, argval=394, argrepr='to L12', offset=362, start_offset=362, starts_line=False, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=366, start_offset=366, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=368, start_offset=368, starts_line=True, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=9, argval='Here we go, here we go, here we go...', argrepr="'Here we go, here we go, here we go...'", offset=378, start_offset=378, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=380, start_offset=380, starts_line=False, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=388, start_offset=388, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=390, start_offset=390, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=75, arg=53, argval=288, argrepr='to L10', offset=392, start_offset=392, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=101, arg=0, argval=0, argrepr='', offset=394, start_offset=394, starts_line=True, line_number=22, label=12, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=59, arg=3, argval=3, argrepr='', offset=396, start_offset=396, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=398, start_offset=398, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=101, arg=1, argval=1, argrepr='', offset=400, start_offset=400, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='PUSH_EXC_INFO', opcode=31, arg=None, argval=None, argrepr='', offset=402, start_offset=402, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=404, start_offset=404, starts_line=True, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=81, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=414, start_offset=414, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=416, start_offset=416, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=424, start_offset=424, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=101, arg=0, argval=0, argrepr='', offset=426, start_offset=426, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=59, arg=3, argval=3, argrepr='', offset=428, start_offset=428, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=430, start_offset=430, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=101, arg=1, argval=1, argrepr='', offset=432, start_offset=432, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), ] # One last piece of inspect fodder to check the default line number handling def simple(): pass expected_opinfo_simple = [ Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=simple.__code__.co_firstlineno, label=None, positions=None), - Instruction(opname='RETURN_CONST', opcode=100, arg=0, argval=None, argrepr='None', offset=2, start_offset=2, starts_line=False, line_number=simple.__code__.co_firstlineno, label=None), + Instruction(opname='RETURN_CONST', opcode=102, arg=0, argval=None, argrepr='None', offset=2, start_offset=2, starts_line=False, line_number=simple.__code__.co_firstlineno, label=None), ] From 560e9570be14e7af7d7e118483850e5b9e70bca8 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 12:02:56 +0200 Subject: [PATCH 12/88] Fix test_fstring --- Grammar/python.gram | 6 ++++-- Lib/test/test_fstring.py | 1 - Parser/parser.c | 4 ++-- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 11bf97a1410606..702cea80bc4bed 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -1462,8 +1462,10 @@ invalid_replacement_field: TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } invalid_conversion_character: - | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: missing conversion character") } - | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: invalid conversion character") } + | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: missing conversion character", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: invalid conversion character", + TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } invalid_arithmetic: | sum ('+'|'-'|'*'|'/'|'%'|'//'|'@') a='not' b=inversion { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "'not' after an operator must be parenthesized") } diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py index c359f2ecce01f1..72724e9c612bc5 100644 --- a/Lib/test/test_fstring.py +++ b/Lib/test/test_fstring.py @@ -1346,7 +1346,6 @@ def test_conversions(self): self.assertAllRaise(SyntaxError, "f-string: expecting '}'", ["f'{3!'", "f'{3!s'", - "f'{3!g'", ]) self.assertAllRaise(SyntaxError, 'f-string: missing conversion character', diff --git a/Parser/parser.c b/Parser/parser.c index 9f256f446e15ff..b5bc2fc8c01eab 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -25400,7 +25400,7 @@ invalid_conversion_character_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: missing conversion character" ); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: missing conversion character" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25426,7 +25426,7 @@ invalid_conversion_character_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: invalid conversion character" ); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: invalid conversion character" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; From 4d172c2d8d50f73b89a4725412d51ee5c92ee67a Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 12:39:13 +0200 Subject: [PATCH 13/88] Fix test_embed --- Objects/interpolationobject.c | 9 +++------ Programs/test_frozenmain.h | 22 +++++++++++----------- 2 files changed, 14 insertions(+), 17 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index d77cf68adc6fca..3de0114f8582bf 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -124,6 +124,7 @@ static PyObject * _get_match_args(void) { PyObject *value = NULL, *expr = NULL, *conv = NULL, *format_spec = NULL; + PyObject *tuple = NULL; value = PyUnicode_FromString("value"); if (!value) { @@ -142,18 +143,14 @@ _get_match_args(void) goto error; } - PyObject *tuple = PyTuple_Pack(4, value, expr, conv, format_spec); - if (!tuple) { - goto error; - } - return tuple; + tuple = PyTuple_Pack(4, value, expr, conv, format_spec); error: Py_XDECREF(value); Py_XDECREF(expr); Py_XDECREF(conv); Py_XDECREF(format_spec); - return NULL; + return tuple; } diff --git a/Programs/test_frozenmain.h b/Programs/test_frozenmain.h index 624d9c0b653ad7..55d05b94ea666a 100644 --- a/Programs/test_frozenmain.h +++ b/Programs/test_frozenmain.h @@ -1,17 +1,17 @@ // 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,8,0,0, - 0,0,0,0,0,243,166,0,0,0,149,0,79,0,79,1, - 70,0,111,0,79,0,79,1,70,1,111,1,88,2,31,0, - 79,2,49,1,0,0,0,0,0,0,29,0,88,2,31,0, - 79,3,88,0,77,6,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,49,2,0,0,0,0,0,0, - 29,0,88,1,77,8,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,31,0,49,0,0,0,0,0, - 0,0,79,4,2,0,0,0,111,5,79,5,16,0,67,20, - 0,0,111,6,88,2,31,0,79,6,88,6,12,0,79,7, - 88,5,88,6,2,0,0,0,12,0,47,4,49,1,0,0, - 0,0,0,0,29,0,72,22,0,0,9,0,29,0,100,1, + 0,0,0,0,0,243,166,0,0,0,149,0,81,0,81,1, + 72,0,113,0,81,0,81,1,72,1,113,1,90,2,32,0, + 81,2,51,1,0,0,0,0,0,0,30,0,90,2,32,0, + 81,3,90,0,79,6,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,51,2,0,0,0,0,0,0, + 30,0,90,1,79,8,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,32,0,51,0,0,0,0,0, + 0,0,81,4,2,0,0,0,113,5,81,5,18,0,69,20, + 0,0,113,6,90,2,32,0,81,6,90,6,13,0,81,7, + 90,5,90,6,2,0,0,0,13,0,48,4,51,1,0,0, + 0,0,0,0,30,0,74,22,0,0,10,0,30,0,102,1, 41,8,233,0,0,0,0,78,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,41,5, From c9362e35aee202a391a7f513f9b91dfe52d209f2 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Oct 2024 20:15:53 +0200 Subject: [PATCH 14/88] Implement interleaving, hash functions and *args __init__ --- Objects/interpolationobject.c | 14 ++++++ Objects/templateobject.c | 86 +++++++++++++++++++++++++++++++---- 2 files changed, 90 insertions(+), 10 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 3de0114f8582bf..3f02a1d9b73c22 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -98,6 +98,19 @@ interpolation_compare(interpolationobject *self, PyObject *other, int op) return PyBool_FromLong(op == Py_EQ ? eq : !eq); } +static Py_hash_t +interpolation_hash(interpolationobject *self) +{ + PyObject *tuple = PyTuple_Pack(4, self->value, self->expr, self->conv, self->format_spec); + if (!tuple) { + return -1; + } + + Py_hash_t hash = PyObject_Hash(tuple); + Py_DECREF(tuple); + return hash; +} + static PyMemberDef interpolation_members[] = { {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"}, {"expr", Py_T_OBJECT_EX, offsetof(interpolationobject, expr), Py_READONLY, "Expr"}, @@ -117,6 +130,7 @@ PyTypeObject _PyInterpolation_Type = { .tp_dealloc = (destructor) interpolation_dealloc, .tp_repr = (reprfunc) interpolation_repr, .tp_richcompare = (richcmpfunc) interpolation_compare, + .tp_hash = (hashfunc) interpolation_hash, .tp_members = interpolation_members, }; diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 7b5ee99bc4d152..1a5da9a7ce809d 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -2,7 +2,11 @@ #include "Python.h" #include +#include "pycore_global_objects.h" // _Py_STR +#include "pycore_runtime.h" // _Py_STR + #include "pycore_template.h" +#include "pycore_interpolation.h" typedef struct { PyObject_HEAD @@ -17,16 +21,71 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return NULL; } - static char *kwlist[] = {"args", NULL}; - PyObject *selfargs; - - if (PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, - &selfargs) < 0) { - Py_DECREF(self); + Py_ssize_t argslen = PyTuple_GET_SIZE(args); + Py_ssize_t interleaved_len = 0; + int last_was_str = 0; + + for (Py_ssize_t i = 0; i < argslen; i++) { + PyObject *item = PyTuple_GET_ITEM(args, i); + if (PyUnicode_Check(item)) { + if (!last_was_str) { + interleaved_len++; + } + last_was_str = 1; + } + else if (PyObject_TypeCheck(item, &_PyInterpolation_Type)) { + if (!last_was_str) { + interleaved_len++; + } + interleaved_len++; + last_was_str = 0; + } + else { + PyErr_SetString(PyExc_TypeError, "Template items need to be of type 'str' or 'Interpolation'"); + return NULL; + } + } + if (!last_was_str) { + interleaved_len++; + } + + PyObject *interleaved = PyTuple_New(interleaved_len); + if (!interleaved) { return NULL; } - Py_XSETREF(self->args, Py_NewRef(selfargs)); + last_was_str = 0; + Py_ssize_t j = 0; + for (Py_ssize_t i = 0; i < argslen; i++) { + PyObject *item = PyTuple_GET_ITEM(args, i); + if (PyUnicode_Check(item)) { + if (last_was_str) { + PyObject *concat = PyUnicode_Concat(PyTuple_GET_ITEM(interleaved, j - 1), item); + if (!concat) { + Py_DECREF(interleaved); + return NULL; + } + PyTuple_SetItem(interleaved, j - 1, concat); + } + else { + PyTuple_SET_ITEM(interleaved, j++, Py_NewRef(item)); + } + last_was_str = 1; + } + else if (PyObject_TypeCheck(item, &_PyInterpolation_Type)) { + if (!last_was_str) { + PyTuple_SET_ITEM(interleaved, j++, &_Py_STR(empty)); + } + PyTuple_SET_ITEM(interleaved, j++, Py_NewRef(item)); + last_was_str = 0; + } + } + if (!last_was_str) { + PyTuple_SET_ITEM(interleaved, j++, &_Py_STR(empty)); + } + + assert(j == interleaved_len); + Py_XSETREF(self->args, interleaved); return self; } @@ -59,6 +118,12 @@ template_compare(templateobject *self, PyObject *other, int op) return PyObject_RichCompare(self->args, ((templateobject *) other)->args, op); } +static Py_hash_t +template_hash(templateobject *self) +{ + return PyObject_Hash(self->args); +} + static PyObject * template_add_template_str(templateobject *template, PyUnicodeObject *str, int templateleft) { @@ -81,7 +146,7 @@ template_add_template_str(templateobject *template, PyUnicodeObject *str, int te PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(str)); } - PyObject *newtemplate = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple); + PyObject *newtemplate = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); Py_DECREF(tuple); return newtemplate; } @@ -105,7 +170,7 @@ template_add_templates(templateobject *self, templateobject *other) PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(PyTuple_GET_ITEM(other->args, j))); } - PyObject *newtemplate = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple); + PyObject *newtemplate = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); Py_DECREF(tuple); return newtemplate; } @@ -149,6 +214,7 @@ PyTypeObject _PyTemplate_Type = { .tp_dealloc = (destructor) template_dealloc, .tp_repr = (reprfunc) template_repr, .tp_richcompare = (richcmpfunc) template_compare, + .tp_hash = (hashfunc) template_hash, .tp_members = template_members, }; @@ -164,7 +230,7 @@ _PyTemplate_Create(PyObject **values, Py_ssize_t oparg) PyTuple_SET_ITEM(tuple, i, Py_NewRef(values[i])); } - PyObject *template = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple); + PyObject *template = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); Py_DECREF(tuple); return template; } From d2bd6736d837a816d2c675fe3e13064a8b8ec7b9 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 25 Oct 2024 10:27:56 +0200 Subject: [PATCH 15/88] Use Argument Clinic for interpolation_new --- .../pycore_global_objects_fini_generated.h | 2 + Include/internal/pycore_global_strings.h | 2 + Include/internal/pycore_interpolation.h | 4 +- .../internal/pycore_runtime_init_generated.h | 2 + .../internal/pycore_unicodeobject_generated.h | 8 ++ Objects/clinic/interpolationobject.c.h | 85 +++++++++++++++++++ Objects/interpolationobject.c | 70 +++++++++++---- 7 files changed, 154 insertions(+), 19 deletions(-) create mode 100644 Objects/clinic/interpolationobject.c.h diff --git a/Include/internal/pycore_global_objects_fini_generated.h b/Include/internal/pycore_global_objects_fini_generated.h index 2fd7d5d13a98b2..7236a418e77c29 100644 --- a/Include/internal/pycore_global_objects_fini_generated.h +++ b/Include/internal/pycore_global_objects_fini_generated.h @@ -867,6 +867,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(consts)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(context)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(contravariant)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(conv)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cookie)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(copy)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(copyreg)); @@ -924,6 +925,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exception)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(existing_file_name)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exp)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(expr)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(extend)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(extra_tokens)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(facility)); diff --git a/Include/internal/pycore_global_strings.h b/Include/internal/pycore_global_strings.h index fc3871570cc49d..b9ebbd23d3ee49 100644 --- a/Include/internal/pycore_global_strings.h +++ b/Include/internal/pycore_global_strings.h @@ -356,6 +356,7 @@ struct _Py_global_strings { STRUCT_FOR_ID(consts) STRUCT_FOR_ID(context) STRUCT_FOR_ID(contravariant) + STRUCT_FOR_ID(conv) STRUCT_FOR_ID(cookie) STRUCT_FOR_ID(copy) STRUCT_FOR_ID(copyreg) @@ -413,6 +414,7 @@ struct _Py_global_strings { STRUCT_FOR_ID(exception) STRUCT_FOR_ID(existing_file_name) STRUCT_FOR_ID(exp) + STRUCT_FOR_ID(expr) STRUCT_FOR_ID(extend) STRUCT_FOR_ID(extra_tokens) STRUCT_FOR_ID(facility) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index cf089ddc8f7063..cc33f7ea6cb675 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -11,11 +11,13 @@ extern "C" { #include "pycore_stackref.h" // _PyStackRef +extern int _conversion_converter(PyObject *arg, PyObject **Py_UNUSED(unused)); + extern PyTypeObject _PyInterpolation_Type; PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); -extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *); +extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); #ifdef __cplusplus } diff --git a/Include/internal/pycore_runtime_init_generated.h b/Include/internal/pycore_runtime_init_generated.h index 3b80e265b0ca50..fedd592d129a1e 100644 --- a/Include/internal/pycore_runtime_init_generated.h +++ b/Include/internal/pycore_runtime_init_generated.h @@ -865,6 +865,7 @@ extern "C" { INIT_ID(consts), \ INIT_ID(context), \ INIT_ID(contravariant), \ + INIT_ID(conv), \ INIT_ID(cookie), \ INIT_ID(copy), \ INIT_ID(copyreg), \ @@ -922,6 +923,7 @@ extern "C" { INIT_ID(exception), \ INIT_ID(existing_file_name), \ INIT_ID(exp), \ + INIT_ID(expr), \ INIT_ID(extend), \ INIT_ID(extra_tokens), \ INIT_ID(facility), \ diff --git a/Include/internal/pycore_unicodeobject_generated.h b/Include/internal/pycore_unicodeobject_generated.h index eb2eca06ec4d4f..a525972d8c4e96 100644 --- a/Include/internal/pycore_unicodeobject_generated.h +++ b/Include/internal/pycore_unicodeobject_generated.h @@ -1220,6 +1220,10 @@ _PyUnicode_InitStaticStrings(PyInterpreterState *interp) { _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(conv); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); string = &_Py_ID(cookie); _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); @@ -1448,6 +1452,10 @@ _PyUnicode_InitStaticStrings(PyInterpreterState *interp) { _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); + string = &_Py_ID(expr); + _PyUnicode_InternStatic(interp, &string); + assert(_PyUnicode_CheckConsistency(string, 1)); + assert(PyUnicode_GET_LENGTH(string) != 1); string = &_Py_ID(extend); _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); diff --git a/Objects/clinic/interpolationobject.c.h b/Objects/clinic/interpolationobject.c.h new file mode 100644 index 00000000000000..da3999df2c4398 --- /dev/null +++ b/Objects/clinic/interpolationobject.c.h @@ -0,0 +1,85 @@ +/*[clinic input] +preserve +[clinic start generated code]*/ + +#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) +# include "pycore_gc.h" // PyGC_Head +# include "pycore_runtime.h" // _Py_ID() +#endif +#include "pycore_modsupport.h" // _PyArg_UnpackKeywords() + +static PyObject * +interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *expr, + PyObject *conv, PyObject *format_spec); + +static PyObject * +interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) +{ + PyObject *return_value = NULL; + #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) + + #define NUM_KEYWORDS 4 + static struct { + PyGC_Head _this_is_not_used; + PyObject_VAR_HEAD + PyObject *ob_item[NUM_KEYWORDS]; + } _kwtuple = { + .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS) + .ob_item = { &_Py_ID(value), &_Py_ID(expr), &_Py_ID(conv), &_Py_ID(format_spec), }, + }; + #undef NUM_KEYWORDS + #define KWTUPLE (&_kwtuple.ob_base.ob_base) + + #else // !Py_BUILD_CORE + # define KWTUPLE NULL + #endif // !Py_BUILD_CORE + + static const char * const _keywords[] = {"value", "expr", "conv", "format_spec", NULL}; + static _PyArg_Parser _parser = { + .keywords = _keywords, + .fname = "Interpolation", + .kwtuple = KWTUPLE, + }; + #undef KWTUPLE + PyObject *argsbuf[4]; + PyObject * const *fastargs; + Py_ssize_t nargs = PyTuple_GET_SIZE(args); + Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 2; + PyObject *value; + PyObject *expr; + PyObject *conv = Py_None; + PyObject *format_spec = &_Py_STR(empty); + + fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 2, 4, 0, argsbuf); + if (!fastargs) { + goto exit; + } + value = fastargs[0]; + if (!PyUnicode_Check(fastargs[1])) { + _PyArg_BadArgument("Interpolation", "argument 'expr'", "str", fastargs[1]); + goto exit; + } + expr = fastargs[1]; + if (!noptargs) { + goto skip_optional_pos; + } + if (fastargs[2]) { + if (!_conversion_converter(fastargs[2], &conv)) { + goto exit; + } + if (!--noptargs) { + goto skip_optional_pos; + } + } + if (!PyUnicode_Check(fastargs[3])) { + _PyArg_BadArgument("Interpolation", "argument 'format_spec'", "str", fastargs[3]); + goto exit; + } + format_spec = fastargs[3]; +skip_optional_pos: + return_value = interpolation_new_impl(type, value, expr, conv, format_spec); + +exit: + return return_value; +} +/*[clinic end generated code: output=1d6fab1d0e07cbad input=a9049054013a1b77]*/ diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 3f02a1d9b73c22..161cc01ad57578 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -9,6 +9,41 @@ #include "pycore_interpolation.h" +/*[clinic input] +module templatelib +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=dbb2236a3de68808]*/ + +#include "clinic/interpolationobject.c.h" + +/*[clinic input] +class templatelib.Interpolation "interpolationobject *" "&_PyInterpolation_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=5b183514b4d7e5af]*/ + +int +_conversion_converter(PyObject *arg, PyObject **Py_UNUSED(unused)) +{ + if (arg == Py_None) { + return 1; + } + + if (!PyUnicode_Check(arg)) { + _PyArg_BadArgument("Interpolation", "argument 'conv'", "str", arg); + return 0; + } + + Py_ssize_t len; + const char *conv = PyUnicode_AsUTF8AndSize(arg, &len); + if (len != 1 || !(conv[0] == 'a' || conv[0] == 'r' || conv[0] == 's')) { + PyErr_SetString(PyExc_ValueError, + "Interpolation() argument 'conv' must be one of 's', 'a' or 'r'"); + return 0; + } + + return 1; +} + typedef struct { PyObject_HEAD PyObject *value; @@ -17,32 +52,31 @@ typedef struct { PyObject *format_spec; } interpolationobject; -static interpolationobject * -interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +/*[clinic input] +@classmethod +templatelib.Interpolation.__new__ as interpolation_new + + value: object + expr: object(subclass_of='&PyUnicode_Type') + conv: object(converter='_conversion_converter') = None + format_spec: object(subclass_of='&PyUnicode_Type', c_default='&_Py_STR(empty)') = "" +[clinic start generated code]*/ + +static PyObject * +interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *expr, + PyObject *conv, PyObject *format_spec) +/*[clinic end generated code: output=417d59bccab99648 input=348d81ee06c4be20]*/ { interpolationobject *self = (interpolationobject *) type->tp_alloc(type, 0); if (!self) { return NULL; } - static char *kwlist[] = {"value", "expr", "conv", "format_spec", NULL}; - - PyObject *value, *expr; - PyObject *conv = NULL; - PyObject *format_spec = NULL; - - if (PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, - &value, &expr, - &conv, &format_spec) < 0) { - Py_DECREF(self); - return NULL; - } - Py_XSETREF(self->value, Py_NewRef(value)); Py_XSETREF(self->expr, Py_NewRef(expr)); - Py_XSETREF(self->conv, Py_NewRef(conv ? conv : Py_None)); - Py_XSETREF(self->format_spec, format_spec ? Py_NewRef(format_spec) : &_Py_STR(empty)); - return self; + Py_XSETREF(self->conv, Py_NewRef(conv)); + Py_XSETREF(self->format_spec, Py_NewRef(format_spec)); + return (PyObject *) self; } static void From 7ae1b60e248ec92793f51f74f8721ab871d51ba7 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 25 Oct 2024 10:43:10 +0200 Subject: [PATCH 16/88] Revert to using different grammar rules for tstring due to format_spec --- Grammar/python.gram | 12 +- Parser/parser.c | 2478 +++++++++++++++++++++++-------------------- Python/codegen.c | 5 - 3 files changed, 1364 insertions(+), 1131 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 702cea80bc4bed..928a10040c4aa7 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -916,8 +916,7 @@ fstring_middle[expr_ty]: | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } fstring_replacement_field[expr_ty]: | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { - (TOK_GET_MODE(p->tok)->tstring ? _PyPegen_interpolation : _PyPegen_formatted_value)( - p, a, debug_expr, conversion, format, rbrace, EXTRA) } + _PyPegen_formatted_value(p, a, debug_expr, conversion, format, rbrace, EXTRA) } | invalid_replacement_field fstring_conversion[ResultTokenWithMetadata*]: | conv_token="!" conv=NAME { _PyPegen_check_fstring_conversion(p, conv_token, conv) } @@ -929,8 +928,15 @@ fstring_format_spec[expr_ty]: fstring[expr_ty]: | a=FSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_joined_str(p, a, (asdl_expr_seq*)b, c) } +tstring_replacement_field[expr_ty]: + | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { + _PyPegen_interpolation(p, a, debug_expr, conversion, format, rbrace, EXTRA) } + | invalid_replacement_field +tstring_middle[expr_ty]: + | tstring_replacement_field + | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } tstring[expr_ty] (memo): - | a=TSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } + | a=TSTRING_START b=tstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) } strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string)+ { _PyPegen_concatenate_strings(p, a, EXTRA) } diff --git a/Parser/parser.c b/Parser/parser.c index b5bc2fc8c01eab..452314887c0e28 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -243,270 +243,273 @@ static char *soft_keywords[] = { #define fstring_full_format_spec_type 1156 #define fstring_format_spec_type 1157 #define fstring_type 1158 -#define tstring_type 1159 -#define string_type 1160 -#define strings_type 1161 -#define list_type 1162 -#define tuple_type 1163 -#define set_type 1164 -#define dict_type 1165 -#define double_starred_kvpairs_type 1166 -#define double_starred_kvpair_type 1167 -#define kvpair_type 1168 -#define for_if_clauses_type 1169 -#define for_if_clause_type 1170 -#define listcomp_type 1171 -#define setcomp_type 1172 -#define genexp_type 1173 -#define dictcomp_type 1174 -#define arguments_type 1175 -#define args_type 1176 -#define kwargs_type 1177 -#define starred_expression_type 1178 -#define kwarg_or_starred_type 1179 -#define kwarg_or_double_starred_type 1180 -#define star_targets_type 1181 -#define star_targets_list_seq_type 1182 -#define star_targets_tuple_seq_type 1183 -#define star_target_type 1184 -#define target_with_star_atom_type 1185 -#define star_atom_type 1186 -#define single_target_type 1187 -#define single_subscript_attribute_target_type 1188 -#define t_primary_type 1189 // Left-recursive -#define t_lookahead_type 1190 -#define del_targets_type 1191 -#define del_target_type 1192 -#define del_t_atom_type 1193 -#define type_expressions_type 1194 -#define func_type_comment_type 1195 -#define invalid_arguments_type 1196 -#define invalid_kwarg_type 1197 -#define expression_without_invalid_type 1198 -#define invalid_legacy_expression_type 1199 -#define invalid_type_param_type 1200 -#define invalid_expression_type 1201 -#define invalid_named_expression_type 1202 -#define invalid_assignment_type 1203 -#define invalid_ann_assign_target_type 1204 -#define invalid_del_stmt_type 1205 -#define invalid_block_type 1206 -#define invalid_comprehension_type 1207 -#define invalid_dict_comprehension_type 1208 -#define invalid_parameters_type 1209 -#define invalid_default_type 1210 -#define invalid_star_etc_type 1211 -#define invalid_kwds_type 1212 -#define invalid_parameters_helper_type 1213 -#define invalid_lambda_parameters_type 1214 -#define invalid_lambda_parameters_helper_type 1215 -#define invalid_lambda_star_etc_type 1216 -#define invalid_lambda_kwds_type 1217 -#define invalid_double_type_comments_type 1218 -#define invalid_with_item_type 1219 -#define invalid_for_if_clause_type 1220 -#define invalid_for_target_type 1221 -#define invalid_group_type 1222 -#define invalid_import_type 1223 -#define invalid_import_from_targets_type 1224 -#define invalid_with_stmt_type 1225 -#define invalid_with_stmt_indent_type 1226 -#define invalid_try_stmt_type 1227 -#define invalid_except_stmt_type 1228 -#define invalid_except_star_stmt_type 1229 -#define invalid_finally_stmt_type 1230 -#define invalid_except_stmt_indent_type 1231 -#define invalid_except_star_stmt_indent_type 1232 -#define invalid_match_stmt_type 1233 -#define invalid_case_block_type 1234 -#define invalid_as_pattern_type 1235 -#define invalid_class_pattern_type 1236 -#define invalid_class_argument_pattern_type 1237 -#define invalid_if_stmt_type 1238 -#define invalid_elif_stmt_type 1239 -#define invalid_else_stmt_type 1240 -#define invalid_while_stmt_type 1241 -#define invalid_for_stmt_type 1242 -#define invalid_def_raw_type 1243 -#define invalid_class_def_raw_type 1244 -#define invalid_double_starred_kvpairs_type 1245 -#define invalid_kvpair_type 1246 -#define invalid_starred_expression_unpacking_type 1247 -#define invalid_starred_expression_type 1248 -#define invalid_replacement_field_type 1249 -#define invalid_conversion_character_type 1250 -#define invalid_arithmetic_type 1251 -#define invalid_factor_type 1252 -#define invalid_type_params_type 1253 -#define _loop0_1_type 1254 -#define _loop1_2_type 1255 -#define _loop0_3_type 1256 -#define _gather_4_type 1257 -#define _tmp_5_type 1258 -#define _tmp_6_type 1259 -#define _tmp_7_type 1260 -#define _tmp_8_type 1261 -#define _tmp_9_type 1262 -#define _tmp_10_type 1263 -#define _tmp_11_type 1264 -#define _loop1_12_type 1265 -#define _tmp_13_type 1266 -#define _loop0_14_type 1267 -#define _gather_15_type 1268 -#define _tmp_16_type 1269 -#define _tmp_17_type 1270 -#define _loop0_18_type 1271 -#define _loop1_19_type 1272 -#define _loop0_20_type 1273 -#define _gather_21_type 1274 -#define _tmp_22_type 1275 -#define _loop0_23_type 1276 -#define _gather_24_type 1277 -#define _loop1_25_type 1278 -#define _tmp_26_type 1279 -#define _tmp_27_type 1280 -#define _loop0_28_type 1281 -#define _loop0_29_type 1282 -#define _loop1_30_type 1283 -#define _loop1_31_type 1284 -#define _loop0_32_type 1285 -#define _loop1_33_type 1286 -#define _loop0_34_type 1287 -#define _gather_35_type 1288 -#define _tmp_36_type 1289 -#define _loop1_37_type 1290 -#define _loop1_38_type 1291 -#define _loop1_39_type 1292 -#define _loop0_40_type 1293 -#define _gather_41_type 1294 -#define _tmp_42_type 1295 -#define _tmp_43_type 1296 -#define _tmp_44_type 1297 -#define _loop0_45_type 1298 -#define _gather_46_type 1299 -#define _loop0_47_type 1300 -#define _gather_48_type 1301 -#define _tmp_49_type 1302 -#define _loop0_50_type 1303 -#define _gather_51_type 1304 -#define _loop0_52_type 1305 -#define _gather_53_type 1306 -#define _loop0_54_type 1307 -#define _gather_55_type 1308 -#define _loop1_56_type 1309 -#define _loop1_57_type 1310 -#define _loop0_58_type 1311 -#define _gather_59_type 1312 -#define _loop1_60_type 1313 -#define _loop1_61_type 1314 -#define _loop1_62_type 1315 -#define _tmp_63_type 1316 -#define _loop0_64_type 1317 -#define _gather_65_type 1318 -#define _tmp_66_type 1319 -#define _tmp_67_type 1320 -#define _tmp_68_type 1321 -#define _tmp_69_type 1322 -#define _tmp_70_type 1323 -#define _loop0_71_type 1324 -#define _loop0_72_type 1325 -#define _loop1_73_type 1326 -#define _loop1_74_type 1327 -#define _loop0_75_type 1328 -#define _loop1_76_type 1329 -#define _loop0_77_type 1330 -#define _loop0_78_type 1331 -#define _loop1_79_type 1332 -#define _tmp_80_type 1333 -#define _loop0_81_type 1334 -#define _gather_82_type 1335 -#define _loop1_83_type 1336 -#define _loop0_84_type 1337 -#define _tmp_85_type 1338 -#define _loop0_86_type 1339 -#define _gather_87_type 1340 -#define _tmp_88_type 1341 -#define _loop0_89_type 1342 -#define _gather_90_type 1343 -#define _loop0_91_type 1344 -#define _gather_92_type 1345 -#define _loop0_93_type 1346 -#define _loop0_94_type 1347 -#define _gather_95_type 1348 -#define _loop1_96_type 1349 -#define _tmp_97_type 1350 -#define _loop0_98_type 1351 -#define _gather_99_type 1352 -#define _loop0_100_type 1353 -#define _gather_101_type 1354 -#define _tmp_102_type 1355 -#define _tmp_103_type 1356 -#define _loop0_104_type 1357 -#define _gather_105_type 1358 -#define _tmp_106_type 1359 -#define _tmp_107_type 1360 -#define _tmp_108_type 1361 -#define _tmp_109_type 1362 -#define _tmp_110_type 1363 -#define _tmp_111_type 1364 -#define _tmp_112_type 1365 -#define _tmp_113_type 1366 -#define _tmp_114_type 1367 -#define _loop0_115_type 1368 -#define _loop0_116_type 1369 -#define _tmp_117_type 1370 -#define _tmp_118_type 1371 -#define _tmp_119_type 1372 -#define _tmp_120_type 1373 -#define _tmp_121_type 1374 -#define _tmp_122_type 1375 -#define _tmp_123_type 1376 -#define _tmp_124_type 1377 -#define _tmp_125_type 1378 -#define _loop0_126_type 1379 -#define _gather_127_type 1380 -#define _tmp_128_type 1381 -#define _tmp_129_type 1382 -#define _tmp_130_type 1383 -#define _tmp_131_type 1384 -#define _loop0_132_type 1385 -#define _gather_133_type 1386 -#define _loop0_134_type 1387 -#define _gather_135_type 1388 -#define _loop0_136_type 1389 -#define _gather_137_type 1390 -#define _tmp_138_type 1391 -#define _loop0_139_type 1392 -#define _tmp_140_type 1393 -#define _tmp_141_type 1394 -#define _tmp_142_type 1395 -#define _tmp_143_type 1396 -#define _tmp_144_type 1397 -#define _tmp_145_type 1398 -#define _tmp_146_type 1399 -#define _tmp_147_type 1400 -#define _tmp_148_type 1401 -#define _tmp_149_type 1402 -#define _tmp_150_type 1403 -#define _tmp_151_type 1404 -#define _tmp_152_type 1405 -#define _tmp_153_type 1406 -#define _tmp_154_type 1407 -#define _tmp_155_type 1408 -#define _tmp_156_type 1409 -#define _tmp_157_type 1410 -#define _tmp_158_type 1411 -#define _tmp_159_type 1412 -#define _tmp_160_type 1413 -#define _tmp_161_type 1414 -#define _tmp_162_type 1415 -#define _tmp_163_type 1416 -#define _tmp_164_type 1417 -#define _loop0_165_type 1418 -#define _tmp_166_type 1419 -#define _tmp_167_type 1420 -#define _tmp_168_type 1421 -#define _tmp_169_type 1422 +#define tstring_replacement_field_type 1159 +#define tstring_middle_type 1160 +#define tstring_type 1161 +#define string_type 1162 +#define strings_type 1163 +#define list_type 1164 +#define tuple_type 1165 +#define set_type 1166 +#define dict_type 1167 +#define double_starred_kvpairs_type 1168 +#define double_starred_kvpair_type 1169 +#define kvpair_type 1170 +#define for_if_clauses_type 1171 +#define for_if_clause_type 1172 +#define listcomp_type 1173 +#define setcomp_type 1174 +#define genexp_type 1175 +#define dictcomp_type 1176 +#define arguments_type 1177 +#define args_type 1178 +#define kwargs_type 1179 +#define starred_expression_type 1180 +#define kwarg_or_starred_type 1181 +#define kwarg_or_double_starred_type 1182 +#define star_targets_type 1183 +#define star_targets_list_seq_type 1184 +#define star_targets_tuple_seq_type 1185 +#define star_target_type 1186 +#define target_with_star_atom_type 1187 +#define star_atom_type 1188 +#define single_target_type 1189 +#define single_subscript_attribute_target_type 1190 +#define t_primary_type 1191 // Left-recursive +#define t_lookahead_type 1192 +#define del_targets_type 1193 +#define del_target_type 1194 +#define del_t_atom_type 1195 +#define type_expressions_type 1196 +#define func_type_comment_type 1197 +#define invalid_arguments_type 1198 +#define invalid_kwarg_type 1199 +#define expression_without_invalid_type 1200 +#define invalid_legacy_expression_type 1201 +#define invalid_type_param_type 1202 +#define invalid_expression_type 1203 +#define invalid_named_expression_type 1204 +#define invalid_assignment_type 1205 +#define invalid_ann_assign_target_type 1206 +#define invalid_del_stmt_type 1207 +#define invalid_block_type 1208 +#define invalid_comprehension_type 1209 +#define invalid_dict_comprehension_type 1210 +#define invalid_parameters_type 1211 +#define invalid_default_type 1212 +#define invalid_star_etc_type 1213 +#define invalid_kwds_type 1214 +#define invalid_parameters_helper_type 1215 +#define invalid_lambda_parameters_type 1216 +#define invalid_lambda_parameters_helper_type 1217 +#define invalid_lambda_star_etc_type 1218 +#define invalid_lambda_kwds_type 1219 +#define invalid_double_type_comments_type 1220 +#define invalid_with_item_type 1221 +#define invalid_for_if_clause_type 1222 +#define invalid_for_target_type 1223 +#define invalid_group_type 1224 +#define invalid_import_type 1225 +#define invalid_import_from_targets_type 1226 +#define invalid_with_stmt_type 1227 +#define invalid_with_stmt_indent_type 1228 +#define invalid_try_stmt_type 1229 +#define invalid_except_stmt_type 1230 +#define invalid_except_star_stmt_type 1231 +#define invalid_finally_stmt_type 1232 +#define invalid_except_stmt_indent_type 1233 +#define invalid_except_star_stmt_indent_type 1234 +#define invalid_match_stmt_type 1235 +#define invalid_case_block_type 1236 +#define invalid_as_pattern_type 1237 +#define invalid_class_pattern_type 1238 +#define invalid_class_argument_pattern_type 1239 +#define invalid_if_stmt_type 1240 +#define invalid_elif_stmt_type 1241 +#define invalid_else_stmt_type 1242 +#define invalid_while_stmt_type 1243 +#define invalid_for_stmt_type 1244 +#define invalid_def_raw_type 1245 +#define invalid_class_def_raw_type 1246 +#define invalid_double_starred_kvpairs_type 1247 +#define invalid_kvpair_type 1248 +#define invalid_starred_expression_unpacking_type 1249 +#define invalid_starred_expression_type 1250 +#define invalid_replacement_field_type 1251 +#define invalid_conversion_character_type 1252 +#define invalid_arithmetic_type 1253 +#define invalid_factor_type 1254 +#define invalid_type_params_type 1255 +#define _loop0_1_type 1256 +#define _loop1_2_type 1257 +#define _loop0_3_type 1258 +#define _gather_4_type 1259 +#define _tmp_5_type 1260 +#define _tmp_6_type 1261 +#define _tmp_7_type 1262 +#define _tmp_8_type 1263 +#define _tmp_9_type 1264 +#define _tmp_10_type 1265 +#define _tmp_11_type 1266 +#define _loop1_12_type 1267 +#define _tmp_13_type 1268 +#define _loop0_14_type 1269 +#define _gather_15_type 1270 +#define _tmp_16_type 1271 +#define _tmp_17_type 1272 +#define _loop0_18_type 1273 +#define _loop1_19_type 1274 +#define _loop0_20_type 1275 +#define _gather_21_type 1276 +#define _tmp_22_type 1277 +#define _loop0_23_type 1278 +#define _gather_24_type 1279 +#define _loop1_25_type 1280 +#define _tmp_26_type 1281 +#define _tmp_27_type 1282 +#define _loop0_28_type 1283 +#define _loop0_29_type 1284 +#define _loop1_30_type 1285 +#define _loop1_31_type 1286 +#define _loop0_32_type 1287 +#define _loop1_33_type 1288 +#define _loop0_34_type 1289 +#define _gather_35_type 1290 +#define _tmp_36_type 1291 +#define _loop1_37_type 1292 +#define _loop1_38_type 1293 +#define _loop1_39_type 1294 +#define _loop0_40_type 1295 +#define _gather_41_type 1296 +#define _tmp_42_type 1297 +#define _tmp_43_type 1298 +#define _tmp_44_type 1299 +#define _loop0_45_type 1300 +#define _gather_46_type 1301 +#define _loop0_47_type 1302 +#define _gather_48_type 1303 +#define _tmp_49_type 1304 +#define _loop0_50_type 1305 +#define _gather_51_type 1306 +#define _loop0_52_type 1307 +#define _gather_53_type 1308 +#define _loop0_54_type 1309 +#define _gather_55_type 1310 +#define _loop1_56_type 1311 +#define _loop1_57_type 1312 +#define _loop0_58_type 1313 +#define _gather_59_type 1314 +#define _loop1_60_type 1315 +#define _loop1_61_type 1316 +#define _loop1_62_type 1317 +#define _tmp_63_type 1318 +#define _loop0_64_type 1319 +#define _gather_65_type 1320 +#define _tmp_66_type 1321 +#define _tmp_67_type 1322 +#define _tmp_68_type 1323 +#define _tmp_69_type 1324 +#define _tmp_70_type 1325 +#define _loop0_71_type 1326 +#define _loop0_72_type 1327 +#define _loop1_73_type 1328 +#define _loop1_74_type 1329 +#define _loop0_75_type 1330 +#define _loop1_76_type 1331 +#define _loop0_77_type 1332 +#define _loop0_78_type 1333 +#define _loop0_79_type 1334 +#define _loop1_80_type 1335 +#define _tmp_81_type 1336 +#define _loop0_82_type 1337 +#define _gather_83_type 1338 +#define _loop1_84_type 1339 +#define _loop0_85_type 1340 +#define _tmp_86_type 1341 +#define _loop0_87_type 1342 +#define _gather_88_type 1343 +#define _tmp_89_type 1344 +#define _loop0_90_type 1345 +#define _gather_91_type 1346 +#define _loop0_92_type 1347 +#define _gather_93_type 1348 +#define _loop0_94_type 1349 +#define _loop0_95_type 1350 +#define _gather_96_type 1351 +#define _loop1_97_type 1352 +#define _tmp_98_type 1353 +#define _loop0_99_type 1354 +#define _gather_100_type 1355 +#define _loop0_101_type 1356 +#define _gather_102_type 1357 +#define _tmp_103_type 1358 +#define _tmp_104_type 1359 +#define _loop0_105_type 1360 +#define _gather_106_type 1361 +#define _tmp_107_type 1362 +#define _tmp_108_type 1363 +#define _tmp_109_type 1364 +#define _tmp_110_type 1365 +#define _tmp_111_type 1366 +#define _tmp_112_type 1367 +#define _tmp_113_type 1368 +#define _tmp_114_type 1369 +#define _tmp_115_type 1370 +#define _loop0_116_type 1371 +#define _loop0_117_type 1372 +#define _tmp_118_type 1373 +#define _tmp_119_type 1374 +#define _tmp_120_type 1375 +#define _tmp_121_type 1376 +#define _tmp_122_type 1377 +#define _tmp_123_type 1378 +#define _tmp_124_type 1379 +#define _tmp_125_type 1380 +#define _tmp_126_type 1381 +#define _loop0_127_type 1382 +#define _gather_128_type 1383 +#define _tmp_129_type 1384 +#define _tmp_130_type 1385 +#define _tmp_131_type 1386 +#define _tmp_132_type 1387 +#define _loop0_133_type 1388 +#define _gather_134_type 1389 +#define _loop0_135_type 1390 +#define _gather_136_type 1391 +#define _loop0_137_type 1392 +#define _gather_138_type 1393 +#define _tmp_139_type 1394 +#define _loop0_140_type 1395 +#define _tmp_141_type 1396 +#define _tmp_142_type 1397 +#define _tmp_143_type 1398 +#define _tmp_144_type 1399 +#define _tmp_145_type 1400 +#define _tmp_146_type 1401 +#define _tmp_147_type 1402 +#define _tmp_148_type 1403 +#define _tmp_149_type 1404 +#define _tmp_150_type 1405 +#define _tmp_151_type 1406 +#define _tmp_152_type 1407 +#define _tmp_153_type 1408 +#define _tmp_154_type 1409 +#define _tmp_155_type 1410 +#define _tmp_156_type 1411 +#define _tmp_157_type 1412 +#define _tmp_158_type 1413 +#define _tmp_159_type 1414 +#define _tmp_160_type 1415 +#define _tmp_161_type 1416 +#define _tmp_162_type 1417 +#define _tmp_163_type 1418 +#define _tmp_164_type 1419 +#define _tmp_165_type 1420 +#define _loop0_166_type 1421 +#define _tmp_167_type 1422 +#define _tmp_168_type 1423 +#define _tmp_169_type 1424 +#define _tmp_170_type 1425 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -667,6 +670,8 @@ static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p); static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p); static expr_ty fstring_format_spec_rule(Parser *p); static expr_ty fstring_rule(Parser *p); +static expr_ty tstring_replacement_field_rule(Parser *p); +static expr_ty tstring_middle_rule(Parser *p); static expr_ty tstring_rule(Parser *p); static expr_ty string_rule(Parser *p); static expr_ty strings_rule(Parser *p); @@ -840,34 +845,34 @@ static asdl_seq *_loop0_75_rule(Parser *p); static asdl_seq *_loop1_76_rule(Parser *p); static asdl_seq *_loop0_77_rule(Parser *p); static asdl_seq *_loop0_78_rule(Parser *p); -static asdl_seq *_loop1_79_rule(Parser *p); -static void *_tmp_80_rule(Parser *p); -static asdl_seq *_loop0_81_rule(Parser *p); -static asdl_seq *_gather_82_rule(Parser *p); -static asdl_seq *_loop1_83_rule(Parser *p); -static asdl_seq *_loop0_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 void *_tmp_88_rule(Parser *p); -static asdl_seq *_loop0_89_rule(Parser *p); -static asdl_seq *_gather_90_rule(Parser *p); -static asdl_seq *_loop0_91_rule(Parser *p); -static asdl_seq *_gather_92_rule(Parser *p); -static asdl_seq *_loop0_93_rule(Parser *p); +static asdl_seq *_loop0_79_rule(Parser *p); +static asdl_seq *_loop1_80_rule(Parser *p); +static void *_tmp_81_rule(Parser *p); +static asdl_seq *_loop0_82_rule(Parser *p); +static asdl_seq *_gather_83_rule(Parser *p); +static asdl_seq *_loop1_84_rule(Parser *p); +static asdl_seq *_loop0_85_rule(Parser *p); +static void *_tmp_86_rule(Parser *p); +static asdl_seq *_loop0_87_rule(Parser *p); +static asdl_seq *_gather_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 asdl_seq *_loop0_92_rule(Parser *p); +static asdl_seq *_gather_93_rule(Parser *p); static asdl_seq *_loop0_94_rule(Parser *p); -static asdl_seq *_gather_95_rule(Parser *p); -static asdl_seq *_loop1_96_rule(Parser *p); -static void *_tmp_97_rule(Parser *p); -static asdl_seq *_loop0_98_rule(Parser *p); -static asdl_seq *_gather_99_rule(Parser *p); -static asdl_seq *_loop0_100_rule(Parser *p); -static asdl_seq *_gather_101_rule(Parser *p); -static void *_tmp_102_rule(Parser *p); +static asdl_seq *_loop0_95_rule(Parser *p); +static asdl_seq *_gather_96_rule(Parser *p); +static asdl_seq *_loop1_97_rule(Parser *p); +static void *_tmp_98_rule(Parser *p); +static asdl_seq *_loop0_99_rule(Parser *p); +static asdl_seq *_gather_100_rule(Parser *p); +static asdl_seq *_loop0_101_rule(Parser *p); +static asdl_seq *_gather_102_rule(Parser *p); static void *_tmp_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 void *_tmp_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 void *_tmp_108_rule(Parser *p); static void *_tmp_109_rule(Parser *p); @@ -876,9 +881,9 @@ 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 *_loop0_115_rule(Parser *p); +static void *_tmp_115_rule(Parser *p); static asdl_seq *_loop0_116_rule(Parser *p); -static void *_tmp_117_rule(Parser *p); +static asdl_seq *_loop0_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); @@ -887,21 +892,21 @@ static void *_tmp_122_rule(Parser *p); static void *_tmp_123_rule(Parser *p); static void *_tmp_124_rule(Parser *p); static void *_tmp_125_rule(Parser *p); -static asdl_seq *_loop0_126_rule(Parser *p); -static asdl_seq *_gather_127_rule(Parser *p); -static void *_tmp_128_rule(Parser *p); +static void *_tmp_126_rule(Parser *p); +static asdl_seq *_loop0_127_rule(Parser *p); +static asdl_seq *_gather_128_rule(Parser *p); static void *_tmp_129_rule(Parser *p); static void *_tmp_130_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 asdl_seq *_loop0_134_rule(Parser *p); -static asdl_seq *_gather_135_rule(Parser *p); -static asdl_seq *_loop0_136_rule(Parser *p); -static asdl_seq *_gather_137_rule(Parser *p); -static void *_tmp_138_rule(Parser *p); -static asdl_seq *_loop0_139_rule(Parser *p); -static void *_tmp_140_rule(Parser *p); +static void *_tmp_132_rule(Parser *p); +static asdl_seq *_loop0_133_rule(Parser *p); +static asdl_seq *_gather_134_rule(Parser *p); +static asdl_seq *_loop0_135_rule(Parser *p); +static asdl_seq *_gather_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 void *_tmp_141_rule(Parser *p); static void *_tmp_142_rule(Parser *p); static void *_tmp_143_rule(Parser *p); @@ -926,11 +931,12 @@ static void *_tmp_161_rule(Parser *p); static void *_tmp_162_rule(Parser *p); static void *_tmp_163_rule(Parser *p); static void *_tmp_164_rule(Parser *p); -static asdl_seq *_loop0_165_rule(Parser *p); -static void *_tmp_166_rule(Parser *p); +static void *_tmp_165_rule(Parser *p); +static asdl_seq *_loop0_166_rule(Parser *p); static void *_tmp_167_rule(Parser *p); static void *_tmp_168_rule(Parser *p); static void *_tmp_169_rule(Parser *p); +static void *_tmp_170_rule(Parser *p); // file: statements? $ @@ -15890,7 +15896,7 @@ fstring_replacement_field_rule(Parser *p) 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 = ( TOK_GET_MODE ( p -> tok ) -> tstring ? _PyPegen_interpolation : _PyPegen_formatted_value ) ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); + _res = _PyPegen_formatted_value ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -16148,7 +16154,166 @@ fstring_rule(Parser *p) return _res; } -// tstring: TSTRING_START fstring_middle* FSTRING_END +// tstring_replacement_field: +// | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' +// | invalid_replacement_field +static expr_ty +tstring_replacement_field_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _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 + { // '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + Token * _literal; + expr_ty a; + void *conversion; + void *debug_expr; + void *format; + Token * rbrace; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = annotated_rhs_rule(p)) // annotated_rhs + && + (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (conversion = fstring_conversion_rule(p), !p->error_indicator) // fstring_conversion? + && + (format = fstring_full_format_spec_rule(p), !p->error_indicator) // fstring_full_format_spec? + && + (rbrace = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + 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 = _PyPegen_interpolation ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + } + if (p->call_invalid_rules) { // invalid_replacement_field + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); + void *invalid_replacement_field_var; + if ( + (invalid_replacement_field_var = invalid_replacement_field_rule(p)) // invalid_replacement_field + ) + { + D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); + _res = invalid_replacement_field_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_replacement_field")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// tstring_middle: tstring_replacement_field | FSTRING_MIDDLE +static expr_ty +tstring_middle_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + { // tstring_replacement_field + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_replacement_field")); + expr_ty tstring_replacement_field_var; + if ( + (tstring_replacement_field_var = tstring_replacement_field_rule(p)) // tstring_replacement_field + ) + { + D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring_replacement_field")); + _res = tstring_replacement_field_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_replacement_field")); + } + { // FSTRING_MIDDLE + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + Token * t; + if ( + (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' + ) + { + D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + _res = _PyPegen_constant_from_token ( p , t ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// tstring: TSTRING_START tstring_middle* FSTRING_END static expr_ty tstring_rule(Parser *p) { @@ -16165,24 +16330,24 @@ tstring_rule(Parser *p) return _res; } int _mark = p->mark; - { // TSTRING_START fstring_middle* FSTRING_END + { // TSTRING_START tstring_middle* FSTRING_END if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START fstring_middle* FSTRING_END")); + D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); Token * a; asdl_seq * b; Token * c; if ( (a = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' && - (b = _loop0_78_rule(p)) // fstring_middle* + (b = _loop0_79_rule(p)) // tstring_middle* && (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' ) { - D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START fstring_middle* FSTRING_END")); + D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); _res = _PyPegen_template_str ( p , a , ( asdl_expr_seq* ) b , c ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -16193,7 +16358,7 @@ tstring_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START fstring_middle* FSTRING_END")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); } _res = NULL; done: @@ -16279,7 +16444,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_79_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_80_rule(p)) // ((fstring | string))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); @@ -16412,7 +16577,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_80_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_81_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -16627,7 +16792,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_82_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_83_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -16786,7 +16951,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_83_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_84_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+")); @@ -16851,7 +17016,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_84_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_85_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))*")); @@ -16894,7 +17059,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_84_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_85_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))*")); @@ -17173,7 +17338,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_85_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_86_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -17422,9 +17587,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_87_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_88_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_89_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]")); @@ -17514,11 +17679,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_90_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_91_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_92_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_93_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+")); @@ -17540,13 +17705,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_90_var; + asdl_seq * _gather_91_var; if ( - (_gather_90_var = _gather_90_rule(p)) // ','.kwarg_or_starred+ + (_gather_91_var = _gather_91_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_90_var; + _res = _gather_91_var; goto done; } p->mark = _mark; @@ -17559,13 +17724,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_92_var; + asdl_seq * _gather_93_var; if ( - (_gather_92_var = _gather_92_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_93_var = _gather_93_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_92_var; + _res = _gather_93_var; goto done; } p->mark = _mark; @@ -17976,7 +18141,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_93_rule(p)) // ((',' star_target))* + (b = _loop0_94_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18032,7 +18197,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_95_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_96_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18082,7 +18247,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_96_rule(p)) // ((',' star_target))+ + (b = _loop1_97_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18170,7 +18335,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_97_rule(p)) // !'*' star_target + (a = _tmp_98_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); @@ -19093,7 +19258,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_99_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_100_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19451,7 +19616,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_101_rule(p)) // ','.expression+ + (a = _gather_102_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19490,7 +19655,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_101_rule(p)) // ','.expression+ + (a = _gather_102_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19523,7 +19688,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_101_rule(p)) // ','.expression+ + (a = _gather_102_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19643,7 +19808,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_101_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_102_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); @@ -19694,7 +19859,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_102_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_103_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -19780,15 +19945,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_105_var; - void *_tmp_103_var; + asdl_seq * _gather_106_var; + void *_tmp_104_var; Token * a; if ( - (_tmp_103_var = _tmp_103_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs + (_tmp_104_var = _tmp_104_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs && (a = _PyPegen_expect_token(p, 12)) // token=',' && - (_gather_105_var = _gather_105_rule(p)) // ','.(starred_expression !'=')+ + (_gather_106_var = _gather_106_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 !'=')+")); @@ -19822,7 +19987,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_106_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_107_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]")); @@ -19882,13 +20047,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_107_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_108_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_108_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_109_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); @@ -20026,7 +20191,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_109_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_110_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -20086,7 +20251,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_110_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) && (a = expression_rule(p)) // expression && @@ -20427,7 +20592,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -20463,7 +20628,7 @@ invalid_expression_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); @@ -20584,7 +20749,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); @@ -20610,7 +20775,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_115_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -20618,7 +20783,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_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 !('=' | ':=')")); @@ -20698,7 +20863,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_115_var; + asdl_seq * _loop0_116_var; expr_ty a; expr_ty expression_var; if ( @@ -20706,7 +20871,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_115_var = _loop0_115_rule(p)) // star_named_expressions* + (_loop0_116_var = _loop0_116_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -20763,10 +20928,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_116_var; + asdl_seq * _loop0_117_var; expr_ty a; if ( - (_loop0_116_var = _loop0_116_rule(p)) // ((star_targets '='))* + (_loop0_117_var = _loop0_117_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -20793,10 +20958,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_116_var; + asdl_seq * _loop0_117_var; expr_ty a; if ( - (_loop0_116_var = _loop0_116_rule(p)) // ((star_targets '='))* + (_loop0_117_var = _loop0_117_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -21052,11 +21217,11 @@ invalid_comprehension_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); - void *_tmp_117_var; + void *_tmp_118_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_117_var = _tmp_117_rule(p)) // '[' | '(' | '{' + (_tmp_118_var = _tmp_118_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -21083,12 +21248,12 @@ invalid_comprehension_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); Token * _literal; - void *_tmp_118_var; + void *_tmp_119_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_118_var = _tmp_118_rule(p)) // '[' | '{' + (_tmp_119_var = _tmp_119_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21118,12 +21283,12 @@ invalid_comprehension_rule(Parser *p) 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_118_var; + void *_tmp_119_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_118_var = _tmp_118_rule(p)) // '[' | '{' + (_tmp_119_var = _tmp_119_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21259,10 +21424,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_32_var; - void *_tmp_119_var; + void *_tmp_120_var; Token * a; if ( - (_tmp_119_var = _tmp_119_rule(p)) // slash_no_default | slash_with_default + (_tmp_120_var = _tmp_120_rule(p)) // slash_no_default | slash_with_default && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && @@ -21364,16 +21529,16 @@ invalid_parameters_rule(Parser *p) asdl_seq * _loop0_32_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_120_var; + void *_tmp_121_var; Token * a; if ( - (_opt_var = _tmp_119_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_120_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_120_var = _tmp_120_rule(p)) // ',' | param_no_default + (_tmp_121_var = _tmp_121_rule(p)) // ',' | param_no_default && (_loop0_32_var_1 = _loop0_32_rule(p)) // param_maybe_default* && @@ -21452,7 +21617,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_121_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_122_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); @@ -21497,12 +21662,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_122_var; + void *_tmp_123_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_122_var = _tmp_122_rule(p)) // ')' | ',' (')' | '**') + (_tmp_123_var = _tmp_123_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); @@ -21586,19 +21751,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_32_var; - void *_tmp_123_var; - void *_tmp_123_var_1; + void *_tmp_124_var; + void *_tmp_124_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_123_var = _tmp_123_rule(p)) // param_no_default | ',' + (_tmp_124_var = _tmp_124_rule(p)) // param_no_default | ',' && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_123_var_1 = _tmp_123_rule(p)) // param_no_default | ',' + (_tmp_124_var_1 = _tmp_124_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 | ',')")); @@ -21713,7 +21878,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_124_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_125_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); @@ -21850,10 +22015,10 @@ 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* '/'")); asdl_seq * _loop0_75_var; - void *_tmp_125_var; + void *_tmp_126_var; Token * a; if ( - (_tmp_125_var = _tmp_125_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_126_var = _tmp_126_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -21913,7 +22078,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_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_127_var; + asdl_seq * _gather_128_var; asdl_seq * _loop0_71_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -21924,7 +22089,7 @@ invalid_lambda_parameters_rule(Parser *p) && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_127_var = _gather_127_rule(p)) // ','.lambda_param+ + (_gather_128_var = _gather_128_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -21955,16 +22120,16 @@ invalid_lambda_parameters_rule(Parser *p) asdl_seq * _loop0_75_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_128_var; + void *_tmp_129_var; Token * a; if ( - (_opt_var = _tmp_125_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_126_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_128_var = _tmp_128_rule(p)) // ',' | lambda_param_no_default + (_tmp_129_var = _tmp_129_rule(p)) // ',' | lambda_param_no_default && (_loop0_75_var_1 = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -22107,11 +22272,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_129_var; + void *_tmp_130_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_129_var = _tmp_129_rule(p)) // ':' | ',' (':' | '**') + (_tmp_130_var = _tmp_130_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); @@ -22165,19 +22330,19 @@ 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_75_var; - void *_tmp_130_var; - void *_tmp_130_var_1; + void *_tmp_131_var; + void *_tmp_131_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_130_var = _tmp_130_rule(p)) // lambda_param_no_default | ',' + (_tmp_131_var = _tmp_131_rule(p)) // lambda_param_no_default | ',' && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_130_var_1 = _tmp_130_rule(p)) // lambda_param_no_default | ',' + (_tmp_131_var_1 = _tmp_131_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 | ',')")); @@ -22295,7 +22460,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_124_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_125_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -22445,13 +22610,13 @@ invalid_for_if_clause_rule(Parser *p) Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_131_var; + void *_tmp_132_var; if ( (_opt_var = _PyPegen_expect_token(p, 682), !p->error_indicator) // 'async'? && (_keyword = _PyPegen_expect_token(p, 678)) // token='for' && - (_tmp_131_var = _tmp_131_rule(p)) // bitwise_or ((',' bitwise_or))* ','? + (_tmp_132_var = _tmp_132_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 679) // token='in' ) @@ -22626,14 +22791,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_133_var; + asdl_seq * _gather_134_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( (a = _PyPegen_expect_token(p, 622)) // token='import' && - (_gather_133_var = _gather_133_rule(p)) // ','.dotted_name+ + (_gather_134_var = _gather_134_rule(p)) // ','.dotted_name+ && (_keyword = _PyPegen_expect_token(p, 621)) // token='from' && @@ -22780,7 +22945,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_135_var; + asdl_seq * _gather_136_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22790,7 +22955,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 633)) // token='with' && - (_gather_135_var = _gather_135_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_136_var = _gather_136_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -22814,7 +22979,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_137_var; + asdl_seq * _gather_138_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -22830,7 +22995,7 @@ invalid_with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_137_var = _gather_137_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_138_var = _gather_138_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -22879,7 +23044,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_135_var; + asdl_seq * _gather_136_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22890,7 +23055,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (a = _PyPegen_expect_token(p, 633)) // token='with' && - (_gather_135_var = _gather_135_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_136_var = _gather_136_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -22918,7 +23083,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_137_var; + asdl_seq * _gather_138_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -22935,7 +23100,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_137_var = _gather_137_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_138_var = _gather_138_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23032,7 +23197,7 @@ invalid_try_stmt_rule(Parser *p) && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_138_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_139_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); @@ -23057,7 +23222,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_139_var; + asdl_seq * _loop0_140_var; asdl_seq * _loop1_37_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23069,7 +23234,7 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_139_var = _loop0_139_rule(p)) // block* + (_loop0_140_var = _loop0_140_rule(p)) // block* && (_loop1_37_var = _loop1_37_rule(p)) // except_block+ && @@ -23106,7 +23271,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_139_var; + asdl_seq * _loop0_140_var; asdl_seq * _loop1_38_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23116,13 +23281,13 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_139_var = _loop0_139_rule(p)) // block* + (_loop0_140_var = _loop0_140_rule(p)) // block* && (_loop1_38_var = _loop1_38_rule(p)) // except_star_block+ && (a = _PyPegen_expect_token(p, 663)) // token='except' && - (_opt_var = _tmp_140_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_141_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -23407,14 +23572,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_141_var; + void *_tmp_142_var; Token * a; if ( (a = _PyPegen_expect_token(p, 663)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_141_var = _tmp_141_rule(p)) // NEWLINE | ':' + (_tmp_142_var = _tmp_142_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_star_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); @@ -24011,7 +24176,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_142_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_143_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -24710,11 +24875,11 @@ 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")); - asdl_seq * _gather_82_var; + asdl_seq * _gather_83_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_82_var = _gather_82_rule(p)) // ','.double_starred_kvpair+ + (_gather_83_var = _gather_83_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24722,7 +24887,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); - _res = _PyPegen_dummy_name(p, _gather_82_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_83_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -24775,7 +24940,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_143_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_144_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -24885,7 +25050,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_143_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_144_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -25173,7 +25338,7 @@ invalid_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_144_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_145_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); @@ -25205,7 +25370,7 @@ invalid_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_145_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_146_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); @@ -25269,9 +25434,9 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_147_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_148_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); @@ -25308,7 +25473,7 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25349,7 +25514,7 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_146_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_147_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -25396,7 +25561,7 @@ invalid_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_147_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_148_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); @@ -25463,14 +25628,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_148_var; + void *_tmp_149_var; Token * a; expr_ty b; expr_ty sum_var; if ( (sum_var = sum_rule(p)) // sum && - (_tmp_148_var = _tmp_148_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' + (_tmp_149_var = _tmp_149_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && (a = _PyPegen_expect_token(p, 687)) // token='not' && @@ -25515,11 +25680,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_149_var; + void *_tmp_150_var; Token * a; expr_ty b; if ( - (_tmp_149_var = _tmp_149_rule(p)) // '+' | '-' | '~' + (_tmp_150_var = _tmp_150_rule(p)) // '+' | '-' | '~' && (a = _PyPegen_expect_token(p, 687)) // token='not' && @@ -26293,12 +26458,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_150_var; + void *_tmp_151_var; while ( - (_tmp_150_var = _tmp_150_rule(p)) // star_targets '=' + (_tmp_151_var = _tmp_151_rule(p)) // star_targets '=' ) { - _res = _tmp_150_var; + _res = _tmp_151_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26631,12 +26796,12 @@ _loop0_18_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_151_var; + void *_tmp_152_var; while ( - (_tmp_151_var = _tmp_151_rule(p)) // '.' | '...' + (_tmp_152_var = _tmp_152_rule(p)) // '.' | '...' ) { - _res = _tmp_151_var; + _res = _tmp_152_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -26698,12 +26863,12 @@ _loop1_19_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_151_var; + void *_tmp_152_var; while ( - (_tmp_151_var = _tmp_151_rule(p)) // '.' | '...' + (_tmp_152_var = _tmp_152_rule(p)) // '.' | '...' ) { - _res = _tmp_151_var; + _res = _tmp_152_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -27050,12 +27215,12 @@ _loop1_25_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); - void *_tmp_152_var; + void *_tmp_153_var; while ( - (_tmp_152_var = _tmp_152_rule(p)) // '@' named_expression NEWLINE + (_tmp_153_var = _tmp_153_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_152_var; + _res = _tmp_153_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29064,12 +29229,12 @@ _loop1_57_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); - void *_tmp_153_var; + void *_tmp_154_var; while ( - (_tmp_153_var = _tmp_153_rule(p)) // ',' star_expression + (_tmp_154_var = _tmp_154_rule(p)) // ',' star_expression ) { - _res = _tmp_153_var; + _res = _tmp_154_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29253,12 +29418,12 @@ _loop1_60_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); - void *_tmp_154_var; + void *_tmp_155_var; while ( - (_tmp_154_var = _tmp_154_rule(p)) // 'or' conjunction + (_tmp_155_var = _tmp_155_rule(p)) // 'or' conjunction ) { - _res = _tmp_154_var; + _res = _tmp_155_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29325,12 +29490,12 @@ _loop1_61_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); - void *_tmp_155_var; + void *_tmp_156_var; while ( - (_tmp_155_var = _tmp_155_rule(p)) // 'and' inversion + (_tmp_156_var = _tmp_156_rule(p)) // 'and' inversion ) { - _res = _tmp_155_var; + _res = _tmp_156_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29517,7 +29682,7 @@ _loop0_64_rule(Parser *p) while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_156_rule(p)) // slice | starred_expression + (elem = _tmp_157_rule(p)) // slice | starred_expression ) { _res = elem; @@ -29582,7 +29747,7 @@ _gather_65_rule(Parser *p) void *elem; asdl_seq * seq; if ( - (elem = _tmp_156_rule(p)) // slice | starred_expression + (elem = _tmp_157_rule(p)) // slice | starred_expression && (seq = _loop0_64_rule(p)) // _loop0_64 ) @@ -30483,9 +30648,76 @@ _loop0_78_rule(Parser *p) return _seq; } -// _loop1_79: (fstring | string) +// _loop0_79: tstring_middle +static asdl_seq * +_loop0_79_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // tstring_middle + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_79[%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 + ) + { + _res = tstring_middle_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_79[%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); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop1_80: (fstring | string) static asdl_seq * -_loop1_79_rule(Parser *p) +_loop1_80_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30510,13 +30742,13 @@ _loop1_79_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); - void *_tmp_157_var; + D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); + void *_tmp_158_var; while ( - (_tmp_157_var = _tmp_157_rule(p)) // fstring | string + (_tmp_158_var = _tmp_158_rule(p)) // fstring | string ) { - _res = _tmp_157_var; + _res = _tmp_158_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30533,7 +30765,7 @@ _loop1_79_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_79[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)")); } if (_n == 0 || p->error_indicator) { @@ -30555,9 +30787,9 @@ _loop1_79_rule(Parser *p) return _seq; } -// _tmp_80: star_named_expression ',' star_named_expressions? +// _tmp_81: star_named_expression ',' star_named_expressions? static void * -_tmp_80_rule(Parser *p) +_tmp_81_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30573,7 +30805,7 @@ _tmp_80_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); Token * _literal; expr_ty y; void *z; @@ -30585,7 +30817,7 @@ _tmp_80_rule(Parser *p) (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? ) { - D(fprintf(stderr, "%*c+ _tmp_80[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c+ _tmp_81[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); _res = _PyPegen_seq_insert_in_front ( p , y , z ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -30595,7 +30827,7 @@ _tmp_80_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_80[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_81[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); } _res = NULL; @@ -30604,9 +30836,9 @@ _tmp_80_rule(Parser *p) return _res; } -// _loop0_81: ',' double_starred_kvpair +// _loop0_82: ',' double_starred_kvpair static asdl_seq * -_loop0_81_rule(Parser *p) +_loop0_82_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30631,7 +30863,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, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -30663,7 +30895,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, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -30680,9 +30912,9 @@ _loop0_81_rule(Parser *p) return _seq; } -// _gather_82: double_starred_kvpair _loop0_81 +// _gather_83: double_starred_kvpair _loop0_82 static asdl_seq * -_gather_82_rule(Parser *p) +_gather_83_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30693,27 +30925,27 @@ _gather_82_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_81 + { // double_starred_kvpair _loop0_82 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_81")); + D(fprintf(stderr, "%*c> _gather_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_81_rule(p)) // _loop0_81 + (seq = _loop0_82_rule(p)) // _loop0_82 ) { - D(fprintf(stderr, "%*c+ _gather_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_81")); + D(fprintf(stderr, "%*c+ _gather_83[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_82[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_81")); + D(fprintf(stderr, "%*c%s _gather_83[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_82")); } _res = NULL; done: @@ -30721,9 +30953,9 @@ _gather_82_rule(Parser *p) return _res; } -// _loop1_83: for_if_clause +// _loop1_84: for_if_clause static asdl_seq * -_loop1_83_rule(Parser *p) +_loop1_84_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30748,7 +30980,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, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_84[%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 @@ -30771,7 +31003,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, "for_if_clause")); } if (_n == 0 || p->error_indicator) { @@ -30793,9 +31025,9 @@ _loop1_83_rule(Parser *p) return _seq; } -// _loop0_84: ('if' disjunction) +// _loop0_85: ('if' disjunction) static asdl_seq * -_loop0_84_rule(Parser *p) +_loop0_85_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30820,13 +31052,13 @@ _loop0_84_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); - void *_tmp_158_var; + D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + void *_tmp_159_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // 'if' disjunction + (_tmp_159_var = _tmp_159_rule(p)) // 'if' disjunction ) { - _res = _tmp_158_var; + _res = _tmp_159_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30843,7 +31075,7 @@ _loop0_84_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_84[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_85[%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); @@ -30860,9 +31092,9 @@ _loop0_84_rule(Parser *p) return _seq; } -// _tmp_85: assignment_expression | expression !':=' +// _tmp_86: assignment_expression | expression !':=' static void * -_tmp_85_rule(Parser *p) +_tmp_86_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30878,18 +31110,18 @@ _tmp_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_86[%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_85[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_86[%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_85[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_86[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } { // expression !':=' @@ -30897,7 +31129,7 @@ _tmp_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -30905,12 +31137,12 @@ _tmp_85_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_85[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_86[%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_85[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_86[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } _res = NULL; @@ -30919,9 +31151,9 @@ _tmp_85_rule(Parser *p) return _res; } -// _loop0_86: ',' (starred_expression | (assignment_expression | expression !':=') !'=') +// _loop0_87: ',' (starred_expression | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_86_rule(Parser *p) +_loop0_87_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -30946,13 +31178,13 @@ _loop0_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_87[%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_159_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_160_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -30978,7 +31210,7 @@ _loop0_86_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_86[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_87[%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); @@ -30995,10 +31227,10 @@ _loop0_86_rule(Parser *p) return _seq; } -// _gather_87: -// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86 +// _gather_88: +// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 static asdl_seq * -_gather_87_rule(Parser *p) +_gather_88_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31009,27 +31241,27 @@ _gather_87_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86 + { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); + D(fprintf(stderr, "%*c> _gather_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_159_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_160_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_86_rule(p)) // _loop0_86 + (seq = _loop0_87_rule(p)) // _loop0_87 ) { - D(fprintf(stderr, "%*c+ _gather_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); + D(fprintf(stderr, "%*c+ _gather_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_87[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_86")); + D(fprintf(stderr, "%*c%s _gather_88[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); } _res = NULL; done: @@ -31037,9 +31269,9 @@ _gather_87_rule(Parser *p) return _res; } -// _tmp_88: ',' kwargs +// _tmp_89: ',' kwargs static void * -_tmp_88_rule(Parser *p) +_tmp_89_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31055,7 +31287,7 @@ _tmp_88_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -31064,7 +31296,7 @@ _tmp_88_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); _res = k; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31074,7 +31306,7 @@ _tmp_88_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_88[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); } _res = NULL; @@ -31083,9 +31315,9 @@ _tmp_88_rule(Parser *p) return _res; } -// _loop0_89: ',' kwarg_or_starred +// _loop0_90: ',' kwarg_or_starred static asdl_seq * -_loop0_89_rule(Parser *p) +_loop0_90_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31110,7 +31342,7 @@ _loop0_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31142,7 +31374,7 @@ _loop0_89_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_89[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_90[%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); @@ -31159,9 +31391,9 @@ _loop0_89_rule(Parser *p) return _seq; } -// _gather_90: kwarg_or_starred _loop0_89 +// _gather_91: kwarg_or_starred _loop0_90 static asdl_seq * -_gather_90_rule(Parser *p) +_gather_91_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31172,27 +31404,27 @@ _gather_90_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_89 + { // kwarg_or_starred _loop0_90 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_89")); + D(fprintf(stderr, "%*c> _gather_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_90")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_89_rule(p)) // _loop0_89 + (seq = _loop0_90_rule(p)) // _loop0_90 ) { - D(fprintf(stderr, "%*c+ _gather_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_89")); + D(fprintf(stderr, "%*c+ _gather_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_90")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_90[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_89")); + D(fprintf(stderr, "%*c%s _gather_91[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_90")); } _res = NULL; done: @@ -31200,9 +31432,9 @@ _gather_90_rule(Parser *p) return _res; } -// _loop0_91: ',' kwarg_or_double_starred +// _loop0_92: ',' kwarg_or_double_starred static asdl_seq * -_loop0_91_rule(Parser *p) +_loop0_92_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31227,7 +31459,7 @@ _loop0_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31259,7 +31491,7 @@ _loop0_91_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_91[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_92[%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); @@ -31276,9 +31508,9 @@ _loop0_91_rule(Parser *p) return _seq; } -// _gather_92: kwarg_or_double_starred _loop0_91 +// _gather_93: kwarg_or_double_starred _loop0_92 static asdl_seq * -_gather_92_rule(Parser *p) +_gather_93_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31289,27 +31521,27 @@ _gather_92_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_91 + { // kwarg_or_double_starred _loop0_92 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_91")); + D(fprintf(stderr, "%*c> _gather_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_91_rule(p)) // _loop0_91 + (seq = _loop0_92_rule(p)) // _loop0_92 ) { - D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_91")); + D(fprintf(stderr, "%*c+ _gather_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_91")); + D(fprintf(stderr, "%*c%s _gather_93[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_92")); } _res = NULL; done: @@ -31317,9 +31549,9 @@ _gather_92_rule(Parser *p) return _res; } -// _loop0_93: (',' star_target) +// _loop0_94: (',' star_target) static asdl_seq * -_loop0_93_rule(Parser *p) +_loop0_94_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31344,13 +31576,13 @@ _loop0_93_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_160_var; + D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_161_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // ',' star_target + (_tmp_161_var = _tmp_161_rule(p)) // ',' star_target ) { - _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 *)); @@ -31367,7 +31599,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, "(',' star_target)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31384,9 +31616,9 @@ _loop0_93_rule(Parser *p) return _seq; } -// _loop0_94: ',' star_target +// _loop0_95: ',' star_target static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_95_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31411,7 +31643,7 @@ _loop0_94_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -31443,7 +31675,7 @@ _loop0_94_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_94[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_95[%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); @@ -31460,9 +31692,9 @@ _loop0_94_rule(Parser *p) return _seq; } -// _gather_95: star_target _loop0_94 +// _gather_96: star_target _loop0_95 static asdl_seq * -_gather_95_rule(Parser *p) +_gather_96_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31473,27 +31705,27 @@ _gather_95_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_94 + { // star_target _loop0_95 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_94")); + D(fprintf(stderr, "%*c> _gather_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_95")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_94_rule(p)) // _loop0_94 + (seq = _loop0_95_rule(p)) // _loop0_95 ) { - D(fprintf(stderr, "%*c+ _gather_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_94")); + D(fprintf(stderr, "%*c+ _gather_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_95")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_95[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_94")); + D(fprintf(stderr, "%*c%s _gather_96[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_95")); } _res = NULL; done: @@ -31501,9 +31733,9 @@ _gather_95_rule(Parser *p) return _res; } -// _loop1_96: (',' star_target) +// _loop1_97: (',' star_target) static asdl_seq * -_loop1_96_rule(Parser *p) +_loop1_97_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31528,13 +31760,13 @@ _loop1_96_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_160_var; + D(fprintf(stderr, "%*c> _loop1_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_161_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // ',' star_target + (_tmp_161_var = _tmp_161_rule(p)) // ',' star_target ) { - _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 *)); @@ -31551,7 +31783,7 @@ _loop1_96_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_96[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_97[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -31573,9 +31805,9 @@ _loop1_96_rule(Parser *p) return _seq; } -// _tmp_97: !'*' star_target +// _tmp_98: !'*' star_target static void * -_tmp_97_rule(Parser *p) +_tmp_98_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31591,7 +31823,7 @@ _tmp_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_98[%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='*' @@ -31599,12 +31831,12 @@ _tmp_97_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_98[%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_97[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_98[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); } _res = NULL; @@ -31613,9 +31845,9 @@ _tmp_97_rule(Parser *p) return _res; } -// _loop0_98: ',' del_target +// _loop0_99: ',' del_target static asdl_seq * -_loop0_98_rule(Parser *p) +_loop0_99_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31640,7 +31872,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, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -31672,7 +31904,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, "',' del_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31689,9 +31921,9 @@ _loop0_98_rule(Parser *p) return _seq; } -// _gather_99: del_target _loop0_98 +// _gather_100: del_target _loop0_99 static asdl_seq * -_gather_99_rule(Parser *p) +_gather_100_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31702,27 +31934,27 @@ _gather_99_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_98 + { // del_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, "del_target _loop0_98")); + D(fprintf(stderr, "%*c> _gather_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_99")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_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, "del_target _loop0_98")); + D(fprintf(stderr, "%*c+ _gather_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_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, "del_target _loop0_98")); + D(fprintf(stderr, "%*c%s _gather_100[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_99")); } _res = NULL; done: @@ -31730,9 +31962,9 @@ _gather_99_rule(Parser *p) return _res; } -// _loop0_100: ',' expression +// _loop0_101: ',' expression static asdl_seq * -_loop0_100_rule(Parser *p) +_loop0_101_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31757,7 +31989,7 @@ _loop0_100_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -31789,7 +32021,7 @@ _loop0_100_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_100[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_101[%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); @@ -31806,9 +32038,9 @@ _loop0_100_rule(Parser *p) return _seq; } -// _gather_101: expression _loop0_100 +// _gather_102: expression _loop0_101 static asdl_seq * -_gather_101_rule(Parser *p) +_gather_102_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31819,27 +32051,27 @@ _gather_101_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_100 + { // expression _loop0_101 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_100")); + D(fprintf(stderr, "%*c> _gather_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_100_rule(p)) // _loop0_100 + (seq = _loop0_101_rule(p)) // _loop0_101 ) { - D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_100")); + D(fprintf(stderr, "%*c+ _gather_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_100")); + D(fprintf(stderr, "%*c%s _gather_102[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_101")); } _res = NULL; done: @@ -31847,9 +32079,9 @@ _gather_101_rule(Parser *p) return _res; } -// _tmp_102: NEWLINE INDENT +// _tmp_103: NEWLINE INDENT static void * -_tmp_102_rule(Parser *p) +_tmp_103_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31865,7 +32097,7 @@ _tmp_102_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -31874,12 +32106,12 @@ _tmp_102_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_103[%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_102[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_103[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); } _res = NULL; @@ -31888,11 +32120,11 @@ _tmp_102_rule(Parser *p) return _res; } -// _tmp_103: +// _tmp_104: // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) // | kwargs static void * -_tmp_103_rule(Parser *p) +_tmp_104_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31908,18 +32140,18 @@ _tmp_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - void *_tmp_161_var; + D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + void *_tmp_162_var; if ( - (_tmp_161_var = _tmp_161_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs + (_tmp_162_var = _tmp_162_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - _res = _tmp_161_var; + D(fprintf(stderr, "%*c+ _tmp_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + _res = _tmp_162_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_103[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } { // kwargs @@ -31927,18 +32159,18 @@ _tmp_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c> _tmp_104[%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_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c+ _tmp_104[%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_103[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); } _res = NULL; @@ -31947,9 +32179,9 @@ _tmp_103_rule(Parser *p) return _res; } -// _loop0_104: ',' (starred_expression !'=') +// _loop0_105: ',' (starred_expression !'=') static asdl_seq * -_loop0_104_rule(Parser *p) +_loop0_105_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -31974,13 +32206,13 @@ _loop0_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); + D(fprintf(stderr, "%*c> _loop0_105[%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_162_rule(p)) // starred_expression !'=' + (elem = _tmp_163_rule(p)) // starred_expression !'=' ) { _res = elem; @@ -32006,7 +32238,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, "',' (starred_expression !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32023,9 +32255,9 @@ _loop0_104_rule(Parser *p) return _seq; } -// _gather_105: (starred_expression !'=') _loop0_104 +// _gather_106: (starred_expression !'=') _loop0_105 static asdl_seq * -_gather_105_rule(Parser *p) +_gather_106_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32036,27 +32268,27 @@ _gather_105_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression !'=') _loop0_104 + { // (starred_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, "(starred_expression !'=') _loop0_104")); + D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_105")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_162_rule(p)) // starred_expression !'=' + (elem = _tmp_163_rule(p)) // starred_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, "(starred_expression !'=') _loop0_104")); + D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_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, "(starred_expression !'=') _loop0_104")); + D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_105")); } _res = NULL; done: @@ -32064,9 +32296,9 @@ _gather_105_rule(Parser *p) return _res; } -// _tmp_106: args | expression for_if_clauses +// _tmp_107: args | expression for_if_clauses static void * -_tmp_106_rule(Parser *p) +_tmp_107_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32082,18 +32314,18 @@ _tmp_106_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c> _tmp_107[%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_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c+ _tmp_107[%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_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, "args")); } { // expression for_if_clauses @@ -32101,7 +32333,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, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_107[%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 ( @@ -32110,12 +32342,12 @@ _tmp_106_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_107[%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_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, "expression for_if_clauses")); } _res = NULL; @@ -32124,9 +32356,9 @@ _tmp_106_rule(Parser *p) return _res; } -// _tmp_107: args ',' +// _tmp_108: args ',' static void * -_tmp_107_rule(Parser *p) +_tmp_108_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32142,7 +32374,7 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -32151,12 +32383,12 @@ _tmp_107_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_108[%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_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, "args ','")); } _res = NULL; @@ -32165,9 +32397,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _tmp_108: ',' | ')' +// _tmp_109: ',' | ')' static void * -_tmp_108_rule(Parser *p) +_tmp_109_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32183,18 +32415,18 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -32202,18 +32434,18 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } _res = NULL; @@ -32222,9 +32454,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _tmp_109: 'True' | 'False' | 'None' +// _tmp_110: 'True' | 'False' | 'None' static void * -_tmp_109_rule(Parser *p) +_tmp_110_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32240,18 +32472,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 610)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'False' @@ -32259,18 +32491,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 612)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } { // 'None' @@ -32278,18 +32510,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 611)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } _res = NULL; @@ -32298,9 +32530,9 @@ _tmp_109_rule(Parser *p) return _res; } -// _tmp_110: NAME '=' +// _tmp_111: NAME '=' static void * -_tmp_110_rule(Parser *p) +_tmp_111_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32316,7 +32548,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, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -32325,12 +32557,12 @@ _tmp_110_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_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, "NAME '='")); } _res = NULL; @@ -32339,9 +32571,9 @@ _tmp_110_rule(Parser *p) return _res; } -// _tmp_111: NAME STRING | SOFT_KEYWORD +// _tmp_112: NAME STRING | SOFT_KEYWORD static void * -_tmp_111_rule(Parser *p) +_tmp_112_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32357,7 +32589,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, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -32366,12 +32598,12 @@ _tmp_111_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_112[%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_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, "NAME STRING")); } { // SOFT_KEYWORD @@ -32379,18 +32611,18 @@ _tmp_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_112[%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_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_112[%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_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, "SOFT_KEYWORD")); } _res = NULL; @@ -32399,9 +32631,9 @@ _tmp_111_rule(Parser *p) return _res; } -// _tmp_112: 'else' | ':' +// _tmp_113: 'else' | ':' static void * -_tmp_112_rule(Parser *p) +_tmp_113_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32417,18 +32649,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, "'else'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 671)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); _res = _keyword; 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, "'else'")); } { // ':' @@ -32436,18 +32668,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, 11)) // 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; @@ -32456,9 +32688,9 @@ _tmp_112_rule(Parser *p) return _res; } -// _tmp_113: '=' | ':=' +// _tmp_114: '=' | ':=' static void * -_tmp_113_rule(Parser *p) +_tmp_114_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32474,18 +32706,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, "'='")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; 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, "'='")); } { // ':=' @@ -32493,18 +32725,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, "':='")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); _res = _literal; 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, "':='")); } _res = NULL; @@ -32513,9 +32745,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_115: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_114_rule(Parser *p) +_tmp_115_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32531,18 +32763,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c> _tmp_115[%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_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c+ _tmp_115[%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_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, "list")); } { // tuple @@ -32550,18 +32782,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c> _tmp_115[%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_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_115[%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_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, "tuple")); } { // genexp @@ -32569,18 +32801,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c> _tmp_115[%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_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_115[%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_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, "genexp")); } { // 'True' @@ -32588,18 +32820,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 610)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; 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, "'True'")); } { // 'None' @@ -32607,18 +32839,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 611)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; 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, "'None'")); } { // 'False' @@ -32626,18 +32858,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 612)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; 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, "'False'")); } _res = NULL; @@ -32646,9 +32878,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _loop0_115: star_named_expressions +// _loop0_116: star_named_expressions static asdl_seq * -_loop0_115_rule(Parser *p) +_loop0_116_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32673,7 +32905,7 @@ _loop0_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_116[%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 @@ -32696,7 +32928,7 @@ _loop0_115_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_116[%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); @@ -32713,9 +32945,9 @@ _loop0_115_rule(Parser *p) return _seq; } -// _loop0_116: (star_targets '=') +// _loop0_117: (star_targets '=') static asdl_seq * -_loop0_116_rule(Parser *p) +_loop0_117_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32740,13 +32972,13 @@ _loop0_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_150_var; + D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); + void *_tmp_151_var; while ( - (_tmp_150_var = _tmp_150_rule(p)) // star_targets '=' + (_tmp_151_var = _tmp_151_rule(p)) // star_targets '=' ) { - _res = _tmp_150_var; + _res = _tmp_151_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32763,7 +32995,7 @@ _loop0_116_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_117[%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); @@ -32780,9 +33012,9 @@ _loop0_116_rule(Parser *p) return _seq; } -// _tmp_117: '[' | '(' | '{' +// _tmp_118: '[' | '(' | '{' static void * -_tmp_117_rule(Parser *p) +_tmp_118_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32798,18 +33030,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, 9)) // 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, "'['")); } { // '(' @@ -32817,18 +33049,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, 7)) // 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, "'('")); } { // '{' @@ -32836,18 +33068,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, 25)) // 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; @@ -32856,9 +33088,9 @@ _tmp_117_rule(Parser *p) return _res; } -// _tmp_118: '[' | '{' +// _tmp_119: '[' | '{' static void * -_tmp_118_rule(Parser *p) +_tmp_119_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32874,18 +33106,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, "'['")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; 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, "'['")); } { // '{' @@ -32893,18 +33125,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, "'{'")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; 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, "'{'")); } _res = NULL; @@ -32913,9 +33145,9 @@ _tmp_118_rule(Parser *p) return _res; } -// _tmp_119: slash_no_default | slash_with_default +// _tmp_120: slash_no_default | slash_with_default static void * -_tmp_119_rule(Parser *p) +_tmp_120_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32931,18 +33163,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, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_120[%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_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_120[%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_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, "slash_no_default")); } { // slash_with_default @@ -32950,18 +33182,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, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_120[%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_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_120[%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_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, "slash_with_default")); } _res = NULL; @@ -32970,9 +33202,9 @@ _tmp_119_rule(Parser *p) return _res; } -// _tmp_120: ',' | param_no_default +// _tmp_121: ',' | param_no_default static void * -_tmp_120_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -32988,18 +33220,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, "','")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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, "','")); } { // param_no_default @@ -33007,18 +33239,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_121[%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_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_121[%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_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, "param_no_default")); } _res = NULL; @@ -33027,9 +33259,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _tmp_121: ')' | ',' +// _tmp_122: ')' | ',' static void * -_tmp_121_rule(Parser *p) +_tmp_122_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33045,18 +33277,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' @@ -33064,18 +33296,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -33084,9 +33316,9 @@ _tmp_121_rule(Parser *p) return _res; } -// _tmp_122: ')' | ',' (')' | '**') +// _tmp_123: ')' | ',' (')' | '**') static void * -_tmp_122_rule(Parser *p) +_tmp_123_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33102,18 +33334,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' (')' | '**') @@ -33121,21 +33353,21 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); Token * _literal; - void *_tmp_163_var; + void *_tmp_164_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_163_var = _tmp_163_rule(p)) // ')' | '**' + (_tmp_164_var = _tmp_164_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_163_var); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_164_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); } _res = NULL; @@ -33144,9 +33376,9 @@ _tmp_122_rule(Parser *p) return _res; } -// _tmp_123: param_no_default | ',' +// _tmp_124: param_no_default | ',' static void * -_tmp_123_rule(Parser *p) +_tmp_124_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33162,18 +33394,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_124[%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_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_124[%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_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, "param_no_default")); } { // ',' @@ -33181,18 +33413,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, 12)) // 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, "','")); } _res = NULL; @@ -33201,9 +33433,9 @@ _tmp_123_rule(Parser *p) return _res; } -// _tmp_124: '*' | '**' | '/' +// _tmp_125: '*' | '**' | '/' static void * -_tmp_124_rule(Parser *p) +_tmp_125_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33219,18 +33451,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, "'*'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _literal; 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, "'*'")); } { // '**' @@ -33238,18 +33470,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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } { // '/' @@ -33257,18 +33489,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, "'/'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _literal; 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, "'/'")); } _res = NULL; @@ -33277,9 +33509,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _tmp_125: lambda_slash_no_default | lambda_slash_with_default +// _tmp_126: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_125_rule(Parser *p) +_tmp_126_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33295,18 +33527,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, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_126[%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_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_126[%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_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, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -33314,18 +33546,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, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_126[%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_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_126[%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_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, "lambda_slash_with_default")); } _res = NULL; @@ -33334,9 +33566,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _loop0_126: ',' lambda_param +// _loop0_127: ',' lambda_param static asdl_seq * -_loop0_126_rule(Parser *p) +_loop0_127_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33361,7 +33593,7 @@ _loop0_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -33393,7 +33625,7 @@ _loop0_126_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_126[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_127[%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); @@ -33410,9 +33642,9 @@ _loop0_126_rule(Parser *p) return _seq; } -// _gather_127: lambda_param _loop0_126 +// _gather_128: lambda_param _loop0_127 static asdl_seq * -_gather_127_rule(Parser *p) +_gather_128_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33423,27 +33655,27 @@ _gather_127_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_126 + { // lambda_param _loop0_127 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_126")); + D(fprintf(stderr, "%*c> _gather_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_127")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_126_rule(p)) // _loop0_126 + (seq = _loop0_127_rule(p)) // _loop0_127 ) { - D(fprintf(stderr, "%*c+ _gather_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_126")); + D(fprintf(stderr, "%*c+ _gather_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_127")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_127[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_126")); + D(fprintf(stderr, "%*c%s _gather_128[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_127")); } _res = NULL; done: @@ -33451,9 +33683,9 @@ _gather_127_rule(Parser *p) return _res; } -// _tmp_128: ',' | lambda_param_no_default +// _tmp_129: ',' | lambda_param_no_default static void * -_tmp_128_rule(Parser *p) +_tmp_129_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33469,18 +33701,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, "','")); } { // lambda_param_no_default @@ -33488,18 +33720,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, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_129[%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_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_129[%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_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, "lambda_param_no_default")); } _res = NULL; @@ -33508,9 +33740,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) { _Pypegen_stack_overflow(p); @@ -33526,18 +33758,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, 11)) // 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, "':'")); } { // ',' (':' | '**') @@ -33545,21 +33777,21 @@ _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; - void *_tmp_164_var; + void *_tmp_165_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_164_var = _tmp_164_rule(p)) // ':' | '**' + (_tmp_165_var = _tmp_165_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_164_var); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_165_var); 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; @@ -33568,9 +33800,9 @@ _tmp_129_rule(Parser *p) return _res; } -// _tmp_130: lambda_param_no_default | ',' +// _tmp_131: lambda_param_no_default | ',' static void * -_tmp_130_rule(Parser *p) +_tmp_131_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33586,18 +33818,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_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_131[%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_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_131[%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_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_param_no_default")); } { // ',' @@ -33605,18 +33837,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, "','")); + D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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, "','")); } _res = NULL; @@ -33625,9 +33857,9 @@ _tmp_130_rule(Parser *p) return _res; } -// _tmp_131: bitwise_or ((',' bitwise_or))* ','? +// _tmp_132: bitwise_or ((',' bitwise_or))* ','? static void * -_tmp_131_rule(Parser *p) +_tmp_132_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33643,25 +33875,25 @@ _tmp_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - asdl_seq * _loop0_165_var; + D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + asdl_seq * _loop0_166_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_165_var = _loop0_165_rule(p)) // ((',' bitwise_or))* + (_loop0_166_var = _loop0_166_rule(p)) // ((',' bitwise_or))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) { - D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_165_var, _opt_var); + D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_166_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); } _res = NULL; @@ -33670,9 +33902,9 @@ _tmp_131_rule(Parser *p) return _res; } -// _loop0_132: ',' dotted_name +// _loop0_133: ',' dotted_name static asdl_seq * -_loop0_132_rule(Parser *p) +_loop0_133_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33697,7 +33929,7 @@ _loop0_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -33729,7 +33961,7 @@ _loop0_132_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_132[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_133[%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); @@ -33746,9 +33978,9 @@ _loop0_132_rule(Parser *p) return _seq; } -// _gather_133: dotted_name _loop0_132 +// _gather_134: dotted_name _loop0_133 static asdl_seq * -_gather_133_rule(Parser *p) +_gather_134_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33759,27 +33991,27 @@ _gather_133_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_132 + { // dotted_name _loop0_133 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_132")); + D(fprintf(stderr, "%*c> _gather_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_133")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_132_rule(p)) // _loop0_132 + (seq = _loop0_133_rule(p)) // _loop0_133 ) { - D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_132")); + D(fprintf(stderr, "%*c+ _gather_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_133")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_133[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_132")); + D(fprintf(stderr, "%*c%s _gather_134[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_133")); } _res = NULL; done: @@ -33787,9 +34019,9 @@ _gather_133_rule(Parser *p) return _res; } -// _loop0_134: ',' (expression ['as' star_target]) +// _loop0_135: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_134_rule(Parser *p) +_loop0_135_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33814,13 +34046,13 @@ _loop0_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_135[%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_166_rule(p)) // expression ['as' star_target] + (elem = _tmp_167_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -33846,7 +34078,7 @@ _loop0_134_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_134[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_135[%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); @@ -33863,9 +34095,9 @@ _loop0_134_rule(Parser *p) return _seq; } -// _gather_135: (expression ['as' star_target]) _loop0_134 +// _gather_136: (expression ['as' star_target]) _loop0_135 static asdl_seq * -_gather_135_rule(Parser *p) +_gather_136_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33876,27 +34108,27 @@ _gather_135_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_134 + { // (expression ['as' star_target]) _loop0_135 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); + D(fprintf(stderr, "%*c> _gather_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_166_rule(p)) // expression ['as' star_target] + (elem = _tmp_167_rule(p)) // expression ['as' star_target] && - (seq = _loop0_134_rule(p)) // _loop0_134 + (seq = _loop0_135_rule(p)) // _loop0_135 ) { - D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); + D(fprintf(stderr, "%*c+ _gather_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_134")); + D(fprintf(stderr, "%*c%s _gather_136[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_135")); } _res = NULL; done: @@ -33904,9 +34136,9 @@ _gather_135_rule(Parser *p) return _res; } -// _loop0_136: ',' (expressions ['as' star_target]) +// _loop0_137: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_136_rule(Parser *p) +_loop0_137_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33931,13 +34163,13 @@ _loop0_136_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_137[%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_167_rule(p)) // expressions ['as' star_target] + (elem = _tmp_168_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -33963,7 +34195,7 @@ _loop0_136_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_137[%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); @@ -33980,9 +34212,9 @@ _loop0_136_rule(Parser *p) return _seq; } -// _gather_137: (expressions ['as' star_target]) _loop0_136 +// _gather_138: (expressions ['as' star_target]) _loop0_137 static asdl_seq * -_gather_137_rule(Parser *p) +_gather_138_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -33993,27 +34225,27 @@ _gather_137_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_136 + { // (expressions ['as' star_target]) _loop0_137 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); + D(fprintf(stderr, "%*c> _gather_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_167_rule(p)) // expressions ['as' star_target] + (elem = _tmp_168_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_136_rule(p)) // _loop0_136 + (seq = _loop0_137_rule(p)) // _loop0_137 ) { - D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); + D(fprintf(stderr, "%*c+ _gather_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_136")); + D(fprintf(stderr, "%*c%s _gather_138[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_137")); } _res = NULL; done: @@ -34021,9 +34253,9 @@ _gather_137_rule(Parser *p) return _res; } -// _tmp_138: 'except' | 'finally' +// _tmp_139: 'except' | 'finally' static void * -_tmp_138_rule(Parser *p) +_tmp_139_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34039,18 +34271,18 @@ _tmp_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 663)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } { // 'finally' @@ -34058,18 +34290,18 @@ _tmp_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 659)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } _res = NULL; @@ -34078,9 +34310,9 @@ _tmp_138_rule(Parser *p) return _res; } -// _loop0_139: block +// _loop0_140: block static asdl_seq * -_loop0_139_rule(Parser *p) +_loop0_140_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34105,7 +34337,7 @@ _loop0_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); + D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -34128,7 +34360,7 @@ _loop0_139_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_139[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_140[%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); @@ -34145,9 +34377,9 @@ _loop0_139_rule(Parser *p) return _seq; } -// _tmp_140: expression ['as' NAME] +// _tmp_141: expression ['as' NAME] static void * -_tmp_140_rule(Parser *p) +_tmp_141_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34163,7 +34395,7 @@ _tmp_140_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_141[%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; @@ -34173,12 +34405,12 @@ _tmp_140_rule(Parser *p) (_opt_var = _tmp_22_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_141[%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_140[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]")); } _res = NULL; @@ -34187,9 +34419,9 @@ _tmp_140_rule(Parser *p) return _res; } -// _tmp_141: NEWLINE | ':' +// _tmp_142: NEWLINE | ':' static void * -_tmp_141_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34205,18 +34437,18 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_142[%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_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_142[%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_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } { // ':' @@ -34224,18 +34456,18 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -34244,9 +34476,9 @@ _tmp_141_rule(Parser *p) return _res; } -// _tmp_142: positional_patterns ',' +// _tmp_143: positional_patterns ',' static void * -_tmp_142_rule(Parser *p) +_tmp_143_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34262,7 +34494,7 @@ _tmp_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -34271,12 +34503,12 @@ _tmp_142_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_143[%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_142[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); } _res = NULL; @@ -34285,9 +34517,9 @@ _tmp_142_rule(Parser *p) return _res; } -// _tmp_143: '}' | ',' +// _tmp_144: '}' | ',' static void * -_tmp_143_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34303,18 +34535,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } { // ',' @@ -34322,18 +34554,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -34342,9 +34574,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: '=' | '!' | ':' | '}' +// _tmp_145: '=' | '!' | ':' | '}' static void * -_tmp_144_rule(Parser *p) +_tmp_145_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34360,18 +34592,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, "'='")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; 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, "'='")); } { // '!' @@ -34379,18 +34611,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, "'!'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; 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, "'!'")); } { // ':' @@ -34398,18 +34630,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } { // '}' @@ -34417,18 +34649,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; 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, "'}'")); } _res = NULL; @@ -34437,9 +34669,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _tmp_145: '!' | ':' | '}' +// _tmp_146: '!' | ':' | '}' static void * -_tmp_145_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34455,18 +34687,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -34474,18 +34706,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -34493,18 +34725,18 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -34513,9 +34745,9 @@ _tmp_145_rule(Parser *p) return _res; } -// _tmp_146: '!' NAME +// _tmp_147: '!' NAME static void * -_tmp_146_rule(Parser *p) +_tmp_147_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34531,7 +34763,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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -34540,12 +34772,12 @@ _tmp_146_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_147[%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_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, "'!' NAME")); } _res = NULL; @@ -34554,9 +34786,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: ':' | '}' +// _tmp_148: ':' | '}' static void * -_tmp_147_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34572,18 +34804,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, "':'")); } { // '}' @@ -34591,18 +34823,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, 26)) // 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; @@ -34611,9 +34843,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: '+' | '-' | '*' | '/' | '%' | '//' | '@' +// _tmp_149: '+' | '-' | '*' | '/' | '%' | '//' | '@' static void * -_tmp_148_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34629,18 +34861,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _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, "'+'")); } { // '-' @@ -34648,18 +34880,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _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, "'-'")); } { // '*' @@ -34667,18 +34899,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _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, "'*'")); } { // '/' @@ -34686,18 +34918,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _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, "'/'")); } { // '%' @@ -34705,18 +34937,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 24)) // token='%' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); _res = _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, "'%'")); } { // '//' @@ -34724,18 +34956,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 47)) // token='//' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); _res = _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, "'//'")); } { // '@' @@ -34743,18 +34975,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); _res = _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, "'@'")); } _res = NULL; @@ -34763,9 +34995,9 @@ _tmp_148_rule(Parser *p) return _res; } -// _tmp_149: '+' | '-' | '~' +// _tmp_150: '+' | '-' | '~' static void * -_tmp_149_rule(Parser *p) +_tmp_150_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34781,18 +35013,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _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, "'+'")); } { // '-' @@ -34800,18 +35032,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _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, "'-'")); } { // '~' @@ -34819,18 +35051,18 @@ _tmp_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 31)) // token='~' ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); _res = _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, "'~'")); } _res = NULL; @@ -34839,9 +35071,9 @@ _tmp_149_rule(Parser *p) return _res; } -// _tmp_150: star_targets '=' +// _tmp_151: star_targets '=' static void * -_tmp_150_rule(Parser *p) +_tmp_151_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34857,7 +35089,7 @@ _tmp_150_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -34866,7 +35098,7 @@ _tmp_150_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -34876,7 +35108,7 @@ _tmp_150_rule(Parser *p) 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, "star_targets '='")); } _res = NULL; @@ -34885,9 +35117,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) { _Pypegen_stack_overflow(p); @@ -34903,18 +35135,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, 23)) // 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, "'.'")); } { // '...' @@ -34922,18 +35154,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, 52)) // 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; @@ -34942,9 +35174,9 @@ _tmp_151_rule(Parser *p) return _res; } -// _tmp_152: '@' named_expression NEWLINE +// _tmp_153: '@' named_expression NEWLINE static void * -_tmp_152_rule(Parser *p) +_tmp_153_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -34960,7 +35192,7 @@ _tmp_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -34972,7 +35204,7 @@ _tmp_152_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); _res = f; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -34982,7 +35214,7 @@ _tmp_152_rule(Parser *p) 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, "'@' named_expression NEWLINE")); } _res = NULL; @@ -34991,9 +35223,9 @@ _tmp_152_rule(Parser *p) return _res; } -// _tmp_153: ',' star_expression +// _tmp_154: ',' star_expression static void * -_tmp_153_rule(Parser *p) +_tmp_154_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35009,7 +35241,7 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -35018,7 +35250,7 @@ _tmp_153_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35028,7 +35260,7 @@ _tmp_153_rule(Parser *p) 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, "',' star_expression")); } _res = NULL; @@ -35037,9 +35269,9 @@ _tmp_153_rule(Parser *p) return _res; } -// _tmp_154: 'or' conjunction +// _tmp_155: 'or' conjunction static void * -_tmp_154_rule(Parser *p) +_tmp_155_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35055,7 +35287,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, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -35064,7 +35296,7 @@ _tmp_154_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35074,7 +35306,7 @@ _tmp_154_rule(Parser *p) 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, "'or' conjunction")); } _res = NULL; @@ -35083,9 +35315,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _tmp_155: 'and' inversion +// _tmp_156: 'and' inversion static void * -_tmp_155_rule(Parser *p) +_tmp_156_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35101,7 +35333,7 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -35110,7 +35342,7 @@ _tmp_155_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35120,7 +35352,7 @@ _tmp_155_rule(Parser *p) 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, "'and' inversion")); } _res = NULL; @@ -35129,9 +35361,9 @@ _tmp_155_rule(Parser *p) return _res; } -// _tmp_156: slice | starred_expression +// _tmp_157: slice | starred_expression static void * -_tmp_156_rule(Parser *p) +_tmp_157_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35147,18 +35379,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, "slice")); + D(fprintf(stderr, "%*c> _tmp_157[%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_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c+ _tmp_157[%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_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, "slice")); } { // starred_expression @@ -35166,18 +35398,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, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_157[%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_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_157[%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_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, "starred_expression")); } _res = NULL; @@ -35186,9 +35418,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: fstring | string +// _tmp_158: fstring | string static void * -_tmp_157_rule(Parser *p) +_tmp_158_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35204,18 +35436,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, "fstring")); + D(fprintf(stderr, "%*c> _tmp_158[%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_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_158[%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_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, "fstring")); } { // string @@ -35223,18 +35455,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, "string")); + D(fprintf(stderr, "%*c> _tmp_158[%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_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c+ _tmp_158[%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_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, "string")); } _res = NULL; @@ -35243,9 +35475,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: 'if' disjunction +// _tmp_159: 'if' disjunction static void * -_tmp_158_rule(Parser *p) +_tmp_159_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35261,7 +35493,7 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -35270,7 +35502,7 @@ _tmp_158_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35280,7 +35512,7 @@ _tmp_158_rule(Parser *p) 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, "'if' disjunction")); } _res = NULL; @@ -35289,9 +35521,9 @@ _tmp_158_rule(Parser *p) return _res; } -// _tmp_159: starred_expression | (assignment_expression | expression !':=') !'=' +// _tmp_160: starred_expression | (assignment_expression | expression !':=') !'=' static void * -_tmp_159_rule(Parser *p) +_tmp_160_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35307,18 +35539,18 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_160[%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_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_160[%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_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, "starred_expression")); } { // (assignment_expression | expression !':=') !'=' @@ -35326,20 +35558,20 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - void *_tmp_85_var; + D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + void *_tmp_86_var; if ( - (_tmp_85_var = _tmp_85_rule(p)) // assignment_expression | expression !':=' + (_tmp_86_var = _tmp_86_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_85_var; + D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_86_var; 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, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -35348,9 +35580,9 @@ _tmp_159_rule(Parser *p) return _res; } -// _tmp_160: ',' star_target +// _tmp_161: ',' star_target static void * -_tmp_160_rule(Parser *p) +_tmp_161_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35366,7 +35598,7 @@ _tmp_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -35375,7 +35607,7 @@ _tmp_160_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35385,7 +35617,7 @@ _tmp_160_rule(Parser *p) 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, "',' star_target")); } _res = NULL; @@ -35394,10 +35626,10 @@ _tmp_160_rule(Parser *p) return _res; } -// _tmp_161: +// _tmp_162: // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs static void * -_tmp_161_rule(Parser *p) +_tmp_162_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35413,24 +35645,24 @@ _tmp_161_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - asdl_seq * _gather_87_var; + D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + asdl_seq * _gather_88_var; Token * _literal; asdl_seq* kwargs_var; if ( - (_gather_87_var = _gather_87_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (_gather_88_var = _gather_88_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_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - _res = _PyPegen_dummy_name(p, _gather_87_var, _literal, kwargs_var); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + _res = _PyPegen_dummy_name(p, _gather_88_var, _literal, kwargs_var); 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, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); } _res = NULL; @@ -35439,9 +35671,9 @@ _tmp_161_rule(Parser *p) return _res; } -// _tmp_162: starred_expression !'=' +// _tmp_163: starred_expression !'=' static void * -_tmp_162_rule(Parser *p) +_tmp_163_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35457,7 +35689,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, "starred_expression !'='")); + D(fprintf(stderr, "%*c> _tmp_163[%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 @@ -35465,12 +35697,12 @@ _tmp_162_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c+ _tmp_163[%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_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, "starred_expression !'='")); } _res = NULL; @@ -35479,9 +35711,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: ')' | '**' +// _tmp_164: ')' | '**' static void * -_tmp_163_rule(Parser *p) +_tmp_164_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35497,18 +35729,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; 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, "')'")); } { // '**' @@ -35516,18 +35748,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } _res = NULL; @@ -35536,9 +35768,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: ':' | '**' +// _tmp_165: ':' | '**' static void * -_tmp_164_rule(Parser *p) +_tmp_165_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35554,18 +35786,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } { // '**' @@ -35573,18 +35805,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } _res = NULL; @@ -35593,9 +35825,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _loop0_165: (',' bitwise_or) +// _loop0_166: (',' bitwise_or) static asdl_seq * -_loop0_165_rule(Parser *p) +_loop0_166_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35620,13 +35852,13 @@ _loop0_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); - void *_tmp_168_var; + D(fprintf(stderr, "%*c> _loop0_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); + void *_tmp_169_var; while ( - (_tmp_168_var = _tmp_168_rule(p)) // ',' bitwise_or + (_tmp_169_var = _tmp_169_rule(p)) // ',' bitwise_or ) { - _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 *)); @@ -35643,7 +35875,7 @@ _loop0_165_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_165[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_166[%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); @@ -35660,9 +35892,9 @@ _loop0_165_rule(Parser *p) return _seq; } -// _tmp_166: expression ['as' star_target] +// _tmp_167: expression ['as' star_target] static void * -_tmp_166_rule(Parser *p) +_tmp_167_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35678,22 +35910,22 @@ _tmp_166_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_167[%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_169_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_170_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_167[%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_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, "expression ['as' star_target]")); } _res = NULL; @@ -35702,9 +35934,9 @@ _tmp_166_rule(Parser *p) return _res; } -// _tmp_167: expressions ['as' star_target] +// _tmp_168: expressions ['as' star_target] static void * -_tmp_167_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35720,22 +35952,22 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_168[%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_169_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_170_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_168[%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_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, "expressions ['as' star_target]")); } _res = NULL; @@ -35744,9 +35976,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _tmp_168: ',' bitwise_or +// _tmp_169: ',' bitwise_or static void * -_tmp_168_rule(Parser *p) +_tmp_169_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35762,7 +35994,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, "',' bitwise_or")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); Token * _literal; expr_ty bitwise_or_var; if ( @@ -35771,12 +36003,12 @@ _tmp_168_rule(Parser *p) (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c+ _tmp_169[%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_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, "',' bitwise_or")); } _res = NULL; @@ -35785,9 +36017,9 @@ _tmp_168_rule(Parser *p) return _res; } -// _tmp_169: 'as' star_target +// _tmp_170: 'as' star_target static void * -_tmp_169_rule(Parser *p) +_tmp_170_rule(Parser *p) { if (p->level++ == MAXSTACK) { _Pypegen_stack_overflow(p); @@ -35803,7 +36035,7 @@ _tmp_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( @@ -35812,12 +36044,12 @@ _tmp_169_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_170[%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_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, "'as' star_target")); } _res = NULL; diff --git a/Python/codegen.c b/Python/codegen.c index 4bb69ee8b214fb..25c6a0787b7c17 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -3901,11 +3901,6 @@ codegen_joined_str(compiler *c, expr_ty e) static int codegen_interpolation(compiler *c, expr_ty e) { - /* The oparg encodes which values are there: - - (oparg >> 2) & 1 == 1, always true, value and str are always there - - (oparg >> 1) & 1 == 1, if conversion is not NULL - - oparg & 1 == 1, if format_spec is not NULL - */ location loc = LOC(e); VISIT(c, expr, e->v.Interpolation.value); From 5e7304f7164233e408c0ee1af62c98dd776a4e87 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 25 Oct 2024 11:28:01 +0200 Subject: [PATCH 17/88] Fix code generation for when there's many values in tstring --- Include/internal/pycore_opcode_metadata.h | 9 +- Include/internal/pycore_template.h | 5 +- Include/internal/pycore_uop_ids.h | 1 + Include/internal/pycore_uop_metadata.h | 4 + Include/opcode_ids.h | 227 +++++++++++----------- Lib/_opcode_metadata.py | 227 +++++++++++----------- Objects/interpolationobject.c | 18 +- Objects/templateobject.c | 19 +- Python/bytecodes.c | 10 +- Python/codegen.c | 5 +- Python/executor_cases.c.h | 16 +- Python/generated_cases.c.h | 19 +- Python/opcode_targets.h | 4 +- Python/optimizer_cases.c.h | 7 + 14 files changed, 321 insertions(+), 250 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 51146cad722964..1600d169975177 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -81,6 +81,8 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return oparg; case BUILD_TEMPLATE: return oparg; + case BUILD_TEMPLATE_FROM_LIST: + return 1; case BUILD_TUPLE: return oparg; case CACHE: @@ -544,6 +546,8 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 1; case BUILD_TEMPLATE: return 1; + case BUILD_TEMPLATE_FROM_LIST: + return 1; case BUILD_TUPLE: return 1; case CACHE: @@ -1045,6 +1049,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TEMPLATE_FROM_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, @@ -1284,6 +1289,7 @@ _PyOpcode_macro_expansion[256] = { [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, 0, 0 } } }, [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, 0, 0 } } }, [BUILD_TEMPLATE] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE, 0, 0 } } }, + [BUILD_TEMPLATE_FROM_LIST] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE_FROM_LIST, 0, 0 } } }, [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, 0, 0 } } }, [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 4, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_AND_ALLOCATE_OBJECT, 2, 1 }, { _CREATE_INIT_FRAME, 0, 0 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_FUNCTION_EXACT_ARGS, 0, 0 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, @@ -1467,6 +1473,7 @@ const char *_PyOpcode_OpName[266] = { [BUILD_SLICE] = "BUILD_SLICE", [BUILD_STRING] = "BUILD_STRING", [BUILD_TEMPLATE] = "BUILD_TEMPLATE", + [BUILD_TEMPLATE_FROM_LIST] = "BUILD_TEMPLATE_FROM_LIST", [BUILD_TUPLE] = "BUILD_TUPLE", [CACHE] = "CACHE", [CALL] = "CALL", @@ -1725,6 +1732,7 @@ const uint8_t _PyOpcode_Deopt[256] = { [BUILD_SLICE] = BUILD_SLICE, [BUILD_STRING] = BUILD_STRING, [BUILD_TEMPLATE] = BUILD_TEMPLATE, + [BUILD_TEMPLATE_FROM_LIST] = BUILD_TEMPLATE_FROM_LIST, [BUILD_TUPLE] = BUILD_TUPLE, [CACHE] = CACHE, [CALL] = CALL, @@ -1923,7 +1931,6 @@ const uint8_t _PyOpcode_Deopt[256] = { #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ - case 118: \ case 119: \ case 120: \ case 121: \ diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 5e9f9d793f6a2e..0f4d05d690f549 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -9,9 +9,12 @@ extern "C" { # error "this header requires Py_BUILD_CORE define" #endif +#include "pycore_stackref.h" // _PyStackRef + extern PyTypeObject _PyTemplate_Type; -PyAPI_FUNC(PyObject *) _PyTemplate_Create(PyObject **values, Py_ssize_t n); +PyAPI_FUNC(PyObject *) _PyTemplate_FromValues(PyObject **values, Py_ssize_t n); +PyAPI_FUNC(PyObject *) _PyTemplate_FromListStackRef(_PyStackRef ref); #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 38c1fce14c1bb4..0deed08b962b70 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -35,6 +35,7 @@ extern "C" { #define _BUILD_SLICE BUILD_SLICE #define _BUILD_STRING BUILD_STRING #define _BUILD_TEMPLATE BUILD_TEMPLATE +#define _BUILD_TEMPLATE_FROM_LIST BUILD_TEMPLATE_FROM_LIST #define _BUILD_TUPLE BUILD_TUPLE #define _CALL_BUILTIN_CLASS 315 #define _CALL_BUILTIN_FAST 316 diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 3aea0ae6cd0900..d175fcfdb97847 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -130,6 +130,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TEMPLATE_FROM_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -320,6 +321,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BUILD_SLICE] = "_BUILD_SLICE", [_BUILD_STRING] = "_BUILD_STRING", [_BUILD_TEMPLATE] = "_BUILD_TEMPLATE", + [_BUILD_TEMPLATE_FROM_LIST] = "_BUILD_TEMPLATE_FROM_LIST", [_BUILD_TUPLE] = "_BUILD_TUPLE", [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", @@ -790,6 +792,8 @@ int _PyUop_num_popped(int opcode, int oparg) return 4; case _BUILD_TEMPLATE: return oparg; + case _BUILD_TEMPLATE_FROM_LIST: + return 1; case _BUILD_TUPLE: return oparg; case _BUILD_LIST: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 89f3832bbc3ae8..03ebe81ce3746e 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -15,119 +15,120 @@ extern "C" { #define BINARY_SUBSCR 2 #define BINARY_OP_INPLACE_ADD_UNICODE 3 #define BUILD_INTERPOLATION 4 -#define CHECK_EG_MATCH 5 -#define CHECK_EXC_MATCH 6 -#define CLEANUP_THROW 7 -#define DELETE_SUBSCR 8 -#define END_ASYNC_FOR 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 BUILD_TEMPLATE_FROM_LIST 5 +#define CHECK_EG_MATCH 6 +#define CHECK_EXC_MATCH 7 +#define CLEANUP_THROW 8 +#define DELETE_SUBSCR 9 +#define END_ASYNC_FOR 10 +#define END_FOR 11 +#define END_SEND 12 +#define EXIT_INIT_CHECK 13 +#define FORMAT_SIMPLE 14 +#define FORMAT_WITH_SPEC 15 +#define GET_AITER 16 #define RESERVED 17 -#define GET_ITER 18 -#define GET_LEN 19 -#define GET_YIELD_FROM_ITER 20 -#define INTERPRETER_EXIT 21 -#define LOAD_BUILD_CLASS 22 -#define LOAD_LOCALS 23 -#define MAKE_FUNCTION 24 -#define MATCH_KEYS 25 -#define MATCH_MAPPING 26 -#define MATCH_SEQUENCE 27 -#define NOP 28 -#define POP_EXCEPT 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_LIST 44 -#define BUILD_MAP 45 -#define BUILD_SET 46 -#define BUILD_SLICE 47 -#define BUILD_STRING 48 -#define BUILD_TEMPLATE 49 -#define BUILD_TUPLE 50 -#define CALL 51 -#define CALL_FUNCTION_EX 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 DELETE_GLOBAL 64 -#define DELETE_NAME 65 -#define DICT_MERGE 66 -#define DICT_UPDATE 67 -#define EXTENDED_ARG 68 -#define FOR_ITER 69 -#define GET_AWAITABLE 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_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_SPECIAL 91 -#define LOAD_SUPER_ATTR 92 -#define MAKE_CELL 93 -#define MAP_ADD 94 -#define MATCH_CLASS 95 -#define POP_JUMP_IF_FALSE 96 -#define POP_JUMP_IF_NONE 97 -#define POP_JUMP_IF_NOT_NONE 98 -#define POP_JUMP_IF_TRUE 99 -#define RAISE_VARARGS 100 -#define RERAISE 101 -#define RETURN_CONST 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_ANEXT 18 +#define GET_ITER 19 +#define GET_LEN 20 +#define GET_YIELD_FROM_ITER 21 +#define INTERPRETER_EXIT 22 +#define LOAD_BUILD_CLASS 23 +#define LOAD_LOCALS 24 +#define MAKE_FUNCTION 25 +#define MATCH_KEYS 26 +#define MATCH_MAPPING 27 +#define MATCH_SEQUENCE 28 +#define NOP 29 +#define POP_EXCEPT 30 +#define POP_TOP 31 +#define PUSH_EXC_INFO 32 +#define PUSH_NULL 33 +#define RETURN_GENERATOR 34 +#define RETURN_VALUE 35 +#define SETUP_ANNOTATIONS 36 +#define STORE_SLICE 37 +#define STORE_SUBSCR 38 +#define TO_BOOL 39 +#define UNARY_INVERT 40 +#define UNARY_NEGATIVE 41 +#define UNARY_NOT 42 +#define WITH_EXCEPT_START 43 +#define BINARY_OP 44 +#define BUILD_LIST 45 +#define BUILD_MAP 46 +#define BUILD_SET 47 +#define BUILD_SLICE 48 +#define BUILD_STRING 49 +#define BUILD_TEMPLATE 50 +#define BUILD_TUPLE 51 +#define CALL 52 +#define CALL_FUNCTION_EX 53 +#define CALL_INTRINSIC_1 54 +#define CALL_INTRINSIC_2 55 +#define CALL_KW 56 +#define COMPARE_OP 57 +#define CONTAINS_OP 58 +#define CONVERT_VALUE 59 +#define COPY 60 +#define COPY_FREE_VARS 61 +#define DELETE_ATTR 62 +#define DELETE_DEREF 63 +#define DELETE_FAST 64 +#define DELETE_GLOBAL 65 +#define DELETE_NAME 66 +#define DICT_MERGE 67 +#define DICT_UPDATE 68 +#define EXTENDED_ARG 69 +#define FOR_ITER 70 +#define GET_AWAITABLE 71 +#define IMPORT_FROM 72 +#define IMPORT_NAME 73 +#define IS_OP 74 +#define JUMP_BACKWARD 75 +#define JUMP_BACKWARD_NO_INTERRUPT 76 +#define JUMP_FORWARD 77 +#define LIST_APPEND 78 +#define LIST_EXTEND 79 +#define LOAD_ATTR 80 +#define LOAD_COMMON_CONSTANT 81 +#define LOAD_CONST 82 +#define LOAD_DEREF 83 +#define LOAD_FAST 84 +#define LOAD_FAST_AND_CLEAR 85 +#define LOAD_FAST_CHECK 86 +#define LOAD_FAST_LOAD_FAST 87 +#define LOAD_FROM_DICT_OR_DEREF 88 +#define LOAD_FROM_DICT_OR_GLOBALS 89 +#define LOAD_GLOBAL 90 +#define LOAD_NAME 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 RETURN_CONST 103 +#define SEND 104 +#define SET_ADD 105 +#define SET_FUNCTION_ATTRIBUTE 106 +#define SET_UPDATE 107 +#define STORE_ATTR 108 +#define STORE_DEREF 109 +#define STORE_FAST 110 +#define STORE_FAST_LOAD_FAST 111 +#define STORE_FAST_STORE_FAST 112 +#define STORE_GLOBAL 113 +#define STORE_NAME 114 +#define SWAP 115 +#define UNPACK_EX 116 +#define UNPACK_SEQUENCE 117 +#define YIELD_VALUE 118 #define RESUME 149 #define BINARY_OP_ADD_FLOAT 150 #define BINARY_OP_ADD_INT 151 @@ -237,7 +238,7 @@ extern "C" { #define SETUP_WITH 264 #define STORE_FAST_MAYBE_NULL 265 -#define HAVE_ARGUMENT 42 +#define HAVE_ARGUMENT 43 #define MIN_SPECIALIZED_OPCODE 150 #define MIN_INSTRUMENTED_OPCODE 236 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index d3c67e5679a1aa..fb49c76f6eeb58 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -205,118 +205,119 @@ 'BINARY_SLICE': 1, 'BINARY_SUBSCR': 2, 'BUILD_INTERPOLATION': 4, - 'CHECK_EG_MATCH': 5, - 'CHECK_EXC_MATCH': 6, - 'CLEANUP_THROW': 7, - 'DELETE_SUBSCR': 8, - 'END_ASYNC_FOR': 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_ITER': 18, - 'GET_LEN': 19, - 'GET_YIELD_FROM_ITER': 20, - 'INTERPRETER_EXIT': 21, - 'LOAD_BUILD_CLASS': 22, - 'LOAD_LOCALS': 23, - 'MAKE_FUNCTION': 24, - 'MATCH_KEYS': 25, - 'MATCH_MAPPING': 26, - 'MATCH_SEQUENCE': 27, - 'NOP': 28, - 'POP_EXCEPT': 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_LIST': 44, - 'BUILD_MAP': 45, - 'BUILD_SET': 46, - 'BUILD_SLICE': 47, - 'BUILD_STRING': 48, - 'BUILD_TEMPLATE': 49, - 'BUILD_TUPLE': 50, - 'CALL': 51, - 'CALL_FUNCTION_EX': 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, - 'DELETE_GLOBAL': 64, - 'DELETE_NAME': 65, - 'DICT_MERGE': 66, - 'DICT_UPDATE': 67, - 'EXTENDED_ARG': 68, - 'FOR_ITER': 69, - 'GET_AWAITABLE': 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_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_SPECIAL': 91, - 'LOAD_SUPER_ATTR': 92, - 'MAKE_CELL': 93, - 'MAP_ADD': 94, - 'MATCH_CLASS': 95, - 'POP_JUMP_IF_FALSE': 96, - 'POP_JUMP_IF_NONE': 97, - 'POP_JUMP_IF_NOT_NONE': 98, - 'POP_JUMP_IF_TRUE': 99, - 'RAISE_VARARGS': 100, - 'RERAISE': 101, - 'RETURN_CONST': 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_TEMPLATE_FROM_LIST': 5, + 'CHECK_EG_MATCH': 6, + 'CHECK_EXC_MATCH': 7, + 'CLEANUP_THROW': 8, + 'DELETE_SUBSCR': 9, + 'END_ASYNC_FOR': 10, + 'END_FOR': 11, + 'END_SEND': 12, + 'EXIT_INIT_CHECK': 13, + 'FORMAT_SIMPLE': 14, + 'FORMAT_WITH_SPEC': 15, + 'GET_AITER': 16, + 'GET_ANEXT': 18, + 'GET_ITER': 19, + 'GET_LEN': 20, + 'GET_YIELD_FROM_ITER': 21, + 'INTERPRETER_EXIT': 22, + 'LOAD_BUILD_CLASS': 23, + 'LOAD_LOCALS': 24, + 'MAKE_FUNCTION': 25, + 'MATCH_KEYS': 26, + 'MATCH_MAPPING': 27, + 'MATCH_SEQUENCE': 28, + 'NOP': 29, + 'POP_EXCEPT': 30, + 'POP_TOP': 31, + 'PUSH_EXC_INFO': 32, + 'PUSH_NULL': 33, + 'RETURN_GENERATOR': 34, + 'RETURN_VALUE': 35, + 'SETUP_ANNOTATIONS': 36, + 'STORE_SLICE': 37, + 'STORE_SUBSCR': 38, + 'TO_BOOL': 39, + 'UNARY_INVERT': 40, + 'UNARY_NEGATIVE': 41, + 'UNARY_NOT': 42, + 'WITH_EXCEPT_START': 43, + 'BINARY_OP': 44, + 'BUILD_LIST': 45, + 'BUILD_MAP': 46, + 'BUILD_SET': 47, + 'BUILD_SLICE': 48, + 'BUILD_STRING': 49, + 'BUILD_TEMPLATE': 50, + 'BUILD_TUPLE': 51, + 'CALL': 52, + 'CALL_FUNCTION_EX': 53, + 'CALL_INTRINSIC_1': 54, + 'CALL_INTRINSIC_2': 55, + 'CALL_KW': 56, + 'COMPARE_OP': 57, + 'CONTAINS_OP': 58, + 'CONVERT_VALUE': 59, + 'COPY': 60, + 'COPY_FREE_VARS': 61, + 'DELETE_ATTR': 62, + 'DELETE_DEREF': 63, + 'DELETE_FAST': 64, + 'DELETE_GLOBAL': 65, + 'DELETE_NAME': 66, + 'DICT_MERGE': 67, + 'DICT_UPDATE': 68, + 'EXTENDED_ARG': 69, + 'FOR_ITER': 70, + 'GET_AWAITABLE': 71, + 'IMPORT_FROM': 72, + 'IMPORT_NAME': 73, + 'IS_OP': 74, + 'JUMP_BACKWARD': 75, + 'JUMP_BACKWARD_NO_INTERRUPT': 76, + 'JUMP_FORWARD': 77, + 'LIST_APPEND': 78, + 'LIST_EXTEND': 79, + 'LOAD_ATTR': 80, + 'LOAD_COMMON_CONSTANT': 81, + 'LOAD_CONST': 82, + 'LOAD_DEREF': 83, + 'LOAD_FAST': 84, + 'LOAD_FAST_AND_CLEAR': 85, + 'LOAD_FAST_CHECK': 86, + 'LOAD_FAST_LOAD_FAST': 87, + 'LOAD_FROM_DICT_OR_DEREF': 88, + 'LOAD_FROM_DICT_OR_GLOBALS': 89, + 'LOAD_GLOBAL': 90, + 'LOAD_NAME': 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, + 'RETURN_CONST': 103, + 'SEND': 104, + 'SET_ADD': 105, + 'SET_FUNCTION_ATTRIBUTE': 106, + 'SET_UPDATE': 107, + 'STORE_ATTR': 108, + 'STORE_DEREF': 109, + 'STORE_FAST': 110, + 'STORE_FAST_LOAD_FAST': 111, + 'STORE_FAST_STORE_FAST': 112, + 'STORE_GLOBAL': 113, + 'STORE_NAME': 114, + 'SWAP': 115, + 'UNPACK_EX': 116, + 'UNPACK_SEQUENCE': 117, + 'YIELD_VALUE': 118, 'INSTRUMENTED_END_FOR': 236, 'INSTRUMENTED_END_SEND': 237, 'INSTRUMENTED_LOAD_SUPER_ATTR': 238, @@ -347,5 +348,5 @@ 'STORE_FAST_MAYBE_NULL': 265, } -HAVE_ARGUMENT = 42 +HAVE_ARGUMENT = 43 MIN_INSTRUMENTED_OPCODE = 236 diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 161cc01ad57578..82c348ec16fc7b 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -229,7 +229,11 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values) { PyObject *args = PyTuple_New(4); if (!args) { - goto error; + PyStackRef_CLOSE(values[0]); + PyStackRef_CLOSE(values[1]); + PyStackRef_XCLOSE(values[2]); + PyStackRef_XCLOSE(values[3]); + return NULL; } PyTuple_SET_ITEM(args, 0, PyStackRef_AsPyObjectSteal(values[0])); @@ -242,16 +246,6 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values) PyTuple_SET_ITEM(args, 3, format_spec ? format_spec : &_Py_STR(empty)); PyObject *interpolation = PyObject_CallObject((PyObject *) &_PyInterpolation_Type, args); - if (!interpolation) { - Py_DECREF(args); - goto error; - } + Py_DECREF(args); return interpolation; - -error: - PyStackRef_CLOSE(values[0]); - PyStackRef_CLOSE(values[1]); - PyStackRef_XCLOSE(values[2]); - PyStackRef_XCLOSE(values[3]); - return NULL; } diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 1a5da9a7ce809d..7777b529608b8e 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -2,6 +2,7 @@ #include "Python.h" #include +#include "pycore_stackref.h" // _PyStackRef #include "pycore_global_objects.h" // _Py_STR #include "pycore_runtime.h" // _Py_STR @@ -219,7 +220,7 @@ PyTypeObject _PyTemplate_Type = { }; PyObject * -_PyTemplate_Create(PyObject **values, Py_ssize_t oparg) +_PyTemplate_FromValues(PyObject **values, Py_ssize_t oparg) { PyObject *tuple = PyTuple_New(oparg); if (!tuple) { @@ -234,3 +235,19 @@ _PyTemplate_Create(PyObject **values, Py_ssize_t oparg) Py_DECREF(tuple); return template; } + +PyObject * +_PyTemplate_FromListStackRef(_PyStackRef ref) +{ + PyObject *list = PyStackRef_AsPyObjectSteal(ref); + + PyObject *tuple = PySequence_Tuple(list); + if (!tuple) { + PyStackRef_CLOSE(ref); + return NULL; + } + + PyObject *template = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); + Py_DECREF(tuple); + return template; +} diff --git a/Python/bytecodes.c b/Python/bytecodes.c index f79d52815984b1..3db166dd9b2399 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1728,6 +1728,7 @@ dummy_func( inst(BUILD_INTERPOLATION, (values[4] -- interpolation)) { PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); + INPUTS_DEAD(); ERROR_IF(interpolation_o == NULL, error); interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); } @@ -1738,13 +1739,20 @@ dummy_func( DECREF_INPUTS(); ERROR_IF(true, error); } - PyObject *template_o = _PyTemplate_Create(pieces_o, oparg); + PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); DECREF_INPUTS(); ERROR_IF(template_o == NULL, error); template = PyStackRef_FromPyObjectSteal(template_o); } + inst(BUILD_TEMPLATE_FROM_LIST, (list -- template)) { + PyObject *template_o = _PyTemplate_FromListStackRef(list); + DECREF_INPUTS(); + ERROR_IF(template_o == NULL, error); + template = PyStackRef_FromPyObjectSteal(template_o); + } + inst(BUILD_TUPLE, (values[oparg] -- tup)) { PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); INPUTS_DEAD(); diff --git a/Python/codegen.c b/Python/codegen.c index 25c6a0787b7c17..8da71178acb9f1 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -3852,15 +3852,12 @@ codegen_template_str(compiler *c, expr_ty e) location loc = LOC(e); Py_ssize_t value_count = asdl_seq_LEN(e->v.TemplateStr.values); if (value_count > STACK_USE_GUIDELINE) { - _Py_DECLARE_STR(empty, ""); - ADDOP_LOAD_CONST_NEW(c, loc, Py_NewRef(&_Py_STR(empty))); - ADDOP_NAME(c, loc, LOAD_METHOD, &_Py_ID(join), names); ADDOP_I(c, loc, BUILD_LIST, 0); for (Py_ssize_t i = 0; i < asdl_seq_LEN(e->v.TemplateStr.values); i++) { VISIT(c, expr, asdl_seq_GET(e->v.TemplateStr.values, i)); ADDOP_I(c, loc, LIST_APPEND, 1); } - ADDOP_I(c, loc, CALL, 1); + ADDOP(c, loc, BUILD_TEMPLATE_FROM_LIST); } else { VISIT_SEQ(c, expr, e->v.TemplateStr.values); diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index ee5f2bcbf84382..ce36953d6b19b6 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2063,7 +2063,7 @@ if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *template_o = _PyTemplate_Create(pieces_o, oparg); + PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); for (int _i = oparg; --_i >= 0;) { @@ -2077,6 +2077,20 @@ break; } + case _BUILD_TEMPLATE_FROM_LIST: { + _PyStackRef list; + _PyStackRef template; + list = stack_pointer[-1]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *template_o = _PyTemplate_FromListStackRef(list); + stack_pointer = _PyFrame_GetStackPointer(frame); + PyStackRef_CLOSE(list); + if (template_o == NULL) JUMP_TO_ERROR(); + template = PyStackRef_FromPyObjectSteal(template_o); + stack_pointer[-1] = template; + break; + } + case _BUILD_TUPLE: { _PyStackRef *values; _PyStackRef tup; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 72c7ecdb9309e6..7199bb1f789048 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -863,7 +863,7 @@ } } _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *template_o = _PyTemplate_Create(pieces_o, oparg); + PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); for (int _i = oparg; --_i >= 0;) { @@ -881,6 +881,23 @@ DISPATCH(); } + TARGET(BUILD_TEMPLATE_FROM_LIST) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BUILD_TEMPLATE_FROM_LIST); + _PyStackRef list; + _PyStackRef template; + list = stack_pointer[-1]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *template_o = _PyTemplate_FromListStackRef(list); + stack_pointer = _PyFrame_GetStackPointer(frame); + PyStackRef_CLOSE(list); + if (template_o == NULL) goto pop_1_error; + template = PyStackRef_FromPyObjectSteal(template_o); + stack_pointer[-1] = template; + DISPATCH(); + } + TARGET(BUILD_TUPLE) { frame->instr_ptr = next_instr; next_instr += 1; diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 8088bc7450c35a..c5392d7d13ff31 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -4,6 +4,7 @@ static void *opcode_targets[256] = { &&TARGET_BINARY_SUBSCR, &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, &&TARGET_BUILD_INTERPOLATION, + &&TARGET_BUILD_TEMPLATE_FROM_LIST, &&TARGET_CHECK_EG_MATCH, &&TARGET_CHECK_EXC_MATCH, &&TARGET_CLEANUP_THROW, @@ -15,8 +16,8 @@ static void *opcode_targets[256] = { &&TARGET_FORMAT_SIMPLE, &&TARGET_FORMAT_WITH_SPEC, &&TARGET_GET_AITER, - &&TARGET_GET_ANEXT, &&TARGET_RESERVED, + &&TARGET_GET_ANEXT, &&TARGET_GET_ITER, &&TARGET_GET_LEN, &&TARGET_GET_YIELD_FROM_ITER, @@ -147,7 +148,6 @@ static void *opcode_targets[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, - &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index c3b5e26ca26341..7bb9dec292ddd4 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -955,6 +955,13 @@ break; } + case _BUILD_TEMPLATE_FROM_LIST: { + _Py_UopsSymbol *template; + template = sym_new_not_null(ctx); + stack_pointer[-1] = template; + break; + } + case _BUILD_TUPLE: { _Py_UopsSymbol *tup; tup = sym_new_not_null(ctx); From c8f22f07772166ee4bdfcb725b703cb21bbb89d1 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 25 Oct 2024 11:31:10 +0200 Subject: [PATCH 18/88] Remove duplicate parens from template repr --- Objects/templateobject.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 7777b529608b8e..525ad9d89ea13a 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -100,7 +100,7 @@ template_dealloc(templateobject *self) static PyObject * template_repr(templateobject *self) { - return PyUnicode_FromFormat("%s(%R)", + return PyUnicode_FromFormat("%s%R", _PyType_Name(Py_TYPE(self)), self->args); } From b0dbe270239ee7c781df91ac0c58d44d3d238040 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 25 Oct 2024 16:39:20 +0200 Subject: [PATCH 19/88] Fix conversion converter for interpolation __new__ --- Include/internal/pycore_interpolation.h | 2 +- Objects/interpolationobject.c | 7 ++++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index cc33f7ea6cb675..6f8259d6b84265 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -11,7 +11,7 @@ extern "C" { #include "pycore_stackref.h" // _PyStackRef -extern int _conversion_converter(PyObject *arg, PyObject **Py_UNUSED(unused)); +extern int _conversion_converter(PyObject *arg, PyObject **conv); extern PyTypeObject _PyInterpolation_Type; diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 82c348ec16fc7b..e1cdc5bd65f153 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -22,7 +22,7 @@ class templatelib.Interpolation "interpolationobject *" "&_PyInterpolation_Type" /*[clinic end generated code: output=da39a3ee5e6b4b0d input=5b183514b4d7e5af]*/ int -_conversion_converter(PyObject *arg, PyObject **Py_UNUSED(unused)) +_conversion_converter(PyObject *arg, PyObject **conv) { if (arg == Py_None) { return 1; @@ -34,13 +34,14 @@ _conversion_converter(PyObject *arg, PyObject **Py_UNUSED(unused)) } Py_ssize_t len; - const char *conv = PyUnicode_AsUTF8AndSize(arg, &len); - if (len != 1 || !(conv[0] == 'a' || conv[0] == 'r' || conv[0] == 's')) { + const char *conv_str = PyUnicode_AsUTF8AndSize(arg, &len); + if (len != 1 || !(conv_str[0] == 'a' || conv_str[0] == 'r' || conv_str[0] == 's')) { PyErr_SetString(PyExc_ValueError, "Interpolation() argument 'conv' must be one of 's', 'a' or 'r'"); return 0; } + *conv = arg; return 1; } From 3e8477123dde5e13dc1548a65afe8ea61f521470 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 1 Nov 2024 09:29:45 +0100 Subject: [PATCH 20/88] Fix test_embed and test_dis -- again --- Include/internal/pycore_opcode_metadata.h | 12 +- Include/internal/pycore_uop_ids.h | 2 +- Include/internal/pycore_uop_metadata.h | 6 +- Include/opcode_ids.h | 2 +- Lib/_opcode_metadata.py | 2 +- Lib/test/test_dis.py | 352 +++++++++++----------- Programs/test_frozenmain.h | 22 +- Python/bytecodes.c | 2 +- Python/codegen.c | 2 +- Python/executor_cases.c.h | 2 +- Python/generated_cases.c.h | 6 +- Python/opcode_targets.h | 2 +- Python/optimizer_cases.c.h | 2 +- 13 files changed, 207 insertions(+), 207 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 1600d169975177..fe327826437163 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -81,7 +81,7 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return oparg; case BUILD_TEMPLATE: return oparg; - case BUILD_TEMPLATE_FROM_LIST: + case BUILD_TEMPLATE_LIST: return 1; case BUILD_TUPLE: return oparg; @@ -546,7 +546,7 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 1; case BUILD_TEMPLATE: return 1; - case BUILD_TEMPLATE_FROM_LIST: + case BUILD_TEMPLATE_LIST: return 1; case BUILD_TUPLE: return 1; @@ -1049,7 +1049,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_TEMPLATE_FROM_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TEMPLATE_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, @@ -1289,7 +1289,7 @@ _PyOpcode_macro_expansion[256] = { [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, 0, 0 } } }, [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, 0, 0 } } }, [BUILD_TEMPLATE] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE, 0, 0 } } }, - [BUILD_TEMPLATE_FROM_LIST] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE_FROM_LIST, 0, 0 } } }, + [BUILD_TEMPLATE_LIST] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE_LIST, 0, 0 } } }, [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, 0, 0 } } }, [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 4, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_AND_ALLOCATE_OBJECT, 2, 1 }, { _CREATE_INIT_FRAME, 0, 0 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_FUNCTION_EXACT_ARGS, 0, 0 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, @@ -1473,7 +1473,7 @@ const char *_PyOpcode_OpName[266] = { [BUILD_SLICE] = "BUILD_SLICE", [BUILD_STRING] = "BUILD_STRING", [BUILD_TEMPLATE] = "BUILD_TEMPLATE", - [BUILD_TEMPLATE_FROM_LIST] = "BUILD_TEMPLATE_FROM_LIST", + [BUILD_TEMPLATE_LIST] = "BUILD_TEMPLATE_LIST", [BUILD_TUPLE] = "BUILD_TUPLE", [CACHE] = "CACHE", [CALL] = "CALL", @@ -1732,7 +1732,7 @@ const uint8_t _PyOpcode_Deopt[256] = { [BUILD_SLICE] = BUILD_SLICE, [BUILD_STRING] = BUILD_STRING, [BUILD_TEMPLATE] = BUILD_TEMPLATE, - [BUILD_TEMPLATE_FROM_LIST] = BUILD_TEMPLATE_FROM_LIST, + [BUILD_TEMPLATE_LIST] = BUILD_TEMPLATE_LIST, [BUILD_TUPLE] = BUILD_TUPLE, [CACHE] = CACHE, [CALL] = CALL, diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 0deed08b962b70..b3ac36499633e5 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -35,7 +35,7 @@ extern "C" { #define _BUILD_SLICE BUILD_SLICE #define _BUILD_STRING BUILD_STRING #define _BUILD_TEMPLATE BUILD_TEMPLATE -#define _BUILD_TEMPLATE_FROM_LIST BUILD_TEMPLATE_FROM_LIST +#define _BUILD_TEMPLATE_LIST BUILD_TEMPLATE_LIST #define _BUILD_TUPLE BUILD_TUPLE #define _CALL_BUILTIN_CLASS 315 #define _CALL_BUILTIN_FAST 316 diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index d175fcfdb97847..3af3c00571d6d0 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -130,7 +130,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BUILD_TEMPLATE_FROM_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -321,7 +321,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BUILD_SLICE] = "_BUILD_SLICE", [_BUILD_STRING] = "_BUILD_STRING", [_BUILD_TEMPLATE] = "_BUILD_TEMPLATE", - [_BUILD_TEMPLATE_FROM_LIST] = "_BUILD_TEMPLATE_FROM_LIST", + [_BUILD_TEMPLATE_LIST] = "_BUILD_TEMPLATE_LIST", [_BUILD_TUPLE] = "_BUILD_TUPLE", [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", @@ -792,7 +792,7 @@ int _PyUop_num_popped(int opcode, int oparg) return 4; case _BUILD_TEMPLATE: return oparg; - case _BUILD_TEMPLATE_FROM_LIST: + case _BUILD_TEMPLATE_LIST: return 1; case _BUILD_TUPLE: return oparg; diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 03ebe81ce3746e..afe5ca0e9ad405 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -15,7 +15,7 @@ extern "C" { #define BINARY_SUBSCR 2 #define BINARY_OP_INPLACE_ADD_UNICODE 3 #define BUILD_INTERPOLATION 4 -#define BUILD_TEMPLATE_FROM_LIST 5 +#define BUILD_TEMPLATE_LIST 5 #define CHECK_EG_MATCH 6 #define CHECK_EXC_MATCH 7 #define CLEANUP_THROW 8 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index fb49c76f6eeb58..1e3e7901fe8d24 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -205,7 +205,7 @@ 'BINARY_SLICE': 1, 'BINARY_SUBSCR': 2, 'BUILD_INTERPOLATION': 4, - 'BUILD_TEMPLATE_FROM_LIST': 5, + 'BUILD_TEMPLATE_LIST': 5, 'CHECK_EG_MATCH': 6, 'CHECK_EXC_MATCH': 7, 'CLEANUP_THROW': 8, diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py index 57ae5e29b9ef2c..b427fc6d7ef720 100644 --- a/Lib/test/test_dis.py +++ b/Lib/test/test_dis.py @@ -1707,201 +1707,201 @@ def _prepare_test_cases(): Instruction = dis.Instruction expected_opinfo_outer = [ - Instruction(opname='MAKE_CELL', opcode=93, arg=0, argval='a', argrepr='a', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_CELL', opcode=93, arg=1, argval='b', argrepr='b', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=94, arg=0, argval='a', argrepr='a', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=94, arg=1, argval='b', argrepr='b', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=4, start_offset=4, starts_line=True, line_number=1, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=5, argval=(3, 4), argrepr='(3, 4)', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='a', argrepr='a', offset=8, start_offset=8, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=1, argval='b', argrepr='b', offset=10, start_offset=10, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_TUPLE', opcode=50, arg=2, argval=2, argrepr='', offset=12, start_offset=12, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=1, argval=code_object_f, argrepr=repr(code_object_f), offset=14, start_offset=14, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_FUNCTION', opcode=24, arg=None, argval=None, argrepr='', offset=16, start_offset=16, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=8, argval=8, argrepr='closure', offset=18, start_offset=18, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=1, argval=1, argrepr='defaults', offset=20, start_offset=20, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='STORE_FAST', opcode=109, arg=2, argval='f', argrepr='f', offset=22, start_offset=22, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='print', argrepr='print + NULL', offset=24, start_offset=24, starts_line=True, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_DEREF', opcode=82, arg=0, argval='a', argrepr='a', offset=34, start_offset=34, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=1, argval='b', argrepr='b', offset=36, start_offset=36, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval='', argrepr="''", offset=38, start_offset=38, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=3, argval=1, argrepr='1', offset=40, start_offset=40, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_LIST', opcode=44, arg=0, argval=0, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_MAP', opcode=45, arg=0, argval=0, argrepr='', offset=44, start_offset=44, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=4, argval='Hello world!', argrepr="'Hello world!'", offset=46, start_offset=46, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=7, argval=7, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=2, argval='f', argrepr='f', offset=58, start_offset=58, starts_line=True, line_number=8, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_VALUE', opcode=34, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=5, argval=(3, 4), argrepr='(3, 4)', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='a', argrepr='a', offset=8, start_offset=8, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=1, argval='b', argrepr='b', offset=10, start_offset=10, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_TUPLE', opcode=51, arg=2, argval=2, argrepr='', offset=12, start_offset=12, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=1, argval=code_object_f, argrepr=repr(code_object_f), offset=14, start_offset=14, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_FUNCTION', opcode=25, arg=None, argval=None, argrepr='', offset=16, start_offset=16, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=8, argval=8, argrepr='closure', offset=18, start_offset=18, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=1, argval=1, argrepr='defaults', offset=20, start_offset=20, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='STORE_FAST', opcode=110, arg=2, argval='f', argrepr='f', offset=22, start_offset=22, starts_line=False, line_number=2, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=1, argval='print', argrepr='print + NULL', offset=24, start_offset=24, starts_line=True, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_DEREF', opcode=83, arg=0, argval='a', argrepr='a', offset=34, start_offset=34, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=1, argval='b', argrepr='b', offset=36, start_offset=36, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=2, argval='', argrepr="''", offset=38, start_offset=38, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=3, argval=1, argrepr='1', offset=40, start_offset=40, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_LIST', opcode=45, arg=0, argval=0, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_MAP', opcode=46, arg=0, argval=0, argrepr='', offset=44, start_offset=44, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=4, argval='Hello world!', argrepr="'Hello world!'", offset=46, start_offset=46, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=7, argval=7, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=2, argval='f', argrepr='f', offset=58, start_offset=58, starts_line=True, line_number=8, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_VALUE', opcode=35, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), ] expected_opinfo_f = [ - Instruction(opname='COPY_FREE_VARS', opcode=60, arg=2, argval=2, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_CELL', opcode=93, arg=0, argval='c', argrepr='c', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_CELL', opcode=93, arg=1, argval='d', argrepr='d', offset=4, start_offset=4, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='COPY_FREE_VARS', opcode=61, arg=2, argval=2, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=94, arg=0, argval='c', argrepr='c', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_CELL', opcode=94, arg=1, argval='d', argrepr='d', offset=4, start_offset=4, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval=(5, 6), argrepr='(5, 6)', offset=8, start_offset=8, starts_line=True, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=3, argval='a', argrepr='a', offset=10, start_offset=10, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=4, argval='b', argrepr='b', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='c', argrepr='c', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=1, argval='d', argrepr='d', offset=16, start_offset=16, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='BUILD_TUPLE', opcode=50, arg=4, argval=4, argrepr='', offset=18, start_offset=18, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=1, argval=code_object_inner, argrepr=repr(code_object_inner), offset=20, start_offset=20, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='MAKE_FUNCTION', opcode=24, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=8, argval=8, argrepr='closure', offset=24, start_offset=24, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=105, arg=1, argval=1, argrepr='defaults', offset=26, start_offset=26, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='STORE_FAST', opcode=109, arg=2, argval='inner', argrepr='inner', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_DEREF', opcode=82, arg=3, argval='a', argrepr='a', offset=40, start_offset=40, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=4, argval='b', argrepr='b', offset=42, start_offset=42, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=0, argval='c', argrepr='c', offset=44, start_offset=44, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=1, argval='d', argrepr='d', offset=46, start_offset=46, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=4, argval=4, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=2, argval='inner', argrepr='inner', offset=58, start_offset=58, starts_line=True, line_number=6, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_VALUE', opcode=34, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=6, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=2, argval=(5, 6), argrepr='(5, 6)', offset=8, start_offset=8, starts_line=True, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=3, argval='a', argrepr='a', offset=10, start_offset=10, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=4, argval='b', argrepr='b', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='c', argrepr='c', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=1, argval='d', argrepr='d', offset=16, start_offset=16, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='BUILD_TUPLE', opcode=51, arg=4, argval=4, argrepr='', offset=18, start_offset=18, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=1, argval=code_object_inner, argrepr=repr(code_object_inner), offset=20, start_offset=20, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='MAKE_FUNCTION', opcode=25, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=8, argval=8, argrepr='closure', offset=24, start_offset=24, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=1, argval=1, argrepr='defaults', offset=26, start_offset=26, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='STORE_FAST', opcode=110, arg=2, argval='inner', argrepr='inner', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=1, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_DEREF', opcode=83, arg=3, argval='a', argrepr='a', offset=40, start_offset=40, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=4, argval='b', argrepr='b', offset=42, start_offset=42, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=0, argval='c', argrepr='c', offset=44, start_offset=44, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=1, argval='d', argrepr='d', offset=46, start_offset=46, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=4, argval=4, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=2, argval='inner', argrepr='inner', offset=58, start_offset=58, starts_line=True, line_number=6, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_VALUE', opcode=35, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=6, label=None, positions=None, cache_info=None), ] expected_opinfo_inner = [ - Instruction(opname='COPY_FREE_VARS', opcode=60, arg=4, argval=4, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='COPY_FREE_VARS', opcode=61, arg=4, argval=4, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='print', argrepr='print + NULL', offset=4, start_offset=4, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_DEREF', opcode=82, arg=2, argval='a', argrepr='a', offset=14, start_offset=14, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=3, argval='b', argrepr='b', offset=16, start_offset=16, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=4, argval='c', argrepr='c', offset=18, start_offset=18, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_DEREF', opcode=82, arg=5, argval='d', argrepr='d', offset=20, start_offset=20, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST_LOAD_FAST', opcode=86, arg=1, argval=('e', 'f'), argrepr='e, f', offset=22, start_offset=22, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=6, argval=6, argrepr='', offset=24, start_offset=24, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=32, start_offset=32, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_CONST', opcode=102, arg=0, argval=None, argrepr='None', offset=34, start_offset=34, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=1, argval='print', argrepr='print + NULL', offset=4, start_offset=4, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_DEREF', opcode=83, arg=2, argval='a', argrepr='a', offset=14, start_offset=14, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=3, argval='b', argrepr='b', offset=16, start_offset=16, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=4, argval='c', argrepr='c', offset=18, start_offset=18, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_DEREF', opcode=83, arg=5, argval='d', argrepr='d', offset=20, start_offset=20, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST_LOAD_FAST', opcode=87, arg=1, argval=('e', 'f'), argrepr='e, f', offset=22, start_offset=22, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=6, argval=6, argrepr='', offset=24, start_offset=24, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=32, start_offset=32, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=34, start_offset=34, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), ] expected_opinfo_jumpy = [ Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=1, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=1, argval='range', argrepr='range + NULL', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=1, argval=10, argrepr='10', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='GET_ITER', opcode=18, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='FOR_ITER', opcode=69, arg=30, argval=88, argrepr='to L4', offset=24, start_offset=24, starts_line=False, line_number=3, label=1, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='STORE_FAST', opcode=109, arg=0, argval='i', argrepr='i', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=40, start_offset=40, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=50, start_offset=50, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=52, start_offset=52, starts_line=True, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval=4, argrepr='4', offset=54, start_offset=54, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=56, arg=18, argval='<', argrepr='bool(<)', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=2, argval=68, argrepr='to L2', offset=60, start_offset=60, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=74, arg=22, argval=24, argrepr='to L1', offset=64, start_offset=64, starts_line=True, line_number=6, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=68, start_offset=68, starts_line=True, line_number=7, label=2, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=3, argval=6, argrepr='6', offset=70, start_offset=70, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=56, arg=148, argval='>', argrepr='bool(>)', offset=72, start_offset=72, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_TRUE', opcode=99, arg=2, argval=84, argrepr='to L3', offset=76, start_offset=76, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=74, arg=30, argval=24, argrepr='to L1', offset=80, start_offset=80, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=84, start_offset=84, starts_line=True, line_number=8, label=3, positions=None, cache_info=None), - Instruction(opname='JUMP_FORWARD', opcode=76, arg=13, argval=114, argrepr='to L5', offset=86, start_offset=86, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), - Instruction(opname='END_FOR', opcode=10, arg=None, argval=None, argrepr='', offset=88, start_offset=88, starts_line=True, line_number=3, label=4, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=90, start_offset=90, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=92, start_offset=92, starts_line=True, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=102, start_offset=102, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=104, start_offset=104, starts_line=False, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=112, start_offset=112, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST_CHECK', opcode=85, arg=0, argval='i', argrepr='i', offset=114, start_offset=114, starts_line=True, line_number=11, label=5, positions=None, cache_info=None), - Instruction(opname='TO_BOOL', opcode=38, arg=None, argval=None, argrepr='', offset=116, start_offset=116, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=33, argval=194, argrepr='to L8', offset=124, start_offset=124, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=128, start_offset=128, starts_line=True, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=138, start_offset=138, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=140, start_offset=140, starts_line=False, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=148, start_offset=148, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=150, start_offset=150, starts_line=True, line_number=13, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=5, argval=1, argrepr='1', offset=152, start_offset=152, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), - Instruction(opname='BINARY_OP', opcode=43, arg=23, argval=23, argrepr='-=', offset=154, start_offset=154, starts_line=False, line_number=13, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='STORE_FAST', opcode=109, arg=0, argval='i', argrepr='i', offset=158, start_offset=158, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=160, start_offset=160, starts_line=True, line_number=14, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=3, argval=6, argrepr='6', offset=162, start_offset=162, starts_line=False, line_number=14, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=56, arg=148, argval='>', argrepr='bool(>)', offset=164, start_offset=164, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=2, argval=176, argrepr='to L6', offset=168, start_offset=168, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=74, arg=31, argval=114, argrepr='to L5', offset=172, start_offset=172, starts_line=True, line_number=15, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=176, start_offset=176, starts_line=True, line_number=16, label=6, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=2, argval=4, argrepr='4', offset=178, start_offset=178, starts_line=False, line_number=16, label=None, positions=None, cache_info=None), - Instruction(opname='COMPARE_OP', opcode=56, arg=18, argval='<', argrepr='bool(<)', offset=180, start_offset=180, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_JUMP_IF_TRUE', opcode=99, arg=2, argval=192, argrepr='to L7', offset=184, start_offset=184, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_BACKWARD', opcode=74, arg=39, argval=114, argrepr='to L5', offset=188, start_offset=188, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='JUMP_FORWARD', opcode=76, arg=11, argval=216, argrepr='to L9', offset=192, start_offset=192, starts_line=True, line_number=17, label=7, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=194, start_offset=194, starts_line=True, line_number=19, label=8, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=6, argval='Who let lolcatz into this test suite?', argrepr="'Who let lolcatz into this test suite?'", offset=204, start_offset=204, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=206, start_offset=206, starts_line=False, line_number=19, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=214, start_offset=214, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), - Instruction(opname='NOP', opcode=28, arg=None, argval=None, argrepr='', offset=216, start_offset=216, starts_line=True, line_number=20, label=9, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=5, argval=1, argrepr='1', offset=218, start_offset=218, starts_line=True, line_number=21, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=7, argval=0, argrepr='0', offset=220, start_offset=220, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), - Instruction(opname='BINARY_OP', opcode=43, arg=11, argval=11, argrepr='/', offset=222, start_offset=222, starts_line=False, line_number=21, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=226, start_offset=226, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_FAST', opcode=83, arg=0, argval='i', argrepr='i', offset=228, start_offset=228, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=59, arg=1, argval=1, argrepr='', offset=230, start_offset=230, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_SPECIAL', opcode=91, arg=1, argval=1, argrepr='__exit__', offset=232, start_offset=232, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='SWAP', opcode=114, arg=2, argval=2, argrepr='', offset=234, start_offset=234, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='SWAP', opcode=114, arg=3, argval=3, argrepr='', offset=236, start_offset=236, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_SPECIAL', opcode=91, arg=0, argval=0, argrepr='__enter__', offset=238, start_offset=238, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=0, argval=0, argrepr='', offset=240, start_offset=240, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='STORE_FAST', opcode=109, arg=1, argval='dodgy', argrepr='dodgy', offset=248, start_offset=248, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=250, start_offset=250, starts_line=True, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=8, argval='Never reach this', argrepr="'Never reach this'", offset=260, start_offset=260, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=262, start_offset=262, starts_line=False, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=270, start_offset=270, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=0, argval=None, argrepr='None', offset=272, start_offset=272, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=0, argval=None, argrepr='None', offset=274, start_offset=274, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_CONST', opcode=81, arg=0, argval=None, argrepr='None', offset=276, start_offset=276, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=3, argval=3, argrepr='', offset=278, start_offset=278, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=286, start_offset=286, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=288, start_offset=288, starts_line=True, line_number=28, label=10, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=298, start_offset=298, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=300, start_offset=300, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=308, start_offset=308, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='RETURN_CONST', opcode=102, arg=0, argval=None, argrepr='None', offset=310, start_offset=310, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='PUSH_EXC_INFO', opcode=31, arg=None, argval=None, argrepr='', offset=312, start_offset=312, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='WITH_EXCEPT_START', opcode=42, arg=None, argval=None, argrepr='', offset=314, start_offset=314, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='TO_BOOL', opcode=38, arg=None, argval=None, argrepr='', offset=316, start_offset=316, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_JUMP_IF_TRUE', opcode=99, arg=1, argval=330, argrepr='to L11', offset=324, start_offset=324, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='RERAISE', opcode=101, arg=2, argval=2, argrepr='', offset=328, start_offset=328, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=330, start_offset=330, starts_line=False, line_number=25, label=11, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=332, start_offset=332, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=334, start_offset=334, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=336, start_offset=336, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=338, start_offset=338, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=75, arg=27, argval=288, argrepr='to L10', offset=340, start_offset=340, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=59, arg=3, argval=3, argrepr='', offset=342, start_offset=342, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=344, start_offset=344, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=101, arg=1, argval=1, argrepr='', offset=346, start_offset=346, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='PUSH_EXC_INFO', opcode=31, arg=None, argval=None, argrepr='', offset=348, start_offset=348, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=4, argval='ZeroDivisionError', argrepr='ZeroDivisionError', offset=350, start_offset=350, starts_line=True, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='CHECK_EXC_MATCH', opcode=6, arg=None, argval=None, argrepr='', offset=360, start_offset=360, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), - Instruction(opname='POP_JUMP_IF_FALSE', opcode=96, arg=14, argval=394, argrepr='to L12', offset=362, start_offset=362, starts_line=False, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=366, start_offset=366, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=368, start_offset=368, starts_line=True, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=9, argval='Here we go, here we go, here we go...', argrepr="'Here we go, here we go, here we go...'", offset=378, start_offset=378, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=380, start_offset=380, starts_line=False, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=388, start_offset=388, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=390, start_offset=390, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=75, arg=53, argval=288, argrepr='to L10', offset=392, start_offset=392, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=101, arg=0, argval=0, argrepr='', offset=394, start_offset=394, starts_line=True, line_number=22, label=12, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=59, arg=3, argval=3, argrepr='', offset=396, start_offset=396, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=398, start_offset=398, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=101, arg=1, argval=1, argrepr='', offset=400, start_offset=400, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='PUSH_EXC_INFO', opcode=31, arg=None, argval=None, argrepr='', offset=402, start_offset=402, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='LOAD_GLOBAL', opcode=89, arg=3, argval='print', argrepr='print + NULL', offset=404, start_offset=404, starts_line=True, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), - Instruction(opname='LOAD_CONST', opcode=81, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=414, start_offset=414, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='CALL', opcode=51, arg=1, argval=1, argrepr='', offset=416, start_offset=416, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), - Instruction(opname='POP_TOP', opcode=30, arg=None, argval=None, argrepr='', offset=424, start_offset=424, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=101, arg=0, argval=0, argrepr='', offset=426, start_offset=426, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), - Instruction(opname='COPY', opcode=59, arg=3, argval=3, argrepr='', offset=428, start_offset=428, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='POP_EXCEPT', opcode=29, arg=None, argval=None, argrepr='', offset=430, start_offset=430, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), - Instruction(opname='RERAISE', opcode=101, arg=1, argval=1, argrepr='', offset=432, start_offset=432, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=1, argval='range', argrepr='range + NULL', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=1, argval=10, argrepr='10', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='GET_ITER', opcode=19, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='FOR_ITER', opcode=70, arg=30, argval=88, argrepr='to L4', offset=24, start_offset=24, starts_line=False, line_number=3, label=1, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='STORE_FAST', opcode=110, arg=0, argval='i', argrepr='i', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=40, start_offset=40, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=50, start_offset=50, starts_line=False, line_number=4, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=52, start_offset=52, starts_line=True, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=2, argval=4, argrepr='4', offset=54, start_offset=54, starts_line=False, line_number=5, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=57, arg=18, argval='<', argrepr='bool(<)', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=68, argrepr='to L2', offset=60, start_offset=60, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=75, arg=22, argval=24, argrepr='to L1', offset=64, start_offset=64, starts_line=True, line_number=6, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=68, start_offset=68, starts_line=True, line_number=7, label=2, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=3, argval=6, argrepr='6', offset=70, start_offset=70, starts_line=False, line_number=7, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=57, arg=148, argval='>', argrepr='bool(>)', offset=72, start_offset=72, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=2, argval=84, argrepr='to L3', offset=76, start_offset=76, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=75, arg=30, argval=24, argrepr='to L1', offset=80, start_offset=80, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=84, start_offset=84, starts_line=True, line_number=8, label=3, positions=None, cache_info=None), + Instruction(opname='JUMP_FORWARD', opcode=77, arg=13, argval=114, argrepr='to L5', offset=86, start_offset=86, starts_line=False, line_number=8, label=None, positions=None, cache_info=None), + Instruction(opname='END_FOR', opcode=11, arg=None, argval=None, argrepr='', offset=88, start_offset=88, starts_line=True, line_number=3, label=4, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=90, start_offset=90, starts_line=False, line_number=3, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=92, start_offset=92, starts_line=True, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=102, start_offset=102, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=104, start_offset=104, starts_line=False, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=112, start_offset=112, starts_line=False, line_number=10, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST_CHECK', opcode=86, arg=0, argval='i', argrepr='i', offset=114, start_offset=114, starts_line=True, line_number=11, label=5, positions=None, cache_info=None), + Instruction(opname='TO_BOOL', opcode=39, arg=None, argval=None, argrepr='', offset=116, start_offset=116, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=33, argval=194, argrepr='to L8', offset=124, start_offset=124, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=128, start_offset=128, starts_line=True, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=138, start_offset=138, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=140, start_offset=140, starts_line=False, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=148, start_offset=148, starts_line=False, line_number=12, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=150, start_offset=150, starts_line=True, line_number=13, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=5, argval=1, argrepr='1', offset=152, start_offset=152, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), + Instruction(opname='BINARY_OP', opcode=44, arg=23, argval=23, argrepr='-=', offset=154, start_offset=154, starts_line=False, line_number=13, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='STORE_FAST', opcode=110, arg=0, argval='i', argrepr='i', offset=158, start_offset=158, starts_line=False, line_number=13, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=160, start_offset=160, starts_line=True, line_number=14, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=3, argval=6, argrepr='6', offset=162, start_offset=162, starts_line=False, line_number=14, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=57, arg=148, argval='>', argrepr='bool(>)', offset=164, start_offset=164, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=176, argrepr='to L6', offset=168, start_offset=168, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=75, arg=31, argval=114, argrepr='to L5', offset=172, start_offset=172, starts_line=True, line_number=15, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=176, start_offset=176, starts_line=True, line_number=16, label=6, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=2, argval=4, argrepr='4', offset=178, start_offset=178, starts_line=False, line_number=16, label=None, positions=None, cache_info=None), + Instruction(opname='COMPARE_OP', opcode=57, arg=18, argval='<', argrepr='bool(<)', offset=180, start_offset=180, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=2, argval=192, argrepr='to L7', offset=184, start_offset=184, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_BACKWARD', opcode=75, arg=39, argval=114, argrepr='to L5', offset=188, start_offset=188, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='JUMP_FORWARD', opcode=77, arg=11, argval=216, argrepr='to L9', offset=192, start_offset=192, starts_line=True, line_number=17, label=7, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=194, start_offset=194, starts_line=True, line_number=19, label=8, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=6, argval='Who let lolcatz into this test suite?', argrepr="'Who let lolcatz into this test suite?'", offset=204, start_offset=204, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=206, start_offset=206, starts_line=False, line_number=19, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=214, start_offset=214, starts_line=False, line_number=19, label=None, positions=None, cache_info=None), + Instruction(opname='NOP', opcode=29, arg=None, argval=None, argrepr='', offset=216, start_offset=216, starts_line=True, line_number=20, label=9, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=5, argval=1, argrepr='1', offset=218, start_offset=218, starts_line=True, line_number=21, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=7, argval=0, argrepr='0', offset=220, start_offset=220, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), + Instruction(opname='BINARY_OP', opcode=44, arg=11, argval=11, argrepr='/', offset=222, start_offset=222, starts_line=False, line_number=21, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=226, start_offset=226, starts_line=False, line_number=21, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_FAST', opcode=84, arg=0, argval='i', argrepr='i', offset=228, start_offset=228, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=60, arg=1, argval=1, argrepr='', offset=230, start_offset=230, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_SPECIAL', opcode=92, arg=1, argval=1, argrepr='__exit__', offset=232, start_offset=232, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='SWAP', opcode=115, arg=2, argval=2, argrepr='', offset=234, start_offset=234, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='SWAP', opcode=115, arg=3, argval=3, argrepr='', offset=236, start_offset=236, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_SPECIAL', opcode=92, arg=0, argval=0, argrepr='__enter__', offset=238, start_offset=238, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=0, argval=0, argrepr='', offset=240, start_offset=240, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='STORE_FAST', opcode=110, arg=1, argval='dodgy', argrepr='dodgy', offset=248, start_offset=248, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=250, start_offset=250, starts_line=True, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=8, argval='Never reach this', argrepr="'Never reach this'", offset=260, start_offset=260, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=262, start_offset=262, starts_line=False, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=270, start_offset=270, starts_line=False, line_number=26, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=0, argval=None, argrepr='None', offset=272, start_offset=272, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=0, argval=None, argrepr='None', offset=274, start_offset=274, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_CONST', opcode=82, arg=0, argval=None, argrepr='None', offset=276, start_offset=276, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=3, argval=3, argrepr='', offset=278, start_offset=278, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=286, start_offset=286, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=288, start_offset=288, starts_line=True, line_number=28, label=10, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=298, start_offset=298, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=300, start_offset=300, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=308, start_offset=308, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=310, start_offset=310, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='PUSH_EXC_INFO', opcode=32, arg=None, argval=None, argrepr='', offset=312, start_offset=312, starts_line=True, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='WITH_EXCEPT_START', opcode=43, arg=None, argval=None, argrepr='', offset=314, start_offset=314, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='TO_BOOL', opcode=39, arg=None, argval=None, argrepr='', offset=316, start_offset=316, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=1, argval=330, argrepr='to L11', offset=324, start_offset=324, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='RERAISE', opcode=102, arg=2, argval=2, argrepr='', offset=328, start_offset=328, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=330, start_offset=330, starts_line=False, line_number=25, label=11, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=30, arg=None, argval=None, argrepr='', offset=332, start_offset=332, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=334, start_offset=334, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=336, start_offset=336, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=338, start_offset=338, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=76, arg=27, argval=288, argrepr='to L10', offset=340, start_offset=340, starts_line=False, line_number=25, label=None, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=60, arg=3, argval=3, argrepr='', offset=342, start_offset=342, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=30, arg=None, argval=None, argrepr='', offset=344, start_offset=344, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=346, start_offset=346, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='PUSH_EXC_INFO', opcode=32, arg=None, argval=None, argrepr='', offset=348, start_offset=348, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=4, argval='ZeroDivisionError', argrepr='ZeroDivisionError', offset=350, start_offset=350, starts_line=True, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='CHECK_EXC_MATCH', opcode=7, arg=None, argval=None, argrepr='', offset=360, start_offset=360, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), + Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=14, argval=394, argrepr='to L12', offset=362, start_offset=362, starts_line=False, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=366, start_offset=366, starts_line=False, line_number=22, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=368, start_offset=368, starts_line=True, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=9, argval='Here we go, here we go, here we go...', argrepr="'Here we go, here we go, here we go...'", offset=378, start_offset=378, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=380, start_offset=380, starts_line=False, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=388, start_offset=388, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=30, arg=None, argval=None, argrepr='', offset=390, start_offset=390, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=76, arg=53, argval=288, argrepr='to L10', offset=392, start_offset=392, starts_line=False, line_number=23, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=102, arg=0, argval=0, argrepr='', offset=394, start_offset=394, starts_line=True, line_number=22, label=12, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=60, arg=3, argval=3, argrepr='', offset=396, start_offset=396, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=30, arg=None, argval=None, argrepr='', offset=398, start_offset=398, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=400, start_offset=400, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='PUSH_EXC_INFO', opcode=32, arg=None, argval=None, argrepr='', offset=402, start_offset=402, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='LOAD_GLOBAL', opcode=90, arg=3, argval='print', argrepr='print + NULL', offset=404, start_offset=404, starts_line=True, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]), + Instruction(opname='LOAD_CONST', opcode=82, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=414, start_offset=414, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='CALL', opcode=52, arg=1, argval=1, argrepr='', offset=416, start_offset=416, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]), + Instruction(opname='POP_TOP', opcode=31, arg=None, argval=None, argrepr='', offset=424, start_offset=424, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=102, arg=0, argval=0, argrepr='', offset=426, start_offset=426, starts_line=False, line_number=28, label=None, positions=None, cache_info=None), + Instruction(opname='COPY', opcode=60, arg=3, argval=3, argrepr='', offset=428, start_offset=428, starts_line=True, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='POP_EXCEPT', opcode=30, arg=None, argval=None, argrepr='', offset=430, start_offset=430, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), + Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=432, start_offset=432, starts_line=False, line_number=None, label=None, positions=None, cache_info=None), ] # One last piece of inspect fodder to check the default line number handling def simple(): pass expected_opinfo_simple = [ Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=simple.__code__.co_firstlineno, label=None, positions=None), - Instruction(opname='RETURN_CONST', opcode=102, arg=0, argval=None, argrepr='None', offset=2, start_offset=2, starts_line=False, line_number=simple.__code__.co_firstlineno, label=None), + Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=2, start_offset=2, starts_line=False, line_number=simple.__code__.co_firstlineno, label=None), ] diff --git a/Programs/test_frozenmain.h b/Programs/test_frozenmain.h index 55d05b94ea666a..47a227496e908a 100644 --- a/Programs/test_frozenmain.h +++ b/Programs/test_frozenmain.h @@ -1,17 +1,17 @@ // 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,8,0,0, - 0,0,0,0,0,243,166,0,0,0,149,0,81,0,81,1, - 72,0,113,0,81,0,81,1,72,1,113,1,90,2,32,0, - 81,2,51,1,0,0,0,0,0,0,30,0,90,2,32,0, - 81,3,90,0,79,6,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,51,2,0,0,0,0,0,0, - 30,0,90,1,79,8,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,32,0,51,0,0,0,0,0, - 0,0,81,4,2,0,0,0,113,5,81,5,18,0,69,20, - 0,0,113,6,90,2,32,0,81,6,90,6,13,0,81,7, - 90,5,90,6,2,0,0,0,13,0,48,4,51,1,0,0, - 0,0,0,0,30,0,74,22,0,0,10,0,30,0,102,1, + 0,0,0,0,0,243,166,0,0,0,149,0,82,0,82,1, + 73,0,114,0,82,0,82,1,73,1,114,1,91,2,33,0, + 82,2,52,1,0,0,0,0,0,0,31,0,91,2,33,0, + 82,3,91,0,80,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, + 31,0,91,1,80,8,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,33,0,52,0,0,0,0,0, + 0,0,82,4,2,0,0,0,114,5,82,5,19,0,70,20, + 0,0,114,6,91,2,33,0,82,6,91,6,14,0,82,7, + 91,5,91,6,2,0,0,0,14,0,49,4,52,1,0,0, + 0,0,0,0,31,0,75,22,0,0,11,0,31,0,103,1, 41,8,233,0,0,0,0,78,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,41,5, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 2d6e58e3092627..668977eef76ed8 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1746,7 +1746,7 @@ dummy_func( template = PyStackRef_FromPyObjectSteal(template_o); } - inst(BUILD_TEMPLATE_FROM_LIST, (list -- template)) { + inst(BUILD_TEMPLATE_LIST, (list -- template)) { PyObject *template_o = _PyTemplate_FromListStackRef(list); DECREF_INPUTS(); ERROR_IF(template_o == NULL, error); diff --git a/Python/codegen.c b/Python/codegen.c index dead5877f3c6f4..663f70b9ac12d3 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -3857,7 +3857,7 @@ codegen_template_str(compiler *c, expr_ty e) VISIT(c, expr, asdl_seq_GET(e->v.TemplateStr.values, i)); ADDOP_I(c, loc, LIST_APPEND, 1); } - ADDOP(c, loc, BUILD_TEMPLATE_FROM_LIST); + ADDOP(c, loc, BUILD_TEMPLATE_LIST); } else { VISIT_SEQ(c, expr, e->v.TemplateStr.values); diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 354b374ecfd450..b0550d9f0813d2 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2077,7 +2077,7 @@ break; } - case _BUILD_TEMPLATE_FROM_LIST: { + case _BUILD_TEMPLATE_LIST: { _PyStackRef list; _PyStackRef template; list = stack_pointer[-1]; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index f0cb9db6155adc..fafb072ba10864 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -856,7 +856,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (true) { + { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -881,10 +881,10 @@ DISPATCH(); } - TARGET(BUILD_TEMPLATE_FROM_LIST) { + TARGET(BUILD_TEMPLATE_LIST) { frame->instr_ptr = next_instr; next_instr += 1; - INSTRUCTION_STATS(BUILD_TEMPLATE_FROM_LIST); + INSTRUCTION_STATS(BUILD_TEMPLATE_LIST); _PyStackRef list; _PyStackRef template; list = stack_pointer[-1]; diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index c5392d7d13ff31..f956b07e3c0a83 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -4,7 +4,7 @@ static void *opcode_targets[256] = { &&TARGET_BINARY_SUBSCR, &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, &&TARGET_BUILD_INTERPOLATION, - &&TARGET_BUILD_TEMPLATE_FROM_LIST, + &&TARGET_BUILD_TEMPLATE_LIST, &&TARGET_CHECK_EG_MATCH, &&TARGET_CHECK_EXC_MATCH, &&TARGET_CLEANUP_THROW, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 7bb9dec292ddd4..dea48114edf3d6 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -955,7 +955,7 @@ break; } - case _BUILD_TEMPLATE_FROM_LIST: { + case _BUILD_TEMPLATE_LIST: { _Py_UopsSymbol *template; template = sym_new_not_null(ctx); stack_pointer[-1] = template; From 9380ab958eb93789b19ab300883eb9c26a6bb050 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 1 Nov 2024 09:36:48 +0100 Subject: [PATCH 21/88] Implement implicit concatenation with TemplateStr --- Grammar/python.gram | 7 +- Parser/action_helpers.c | 265 +++++++++++++++++++++++++++++++--------- Parser/parser.c | 106 +++++++++------- 3 files changed, 268 insertions(+), 110 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 928a10040c4aa7..b5cb2b30de42d7 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -500,7 +500,7 @@ literal_pattern[pattern_ty]: literal_expr[expr_ty]: | signed_number !('+' | '-') | complex_number - | &(STRING|FSTRING_START) strings + | &(STRING|FSTRING_START|TSTRING_START) strings | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) } | 'True' { _PyAST_Constant(Py_True, NULL, EXTRA) } | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) } @@ -840,8 +840,7 @@ atom[expr_ty]: | 'True' { _PyAST_Constant(Py_True, NULL, EXTRA) } | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) } | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) } - | &(STRING|FSTRING_START) strings - | &TSTRING_START tstring + | &(STRING|FSTRING_START|TSTRING_START) strings | NUMBER | &'(' (tuple | group | genexp) | &'[' (list | listcomp) @@ -939,7 +938,7 @@ tstring[expr_ty] (memo): | a=TSTRING_START b=tstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) } -strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string)+ { _PyPegen_concatenate_strings(p, a, EXTRA) } +strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string|tstring)+ { _PyPegen_concatenate_strings(p, a, EXTRA) } list[expr_ty]: | '[' a=[star_named_expressions] ']' { _PyAST_List(a, Load, EXTRA) } diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 016df531a784bd..307ce441358b9e 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1587,70 +1587,100 @@ expr_ty _PyPegen_formatted_value(Parser *p, expr_ty expression, Token *debug, Re return _PyAST_JoinedStr(values, lineno, col_offset, debug_end_line, debug_end_offset, p->arena); } -expr_ty -_PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, - int lineno, int col_offset, int end_lineno, - int end_col_offset, PyArena *arena) +static expr_ty +_build_concatenated_bytes(Parser *p, asdl_expr_seq *strings, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena) { Py_ssize_t len = asdl_seq_LEN(strings); assert(len > 0); - int f_string_found = 0; - int unicode_string_found = 0; - int bytes_found = 0; + PyObject* res = Py_GetConstant(Py_CONSTANT_EMPTY_BYTES); - Py_ssize_t i = 0; - Py_ssize_t n_flattened_elements = 0; - for (i = 0; i < len; i++) { + /* Bytes literals never get a kind, but just for consistency + since they are represented as Constant nodes, we'll mirror + the same behavior as unicode strings for determining the + kind. */ + PyObject* kind = asdl_seq_GET(strings, 0)->v.Constant.kind; + for (Py_ssize_t i = 0; i < len; i++) { expr_ty elem = asdl_seq_GET(strings, i); - switch(elem->kind) { - case Constant_kind: - if (PyBytes_CheckExact(elem->v.Constant.value)) { - bytes_found = 1; - } else { - unicode_string_found = 1; - } - n_flattened_elements++; - break; - case JoinedStr_kind: - n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values); - f_string_found = 1; - break; - default: - n_flattened_elements++; - f_string_found = 1; - break; - } + PyBytes_Concat(&res, elem->v.Constant.value); } + if (!res || _PyArena_AddPyObject(arena, res) < 0) { + Py_XDECREF(res); + return NULL; + } + return _PyAST_Constant(res, kind, lineno, col_offset, end_lineno, end_col_offset, p->arena); +} - if ((unicode_string_found || f_string_found) && bytes_found) { - RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals"); +static expr_ty +_build_concatenated_unicode(Parser *p, asdl_expr_seq *strings, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena) +{ + Py_ssize_t len = asdl_seq_LEN(strings); + assert(len > 1); + + expr_ty first = asdl_seq_GET(strings, 0); + + /* When a string is getting concatenated, the kind of the string + is determined by the first string in the concatenation + sequence. + + u"abc" "def" -> u"abcdef" + "abc" u"abc" -> "abcabc" */ + PyObject *kind = first->v.Constant.kind; + + PyUnicodeWriter *writer = PyUnicodeWriter_Create(0); + if (writer == NULL) { return NULL; } - if (bytes_found) { - PyObject* res = Py_GetConstant(Py_CONSTANT_EMPTY_BYTES); + for (Py_ssize_t i = 0; i < len; i++) { + expr_ty current_elem = asdl_seq_GET(strings, i); + assert(current_elem->kind == Constant_kind); - /* Bytes literals never get a kind, but just for consistency - since they are represented as Constant nodes, we'll mirror - the same behavior as unicode strings for determining the - kind. */ - PyObject* kind = asdl_seq_GET(strings, 0)->v.Constant.kind; - for (i = 0; i < len; i++) { - expr_ty elem = asdl_seq_GET(strings, i); - PyBytes_Concat(&res, elem->v.Constant.value); - } - if (!res || _PyArena_AddPyObject(arena, res) < 0) { - Py_XDECREF(res); + if (PyUnicodeWriter_WriteStr(writer, + current_elem->v.Constant.value)) { + PyUnicodeWriter_Discard(writer); return NULL; } - return _PyAST_Constant(res, kind, lineno, col_offset, end_lineno, end_col_offset, p->arena); } - if (!f_string_found && len == 1) { - return asdl_seq_GET(strings, 0); + PyObject *final = PyUnicodeWriter_Finish(writer); + if (final == NULL) { + return NULL; + } + if (_PyArena_AddPyObject(p->arena, final) < 0) { + Py_DECREF(final); + return NULL; + } + return _PyAST_Constant(final, kind, lineno, col_offset, + end_lineno, end_col_offset, arena); +} + +static expr_ty +_build_concatenated_joined_str(Parser *p, asdl_expr_seq *strings, + int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + Py_ssize_t len = asdl_seq_LEN(strings); + assert(len > 0); + + Py_ssize_t n_flattened_elements = 0; + for (Py_ssize_t i = 0; i < len; i++) { + expr_ty elem = asdl_seq_GET(strings, i); + switch(elem->kind) { + case JoinedStr_kind: + n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values); + break; + default: + n_flattened_elements++; + break; + } } + asdl_expr_seq* flattened = _Py_asdl_expr_seq_new(n_flattened_elements, p->arena); if (flattened == NULL) { return NULL; @@ -1658,12 +1688,11 @@ _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, /* build flattened list */ Py_ssize_t current_pos = 0; - Py_ssize_t j = 0; - for (i = 0; i < len; i++) { + for (Py_ssize_t i = 0; i < len; i++) { expr_ty elem = asdl_seq_GET(strings, i); switch(elem->kind) { case JoinedStr_kind: - for (j = 0; j < asdl_seq_LEN(elem->v.JoinedStr.values); j++) { + for (Py_ssize_t j = 0; j < asdl_seq_LEN(elem->v.JoinedStr.values); j++) { expr_ty subvalue = asdl_seq_GET(elem->v.JoinedStr.values, j); if (subvalue == NULL) { return NULL; @@ -1680,13 +1709,13 @@ _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, /* calculate folded element count */ Py_ssize_t n_elements = 0; int prev_is_constant = 0; - for (i = 0; i < n_flattened_elements; i++) { + for (Py_ssize_t i = 0; i < n_flattened_elements; i++) { expr_ty elem = asdl_seq_GET(flattened, i); /* The concatenation of a FormattedValue and an empty Constant should lead to the FormattedValue itself. Thus, we will not take any empty constants into account, just as in `_PyPegen_joined_str` */ - if (f_string_found && elem->kind == Constant_kind && + if (elem->kind == Constant_kind && PyUnicode_CheckExact(elem->v.Constant.value) && PyUnicode_GET_LENGTH(elem->v.Constant.value) == 0) continue; @@ -1704,7 +1733,7 @@ _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, /* build folded list */ current_pos = 0; - for (i = 0; i < n_flattened_elements; i++) { + for (Py_ssize_t i = 0; i < n_flattened_elements; i++) { expr_ty elem = asdl_seq_GET(flattened, i); /* if the current elem and the following are constants, @@ -1727,6 +1756,7 @@ _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, return NULL; } expr_ty last_elem = elem; + Py_ssize_t j; for (j = i; j < n_flattened_elements; j++) { expr_ty current_elem = asdl_seq_GET(flattened, j); if (current_elem->kind == Constant_kind) { @@ -1760,8 +1790,7 @@ _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, } /* Drop all empty contanst strings */ - if (f_string_found && - PyUnicode_CheckExact(elem->v.Constant.value) && + if (PyUnicode_CheckExact(elem->v.Constant.value) && PyUnicode_GET_LENGTH(elem->v.Constant.value) == 0) { continue; } @@ -1770,13 +1799,127 @@ _PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, asdl_seq_SET(values, current_pos++, elem); } - if (!f_string_found) { - assert(n_elements == 1); - expr_ty elem = asdl_seq_GET(values, 0); - assert(elem->kind == Constant_kind); - return elem; - } - assert(current_pos == n_elements); return _PyAST_JoinedStr(values, lineno, col_offset, end_lineno, end_col_offset, p->arena); } + +static expr_ty +_build_concatenated_template_str(Parser *p, asdl_expr_seq *strings, + int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + Py_ssize_t len = asdl_seq_LEN(strings); + assert(len > 0); + + Py_ssize_t n_flattened_elements = 0; + for (Py_ssize_t i = 0; i < len; i++) { + expr_ty elem = asdl_seq_GET(strings, i); + switch(elem->kind) { + case TemplateStr_kind: + n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values); + break; + default: + n_flattened_elements++; + break; + } + } + + + asdl_expr_seq* flattened = _Py_asdl_expr_seq_new(n_flattened_elements, p->arena); + if (flattened == NULL) { + return NULL; + } + + Py_ssize_t pos = 0; + for (Py_ssize_t i = 0; i < len; i++) { + expr_ty elem = asdl_seq_GET(strings, i); + + switch (elem->kind) { + case TemplateStr_kind: + for (Py_ssize_t j = 0; j < asdl_seq_LEN(elem->v.TemplateStr.values); j++) { + expr_ty subitem = asdl_seq_GET(elem->v.TemplateStr.values, j); + asdl_seq_SET(flattened, pos++, subitem); + } + break; + case JoinedStr_kind: { + expr_ty joined_str = _build_concatenated_joined_str(p, + elem->v.JoinedStr.values, lineno, col_offset, + end_lineno, end_col_offset, arena); + asdl_seq_SET(flattened, pos++, joined_str); + break; + } + default: + asdl_seq_SET(flattened, pos++, elem); + break; + } + } + + return _PyAST_TemplateStr(flattened, lineno, col_offset, end_lineno, + end_col_offset, arena); +} + +expr_ty +_PyPegen_concatenate_strings(Parser *p, asdl_expr_seq *strings, + int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + Py_ssize_t len = asdl_seq_LEN(strings); + assert(len > 0); + + int t_string_found = 0; + int f_string_found = 0; + int unicode_string_found = 0; + int bytes_found = 0; + + Py_ssize_t i = 0; + for (i = 0; i < len; i++) { + expr_ty elem = asdl_seq_GET(strings, i); + switch(elem->kind) { + case Constant_kind: + if (PyBytes_CheckExact(elem->v.Constant.value)) { + bytes_found = 1; + } else { + unicode_string_found = 1; + } + break; + case JoinedStr_kind: + f_string_found = 1; + break; + case TemplateStr_kind: + t_string_found = 1; + break; + default: + f_string_found = 1; + break; + } + } + + // Cannot mix unicode and bytes + if ((unicode_string_found || f_string_found || t_string_found) && bytes_found) { + RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals"); + return NULL; + } + + // If it's only bytes or only unicode string, do a simple concat + if (!f_string_found && !t_string_found) { + if (len == 1) { + return asdl_seq_GET(strings, 0); + } + else if (bytes_found) { + return _build_concatenated_bytes(p, strings, lineno, col_offset, + end_lineno, end_col_offset, arena); + } + else { + return _build_concatenated_unicode(p, strings, lineno, col_offset, + end_lineno, end_col_offset, arena); + } + } + + if (t_string_found) { + return _build_concatenated_template_str(p, strings, lineno, + col_offset, end_lineno, end_col_offset, arena); + } + + return _build_concatenated_joined_str(p, strings, lineno, + col_offset, end_lineno, end_col_offset, arena); +} diff --git a/Parser/parser.c b/Parser/parser.c index 452314887c0e28..31a28f20946275 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -8198,7 +8198,7 @@ literal_pattern_rule(Parser *p) // literal_expr: // | signed_number !('+' | '-') // | complex_number -// | &(STRING | FSTRING_START) strings +// | &(STRING | FSTRING_START | TSTRING_START) strings // | 'None' // | 'True' // | 'False' @@ -8263,12 +8263,12 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); } - { // &(STRING | FSTRING_START) strings + { // &(STRING | FSTRING_START | TSTRING_START) strings if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); expr_ty strings_var; if ( _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_43_rule, p) @@ -8276,13 +8276,13 @@ literal_expr_rule(Parser *p) (strings_var = strings_rule(p)) // strings ) { - D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); _res = strings_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START) strings")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); } { // 'None' if (p->error_indicator) { @@ -14450,8 +14450,7 @@ slice_rule(Parser *p) // | 'True' // | 'False' // | 'None' -// | &(STRING | FSTRING_START) strings -// | &TSTRING_START tstring +// | &(STRING | FSTRING_START | TSTRING_START) strings // | NUMBER // | &'(' (tuple | group | genexp) // | &'[' (list | listcomp) @@ -14596,12 +14595,12 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } - { // &(STRING | FSTRING_START) strings + { // &(STRING | FSTRING_START | TSTRING_START) strings if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); + D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); expr_ty strings_var; if ( _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_43_rule, p) @@ -14609,34 +14608,13 @@ atom_rule(Parser *p) (strings_var = strings_rule(p)) // strings ) { - D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings")); + D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); _res = strings_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, "&(STRING | FSTRING_START) strings")); - } - { // &TSTRING_START tstring - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&TSTRING_START tstring")); - expr_ty tstring_var; - if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, TSTRING_START) // token=TSTRING_START - && - (tstring_var = tstring_rule(p)) // tstring - ) - { - D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&TSTRING_START tstring")); - _res = tstring_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, "&TSTRING_START tstring")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); } { // NUMBER if (p->error_indicator) { @@ -16410,7 +16388,7 @@ string_rule(Parser *p) return _res; } -// strings: ((fstring | string))+ +// strings: ((fstring | string | tstring))+ static expr_ty strings_rule(Parser *p) { @@ -16436,18 +16414,18 @@ strings_rule(Parser *p) 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 - { // ((fstring | string))+ + { // ((fstring | string | tstring))+ if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); + D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((fstring | string | tstring))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_80_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_80_rule(p)) // ((fstring | string | tstring))+ ) { - D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); + D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string | tstring))+")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -16467,7 +16445,7 @@ strings_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string))+")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string | tstring))+")); } _res = NULL; done: @@ -28354,7 +28332,7 @@ _tmp_42_rule(Parser *p) return _res; } -// _tmp_43: STRING | FSTRING_START +// _tmp_43: STRING | FSTRING_START | TSTRING_START static void * _tmp_43_rule(Parser *p) { @@ -28405,6 +28383,25 @@ _tmp_43_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START")); } + { // TSTRING_START + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START")); + Token * tstring_start_var; + if ( + (tstring_start_var = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' + ) + { + D(fprintf(stderr, "%*c+ _tmp_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START")); + _res = tstring_start_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START")); + } _res = NULL; done: p->level--; @@ -30715,7 +30712,7 @@ _loop0_79_rule(Parser *p) return _seq; } -// _loop1_80: (fstring | string) +// _loop1_80: (fstring | string | tstring) static asdl_seq * _loop1_80_rule(Parser *p) { @@ -30737,15 +30734,15 @@ _loop1_80_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // (fstring | string) + { // (fstring | string | tstring) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); + D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string | tstring)")); void *_tmp_158_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // fstring | string + (_tmp_158_var = _tmp_158_rule(p)) // fstring | string | tstring ) { _res = _tmp_158_var; @@ -30766,7 +30763,7 @@ _loop1_80_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string | tstring)")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -35418,7 +35415,7 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: fstring | string +// _tmp_158: fstring | string | tstring static void * _tmp_158_rule(Parser *p) { @@ -35469,6 +35466,25 @@ _tmp_158_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string")); } + { // tstring + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); + expr_ty tstring_var; + if ( + (tstring_var = tstring_rule(p)) // tstring + ) + { + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring")); + _res = tstring_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring")); + } _res = NULL; done: p->level--; From f20763758a371cb530514b9912c8d30ef5715b86 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 20 Feb 2025 17:33:11 +0100 Subject: [PATCH 22/88] Implement new specification of template type --- Include/internal/pycore_interpolation.h | 1 + Include/internal/pycore_template.h | 1 + Objects/interpolationobject.c | 6 + Objects/object.c | 1 + Objects/templateobject.c | 335 +++++++++++++++++++----- 5 files changed, 278 insertions(+), 66 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 6f8259d6b84265..88cd6f2b47324e 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -18,6 +18,7 @@ extern PyTypeObject _PyInterpolation_Type; PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); +extern PyObject *_PyInterpolation_GetValue(PyObject *interpolation); #ifdef __cplusplus } diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 0f4d05d690f549..097f6f5d809827 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -12,6 +12,7 @@ extern "C" { #include "pycore_stackref.h" // _PyStackRef extern PyTypeObject _PyTemplate_Type; +extern PyTypeObject _PyTemplateIter_Type; PyAPI_FUNC(PyObject *) _PyTemplate_FromValues(PyObject **values, Py_ssize_t n); PyAPI_FUNC(PyObject *) _PyTemplate_FromListStackRef(_PyStackRef ref); diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index e1cdc5bd65f153..e1192b71c10d0c 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -250,3 +250,9 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values) Py_DECREF(args); return interpolation; } + +PyObject * +_PyInterpolation_GetValue(PyObject *interpolation) +{ + return ((interpolationobject *) interpolation)->value; +} diff --git a/Objects/object.c b/Objects/object.c index a7b0ae41d25e8b..1048c828e5d438 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -2398,6 +2398,7 @@ static PyTypeObject* static_types[] = { &_PyNoDefault_Type, &_PyInterpolation_Type, &_PyTemplate_Type, + &_PyTemplateIter_Type, // subclasses: _PyTypes_FiniTypes() deallocates them before their base // class diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 525ad9d89ea13a..d1b5609b5758d3 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -11,169 +11,337 @@ typedef struct { PyObject_HEAD - PyObject *args; + PyObject *stringsiter; + PyObject *interpolationsiter; + int from_strings; +} templateiterobject; + +static PyObject * +templateiter_next(templateiterobject *self) +{ + PyObject *item; + if (self->from_strings) { + item = PyIter_Next(self->stringsiter); + } else { + item = PyIter_Next(self->interpolationsiter); + } + self->from_strings = !self->from_strings; + return item; +} + +static void +templateiter_dealloc(templateiterobject *self) +{ + Py_CLEAR(self->stringsiter); + Py_CLEAR(self->interpolationsiter); + Py_TYPE(self)->tp_free(self); +} + +PyTypeObject _PyTemplateIter_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "templatelib.TemplateIter", + .tp_doc = PyDoc_STR("Template iterator object"), + .tp_basicsize = sizeof(templateiterobject), + .tp_itemsize = 0, + .tp_dealloc = (destructor) templateiter_dealloc, + .tp_iter = PyObject_SelfIter, + .tp_iternext = (iternextfunc) templateiter_next, +}; + +typedef struct { + PyObject_HEAD + PyObject *strings; + PyObject *interpolations; } templateobject; static templateobject * template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { + if (kwds != NULL) { + PyErr_SetString(PyExc_TypeError, "Template.__new__ only accepts *args arguments"); + return NULL; + } + templateobject *self = (templateobject *) type->tp_alloc(type, 0); if (!self) { return NULL; } Py_ssize_t argslen = PyTuple_GET_SIZE(args); - Py_ssize_t interleaved_len = 0; + Py_ssize_t stringslen = 0; + Py_ssize_t interpolationslen = 0; int last_was_str = 0; for (Py_ssize_t i = 0; i < argslen; i++) { PyObject *item = PyTuple_GET_ITEM(args, i); if (PyUnicode_Check(item)) { if (!last_was_str) { - interleaved_len++; + stringslen++; } last_was_str = 1; } else if (PyObject_TypeCheck(item, &_PyInterpolation_Type)) { if (!last_was_str) { - interleaved_len++; + stringslen++; } - interleaved_len++; + interpolationslen++; last_was_str = 0; } else { - PyErr_SetString(PyExc_TypeError, "Template items need to be of type 'str' or 'Interpolation'"); + Py_DECREF(self); + PyErr_SetString(PyExc_TypeError, "Template.__new__ *args need to be of type 'str' or 'Interpolation'"); return NULL; } } if (!last_was_str) { - interleaved_len++; + stringslen++; + } + + PyObject *strings = PyTuple_New(stringslen); + if (!strings) { + Py_DECREF(self); + return NULL; } - PyObject *interleaved = PyTuple_New(interleaved_len); - if (!interleaved) { + PyObject *interpolations = PyTuple_New(interpolationslen); + if (!interpolations) { + Py_DECREF(self); + Py_DECREF(strings); return NULL; } last_was_str = 0; - Py_ssize_t j = 0; + Py_ssize_t stringsidx = 0, interpolationsidx = 0; for (Py_ssize_t i = 0; i < argslen; i++) { PyObject *item = PyTuple_GET_ITEM(args, i); if (PyUnicode_Check(item)) { if (last_was_str) { - PyObject *concat = PyUnicode_Concat(PyTuple_GET_ITEM(interleaved, j - 1), item); + PyObject *laststring = PyTuple_GET_ITEM(strings, stringsidx - 1); + PyObject *concat = PyUnicode_Concat(laststring, item); + Py_DECREF(laststring); if (!concat) { - Py_DECREF(interleaved); - return NULL; + goto error; } - PyTuple_SetItem(interleaved, j - 1, concat); + PyTuple_SET_ITEM(strings, stringsidx - 1, concat); } else { - PyTuple_SET_ITEM(interleaved, j++, Py_NewRef(item)); + PyTuple_SET_ITEM(strings, stringsidx++, Py_NewRef(item)); } last_was_str = 1; } else if (PyObject_TypeCheck(item, &_PyInterpolation_Type)) { if (!last_was_str) { - PyTuple_SET_ITEM(interleaved, j++, &_Py_STR(empty)); + PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } - PyTuple_SET_ITEM(interleaved, j++, Py_NewRef(item)); + PyTuple_SET_ITEM(interpolations, interpolationsidx, Py_NewRef(item)); last_was_str = 0; } } if (!last_was_str) { - PyTuple_SET_ITEM(interleaved, j++, &_Py_STR(empty)); + PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } - assert(j == interleaved_len); - Py_XSETREF(self->args, interleaved); + self->strings = strings; + self->interpolations = interpolations; return self; + +error: + Py_DECREF(self); + Py_DECREF(strings); + Py_DECREF(interpolations); + return NULL; } static void template_dealloc(templateobject *self) { - Py_CLEAR(self->args); + Py_CLEAR(self->strings); + Py_CLEAR(self->interpolations); Py_TYPE(self)->tp_free(self); } static PyObject * template_repr(templateobject *self) { - return PyUnicode_FromFormat("%s%R", + return PyUnicode_FromFormat("%s(strings=%R, interpolations=%R)", _PyType_Name(Py_TYPE(self)), - self->args); + self->strings, + self->interpolations); } -static PyObject * -template_compare(templateobject *self, PyObject *other, int op) +static templateiterobject * +template_iter(templateobject *self) { - if (op == Py_LT || op == Py_LE || op == Py_GT || op == Py_GE) { - Py_RETURN_NOTIMPLEMENTED; + templateiterobject *iter = PyObject_New(templateiterobject, &_PyTemplateIter_Type); + if (iter == NULL) { + return NULL; + } + + PyObject *stringsiter = PyObject_GetIter(self->strings); + if (stringsiter == NULL) { + Py_DECREF(iter); + return NULL; } - if (!PyObject_TypeCheck(other, &_PyTemplate_Type)) { - return (op == Py_EQ) ? Py_False : Py_True; + PyObject *interpolationsiter = PyObject_GetIter(self->interpolations); + if (interpolationsiter == NULL) { + Py_DECREF(iter); + Py_DECREF(stringsiter); + return NULL; } - return PyObject_RichCompare(self->args, ((templateobject *) other)->args, op); + iter->stringsiter = stringsiter; + iter->interpolationsiter = interpolationsiter; + iter->from_strings = 1; + return iter; } -static Py_hash_t -template_hash(templateobject *self) +static PyObject * +template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyObject *interpolations) { - return PyObject_Hash(self->args); + PyObject *template = type->tp_alloc(type, 0); + if (template == NULL) { + return NULL; + } + + ((templateobject *) template)->strings = strings; + ((templateobject *) template)->interpolations = interpolations; + return template; +} + +static PyObject * +template_interpolations_copy(PyObject *interpolations) { + Py_ssize_t interpolationslen = PyTuple_GET_SIZE(interpolations); + PyObject *newinterpolations = PyTuple_New(interpolationslen); + if (!newinterpolations) { + return NULL; + } + + for (Py_ssize_t i = 0; i < interpolationslen; i++) { + PyTuple_SET_ITEM(newinterpolations, i, Py_NewRef(PyTuple_GET_ITEM(interpolations, i))); + } + return newinterpolations; +} + +static PyObject * +template_interpolations_concat(PyObject *left, PyObject *right) { + Py_ssize_t leftlen = PyTuple_GET_SIZE(left); + Py_ssize_t rightlen = PyTuple_GET_SIZE(right); + Py_ssize_t interpolationslen = leftlen + rightlen; + + PyObject *newinterpolations = PyTuple_New(interpolationslen); + if (!newinterpolations) { + return NULL; + } + + Py_ssize_t index = 0; + for (Py_ssize_t i = 0; i < leftlen; i++) { + PyTuple_SET_ITEM(newinterpolations, index++, Py_NewRef(PyTuple_GET_ITEM(left, i))); + } + for (Py_ssize_t i = 0; i < rightlen; i++) { + PyTuple_SET_ITEM(newinterpolations, index++, Py_NewRef(PyTuple_GET_ITEM(right, i))); + } + return newinterpolations; } static PyObject * -template_add_template_str(templateobject *template, PyUnicodeObject *str, int templateleft) +template_add_template_str(templateobject *template, PyObject *str) { - Py_ssize_t templatesize = PyTuple_GET_SIZE(template->args); + Py_ssize_t stringslen = PyTuple_GET_SIZE(template->strings); + PyObject *string = PyTuple_GET_ITEM(template->strings, stringslen - 1); + PyObject *concat = PyUnicode_Concat(string, str); + if (concat == NULL) { + return NULL; + } - PyObject *tuple = PyTuple_New(templatesize + 1); - if (!tuple) { + PyObject *newstrings = PyTuple_New(stringslen); + if (newstrings == NULL) { + Py_DECREF(concat); + return NULL; + } + + for (Py_ssize_t i = 0; i < stringslen - 1; i++) { + PyTuple_SET_ITEM(newstrings, i, Py_NewRef(PyTuple_GET_ITEM(template->strings, i))); + } + PyTuple_SET_ITEM(newstrings, stringslen - 1, concat); + + PyObject *newinterpolations = template_interpolations_copy(template->interpolations); + if (newinterpolations == NULL) { + // No need to decref concat here since it's in newstrings + Py_DECREF(newstrings); return NULL; } - Py_ssize_t i = 0; - Py_ssize_t j = 0; - if (!templateleft) { - PyTuple_SET_ITEM(tuple, i++, Py_NewRef(str)); + return template_from_strings_interpolations(Py_TYPE(template), newstrings, newinterpolations); +} + +static PyObject * +template_add_str_template(templateobject *template, PyObject *str) +{ + Py_ssize_t stringslen = PyTuple_GET_SIZE(template->strings); + PyObject *string = PyTuple_GET_ITEM(template->strings, 0); + PyObject *concat = PyUnicode_Concat(str, string); + if (concat == NULL) { + return NULL; + } + + PyObject *newstrings = PyTuple_New(stringslen); + if (newstrings == NULL) { + Py_DECREF(concat); + return NULL; } - for (j = 0; j < templatesize; j++) { - PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(PyTuple_GET_ITEM(template->args, j))); + + PyTuple_SET_ITEM(newstrings, 0, concat); + for (Py_ssize_t i = 1; i < stringslen; i++) { + PyTuple_SET_ITEM(newstrings, i, Py_NewRef(PyTuple_GET_ITEM(template->strings, i))); } - if (templateleft) { - PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(str)); + + PyObject *newinterpolations = template_interpolations_copy(template->interpolations); + if (newinterpolations == NULL) { + // No need to decref concat here since it's in newstrings + Py_DECREF(newstrings); + return NULL; } - PyObject *newtemplate = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); - Py_DECREF(tuple); - return newtemplate; + return template_from_strings_interpolations(Py_TYPE(template), newstrings, newinterpolations); } static PyObject * template_add_templates(templateobject *self, templateobject *other) { - Py_ssize_t selfsize = PyTuple_GET_SIZE(self->args); - Py_ssize_t othersize = PyTuple_GET_SIZE(other->args); + Py_ssize_t left_stringslen = PyTuple_GET_SIZE(self->strings); + PyObject *left_laststring = PyTuple_GET_ITEM(self->strings, left_stringslen - 1); + Py_ssize_t right_stringslen = PyTuple_GET_SIZE(other->strings); + PyObject *right_firststring = PyTuple_GET_ITEM(other->strings, 0); - PyObject *tuple = PyTuple_New(selfsize + othersize); - if (!tuple) { + PyObject *concat = PyUnicode_Concat(left_laststring, right_firststring); + if (concat == NULL) { + return NULL; + } + + PyObject *newstrings = PyTuple_New(left_stringslen + right_stringslen - 1); + if (newstrings == NULL) { + Py_DECREF(concat); return NULL; } - Py_ssize_t i; - for (i = 0; i < selfsize; i++) { - PyTuple_SET_ITEM(tuple, i, Py_NewRef(PyTuple_GET_ITEM(self->args, i))); + Py_ssize_t index = 0; + for (Py_ssize_t i = 0; i < left_stringslen - 1; i++) { + PyTuple_SET_ITEM(newstrings, index++, Py_NewRef(PyTuple_GET_ITEM(self->strings, i))); } - for (Py_ssize_t j = 0; j < othersize; j++) { - PyTuple_SET_ITEM(tuple, i + j, Py_NewRef(PyTuple_GET_ITEM(other->args, j))); + PyTuple_SET_ITEM(newstrings, index++, concat); + for (Py_ssize_t i = 1; i < right_stringslen; i++) { + PyTuple_SET_ITEM(newstrings, index++, Py_NewRef(PyTuple_GET_ITEM(other->strings, i))); } - PyObject *newtemplate = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); - Py_DECREF(tuple); - return newtemplate; + PyObject *newinterpolations = template_interpolations_concat(self->interpolations, other->interpolations); + if (newinterpolations == NULL) { + // No need to decref concat here since it's in newstrings + Py_DECREF(newstrings); + return NULL; + } + + return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); } static PyObject * @@ -184,19 +352,54 @@ template_add(PyObject *self, PyObject *other) return template_add_templates((templateobject *) self, (templateobject *) other); } else if (PyObject_TypeCheck(self, &_PyTemplate_Type) && PyUnicode_Check(other)) { - return template_add_template_str((templateobject *) self, (PyUnicodeObject *) other, 1); + return template_add_template_str((templateobject *) self, other); } else if (PyUnicode_Check(self) && PyObject_TypeCheck(other, &_PyTemplate_Type)) { - return template_add_template_str((templateobject *) other, (PyUnicodeObject *) self, 0); + return template_add_str_template((templateobject *) other, self); } else { Py_RETURN_NOTIMPLEMENTED; } } +static PyObject * +template_values_get(templateobject *self, void *Py_UNUSED(data)) +{ + PyObject *values = PyTuple_New(PyTuple_GET_SIZE(self->interpolations)); + if (values == NULL) { + return NULL; + } + + PyObject *interpolationsiter = PyObject_GetIter(self->interpolations); + if (interpolationsiter == NULL) { + Py_DECREF(values); + return NULL; + } + + PyObject *item; + Py_ssize_t index = 0; + while ((item = PyIter_Next(interpolationsiter))) { + PyTuple_SET_ITEM(values, index++, Py_NewRef(_PyInterpolation_GetValue(item))); + Py_DECREF(item); + } + + Py_DECREF(interpolationsiter); + if (PyErr_Occurred()) { + Py_DECREF(values); + return NULL; + } + return values; +} + static PyMemberDef template_members[] = { - {"args", Py_T_OBJECT_EX, offsetof(templateobject, args), Py_READONLY, "Args"}, - {NULL} + {"strings", Py_T_OBJECT_EX, offsetof(templateobject, strings), Py_READONLY, "Strings"}, + {"interpolations", Py_T_OBJECT_EX, offsetof(templateobject, interpolations), Py_READONLY, "Interpolations"}, + {NULL}, +}; + +static PyGetSetDef template_getset[] = { + {"values", (getter) template_values_get, NULL, "Values of interpolations", NULL}, + {NULL}, }; static PyNumberMethods template_as_number = { @@ -214,9 +417,9 @@ PyTypeObject _PyTemplate_Type = { .tp_new = (newfunc) template_new, .tp_dealloc = (destructor) template_dealloc, .tp_repr = (reprfunc) template_repr, - .tp_richcompare = (richcmpfunc) template_compare, - .tp_hash = (hashfunc) template_hash, .tp_members = template_members, + .tp_getset = template_getset, + .tp_iter = (getiterfunc) template_iter, }; PyObject * From 29b1386adbbd32df6330166b7d43361ab5ee5ea5 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 20 Feb 2025 20:10:23 +0100 Subject: [PATCH 23/88] Replace nb_add with sq_concat --- Objects/templateobject.c | 108 +++++++++++++++++++++++++-------------- 1 file changed, 69 insertions(+), 39 deletions(-) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index d1b5609b5758d3..8426ac06b3cd3f 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -245,10 +245,10 @@ template_interpolations_concat(PyObject *left, PyObject *right) { } static PyObject * -template_add_template_str(templateobject *template, PyObject *str) +template_strings_append_str(PyObject *strings, PyObject *str) { - Py_ssize_t stringslen = PyTuple_GET_SIZE(template->strings); - PyObject *string = PyTuple_GET_ITEM(template->strings, stringslen - 1); + Py_ssize_t stringslen = PyTuple_GET_SIZE(strings); + PyObject *string = PyTuple_GET_ITEM(strings, stringslen - 1); PyObject *concat = PyUnicode_Concat(string, str); if (concat == NULL) { return NULL; @@ -261,25 +261,18 @@ template_add_template_str(templateobject *template, PyObject *str) } for (Py_ssize_t i = 0; i < stringslen - 1; i++) { - PyTuple_SET_ITEM(newstrings, i, Py_NewRef(PyTuple_GET_ITEM(template->strings, i))); + PyTuple_SET_ITEM(newstrings, i, Py_NewRef(PyTuple_GET_ITEM(strings, i))); } PyTuple_SET_ITEM(newstrings, stringslen - 1, concat); - PyObject *newinterpolations = template_interpolations_copy(template->interpolations); - if (newinterpolations == NULL) { - // No need to decref concat here since it's in newstrings - Py_DECREF(newstrings); - return NULL; - } - - return template_from_strings_interpolations(Py_TYPE(template), newstrings, newinterpolations); + return newstrings; } static PyObject * -template_add_str_template(templateobject *template, PyObject *str) +template_strings_prepend_str(PyObject *strings, PyObject *str) { - Py_ssize_t stringslen = PyTuple_GET_SIZE(template->strings); - PyObject *string = PyTuple_GET_ITEM(template->strings, 0); + Py_ssize_t stringslen = PyTuple_GET_SIZE(strings); + PyObject *string = PyTuple_GET_ITEM(strings, 0); PyObject *concat = PyUnicode_Concat(str, string); if (concat == NULL) { return NULL; @@ -293,26 +286,19 @@ template_add_str_template(templateobject *template, PyObject *str) PyTuple_SET_ITEM(newstrings, 0, concat); for (Py_ssize_t i = 1; i < stringslen; i++) { - PyTuple_SET_ITEM(newstrings, i, Py_NewRef(PyTuple_GET_ITEM(template->strings, i))); - } - - PyObject *newinterpolations = template_interpolations_copy(template->interpolations); - if (newinterpolations == NULL) { - // No need to decref concat here since it's in newstrings - Py_DECREF(newstrings); - return NULL; + PyTuple_SET_ITEM(newstrings, i, Py_NewRef(PyTuple_GET_ITEM(strings, i))); } - return template_from_strings_interpolations(Py_TYPE(template), newstrings, newinterpolations); + return newstrings; } static PyObject * -template_add_templates(templateobject *self, templateobject *other) +template_strings_concat(PyObject *left, PyObject *right) { - Py_ssize_t left_stringslen = PyTuple_GET_SIZE(self->strings); - PyObject *left_laststring = PyTuple_GET_ITEM(self->strings, left_stringslen - 1); - Py_ssize_t right_stringslen = PyTuple_GET_SIZE(other->strings); - PyObject *right_firststring = PyTuple_GET_ITEM(other->strings, 0); + Py_ssize_t left_stringslen = PyTuple_GET_SIZE(left); + PyObject *left_laststring = PyTuple_GET_ITEM(left, left_stringslen - 1); + Py_ssize_t right_stringslen = PyTuple_GET_SIZE(right); + PyObject *right_firststring = PyTuple_GET_ITEM(right, 0); PyObject *concat = PyUnicode_Concat(left_laststring, right_firststring); if (concat == NULL) { @@ -327,16 +313,26 @@ template_add_templates(templateobject *self, templateobject *other) Py_ssize_t index = 0; for (Py_ssize_t i = 0; i < left_stringslen - 1; i++) { - PyTuple_SET_ITEM(newstrings, index++, Py_NewRef(PyTuple_GET_ITEM(self->strings, i))); + PyTuple_SET_ITEM(newstrings, index++, Py_NewRef(PyTuple_GET_ITEM(left, i))); } PyTuple_SET_ITEM(newstrings, index++, concat); for (Py_ssize_t i = 1; i < right_stringslen; i++) { - PyTuple_SET_ITEM(newstrings, index++, Py_NewRef(PyTuple_GET_ITEM(other->strings, i))); + PyTuple_SET_ITEM(newstrings, index++, Py_NewRef(PyTuple_GET_ITEM(right, i))); + } + + return newstrings; +} + +static PyObject * +template_concat_templates(templateobject *self, templateobject *other) +{ + PyObject *newstrings = template_strings_concat(self->strings, other->strings); + if (newstrings == NULL) { + return NULL; } PyObject *newinterpolations = template_interpolations_concat(self->interpolations, other->interpolations); if (newinterpolations == NULL) { - // No need to decref concat here since it's in newstrings Py_DECREF(newstrings); return NULL; } @@ -345,17 +341,51 @@ template_add_templates(templateobject *self, templateobject *other) } static PyObject * -template_add(PyObject *self, PyObject *other) +template_concat_template_str(templateobject *self, PyObject *str) +{ + PyObject *newstrings = template_strings_append_str(self->strings, str); + if (newstrings == NULL) { + return NULL; + } + + PyObject *newinterpolations = template_interpolations_copy(self->interpolations); + if (newinterpolations == NULL) { + Py_DECREF(newstrings); + return NULL; + } + + return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); +} + +static PyObject * +template_concat_str_template(templateobject *self, PyObject *str) +{ + PyObject *newstrings = template_strings_prepend_str(self->strings, str); + if (newstrings == NULL) { + return NULL; + } + + PyObject *newinterpolations = template_interpolations_copy(self->interpolations); + if (newinterpolations == NULL) { + Py_DECREF(newstrings); + return NULL; + } + + return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); +} + +static PyObject * +template_concat(PyObject *self, PyObject *other) { if (PyObject_TypeCheck(self, &_PyTemplate_Type) && PyObject_TypeCheck(other, &_PyTemplate_Type)) { - return template_add_templates((templateobject *) self, (templateobject *) other); + return template_concat_templates((templateobject *) self, (templateobject *) other); } else if (PyObject_TypeCheck(self, &_PyTemplate_Type) && PyUnicode_Check(other)) { - return template_add_template_str((templateobject *) self, other); + return template_concat_template_str((templateobject *) self, other); } else if (PyUnicode_Check(self) && PyObject_TypeCheck(other, &_PyTemplate_Type)) { - return template_add_str_template((templateobject *) other, self); + return template_concat_str_template((templateobject *) other, self); } else { Py_RETURN_NOTIMPLEMENTED; @@ -402,8 +432,8 @@ static PyGetSetDef template_getset[] = { {NULL}, }; -static PyNumberMethods template_as_number = { - .nb_add = template_add, +static PySequenceMethods template_as_sequence = { + .sq_concat = template_concat, }; PyTypeObject _PyTemplate_Type = { @@ -413,7 +443,7 @@ PyTypeObject _PyTemplate_Type = { .tp_basicsize = sizeof(templateobject), .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, - .tp_as_number = &template_as_number, + .tp_as_sequence = &template_as_sequence, .tp_new = (newfunc) template_new, .tp_dealloc = (destructor) template_dealloc, .tp_repr = (reprfunc) template_repr, From aad5d6789ade4c608711e39b8ac4ea887c6e7428 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 21 Feb 2025 14:49:42 +0100 Subject: [PATCH 24/88] Correctly implement str + tstring --- Include/internal/pycore_template.h | 2 ++ Objects/templateobject.c | 14 +++++++------- Objects/unicodeobject.c | 15 +++++++++++---- 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 097f6f5d809827..27d0d1d3315329 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -14,6 +14,8 @@ extern "C" { extern PyTypeObject _PyTemplate_Type; extern PyTypeObject _PyTemplateIter_Type; +extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); + PyAPI_FUNC(PyObject *) _PyTemplate_FromValues(PyObject **values, Py_ssize_t n); PyAPI_FUNC(PyObject *) _PyTemplate_FromListStackRef(_PyStackRef ref); diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 8426ac06b3cd3f..ae8a85e0ebba94 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -341,9 +341,9 @@ template_concat_templates(templateobject *self, templateobject *other) } static PyObject * -template_concat_template_str(templateobject *self, PyObject *str) +template_concat_template_str(templateobject *self, PyObject *other) { - PyObject *newstrings = template_strings_append_str(self->strings, str); + PyObject *newstrings = template_strings_append_str(self->strings, other); if (newstrings == NULL) { return NULL; } @@ -358,9 +358,9 @@ template_concat_template_str(templateobject *self, PyObject *str) } static PyObject * -template_concat_str_template(templateobject *self, PyObject *str) +template_concat_str_template(templateobject *self, PyObject *other) { - PyObject *newstrings = template_strings_prepend_str(self->strings, str); + PyObject *newstrings = template_strings_prepend_str(self->strings, other); if (newstrings == NULL) { return NULL; } @@ -374,8 +374,8 @@ template_concat_str_template(templateobject *self, PyObject *str) return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); } -static PyObject * -template_concat(PyObject *self, PyObject *other) +PyObject * +_PyTemplate_Concat(PyObject *self, PyObject *other) { if (PyObject_TypeCheck(self, &_PyTemplate_Type) && PyObject_TypeCheck(other, &_PyTemplate_Type)) { @@ -433,7 +433,7 @@ static PyGetSetDef template_getset[] = { }; static PySequenceMethods template_as_sequence = { - .sq_concat = template_concat, + .sq_concat = _PyTemplate_Concat, }; PyTypeObject _PyTemplate_Type = { diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index 03f15b37598363..9861211ba397a9 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -58,6 +58,7 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. #include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI #include "pycore_unicodeobject.h" // struct _Py_unicode_state #include "pycore_unicodeobject_generated.h" // _PyUnicode_InitStaticStrings() +#include "pycore_template.h" // _PyTemplate_Type #include "stringlib/eq.h" // unicode_eq() #include // ptrdiff_t @@ -11614,10 +11615,16 @@ PyUnicode_Concat(PyObject *left, PyObject *right) return NULL; if (!PyUnicode_Check(right)) { - PyErr_Format(PyExc_TypeError, - "can only concatenate str (not \"%.200s\") to str", - Py_TYPE(right)->tp_name); - return NULL; + if (PyObject_TypeCheck(right, &_PyTemplate_Type)) { + // str + tstring is implemented in the tstring type + return _PyTemplate_Concat(left, right); + } + else { + PyErr_Format(PyExc_TypeError, + "can only concatenate str (not \"%.200s\") to str", + Py_TYPE(right)->tp_name); + return NULL; + } } /* Shortcuts */ From 77822be914ae94f4a14988cc8e3d41f4656be334 Mon Sep 17 00:00:00 2001 From: Wingy Date: Wed, 9 Apr 2025 05:24:08 -0400 Subject: [PATCH 25/88] Make changes requested by Steering Council (#57) * Rename expr to expression, conv to conversion * Move templatelib under string lib * Add strings lib to LIBSUBDIRS * Update type of Template/TemplateIter/Interpolation --- .../pycore_global_objects_fini_generated.h | 4 +- Include/internal/pycore_global_strings.h | 4 +- .../internal/pycore_runtime_init_generated.h | 4 +- .../internal/pycore_unicodeobject_generated.h | 4 +- Lib/{string.py => string/__init__.py} | 0 Lib/{ => string}/templatelib.py | 0 Makefile.pre.in | 1 + Objects/clinic/interpolationobject.c.h | 23 ++++--- Objects/interpolationobject.c | 67 ++++++++++--------- Objects/templateobject.c | 4 +- 10 files changed, 57 insertions(+), 54 deletions(-) rename Lib/{string.py => string/__init__.py} (100%) rename Lib/{ => string}/templatelib.py (100%) diff --git a/Include/internal/pycore_global_objects_fini_generated.h b/Include/internal/pycore_global_objects_fini_generated.h index 782233b34e3461..353ea757d33a90 100644 --- a/Include/internal/pycore_global_objects_fini_generated.h +++ b/Include/internal/pycore_global_objects_fini_generated.h @@ -867,7 +867,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(consts)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(context)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(contravariant)); - _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(conv)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(conversion)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(cookie)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(copy)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(copyreg)); @@ -925,7 +925,7 @@ _PyStaticObjects_CheckRefcnt(PyInterpreterState *interp) { _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exception)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(existing_file_name)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(exp)); - _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(expr)); + _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(expression)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(extend)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(extra_tokens)); _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(facility)); diff --git a/Include/internal/pycore_global_strings.h b/Include/internal/pycore_global_strings.h index 3c398dd5d871d3..812bf1b41852bf 100644 --- a/Include/internal/pycore_global_strings.h +++ b/Include/internal/pycore_global_strings.h @@ -356,7 +356,7 @@ struct _Py_global_strings { STRUCT_FOR_ID(consts) STRUCT_FOR_ID(context) STRUCT_FOR_ID(contravariant) - STRUCT_FOR_ID(conv) + STRUCT_FOR_ID(conversion) STRUCT_FOR_ID(cookie) STRUCT_FOR_ID(copy) STRUCT_FOR_ID(copyreg) @@ -414,7 +414,7 @@ struct _Py_global_strings { STRUCT_FOR_ID(exception) STRUCT_FOR_ID(existing_file_name) STRUCT_FOR_ID(exp) - STRUCT_FOR_ID(expr) + STRUCT_FOR_ID(expression) STRUCT_FOR_ID(extend) STRUCT_FOR_ID(extra_tokens) STRUCT_FOR_ID(facility) diff --git a/Include/internal/pycore_runtime_init_generated.h b/Include/internal/pycore_runtime_init_generated.h index 831242407bfacd..8953b0f0c6ee63 100644 --- a/Include/internal/pycore_runtime_init_generated.h +++ b/Include/internal/pycore_runtime_init_generated.h @@ -865,7 +865,7 @@ extern "C" { INIT_ID(consts), \ INIT_ID(context), \ INIT_ID(contravariant), \ - INIT_ID(conv), \ + INIT_ID(conversion), \ INIT_ID(cookie), \ INIT_ID(copy), \ INIT_ID(copyreg), \ @@ -923,7 +923,7 @@ extern "C" { INIT_ID(exception), \ INIT_ID(existing_file_name), \ INIT_ID(exp), \ - INIT_ID(expr), \ + INIT_ID(expression), \ INIT_ID(extend), \ INIT_ID(extra_tokens), \ INIT_ID(facility), \ diff --git a/Include/internal/pycore_unicodeobject_generated.h b/Include/internal/pycore_unicodeobject_generated.h index 096bc950b62495..514aea181c84d6 100644 --- a/Include/internal/pycore_unicodeobject_generated.h +++ b/Include/internal/pycore_unicodeobject_generated.h @@ -1220,7 +1220,7 @@ _PyUnicode_InitStaticStrings(PyInterpreterState *interp) { _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); - string = &_Py_ID(conv); + string = &_Py_ID(conversion); _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); @@ -1452,7 +1452,7 @@ _PyUnicode_InitStaticStrings(PyInterpreterState *interp) { _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); - string = &_Py_ID(expr); + string = &_Py_ID(expression); _PyUnicode_InternStatic(interp, &string); assert(_PyUnicode_CheckConsistency(string, 1)); assert(PyUnicode_GET_LENGTH(string) != 1); diff --git a/Lib/string.py b/Lib/string/__init__.py similarity index 100% rename from Lib/string.py rename to Lib/string/__init__.py diff --git a/Lib/templatelib.py b/Lib/string/templatelib.py similarity index 100% rename from Lib/templatelib.py rename to Lib/string/templatelib.py diff --git a/Makefile.pre.in b/Makefile.pre.in index 9244d10af5b22c..23cb80f82958da 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -2422,6 +2422,7 @@ LIBSUBDIRS= asyncio \ re \ site-packages \ sqlite3 \ + string \ sysconfig \ tkinter \ tomllib \ diff --git a/Objects/clinic/interpolationobject.c.h b/Objects/clinic/interpolationobject.c.h index d2c365bf19ba95..c1201f09ebe939 100644 --- a/Objects/clinic/interpolationobject.c.h +++ b/Objects/clinic/interpolationobject.c.h @@ -9,8 +9,9 @@ preserve #include "pycore_modsupport.h" // _PyArg_UnpackKeywords() static PyObject * -interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *expr, - PyObject *conv, PyObject *format_spec); +interpolation_new_impl(PyTypeObject *type, PyObject *value, + PyObject *expression, PyObject *conversion, + PyObject *format_spec); static PyObject * interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) @@ -25,7 +26,7 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) PyObject *ob_item[NUM_KEYWORDS]; } _kwtuple = { .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS) - .ob_item = { &_Py_ID(value), &_Py_ID(expr), &_Py_ID(conv), &_Py_ID(format_spec), }, + .ob_item = { &_Py_ID(value), &_Py_ID(expression), &_Py_ID(conversion), &_Py_ID(format_spec), }, }; #undef NUM_KEYWORDS #define KWTUPLE (&_kwtuple.ob_base.ob_base) @@ -34,7 +35,7 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) # define KWTUPLE NULL #endif // !Py_BUILD_CORE - static const char * const _keywords[] = {"value", "expr", "conv", "format_spec", NULL}; + static const char * const _keywords[] = {"value", "expression", "conversion", "format_spec", NULL}; static _PyArg_Parser _parser = { .keywords = _keywords, .fname = "Interpolation", @@ -46,8 +47,8 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) Py_ssize_t nargs = PyTuple_GET_SIZE(args); Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 2; PyObject *value; - PyObject *expr; - PyObject *conv = Py_None; + PyObject *expression; + PyObject *conversion = Py_None; PyObject *format_spec = &_Py_STR(empty); fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, @@ -57,15 +58,15 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) } value = fastargs[0]; if (!PyUnicode_Check(fastargs[1])) { - _PyArg_BadArgument("Interpolation", "argument 'expr'", "str", fastargs[1]); + _PyArg_BadArgument("Interpolation", "argument 'expression'", "str", fastargs[1]); goto exit; } - expr = fastargs[1]; + expression = fastargs[1]; if (!noptargs) { goto skip_optional_pos; } if (fastargs[2]) { - if (!_conversion_converter(fastargs[2], &conv)) { + if (!_conversion_converter(fastargs[2], &conversion)) { goto exit; } if (!--noptargs) { @@ -78,9 +79,9 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) } format_spec = fastargs[3]; skip_optional_pos: - return_value = interpolation_new_impl(type, value, expr, conv, format_spec); + return_value = interpolation_new_impl(type, value, expression, conversion, format_spec); exit: return return_value; } -/*[clinic end generated code: output=1b9999b820dd5ce2 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=0250f606411f12f1 input=a9049054013a1b77]*/ diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index e1192b71c10d0c..31be92d480084f 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -22,14 +22,14 @@ class templatelib.Interpolation "interpolationobject *" "&_PyInterpolation_Type" /*[clinic end generated code: output=da39a3ee5e6b4b0d input=5b183514b4d7e5af]*/ int -_conversion_converter(PyObject *arg, PyObject **conv) +_conversion_converter(PyObject *arg, PyObject **conversion) { if (arg == Py_None) { return 1; } if (!PyUnicode_Check(arg)) { - _PyArg_BadArgument("Interpolation", "argument 'conv'", "str", arg); + _PyArg_BadArgument("Interpolation", "argument 'conversion'", "str", arg); return 0; } @@ -37,19 +37,19 @@ _conversion_converter(PyObject *arg, PyObject **conv) const char *conv_str = PyUnicode_AsUTF8AndSize(arg, &len); if (len != 1 || !(conv_str[0] == 'a' || conv_str[0] == 'r' || conv_str[0] == 's')) { PyErr_SetString(PyExc_ValueError, - "Interpolation() argument 'conv' must be one of 's', 'a' or 'r'"); + "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'"); return 0; } - *conv = arg; + *conversion = arg; return 1; } typedef struct { PyObject_HEAD PyObject *value; - PyObject *expr; - PyObject *conv; + PyObject *expression; + PyObject *conversion; PyObject *format_spec; } interpolationobject; @@ -58,15 +58,16 @@ typedef struct { templatelib.Interpolation.__new__ as interpolation_new value: object - expr: object(subclass_of='&PyUnicode_Type') - conv: object(converter='_conversion_converter') = None + expression: object(subclass_of='&PyUnicode_Type') + conversion: object(converter='_conversion_converter') = None format_spec: object(subclass_of='&PyUnicode_Type', c_default='&_Py_STR(empty)') = "" [clinic start generated code]*/ static PyObject * -interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *expr, - PyObject *conv, PyObject *format_spec) -/*[clinic end generated code: output=417d59bccab99648 input=348d81ee06c4be20]*/ +interpolation_new_impl(PyTypeObject *type, PyObject *value, + PyObject *expression, PyObject *conversion, + PyObject *format_spec) +/*[clinic end generated code: output=6488e288765bc1a9 input=0abc8e498fb744a7]*/ { interpolationobject *self = (interpolationobject *) type->tp_alloc(type, 0); if (!self) { @@ -74,8 +75,8 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *expr, } Py_XSETREF(self->value, Py_NewRef(value)); - Py_XSETREF(self->expr, Py_NewRef(expr)); - Py_XSETREF(self->conv, Py_NewRef(conv)); + Py_XSETREF(self->expression, Py_NewRef(expression)); + Py_XSETREF(self->conversion, Py_NewRef(conversion)); Py_XSETREF(self->format_spec, Py_NewRef(format_spec)); return (PyObject *) self; } @@ -84,8 +85,8 @@ static void interpolation_dealloc(interpolationobject *self) { Py_CLEAR(self->value); - Py_CLEAR(self->expr); - Py_CLEAR(self->conv); + Py_CLEAR(self->expression); + Py_CLEAR(self->conversion); Py_CLEAR(self->format_spec); Py_TYPE(self)->tp_free(self); } @@ -95,8 +96,8 @@ interpolation_repr(interpolationobject *self) { return PyUnicode_FromFormat("%s(%R, %R, %R, %R)", _PyType_Name(Py_TYPE(self)), - self->value, self->expr, - self->conv, self->format_spec); + self->value, self->expression, + self->conversion, self->format_spec); } static PyObject * @@ -116,11 +117,11 @@ interpolation_compare(interpolationobject *self, PyObject *other, int op) if (valueeq == -1) { return NULL; } - int expreq = PyUnicode_Compare(self->expr, other_i->expr); + int expreq = PyUnicode_Compare(self->expression, other_i->expression); if (expreq == -1 && PyErr_Occurred()) { return NULL; } - int conveq = PyObject_RichCompareBool(self->conv, other_i->conv, Py_EQ); // conv might be Py_None + int conveq = PyObject_RichCompareBool(self->conversion, other_i->conversion, Py_EQ); // conversion might be Py_None if (conveq == -1) { return NULL; } @@ -136,7 +137,7 @@ interpolation_compare(interpolationobject *self, PyObject *other, int op) static Py_hash_t interpolation_hash(interpolationobject *self) { - PyObject *tuple = PyTuple_Pack(4, self->value, self->expr, self->conv, self->format_spec); + PyObject *tuple = PyTuple_Pack(4, self->value, self->expression, self->conversion, self->format_spec); if (!tuple) { return -1; } @@ -148,15 +149,15 @@ interpolation_hash(interpolationobject *self) static PyMemberDef interpolation_members[] = { {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"}, - {"expr", Py_T_OBJECT_EX, offsetof(interpolationobject, expr), Py_READONLY, "Expr"}, - {"conv", Py_T_OBJECT_EX, offsetof(interpolationobject, conv), Py_READONLY, "Conversion"}, + {"expression", Py_T_OBJECT_EX, offsetof(interpolationobject, expression), Py_READONLY, "Expression"}, + {"conversion", Py_T_OBJECT_EX, offsetof(interpolationobject, conversion), Py_READONLY, "Conversion"}, {"format_spec", Py_T_OBJECT_EX, offsetof(interpolationobject, format_spec), Py_READONLY, "Format specifier"}, {NULL} }; PyTypeObject _PyInterpolation_Type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "templatelib.Interpolation", + .tp_name = "string.templatelib.Interpolation", .tp_doc = PyDoc_STR("Interpolation object"), .tp_basicsize = sizeof(interpolationobject), .tp_itemsize = 0, @@ -172,19 +173,19 @@ PyTypeObject _PyInterpolation_Type = { static PyObject * _get_match_args(void) { - PyObject *value = NULL, *expr = NULL, *conv = NULL, *format_spec = NULL; + PyObject *value = NULL, *expression = NULL, *conversion = NULL, *format_spec = NULL; PyObject *tuple = NULL; value = PyUnicode_FromString("value"); if (!value) { goto error; } - expr = PyUnicode_FromString("expr"); - if (!expr) { + expression = PyUnicode_FromString("expression"); + if (!expression) { goto error; } - conv = PyUnicode_FromString("conv"); - if (!conv) { + conversion = PyUnicode_FromString("conversion"); + if (!conversion) { goto error; } format_spec = PyUnicode_FromString("format_spec"); @@ -192,12 +193,12 @@ _get_match_args(void) goto error; } - tuple = PyTuple_Pack(4, value, expr, conv, format_spec); + tuple = PyTuple_Pack(4, value, expression, conversion, format_spec); error: Py_XDECREF(value); - Py_XDECREF(expr); - Py_XDECREF(conv); + Py_XDECREF(expression); + Py_XDECREF(conversion); Py_XDECREF(format_spec); return tuple; @@ -240,8 +241,8 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values) PyTuple_SET_ITEM(args, 0, PyStackRef_AsPyObjectSteal(values[0])); PyTuple_SET_ITEM(args, 1, PyStackRef_AsPyObjectSteal(values[1])); - PyObject *conv = PyStackRef_AsPyObjectSteal(values[2]); - PyTuple_SET_ITEM(args, 2, conv ? conv : Py_NewRef(Py_None)); + PyObject *conversion = PyStackRef_AsPyObjectSteal(values[2]); + PyTuple_SET_ITEM(args, 2, conversion ? conversion : Py_NewRef(Py_None)); PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]); PyTuple_SET_ITEM(args, 3, format_spec ? format_spec : &_Py_STR(empty)); diff --git a/Objects/templateobject.c b/Objects/templateobject.c index ae8a85e0ebba94..656670aa2a5606 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -39,7 +39,7 @@ templateiter_dealloc(templateiterobject *self) PyTypeObject _PyTemplateIter_Type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "templatelib.TemplateIter", + .tp_name = "string.templatelib.TemplateIter", .tp_doc = PyDoc_STR("Template iterator object"), .tp_basicsize = sizeof(templateiterobject), .tp_itemsize = 0, @@ -438,7 +438,7 @@ static PySequenceMethods template_as_sequence = { PyTypeObject _PyTemplate_Type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "templatelib.Template", + .tp_name = "string.templatelib.Template", .tp_doc = PyDoc_STR("Template object"), .tp_basicsize = sizeof(templateobject), .tp_itemsize = 0, From 422a515201ef50253a1c35e46d03977f0d3a3644 Mon Sep 17 00:00:00 2001 From: Koudai Aono Date: Wed, 9 Apr 2025 18:39:32 +0900 Subject: [PATCH 26/88] Remove unnecessary _Py_TPFLAGS_MATCH_SELF from Template type (#60) --- Objects/templateobject.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 656670aa2a5606..589f1f55b89846 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -442,7 +442,7 @@ PyTypeObject _PyTemplate_Type = { .tp_doc = PyDoc_STR("Template object"), .tp_basicsize = sizeof(templateobject), .tp_itemsize = 0, - .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_as_sequence = &template_as_sequence, .tp_new = (newfunc) template_new, .tp_dealloc = (destructor) template_dealloc, From bb7359afed0d0cb19a622e2ed35be48107f6c3f5 Mon Sep 17 00:00:00 2001 From: Koudai Aono Date: Wed, 9 Apr 2025 21:11:14 +0900 Subject: [PATCH 27/88] Fix memory leak in template concat error handling (#59) Co-authored-by: Lysandros Nikolaou --- Objects/templateobject.c | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 589f1f55b89846..4f49c774ff5282 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -204,8 +204,8 @@ template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyOb return NULL; } - ((templateobject *) template)->strings = strings; - ((templateobject *) template)->interpolations = interpolations; + ((templateobject *) template)->strings = Py_NewRef(strings); + ((templateobject *) template)->interpolations = Py_NewRef(interpolations); return template; } @@ -337,7 +337,12 @@ template_concat_templates(templateobject *self, templateobject *other) return NULL; } - return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + PyObject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + + Py_DECREF(newstrings); + Py_DECREF(newinterpolations); + + return newtemplate; } static PyObject * @@ -354,7 +359,12 @@ template_concat_template_str(templateobject *self, PyObject *other) return NULL; } - return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + PyObject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + + Py_DECREF(newstrings); + Py_DECREF(newinterpolations); + + return newtemplate; } static PyObject * @@ -371,7 +381,12 @@ template_concat_str_template(templateobject *self, PyObject *other) return NULL; } - return template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + PyObject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + + Py_DECREF(newstrings); + Py_DECREF(newinterpolations); + + return newtemplate; } PyObject * From 6a7b4488f96291c657368a8cdb65a56801547445 Mon Sep 17 00:00:00 2001 From: Dave Peck Date: Wed, 9 Apr 2025 09:29:29 -0700 Subject: [PATCH 28/88] PEP 750 bug and spec fix (#58) * Bugfix: increment `interpolationsidx` in `template_new()` * Spec fix: don't return empty strings from `templateiter_next()` --------- Co-authored-by: Lysandros Nikolaou --- Objects/templateobject.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 4f49c774ff5282..ab517d55105082 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -22,10 +22,15 @@ templateiter_next(templateiterobject *self) PyObject *item; if (self->from_strings) { item = PyIter_Next(self->stringsiter); + self->from_strings = 0; + if (PyUnicode_GET_LENGTH(item) == 0) { + Py_SETREF(item, PyIter_Next(self->interpolationsiter)); + self->from_strings = 1; + } } else { item = PyIter_Next(self->interpolationsiter); + self->from_strings = 1; } - self->from_strings = !self->from_strings; return item; } @@ -133,7 +138,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) if (!last_was_str) { PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } - PyTuple_SET_ITEM(interpolations, interpolationsidx, Py_NewRef(item)); + PyTuple_SET_ITEM(interpolations, interpolationsidx++, Py_NewRef(item)); last_was_str = 0; } } From e6d01effbf97a9efa1acd5941ecd6bbb83c566a3 Mon Sep 17 00:00:00 2001 From: Dave Peck Date: Thu, 10 Apr 2025 01:21:43 -0700 Subject: [PATCH 29/88] Fix for segv in `_PyInterpolation_FromStackRefSteal` (#61) --- Objects/interpolationobject.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 31be92d480084f..54dfa3d9f49482 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -241,11 +241,19 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values) PyTuple_SET_ITEM(args, 0, PyStackRef_AsPyObjectSteal(values[0])); PyTuple_SET_ITEM(args, 1, PyStackRef_AsPyObjectSteal(values[1])); - PyObject *conversion = PyStackRef_AsPyObjectSteal(values[2]); - PyTuple_SET_ITEM(args, 2, conversion ? conversion : Py_NewRef(Py_None)); + if (PyStackRef_IsNull(values[2])) { + PyTuple_SET_ITEM(args, 2, Py_NewRef(Py_None)); + } else { + PyObject *conversion = PyStackRef_AsPyObjectSteal(values[2]); + PyTuple_SET_ITEM(args, 2, conversion); + } - PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]); - PyTuple_SET_ITEM(args, 3, format_spec ? format_spec : &_Py_STR(empty)); + if (PyStackRef_IsNull(values[3])) { + PyTuple_SET_ITEM(args, 3, &_Py_STR(empty)); + } else { + PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]); + PyTuple_SET_ITEM(args, 3, format_spec); + } PyObject *interpolation = PyObject_CallObject((PyObject *) &_PyInterpolation_Type, args); Py_DECREF(args); From 0801f170e03aa3b1582e2b49603385cecdbf4a8c Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 10 Apr 2025 10:34:41 +0200 Subject: [PATCH 30/88] More minor fixes after merge with main --- Objects/clinic/interpolationobject.c.h | 4 +++- Python/bytecodes.c | 4 +++- Python/executor_cases.c.h | 12 +++--------- Python/generated_cases.c.h | 12 ++---------- Python/stdlib_module_names.h | 1 + 5 files changed, 12 insertions(+), 21 deletions(-) diff --git a/Objects/clinic/interpolationobject.c.h b/Objects/clinic/interpolationobject.c.h index c1201f09ebe939..7a94dabafc92f2 100644 --- a/Objects/clinic/interpolationobject.c.h +++ b/Objects/clinic/interpolationobject.c.h @@ -23,9 +23,11 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) static struct { PyGC_Head _this_is_not_used; PyObject_VAR_HEAD + Py_hash_t ob_hash; PyObject *ob_item[NUM_KEYWORDS]; } _kwtuple = { .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS) + .ob_hash = -1, .ob_item = { &_Py_ID(value), &_Py_ID(expression), &_Py_ID(conversion), &_Py_ID(format_spec), }, }; #undef NUM_KEYWORDS @@ -84,4 +86,4 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) exit: return return_value; } -/*[clinic end generated code: output=0250f606411f12f1 input=a9049054013a1b77]*/ +/*[clinic end generated code: output=599742a5ccd6f060 input=a9049054013a1b77]*/ diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b8fa484cb5473b..3c04bf2f76ec13 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -32,6 +32,8 @@ #include "pycore_stackref.h" #include "pycore_tuple.h" // _PyTuple_ITEMS() #include "pycore_typeobject.h" // _PySuper_Lookup() +#include "pycore_interpolation.h" +#include "pycore_template.h" #include "pycore_dict.h" #include "dictobject.h" @@ -1891,7 +1893,7 @@ dummy_func( inst(BUILD_TEMPLATE_LIST, (list -- template)) { PyObject *template_o = _PyTemplate_FromListStackRef(list); - DECREF_INPUTS(); + INPUTS_DEAD(); ERROR_IF(template_o == NULL, error); template = PyStackRef_FromPyObjectSteal(template_o); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 55f5a109c00436..8bae14a1ee9390 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2643,20 +2643,14 @@ list = stack_pointer[-1]; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromListStackRef(list); - _PyStackRef tmp = list; - list = PyStackRef_NULL; - stack_pointer[-1] = list; - PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (template_o == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); JUMP_TO_ERROR(); } template = PyStackRef_FromPyObjectSteal(template_o); - stack_pointer[0] = template; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = template; break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 009bfb87cb0dad..79a80b1a52f20c 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1380,20 +1380,12 @@ list = stack_pointer[-1]; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromListStackRef(list); - _PyStackRef tmp = list; - list = PyStackRef_NULL; - stack_pointer[-1] = list; - PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (template_o == NULL) { - JUMP_TO_LABEL(error); + JUMP_TO_LABEL(pop_1_error); } template = PyStackRef_FromPyObjectSteal(template_o); - stack_pointer[0] = template; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = template; DISPATCH(); } diff --git a/Python/stdlib_module_names.h b/Python/stdlib_module_names.h index 9ae15f8cfe71bf..9cc77b53a638cf 100644 --- a/Python/stdlib_module_names.h +++ b/Python/stdlib_module_names.h @@ -89,6 +89,7 @@ static const char* _Py_stdlib_module_names[] = { "_suggestions", "_symtable", "_sysconfig", +"_templatelib", "_thread", "_threading_local", "_tkinter", From a51e954cb17dad25e077eab422432d656af14e78 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 10 Apr 2025 11:02:56 +0200 Subject: [PATCH 31/88] Fix JIT build --- Include/internal/pycore_opcode_metadata.h | 6 +++--- Include/internal/pycore_uop_metadata.h | 6 +++--- Python/executor_cases.c.h | 6 ------ Python/generated_cases.c.h | 6 ------ Python/jit.c | 2 ++ Tools/cases_generator/analyzer.py | 3 +++ Tools/jit/template.c | 2 ++ 7 files changed, 13 insertions(+), 18 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 5c402b9d201002..15d5f49d0cd005 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1089,14 +1089,14 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_INTERPOLATION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_INTERPOLATION] = { true, INSTR_FMT_IX, HAS_ERROR_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 }, [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_TEMPLATE_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [BUILD_TEMPLATE_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index de48f571f91f7d..fb1876cecb4390 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -144,9 +144,9 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG, + [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 8bae14a1ee9390..aa3a7aecfbd41a 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2579,9 +2579,7 @@ _PyStackRef *values; _PyStackRef interpolation; values = &stack_pointer[-4]; - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); - stack_pointer = _PyFrame_GetStackPointer(frame); if (interpolation_o == NULL) { stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); @@ -2613,9 +2611,7 @@ assert(WITHIN_STACK_BOUNDS()); JUMP_TO_ERROR(); } - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); _PyFrame_SetStackPointer(frame, stack_pointer); _PyStackRef tmp; @@ -2641,9 +2637,7 @@ _PyStackRef list; _PyStackRef template; list = stack_pointer[-1]; - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromListStackRef(list); - stack_pointer = _PyFrame_GetStackPointer(frame); if (template_o == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 79a80b1a52f20c..7111d6c970ec65 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1090,9 +1090,7 @@ _PyStackRef *values; _PyStackRef interpolation; values = &stack_pointer[-4]; - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); - stack_pointer = _PyFrame_GetStackPointer(frame); if (interpolation_o == NULL) { JUMP_TO_LABEL(pop_4_error); } @@ -1343,9 +1341,7 @@ assert(WITHIN_STACK_BOUNDS()); JUMP_TO_LABEL(error); } - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); _PyFrame_SetStackPointer(frame, stack_pointer); _PyStackRef tmp; @@ -1378,9 +1374,7 @@ _PyStackRef list; _PyStackRef template; list = stack_pointer[-1]; - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromListStackRef(list); - stack_pointer = _PyFrame_GetStackPointer(frame); if (template_o == NULL) { JUMP_TO_LABEL(pop_1_error); } diff --git a/Python/jit.c b/Python/jit.c index 8a91d2f62a4627..d9382d25ac156c 100644 --- a/Python/jit.c +++ b/Python/jit.c @@ -23,6 +23,8 @@ #include "pycore_sliceobject.h" #include "pycore_tuple.h" #include "pycore_unicodeobject.h" +#include "pycore_interpolation.h" +#include "pycore_template.h" #include "pycore_jit.h" diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index a217d7136a5401..39538c6b9f9e31 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -630,6 +630,7 @@ def has_error_without_pop(op: parser.CodeDef) -> bool: "_PyFrame_StackPush", "_PyFunction_SetVersion", "_PyGen_GetGeneratorFromFrame", + "_PyInterpolation_FromStackRefSteal", "_PyInterpreterState_GET", "_PyList_AppendTakeRef", "_PyList_ITEMS", @@ -648,6 +649,8 @@ def has_error_without_pop(op: parser.CodeDef) -> bool: "_PyObject_InlineValues", "_PyObject_IsUniquelyReferenced", "_PyObject_ManagedDictPointer", + "_PyTemplate_FromValues", + "_PyTemplate_FromListStackRef", "_PyThreadState_HasStackSpace", "_PyTuple_FromStackRefStealOnSuccess", "_PyTuple_ITEMS", diff --git a/Tools/jit/template.c b/Tools/jit/template.c index bc18e702eeaa3b..ee23b86b198ae2 100644 --- a/Tools/jit/template.c +++ b/Tools/jit/template.c @@ -27,6 +27,8 @@ #include "pycore_stackref.h" #include "pycore_tuple.h" #include "pycore_unicodeobject.h" +#include "pycore_interpolation.h" +#include "pycore_template.h" #include "ceval_macros.h" From 76816a1d202e988da37c2d36249e3e46b1ff6e21 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 10 Apr 2025 11:15:56 +0200 Subject: [PATCH 32/88] Fix Windows build --- PCbuild/_freeze_module.vcxproj | 2 ++ PCbuild/pythoncore.vcxproj | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/PCbuild/_freeze_module.vcxproj b/PCbuild/_freeze_module.vcxproj index 59d664dc1745c1..1f3f3170f3fa48 100644 --- a/PCbuild/_freeze_module.vcxproj +++ b/PCbuild/_freeze_module.vcxproj @@ -143,6 +143,7 @@ + @@ -158,6 +159,7 @@ + diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj index ac2e7e848994a4..d12c5f9f32f265 100644 --- a/PCbuild/pythoncore.vcxproj +++ b/PCbuild/pythoncore.vcxproj @@ -264,6 +264,7 @@ + @@ -310,6 +311,7 @@ + @@ -529,6 +531,7 @@ + @@ -544,6 +547,7 @@ + From 2c53f55446600d5c29fd71b478be059b632f6e7b Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 10 Apr 2025 11:42:39 +0200 Subject: [PATCH 33/88] Remove smelly _conversion_converter symbol --- Include/internal/pycore_interpolation.h | 2 -- Objects/interpolationobject.c | 30 ++++++++++++------------- 2 files changed, 14 insertions(+), 18 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 88cd6f2b47324e..ba170fbfded085 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -11,8 +11,6 @@ extern "C" { #include "pycore_stackref.h" // _PyStackRef -extern int _conversion_converter(PyObject *arg, PyObject **conv); - extern PyTypeObject _PyInterpolation_Type; PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 54dfa3d9f49482..57a857536a7ed0 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -9,19 +9,7 @@ #include "pycore_interpolation.h" -/*[clinic input] -module templatelib -[clinic start generated code]*/ -/*[clinic end generated code: output=da39a3ee5e6b4b0d input=dbb2236a3de68808]*/ - -#include "clinic/interpolationobject.c.h" - -/*[clinic input] -class templatelib.Interpolation "interpolationobject *" "&_PyInterpolation_Type" -[clinic start generated code]*/ -/*[clinic end generated code: output=da39a3ee5e6b4b0d input=5b183514b4d7e5af]*/ - -int +static int _conversion_converter(PyObject *arg, PyObject **conversion) { if (arg == Py_None) { @@ -29,7 +17,10 @@ _conversion_converter(PyObject *arg, PyObject **conversion) } if (!PyUnicode_Check(arg)) { - _PyArg_BadArgument("Interpolation", "argument 'conversion'", "str", arg); + PyErr_Format(PyExc_TypeError, + "%.200s() %.200s must be %.50s, not %.50s", + "Interpolation", "argument 'conversion'", "str", + arg == Py_None ? "None" : Py_TYPE(arg)->tp_name); return 0; } @@ -45,6 +36,13 @@ _conversion_converter(PyObject *arg, PyObject **conversion) return 1; } +#include "clinic/interpolationobject.c.h" + +/*[clinic input] +class Interpolation "interpolationobject *" "&_PyInterpolation_Type" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=161c64a16f9c4544]*/ + typedef struct { PyObject_HEAD PyObject *value; @@ -55,7 +53,7 @@ typedef struct { /*[clinic input] @classmethod -templatelib.Interpolation.__new__ as interpolation_new +Interpolation.__new__ as interpolation_new value: object expression: object(subclass_of='&PyUnicode_Type') @@ -67,7 +65,7 @@ static PyObject * interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *expression, PyObject *conversion, PyObject *format_spec) -/*[clinic end generated code: output=6488e288765bc1a9 input=0abc8e498fb744a7]*/ +/*[clinic end generated code: output=6488e288765bc1a9 input=d91711024068528c]*/ { interpolationobject *self = (interpolationobject *) type->tp_alloc(type, 0); if (!self) { From fa4b5313bf151a1445e2e3d8ccaed90406977e9a Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 10 Apr 2025 11:59:55 +0200 Subject: [PATCH 34/88] Fix check-c-globals --- Tools/c-analyzer/TODO | 3 +++ Tools/c-analyzer/cpython/globals-to-fix.tsv | 3 +++ 2 files changed, 6 insertions(+) diff --git a/Tools/c-analyzer/TODO b/Tools/c-analyzer/TODO index d509489176b945..2077534ccf4128 100644 --- a/Tools/c-analyzer/TODO +++ b/Tools/c-analyzer/TODO @@ -794,6 +794,7 @@ Objects/genobject.c:_PyAsyncGenASend_Type PyTypeObject _P Objects/genobject.c:_PyAsyncGenAThrow_Type PyTypeObject _PyAsyncGenAThrow_Type Objects/genobject.c:_PyAsyncGenWrappedValue_Type PyTypeObject _PyAsyncGenWrappedValue_Type Objects/genobject.c:_PyCoroWrapper_Type PyTypeObject _PyCoroWrapper_Type +Objects/interpolationobject.c:_PyInterpolation_Type PyTypeObject _PyInterpolation_Type Objects/interpreteridobject.c:_PyInterpreterID_Type PyTypeObject _PyInterpreterID_Type Objects/iterobject.c:PyCallIter_Type PyTypeObject PyCallIter_Type Objects/iterobject.c:PySeqIter_Type PyTypeObject PySeqIter_Type @@ -827,6 +828,8 @@ Objects/sliceobject.c:PyEllipsis_Type PyTypeObject Py Objects/sliceobject.c:PySlice_Type PyTypeObject PySlice_Type Objects/stringlib/unicode_format.h:PyFieldNameIter_Type static PyTypeObject PyFieldNameIter_Type Objects/stringlib/unicode_format.h:PyFormatterIter_Type static PyTypeObject PyFormatterIter_Type +Objects/templateobject.c:_PyTemplateIter_Type PyTypeObject _PyTemplateIter_Type +Objects/templateobject.c:_PyTemplate_Type PyTypeObject _PyTemplate_Type Objects/tupleobject.c:PyTupleIter_Type PyTypeObject PyTupleIter_Type Objects/tupleobject.c:PyTuple_Type PyTypeObject PyTuple_Type Objects/typeobject.c:PyBaseObject_Type PyTypeObject PyBaseObject_Type diff --git a/Tools/c-analyzer/cpython/globals-to-fix.tsv b/Tools/c-analyzer/cpython/globals-to-fix.tsv index 54954cfb5f83ff..3c3cb2f9c86f16 100644 --- a/Tools/c-analyzer/cpython/globals-to-fix.tsv +++ b/Tools/c-analyzer/cpython/globals-to-fix.tsv @@ -55,6 +55,7 @@ Objects/genobject.c - _PyAsyncGenASend_Type - Objects/genobject.c - _PyAsyncGenAThrow_Type - Objects/genobject.c - _PyAsyncGenWrappedValue_Type - Objects/genobject.c - _PyCoroWrapper_Type - +Objects/interpolationobject.c - _PyInterpolation_Type - Objects/iterobject.c - PyCallIter_Type - Objects/iterobject.c - PySeqIter_Type - Objects/iterobject.c - _PyAnextAwaitable_Type - @@ -86,6 +87,8 @@ Objects/setobject.c - PySetIter_Type - Objects/setobject.c - PySet_Type - Objects/sliceobject.c - PyEllipsis_Type - Objects/sliceobject.c - PySlice_Type - +Objects/templateobject.c - _PyTemplateIter_Type - +Objects/templateobject.c - _PyTemplate_Type - Objects/tupleobject.c - PyTupleIter_Type - Objects/tupleobject.c - PyTuple_Type - Objects/typeobject.c - _PyBufferWrapper_Type - From 98e5d83c4db3362841d4e23aa0a89d748f7c3f05 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 11 Apr 2025 16:42:53 +0200 Subject: [PATCH 35/88] Fix various stuff in the VM --- Include/internal/pycore_interpolation.h | 2 +- Include/internal/pycore_opcode_metadata.h | 6 ++--- Include/internal/pycore_template.h | 2 +- Include/internal/pycore_uop_metadata.h | 6 ++--- Objects/interpolationobject.c | 28 ++++++++--------------- Objects/templateobject.c | 11 ++++----- Python/bytecodes.c | 11 +++++---- Python/executor_cases.c.h | 20 ++++++++++------ Python/generated_cases.c.h | 20 ++++++++++++---- Tools/cases_generator/analyzer.py | 5 ++-- 10 files changed, 59 insertions(+), 52 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index ba170fbfded085..8c1161008a8d69 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -13,7 +13,7 @@ extern "C" { extern PyTypeObject _PyInterpolation_Type; -PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values); +PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values); extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); extern PyObject *_PyInterpolation_GetValue(PyObject *interpolation); diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 15d5f49d0cd005..5548fb0858bbd7 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1089,14 +1089,14 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_INTERPOLATION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG }, + [BUILD_INTERPOLATION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_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 }, [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [BUILD_TEMPLATE_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG }, + [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TEMPLATE_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 27d0d1d3315329..9d53e41a08fdc9 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -17,7 +17,7 @@ extern PyTypeObject _PyTemplateIter_Type; extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); PyAPI_FUNC(PyObject *) _PyTemplate_FromValues(PyObject **values, Py_ssize_t n); -PyAPI_FUNC(PyObject *) _PyTemplate_FromListStackRef(_PyStackRef ref); +PyAPI_FUNC(PyObject *) _PyTemplate_FromList(PyObject *list); #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index fb1876cecb4390..215b2f1c725c55 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -144,9 +144,9 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG, - [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG, + [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, + [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 57a857536a7ed0..ee2ce35b46a8b3 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -225,37 +225,29 @@ _PyInterpolation_InitTypes(PyInterpreterState *interp) } PyObject * -_PyInterpolation_FromStackRefSteal(_PyStackRef *values) +_PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values) { - PyObject *args = PyTuple_New(4); - if (!args) { - PyStackRef_CLOSE(values[0]); - PyStackRef_CLOSE(values[1]); - PyStackRef_XCLOSE(values[2]); - PyStackRef_XCLOSE(values[3]); + interpolationobject *interpolation = (interpolationobject *) _PyInterpolation_Type.tp_alloc(&_PyInterpolation_Type, 0); + if (!interpolation) { return NULL; } - PyTuple_SET_ITEM(args, 0, PyStackRef_AsPyObjectSteal(values[0])); - PyTuple_SET_ITEM(args, 1, PyStackRef_AsPyObjectSteal(values[1])); + interpolation->value = PyStackRef_AsPyObjectSteal(values[0]); + interpolation->expression = PyStackRef_AsPyObjectSteal(values[1]); if (PyStackRef_IsNull(values[2])) { - PyTuple_SET_ITEM(args, 2, Py_NewRef(Py_None)); + interpolation->conversion = Py_NewRef(Py_None); } else { - PyObject *conversion = PyStackRef_AsPyObjectSteal(values[2]); - PyTuple_SET_ITEM(args, 2, conversion); + interpolation->conversion = PyStackRef_AsPyObjectSteal(values[2]); } if (PyStackRef_IsNull(values[3])) { - PyTuple_SET_ITEM(args, 3, &_Py_STR(empty)); + interpolation->format_spec = Py_NewRef(&_Py_STR(empty)); } else { - PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]); - PyTuple_SET_ITEM(args, 3, format_spec); + interpolation->format_spec = PyStackRef_AsPyObjectSteal(values[3]); } - PyObject *interpolation = PyObject_CallObject((PyObject *) &_PyInterpolation_Type, args); - Py_DECREF(args); - return interpolation; + return (PyObject *) interpolation; } PyObject * diff --git a/Objects/templateobject.c b/Objects/templateobject.c index ab517d55105082..22b7dd2d9c084a 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -484,23 +484,20 @@ _PyTemplate_FromValues(PyObject **values, Py_ssize_t oparg) PyTuple_SET_ITEM(tuple, i, Py_NewRef(values[i])); } - PyObject *template = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); + PyObject *template = (PyObject *) template_new(&_PyTemplate_Type, tuple, NULL); Py_DECREF(tuple); return template; } PyObject * -_PyTemplate_FromListStackRef(_PyStackRef ref) +_PyTemplate_FromList(PyObject *list) { - PyObject *list = PyStackRef_AsPyObjectSteal(ref); - - PyObject *tuple = PySequence_Tuple(list); + PyObject *tuple = PyList_AsTuple(list); if (!tuple) { - PyStackRef_CLOSE(ref); return NULL; } - PyObject *template = PyObject_CallObject((PyObject *) &_PyTemplate_Type, tuple); + PyObject *template = (PyObject *) template_new(&_PyTemplate_Type, tuple, NULL); Py_DECREF(tuple); return template; } diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 3c04bf2f76ec13..3ccb279cd579d9 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1872,9 +1872,11 @@ dummy_func( } inst(BUILD_INTERPOLATION, (values[4] -- interpolation)) { - PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); + PyObject *interpolation_o = _PyInterpolation_FromStackRefStealOnSuccess(values); + if (interpolation_o == NULL) { + ERROR_NO_POP(); + } INPUTS_DEAD(); - ERROR_IF(interpolation_o == NULL, error); interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); } @@ -1892,8 +1894,9 @@ dummy_func( } inst(BUILD_TEMPLATE_LIST, (list -- template)) { - PyObject *template_o = _PyTemplate_FromListStackRef(list); - INPUTS_DEAD(); + PyObject *list_o = PyStackRef_AsPyObjectBorrow(list); + PyObject *template_o = _PyTemplate_FromList(list_o); + PyStackRef_CLOSE(list); ERROR_IF(template_o == NULL, error); template = PyStackRef_FromPyObjectSteal(template_o); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index aa3a7aecfbd41a..e6731a0c26c897 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2579,10 +2579,8 @@ _PyStackRef *values; _PyStackRef interpolation; values = &stack_pointer[-4]; - PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); + PyObject *interpolation_o = _PyInterpolation_FromStackRefStealOnSuccess(values); if (interpolation_o == NULL) { - stack_pointer += -4; - assert(WITHIN_STACK_BOUNDS()); JUMP_TO_ERROR(); } interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); @@ -2611,7 +2609,9 @@ assert(WITHIN_STACK_BOUNDS()); JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); _PyFrame_SetStackPointer(frame, stack_pointer); _PyStackRef tmp; @@ -2637,14 +2637,20 @@ _PyStackRef list; _PyStackRef template; list = stack_pointer[-1]; - PyObject *template_o = _PyTemplate_FromListStackRef(list); + PyObject *list_o = PyStackRef_AsPyObjectBorrow(list); + PyObject *template_o = _PyTemplate_FromList(list_o); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(list); + stack_pointer = _PyFrame_GetStackPointer(frame); if (template_o == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); JUMP_TO_ERROR(); } template = PyStackRef_FromPyObjectSteal(template_o); - stack_pointer[-1] = template; + stack_pointer[0] = template; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 7111d6c970ec65..35bdd8ea54773c 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1090,9 +1090,9 @@ _PyStackRef *values; _PyStackRef interpolation; values = &stack_pointer[-4]; - PyObject *interpolation_o = _PyInterpolation_FromStackRefSteal(values); + PyObject *interpolation_o = _PyInterpolation_FromStackRefStealOnSuccess(values); if (interpolation_o == NULL) { - JUMP_TO_LABEL(pop_4_error); + JUMP_TO_LABEL(error); } interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); stack_pointer[-4] = interpolation; @@ -1341,7 +1341,9 @@ assert(WITHIN_STACK_BOUNDS()); JUMP_TO_LABEL(error); } + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); _PyFrame_SetStackPointer(frame, stack_pointer); _PyStackRef tmp; @@ -1374,12 +1376,20 @@ _PyStackRef list; _PyStackRef template; list = stack_pointer[-1]; - PyObject *template_o = _PyTemplate_FromListStackRef(list); + PyObject *list_o = PyStackRef_AsPyObjectBorrow(list); + PyObject *template_o = _PyTemplate_FromList(list_o); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(list); + stack_pointer = _PyFrame_GetStackPointer(frame); if (template_o == NULL) { - JUMP_TO_LABEL(pop_1_error); + JUMP_TO_LABEL(error); } template = PyStackRef_FromPyObjectSteal(template_o); - stack_pointer[-1] = template; + stack_pointer[0] = template; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 39538c6b9f9e31..fbb0008aae02a0 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -630,7 +630,7 @@ def has_error_without_pop(op: parser.CodeDef) -> bool: "_PyFrame_StackPush", "_PyFunction_SetVersion", "_PyGen_GetGeneratorFromFrame", - "_PyInterpolation_FromStackRefSteal", + "_PyInterpolation_FromStackRefStealOnSuccess", "_PyInterpreterState_GET", "_PyList_AppendTakeRef", "_PyList_ITEMS", @@ -649,8 +649,7 @@ def has_error_without_pop(op: parser.CodeDef) -> bool: "_PyObject_InlineValues", "_PyObject_IsUniquelyReferenced", "_PyObject_ManagedDictPointer", - "_PyTemplate_FromValues", - "_PyTemplate_FromListStackRef", + "_PyTemplate_FromList", "_PyThreadState_HasStackSpace", "_PyTuple_FromStackRefStealOnSuccess", "_PyTuple_ITEMS", From a7c57fe25b3219335ea08b32967f61f3e776f0a6 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 11 Apr 2025 17:50:49 +0200 Subject: [PATCH 36/88] Add tests --- Lib/test/test_tstring.py | 391 +++++++++++++++++++++++++++++++++++++++ Parser/action_helpers.c | 13 +- 2 files changed, 398 insertions(+), 6 deletions(-) create mode 100644 Lib/test/test_tstring.py diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py new file mode 100644 index 00000000000000..18c419ddc1e106 --- /dev/null +++ b/Lib/test/test_tstring.py @@ -0,0 +1,391 @@ +import ast +import unittest + +from string.templatelib import Template, Interpolation + + +def convert(value, conversion) -> object: + if conversion == "a": + return ascii(value) + elif conversion == "r": + return repr(value) + elif conversion == "s": + return str(value) + return value + + +def f(template) -> str: + parts = [] + for item in template: + match item: + case str() as s: + parts.append(s) + case Interpolation(value, _, conversion, format_spec): + value = convert(value, conversion) + value = format(value, format_spec) + parts.append(value) + return "".join(parts) + + +class TestTString(unittest.TestCase): + def assertAllRaise(self, exception_type, regex, error_strings): + for s in error_strings: + with self.subTest(s=s): + with self.assertRaisesRegex(exception_type, regex): + eval(s) + + def test_template_basic_creation(self): + # Simple t-string creation + t = t"Hello, world" + self.assertTrue(isinstance(t, Template)) + self.assertEqual(t.strings, ("Hello, world",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "Hello, world") + + # Empty t-string + t = t"" + self.assertEqual(t.strings, ("",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "") + + # Multi-line t-string + t = t"""Hello, +world""" + self.assertEqual(t.strings, ("Hello,\nworld",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "Hello,\nworld") + + def test_string_representation(self): + # Test __repr__ + t = t"Hello" + self.assertEqual(repr(t), "Template(strings=('Hello',), interpolations=())") + + name = "Python" + t = t"Hello, {name}" + self.assertEqual(repr(t), + "Template(strings=('Hello, ', ''), " + "interpolations=(Interpolation('Python', 'name', None, ''),))" + ) + + def test_interpolation_basics(self): + # Test basic interpolation + name = "Python" + t = t"Hello, {name}" + self.assertEqual(t.strings, ("Hello, ", "")) + self.assertEqual(t.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Python") + + # Multiple interpolations + first = "Python" + last = "Developer" + t = t"{first} {last}" + self.assertEqual(t.strings, ("", " ", "")) + self.assertEqual(t.interpolations[0].value, first) + self.assertEqual(t.interpolations[0].expression, "first") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(t.interpolations[1].value, last) + self.assertEqual(t.interpolations[1].expression, "last") + self.assertEqual(t.interpolations[1].conversion, None) + self.assertEqual(t.interpolations[1].format_spec, "") + self.assertEqual(f(t), "Python Developer") + + # Interpolation with expressions + a = 10 + b = 20 + t = t"Sum: {a + b}" + self.assertEqual(t.strings, ("Sum: ", "")) + self.assertEqual(t.interpolations[0].value, a + b) + self.assertEqual(t.interpolations[0].expression, "a + b") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Sum: 30") + + # Interpolation with function + def square(x): + return x * x + t = t"Square: {square(5)}" + self.assertEqual(t.strings, ("Square: ", "")) + self.assertEqual(t.interpolations[0].value, square(5)) + self.assertEqual(t.interpolations[0].expression, "square(5)") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Square: 25") + + # Test attribute access in expressions + class Person: + def __init__(self, name): + self.name = name + + def upper(self): + return self.name.upper() + + person = Person("Alice") + t = t"Name: {person.name}" + self.assertEqual(t.strings, ("Name: ", "")) + self.assertEqual(t.interpolations[0].value, person.name) + self.assertEqual(t.interpolations[0].expression, "person.name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Name: Alice") + + # Test method calls + t = t"Name: {person.upper()}" + self.assertEqual(t.strings, ("Name: ", "")) + self.assertEqual(t.interpolations[0].value, person.upper()) + self.assertEqual(t.interpolations[0].expression, "person.upper()") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Name: ALICE") + + # Test dictionary access + data = {"name": "Bob", "age": 30} + t = t"Name: {data['name']}, Age: {data['age']}" + self.assertEqual(t.strings, ("Name: ", ", Age: ", "")) + self.assertEqual(t.interpolations[0].value, data["name"]) + self.assertEqual(t.interpolations[0].expression, "data['name']") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(t.interpolations[1].value, data["age"]) + self.assertEqual(t.interpolations[1].expression, "data['age']") + self.assertEqual(t.interpolations[1].conversion, None) + self.assertEqual(t.interpolations[1].format_spec, "") + self.assertEqual(f(t), "Name: Bob, Age: 30") + + def test_format_specifiers(self): + # Test basic format specifiers + value = 3.14159 + t = t"Pi: {value:.2f}" + self.assertEqual(t.strings, ("Pi: ", "")) + self.assertEqual(t.interpolations[0].value, value) + self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, ".2f") + self.assertEqual(f(t), "Pi: 3.14") + + def test_conversions(self): + # Test !s conversion (str) + obj = object() + t = t"Object: {obj!s}" + self.assertEqual(t.strings, ("Object: ", "")) + self.assertEqual(t.interpolations[0].value, obj) + self.assertEqual(t.interpolations[0].expression, "obj") + self.assertEqual(t.interpolations[0].conversion, "s") + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), f"Object: {str(obj)}") + + # Test !r conversion (repr) + t = t"Data: {obj!r}" + self.assertEqual(t.strings, ("Data: ", "")) + self.assertEqual(t.interpolations[0].value, obj) + self.assertEqual(t.interpolations[0].expression, "obj") + self.assertEqual(t.interpolations[0].conversion, "r") + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), f"Data: {repr(obj)}") + + # Test !a conversion (ascii) + text = "Café" + t = t"ASCII: {text!a}" + self.assertEqual(t.strings, ("ASCII: ", "")) + self.assertEqual(t.interpolations[0].value, text) + self.assertEqual(t.interpolations[0].expression, "text") + self.assertEqual(t.interpolations[0].conversion, "a") + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), f"ASCII: {ascii(text)}") + + # Test !z conversion (error) + num = 1 + with self.assertRaises(SyntaxError): + eval("t'{num!z}'") + + def test_debug_specifier(self): + # Test debug specifier + value = 42 + t = t"Value: {value=}" + self.assertEqual(t.strings, ("Value: value=", "")) + self.assertEqual(t.interpolations[0].value, value) + self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].conversion, "r") + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Value: value=42") + + # Test debug specifier with format (conversion default to !r) + t = t"Value: {value=:.2f}" + self.assertEqual(t.strings, ("Value: value=", "")) + self.assertEqual(t.interpolations[0].value, value) + self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, ".2f") + self.assertEqual(f(t), "Value: value=42.00") + + # Test debug specifier with conversion + t = t"Value: {value=!s}" + self.assertEqual(t.strings, ("Value: value=", "")) + self.assertEqual(t.interpolations[0].value, value) + self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].conversion, "s") + self.assertEqual(t.interpolations[0].format_spec, "") + + # Test white space in debug specifier + t = t"Value: {value = }" + self.assertEqual(t.strings, ("Value: value = ", "")) + self.assertEqual(t.interpolations[0].value, value) + self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].conversion, "r") + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Value: value = 42") + + def test_raw_tstrings(self): + path = r"C:\Users" + t = rt"{path}\Documents" + self.assertEqual(t.strings, ("", r"\Documents",)) + self.assertEqual(t.interpolations[0].value, path) + self.assertEqual(t.interpolations[0].expression, "path") + self.assertEqual(f(t), r"C:\Users\Documents") + + # Test alternative prefix + t = tr"{path}\Documents" + self.assertEqual(t.strings, ("", r"\Documents",)) + self.assertEqual(t.interpolations[0].value, path) + + + def test_template_concatenation(self): + # Test template + template + t1 = t"Hello, " + t2 = t"world" + combined = t1 + t2 + self.assertEqual(combined.strings, ("Hello, world",)) + self.assertEqual(len(combined.interpolations), 0) + self.assertEqual(f(combined), "Hello, world") + + # Test template + string + t1 = t"Hello" + combined = t1 + ", world" + self.assertEqual(combined.strings, ("Hello, world",)) + self.assertEqual(len(combined.interpolations), 0) + self.assertEqual(f(combined), "Hello, world") + + # Test template + template with interpolation + name = "Python" + t1 = t"Hello, " + t2 = t"{name}" + combined = t1 + t2 + self.assertEqual(combined.strings, ("Hello, ", "")) + self.assertEqual(combined.interpolations[0].value, name) + self.assertEqual(combined.interpolations[0].expression, "name") + self.assertEqual(combined.interpolations[0].conversion, None) + self.assertEqual(combined.interpolations[0].format_spec, "") + self.assertEqual(f(combined), "Hello, Python") + + # Test string + template + t = "Hello, " + t"{name}" + self.assertEqual(t.strings, ("Hello, ", "")) + self.assertEqual(t.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Python") + + def test_nested_templates(self): + # Test a template inside another template expression + name = "Python" + inner = t"{name}" + t = t"Language: {inner}" + + self.assertEqual(t.strings, ("Language: ", "")) + self.assertEqual(t.interpolations[0].value.strings, ("", "")) + self.assertEqual(t.interpolations[0].value.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].value.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].value.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].value.interpolations[0].format_spec, "") + self.assertEqual(t.interpolations[0].expression, "inner") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + + def test_ast_structure(self): + # Test AST structure for simple t-string + tree = ast.parse('t"Hello"') + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) + + # Test AST for t-string with interpolation + tree = ast.parse('t"Hello {name}"') + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) + self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) + + def test_error_conditions(self): + # Test syntax errors + with self.assertRaisesRegex(SyntaxError, "'{' was never closed"): + eval("t'{") + + with self.assertRaisesRegex(SyntaxError, "t-string: expecting '}'"): + eval("t'{a'") + + with self.assertRaisesRegex(SyntaxError, "t-string: single '}' is not allowed"): + eval("t'}'") + + # Test missing variables + with self.assertRaises(NameError): + eval("t'Hello, {name}'") + + # Test invalid conversion + num = 1 + with self.assertRaises(SyntaxError): + eval("t'{num!z}'") + + def test_literal_concatenation(self): + # Test concatenation of t-string literals + t = t"Hello, " t"world" + self.assertEqual(t.strings, ("Hello, world",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "Hello, world") + + # Test concatenation with interpolation + name = "Python" + t = t"Hello, " t"{name}" + self.assertEqual(t.strings, ("Hello, ", "")) + self.assertEqual(t.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Python") + + # Test concatenation with string literal + name = "Python" + t = t"Hello, {name}" "and welcome!" + self.assertEqual(t.strings, ("Hello, ", "and welcome!")) + self.assertEqual(t.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Pythonand welcome!") + + def test_triple_quoted(self): + # Test triple-quoted t-strings + t = t""" + Hello, + world + """ + self.assertEqual(t.strings, ("\n Hello,\n world\n ",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "\n Hello,\n world\n ") + + # Test triple-quoted with interpolation + name = "Python" + t = t""" + Hello, + {name} + """ + self.assertEqual(t.strings, ("\n Hello,\n ", "\n ")) + self.assertEqual(t.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "\n Hello,\n Python\n ") + +if __name__ == '__main__': + unittest.main() diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 626f38f35ac9bd..27be9638832d86 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1295,7 +1295,7 @@ _PyPegen_decode_fstring_part(Parser* p, int is_raw, expr_ty constant, Token* tok } static asdl_expr_seq * -_get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b) +_get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b, int tstring) { Py_ssize_t n_items = asdl_seq_LEN(raw_expressions); Py_ssize_t total_items = n_items; @@ -1323,13 +1323,14 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b // This should correspond to a JoinedStr node of two elements // created _PyPegen_formatted_value. This situation can only be the result of - // a f-string debug expression where the first element is a constant with the text and the second + // a (f|t)-string debug expression where the first element is a constant with the text and the second // a formatted value with the expression. if (item->kind == JoinedStr_kind) { asdl_expr_seq *values = item->v.JoinedStr.values; if (asdl_seq_LEN(values) != 2) { PyErr_Format(PyExc_SystemError, - "unexpected JoinedStr node without debug data in f-string at line %d", + tstring ? "unexpected TemplateStr node without debug data in t-string at line %d" + : "unexpected JoinedStr node without debug data in f-string at line %d", item->lineno); return NULL; } @@ -1339,7 +1340,7 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b asdl_seq_SET(seq, index++, first); expr_ty second = asdl_seq_GET(values, 1); - assert(second->kind == FormattedValue_kind); + assert((tstring && second->kind == Interpolation_kind) || second->kind == FormattedValue_kind); asdl_seq_SET(seq, index++, second); continue; @@ -1381,7 +1382,7 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b expr_ty _PyPegen_template_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b) { - asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b); + asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b, 1); return _PyAST_TemplateStr(resized_exprs, a->lineno, a->col_offset, b->end_lineno, b->end_col_offset, p->arena); @@ -1390,7 +1391,7 @@ _PyPegen_template_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token expr_ty _PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* raw_expressions, Token*b) { - asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b); + asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b, 0); return _PyAST_JoinedStr(resized_exprs, a->lineno, a->col_offset, b->end_lineno, b->end_col_offset, p->arena); From d6c470c7c8105fe07ed2413c168f6c5c552d6bd8 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Fri, 11 Apr 2025 16:53:39 +0100 Subject: [PATCH 37/88] Fix Windows build (#64) --- Lib/string/templatelib.py | 4 ++-- Modules/Setup | 1 + Modules/_templatelibmodule.c | 27 ++++++++------------------- Objects/interpolationobject.c | 2 +- Objects/templateobject.c | 2 +- PC/config.c | 2 ++ PCbuild/pythoncore.vcxproj | 1 + PCbuild/pythoncore.vcxproj.filters | 9 +++++++++ configure | 28 ++++++++++++++++++++++++++++ configure.ac | 1 + 10 files changed, 54 insertions(+), 23 deletions(-) diff --git a/Lib/string/templatelib.py b/Lib/string/templatelib.py index 89199aebb9d09d..22f7edb68eb83a 100644 --- a/Lib/string/templatelib.py +++ b/Lib/string/templatelib.py @@ -1,3 +1,3 @@ -from _templatelib import Template, Interpolation +"""Support for template string literals (t-strings).""" -__all__ = ['Template', 'Interpolation'] +from _templatelib import Template, Interpolation diff --git a/Modules/Setup b/Modules/Setup index f75f44e98c7818..1d295669f48b0d 100644 --- a/Modules/Setup +++ b/Modules/Setup @@ -150,6 +150,7 @@ PYTHONPATH=$(COREPYTHONPATH) #_socket socketmodule.c #_statistics _statisticsmodule.c #_struct _struct.c +#_templatelib _templatelibmodule.c #_types _typesmodule.c #_typing _typingmodule.c #_zoneinfo _zoneinfo.c diff --git a/Modules/_templatelibmodule.c b/Modules/_templatelibmodule.c index 94c57c4443c4dc..54d06c85aba65d 100644 --- a/Modules/_templatelibmodule.c +++ b/Modules/_templatelibmodule.c @@ -1,12 +1,8 @@ -/* interpreter-internal types for templatelib */ - -#ifndef Py_BUILD_CORE -#define Py_BUILD_CORE -#endif +/* interpreter-internal types for string.templatelib */ #include "Python.h" -#include "pycore_template.h" -#include "pycore_interpolation.h" +#include "pycore_template.h" // _PyTemplate_Type +#include "pycore_interpolation.h" // _PyInterpolation_Type static int _templatelib_exec(PyObject *m) @@ -20,9 +16,6 @@ _templatelib_exec(PyObject *m) return 0; } -PyDoc_STRVAR(_templatelib_doc, -"Interpreter-internal types for t-string templates.\n"); - static struct PyModuleDef_Slot _templatelib_slots[] = { {Py_mod_exec, _templatelib_exec}, {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, @@ -31,15 +24,11 @@ static struct PyModuleDef_Slot _templatelib_slots[] = { }; static struct PyModuleDef _templatemodule = { - PyModuleDef_HEAD_INIT, - "_templatelib", - _templatelib_doc, - 0, - NULL, - _templatelib_slots, - NULL, - NULL, - NULL + .m_base = PyModuleDef_HEAD_INIT, + .m_name = "_templatelib", + .m_doc = "Interpreter-internal types for t-string templates.", + .m_size = 0, + .m_slots = _templatelib_slots, }; PyMODINIT_FUNC diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index ee2ce35b46a8b3..62f464ada93e25 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -1,4 +1,4 @@ -/* Interpolation object implementation */ +/* t-string Interpolation object implementation */ #include "Python.h" #include diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 22b7dd2d9c084a..201b4c4bb2cad4 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -1,4 +1,4 @@ -/* Interpolation object implementation */ +/* t-string Template object implementation */ #include "Python.h" #include diff --git a/PC/config.c b/PC/config.c index 6ce2131c7b84d0..e09ad0db2ef5ee 100644 --- a/PC/config.c +++ b/PC/config.c @@ -19,6 +19,7 @@ extern PyObject* PyInit__operator(void); extern PyObject* PyInit__signal(void); extern PyObject* PyInit__statistics(void); extern PyObject* PyInit__sysconfig(void); +extern PyObject* PyInit__templatelib(void); extern PyObject* PyInit__types(void); extern PyObject* PyInit__typing(void); extern PyObject* PyInit_time(void); @@ -106,6 +107,7 @@ struct _inittab _PyImport_Inittab[] = { {"_signal", PyInit__signal}, {"_sysconfig", PyInit__sysconfig}, {"time", PyInit_time}, + {"_templatelib", PyInit__templatelib}, {"_thread", PyInit__thread}, {"_tokenize", PyInit__tokenize}, {"_types", PyInit__types}, diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj index d12c5f9f32f265..6ea92f1dea3fcb 100644 --- a/PCbuild/pythoncore.vcxproj +++ b/PCbuild/pythoncore.vcxproj @@ -485,6 +485,7 @@ + diff --git a/PCbuild/pythoncore.vcxproj.filters b/PCbuild/pythoncore.vcxproj.filters index acb4ab35dcad97..043814a305874e 100644 --- a/PCbuild/pythoncore.vcxproj.filters +++ b/PCbuild/pythoncore.vcxproj.filters @@ -708,6 +708,9 @@ Include\internal + + Include\internal + Include\cpython @@ -840,6 +843,9 @@ Include\internal + + Include\internal + Include\internal @@ -998,6 +1004,9 @@ Modules + + Modules + Modules diff --git a/configure b/configure index 1b75ddfa26dcdd..bd705bb52aa13b 100755 --- a/configure +++ b/configure @@ -785,6 +785,8 @@ MODULE__TYPING_FALSE MODULE__TYPING_TRUE MODULE__TYPES_FALSE MODULE__TYPES_TRUE +MODULE__TEMPLATELIB_FALSE +MODULE__TEMPLATELIB_TRUE MODULE__STRUCT_FALSE MODULE__STRUCT_TRUE MODULE_SELECT_FALSE @@ -31010,6 +31012,28 @@ then : +fi + + + if test "$py_cv_module__templatelib" != "n/a" +then : + py_cv_module__templatelib=yes +fi + if test "$py_cv_module__templatelib" = yes; then + MODULE__TEMPLATELIB_TRUE= + MODULE__TEMPLATELIB_FALSE='#' +else + MODULE__TEMPLATELIB_TRUE='#' + MODULE__TEMPLATELIB_FALSE= +fi + + as_fn_append MODULE_BLOCK "MODULE__TEMPLATELIB_STATE=$py_cv_module__templatelib$as_nl" + if test "x$py_cv_module__templatelib" = xyes +then : + + + + fi @@ -33747,6 +33771,10 @@ if test -z "${MODULE__STRUCT_TRUE}" && test -z "${MODULE__STRUCT_FALSE}"; then as_fn_error $? "conditional \"MODULE__STRUCT\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi +if test -z "${MODULE__TEMPLATELIB_TRUE}" && test -z "${MODULE__TEMPLATELIB_FALSE}"; then + as_fn_error $? "conditional \"MODULE__TEMPLATELIB\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi if test -z "${MODULE__TYPES_TRUE}" && test -z "${MODULE__TYPES_FALSE}"; then as_fn_error $? "conditional \"MODULE__TYPES\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 diff --git a/configure.ac b/configure.ac index c449bb5ebb3cd4..8586fd48de0f8e 100644 --- a/configure.ac +++ b/configure.ac @@ -7787,6 +7787,7 @@ PY_STDLIB_MOD_SIMPLE([_queue]) PY_STDLIB_MOD_SIMPLE([_random]) PY_STDLIB_MOD_SIMPLE([select]) PY_STDLIB_MOD_SIMPLE([_struct]) +PY_STDLIB_MOD_SIMPLE([_templatelib]) PY_STDLIB_MOD_SIMPLE([_types]) PY_STDLIB_MOD_SIMPLE([_typing]) PY_STDLIB_MOD_SIMPLE([_interpreters]) From 7573346958b09d2053e4dfb26672c5856c20986d Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 11 Apr 2025 18:03:58 +0200 Subject: [PATCH 38/88] Fix lint --- Lib/test/test_tstring.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 18c419ddc1e106..b494cc7425ab4b 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -250,7 +250,7 @@ def test_raw_tstrings(self): t = tr"{path}\Documents" self.assertEqual(t.strings, ("", r"\Documents",)) self.assertEqual(t.interpolations[0].value, path) - + def test_template_concatenation(self): # Test template + template @@ -304,7 +304,7 @@ def test_nested_templates(self): self.assertEqual(t.interpolations[0].expression, "inner") self.assertEqual(t.interpolations[0].conversion, None) self.assertEqual(t.interpolations[0].format_spec, "") - + def test_ast_structure(self): # Test AST structure for simple t-string tree = ast.parse('t"Hello"') @@ -324,7 +324,7 @@ def test_error_conditions(self): with self.assertRaisesRegex(SyntaxError, "t-string: expecting '}'"): eval("t'{a'") - + with self.assertRaisesRegex(SyntaxError, "t-string: single '}' is not allowed"): eval("t'}'") From 4f91ea3b5af8a1059ad43ba606c3999b3777e3fe Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 12 Apr 2025 01:26:27 +0200 Subject: [PATCH 39/88] Skip test_tstring.py from ruff --- Lib/test/.ruff.toml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Lib/test/.ruff.toml b/Lib/test/.ruff.toml index 1c9bac507209b1..079a6cf2084192 100644 --- a/Lib/test/.ruff.toml +++ b/Lib/test/.ruff.toml @@ -7,6 +7,8 @@ extend-exclude = [ # Failed to lint "encoded_modules/module_iso_8859_1.py", "encoded_modules/module_koi8_r.py", + # SyntaxError because of t-strings + "test_tstring.py", # TODO Fix: F811 Redefinition of unused name "test_buffer.py", "test_dataclasses/__init__.py", From 14d9fa442ebd6284083b7d7e0a222bb9df8db10d Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 12 Apr 2025 01:26:45 +0200 Subject: [PATCH 40/88] Fix parser bug and implement ast_unparse in Python --- Lib/_ast_unparse.py | 80 ++++++++++++++++++++++++++--------------- Parser/action_helpers.c | 76 ++++++++++++++------------------------- 2 files changed, 78 insertions(+), 78 deletions(-) diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py index 56d9e935dd9d87..2c37082b263aaf 100644 --- a/Lib/_ast_unparse.py +++ b/Lib/_ast_unparse.py @@ -573,21 +573,11 @@ def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES): quote_type = quote_types[0] self.write(f"{quote_type}{string}{quote_type}") - def visit_JoinedStr(self, node): - self.write("f") - - fstring_parts = [] - for value in node.values: - with self.buffered() as buffer: - self._write_fstring_inner(value) - fstring_parts.append( - ("".join(buffer), isinstance(value, Constant)) - ) - - new_fstring_parts = [] + def _ftstring_helper(self, node, ftstring_parts): + new_ftstring_parts = [] quote_types = list(_ALL_QUOTES) fallback_to_repr = False - for value, is_constant in fstring_parts: + for value, is_constant in ftstring_parts: if is_constant: value, new_quote_types = self._str_literal_helper( value, @@ -606,30 +596,47 @@ def visit_JoinedStr(self, node): new_quote_types = [q for q in quote_types if q not in value] if new_quote_types: quote_types = new_quote_types - new_fstring_parts.append(value) + new_ftstring_parts.append(value) if fallback_to_repr: # If we weren't able to find a quote type that works for all parts # of the JoinedStr, fallback to using repr and triple single quotes. quote_types = ["'''"] - new_fstring_parts.clear() - for value, is_constant in fstring_parts: + new_ftstring_parts.clear() + for value, is_constant in ftstring_parts: if is_constant: value = repr('"' + value) # force repr to use single quotes expected_prefix = "'\"" assert value.startswith(expected_prefix), repr(value) value = value[len(expected_prefix):-1] - new_fstring_parts.append(value) + new_ftstring_parts.append(value) - value = "".join(new_fstring_parts) + value = "".join(new_ftstring_parts) quote_type = quote_types[0] self.write(f"{quote_type}{value}{quote_type}") - def _write_fstring_inner(self, node, is_format_spec=False): + def _write_ftstring(self, node, prefix): + self.write(prefix) + fstring_parts = [] + for value in node.values: + with self.buffered() as buffer: + self._write_ftstring_inner(value) + fstring_parts.append( + ("".join(buffer), isinstance(value, Constant)) + ) + self._ftstring_helper(node, fstring_parts) + + def visit_JoinedStr(self, node): + self._write_ftstring(node, "f") + + def visit_TemplateStr(self, node): + self._write_ftstring(node, "t") + + def _write_ftstring_inner(self, node, is_format_spec=False): if isinstance(node, JoinedStr): # for both the f-string itself, and format_spec for value in node.values: - self._write_fstring_inner(value, is_format_spec=is_format_spec) + self._write_ftstring_inner(value, is_format_spec=is_format_spec) elif isinstance(node, Constant) and isinstance(node.value, str): value = node.value.replace("{", "{{").replace("}", "}}") @@ -641,26 +648,41 @@ def _write_fstring_inner(self, node, is_format_spec=False): self.write(value) elif isinstance(node, FormattedValue): self.visit_FormattedValue(node) + elif isinstance(node, Interpolation): + self.visit_Interpolation(node) else: raise ValueError(f"Unexpected node inside JoinedStr, {node!r}") - def visit_FormattedValue(self, node): - def unparse_inner(inner): - unparser = type(self)() - unparser.set_precedence(_Precedence.TEST.next(), inner) - return unparser.visit(inner) + def _unparse_interpolation_value(self, inner): + unparser = type(self)() + unparser.set_precedence(_Precedence.TEST.next(), inner) + return unparser.visit(inner) + + def _write_fstring_conversion(self, node): + if node.conversion != -1: + self.write(f"!{chr(node.conversion)}") + + def _write_tstring_conversion(self, node): + if node.conversion is not None: + self.write(f"!{node.conversion}") + def _write_interpolation(self, node, write_conversion): with self.delimit("{", "}"): - expr = unparse_inner(node.value) + expr = self._unparse_interpolation_value(node.value) if expr.startswith("{"): # Separate pair of opening brackets as "{ {" self.write(" ") self.write(expr) - if node.conversion != -1: - self.write(f"!{chr(node.conversion)}") + write_conversion(node) if node.format_spec: self.write(":") - self._write_fstring_inner(node.format_spec, is_format_spec=True) + self._write_ftstring_inner(node.format_spec, is_format_spec=True) + + def visit_FormattedValue(self, node): + self._write_interpolation(node, self._write_fstring_conversion) + + def visit_Interpolation(self, node): + self._write_interpolation(node, self._write_tstring_conversion) def visit_Name(self, node): self.write(node.id) diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 27be9638832d86..286514cfc22b4d 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1654,8 +1654,8 @@ _build_concatenated_unicode(Parser *p, asdl_expr_seq *strings, int lineno, end_lineno, end_col_offset, arena); } -static expr_ty -_build_concatenated_joined_str(Parser *p, asdl_expr_seq *strings, +static asdl_expr_seq * +_build_concatenated_str(Parser *p, asdl_expr_seq *strings, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) { @@ -1669,6 +1669,9 @@ _build_concatenated_joined_str(Parser *p, asdl_expr_seq *strings, case JoinedStr_kind: n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values); break; + case TemplateStr_kind: + n_flattened_elements += asdl_seq_LEN(elem->v.TemplateStr.values); + break; default: n_flattened_elements++; break; @@ -1695,6 +1698,15 @@ _build_concatenated_joined_str(Parser *p, asdl_expr_seq *strings, asdl_seq_SET(flattened, current_pos++, subvalue); } break; + case TemplateStr_kind: + for (Py_ssize_t j = 0; j < asdl_seq_LEN(elem->v.TemplateStr.values); j++) { + expr_ty subvalue = asdl_seq_GET(elem->v.TemplateStr.values, j); + if (subvalue == NULL) { + return NULL; + } + asdl_seq_SET(flattened, current_pos++, subvalue); + } + break; default: asdl_seq_SET(flattened, current_pos++, elem); break; @@ -1795,6 +1807,16 @@ _build_concatenated_joined_str(Parser *p, asdl_expr_seq *strings, } assert(current_pos == n_elements); + return values; +} + +static expr_ty +_build_concatenated_joined_str(Parser *p, asdl_expr_seq *strings, + int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena) +{ + asdl_expr_seq *values = _build_concatenated_str(p, strings, lineno, + col_offset, end_lineno, end_col_offset, arena); return _PyAST_JoinedStr(values, lineno, col_offset, end_lineno, end_col_offset, p->arena); } @@ -1803,53 +1825,9 @@ _build_concatenated_template_str(Parser *p, asdl_expr_seq *strings, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) { - Py_ssize_t len = asdl_seq_LEN(strings); - assert(len > 0); - - Py_ssize_t n_flattened_elements = 0; - for (Py_ssize_t i = 0; i < len; i++) { - expr_ty elem = asdl_seq_GET(strings, i); - switch(elem->kind) { - case TemplateStr_kind: - n_flattened_elements += asdl_seq_LEN(elem->v.JoinedStr.values); - break; - default: - n_flattened_elements++; - break; - } - } - - - asdl_expr_seq* flattened = _Py_asdl_expr_seq_new(n_flattened_elements, p->arena); - if (flattened == NULL) { - return NULL; - } - - Py_ssize_t pos = 0; - for (Py_ssize_t i = 0; i < len; i++) { - expr_ty elem = asdl_seq_GET(strings, i); - - switch (elem->kind) { - case TemplateStr_kind: - for (Py_ssize_t j = 0; j < asdl_seq_LEN(elem->v.TemplateStr.values); j++) { - expr_ty subitem = asdl_seq_GET(elem->v.TemplateStr.values, j); - asdl_seq_SET(flattened, pos++, subitem); - } - break; - case JoinedStr_kind: { - expr_ty joined_str = _build_concatenated_joined_str(p, - elem->v.JoinedStr.values, lineno, col_offset, - end_lineno, end_col_offset, arena); - asdl_seq_SET(flattened, pos++, joined_str); - break; - } - default: - asdl_seq_SET(flattened, pos++, elem); - break; - } - } - - return _PyAST_TemplateStr(flattened, lineno, col_offset, end_lineno, + asdl_expr_seq *values = _build_concatenated_str(p, strings, lineno, + col_offset, end_lineno, end_col_offset, arena); + return _PyAST_TemplateStr(values, lineno, col_offset, end_lineno, end_col_offset, arena); } From bf893257fb4ba2b30ef8f81e6fb11381b4653b71 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 12 Apr 2025 01:27:18 +0200 Subject: [PATCH 41/88] Modify CODEOWNERS --- .github/CODEOWNERS | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 45d06317c265be..1b0e953234296a 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -316,3 +316,13 @@ Lib/test/test__colorize.py @hugovk # Fuzzing Modules/_xxtestfuzz/ @ammaraskar + +# t-strings +Include/internal/pycore_interpolation.h @lysnikolaou +Include/internal/pycore_template.h @lysnikolaou +Objects/interpolationobject.c @lysnikolaou +Objects/clinic/interpolationobject.c.h @lysnikolaou +Objects/templateobject.c @lysnikolaou +Modules/_templatelibmodule.c @lysnikolaou +Lib/string/templatelib.py @lysnikolaou +Lib/test/test_tstring.py @lysnikolaou From b7edcd672611c239a9739546a976e4cf07e86d30 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 12 Apr 2025 01:51:00 +0200 Subject: [PATCH 42/88] Do not use _PyAST_ExprAsUnicode (unparse) for interpolation expression --- Lib/test/test_tstring.py | 8 +++---- Parser/action_helpers.c | 34 +++++++++++++-------------- Parser/lexer/lexer.c | 12 +++++----- Parser/lexer/lexer.h | 2 +- Parser/tokenizer/file_tokenizer.c | 4 ++-- Parser/tokenizer/readline_tokenizer.c | 2 +- 6 files changed, 30 insertions(+), 32 deletions(-) diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index b494cc7425ab4b..ba3efbc067e616 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -207,7 +207,7 @@ def test_debug_specifier(self): t = t"Value: {value=}" self.assertEqual(t.strings, ("Value: value=", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].expression, "value=") self.assertEqual(t.interpolations[0].conversion, "r") self.assertEqual(t.interpolations[0].format_spec, "") self.assertEqual(f(t), "Value: value=42") @@ -216,7 +216,7 @@ def test_debug_specifier(self): t = t"Value: {value=:.2f}" self.assertEqual(t.strings, ("Value: value=", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].expression, "value=") self.assertEqual(t.interpolations[0].conversion, None) self.assertEqual(t.interpolations[0].format_spec, ".2f") self.assertEqual(f(t), "Value: value=42.00") @@ -225,7 +225,7 @@ def test_debug_specifier(self): t = t"Value: {value=!s}" self.assertEqual(t.strings, ("Value: value=", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].expression, "value=") self.assertEqual(t.interpolations[0].conversion, "s") self.assertEqual(t.interpolations[0].format_spec, "") @@ -233,7 +233,7 @@ def test_debug_specifier(self): t = t"Value: {value = }" self.assertEqual(t.strings, ("Value: value = ", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") + self.assertEqual(t.interpolations[0].expression, "value = ") self.assertEqual(t.interpolations[0].conversion, "r") self.assertEqual(t.interpolations[0].format_spec, "") self.assertEqual(f(t), "Value: value = 42") diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 286514cfc22b4d..1d55deef04d93f 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1479,11 +1479,6 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) { - constant exprstr = _PyAST_ExprAsUnicode(expression); - if (exprstr == NULL) { - return NULL; - } - constant convstr = NULL; int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); if (conversion_val >= 0) { @@ -1495,35 +1490,38 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu } } - expr_ty interpolation = _PyAST_Interpolation( - expression, exprstr, convstr, format ? (expr_ty) format->result : NULL, - lineno, col_offset, end_lineno, - end_col_offset, arena - ); - - if (!debug) { - return interpolation; - } - /* Find the non whitespace token after the "=" */ int debug_end_line, debug_end_offset; PyObject *debug_metadata; + constant exprstr; if (conversion) { debug_end_line = ((expr_ty) conversion->result)->lineno; debug_end_offset = ((expr_ty) conversion->result)->col_offset; - debug_metadata = conversion->metadata; + debug_metadata = exprstr = conversion->metadata; } else if (format) { debug_end_line = ((expr_ty) format->result)->lineno; debug_end_offset = ((expr_ty) format->result)->col_offset + 1; - debug_metadata = format->metadata; + debug_metadata = exprstr = format->metadata; } else { debug_end_line = end_lineno; debug_end_offset = end_col_offset; - debug_metadata = closing_brace->metadata; + debug_metadata = exprstr = closing_brace->metadata; } + + assert(exprstr != NULL); + expr_ty interpolation = _PyAST_Interpolation( + expression, exprstr, convstr, format ? (expr_ty) format->result : NULL, + lineno, col_offset, end_lineno, + end_col_offset, arena + ); + + if (!debug) { + return interpolation; + } + expr_ty debug_text = _PyAST_Constant(debug_metadata, NULL, lineno, col_offset + 1, debug_end_line, debug_end_offset - 1, p->arena); if (!debug_text) { diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index a02f87531e0917..794b0e5bc81838 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -108,12 +108,12 @@ tok_backup(struct tok_state *tok, int c) } static int -set_fstring_expr(struct tok_state* tok, struct token *token, char c) { +set_ftstring_expr(struct tok_state* tok, struct token *token, char c) { assert(token != NULL); assert(c == '}' || c == ':' || c == '!'); tokenizer_mode *tok_mode = TOK_GET_MODE(tok); - if (!tok_mode->f_string_debug || token->metadata) { + if (!(tok_mode->f_string_debug || tok_mode->tstring) || token->metadata) { return 0; } PyObject *res = NULL; @@ -173,7 +173,7 @@ set_fstring_expr(struct tok_state* tok, struct token *token, char c) { } int -_PyLexer_update_fstring_expr(struct tok_state *tok, char cur) +_PyLexer_update_ftstring_expr(struct tok_state *tok, char cur) { assert(tok->cur != NULL); @@ -1152,10 +1152,10 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t int cursor_in_format_with_debug = cursor == 1 && (current_tok->f_string_debug || in_format_spec); int cursor_valid = cursor == 0 || cursor_in_format_with_debug; - if ((cursor_valid) && !_PyLexer_update_fstring_expr(tok, c)) { + if ((cursor_valid) && !_PyLexer_update_ftstring_expr(tok, c)) { return MAKE_TOKEN(ENDMARKER); } - if ((cursor_valid) && c != '{' && set_fstring_expr(tok, token, c)) { + if ((cursor_valid) && c != '{' && set_ftstring_expr(tok, token, c)) { return MAKE_TOKEN(ERRORTOKEN); } @@ -1404,7 +1404,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct } if (c == '{') { - if (!_PyLexer_update_fstring_expr(tok, c)) { + if (!_PyLexer_update_ftstring_expr(tok, c)) { return MAKE_TOKEN(ENDMARKER); } int peek = tok_nextc(tok); diff --git a/Parser/lexer/lexer.h b/Parser/lexer/lexer.h index 7f21bf56bba2d1..1d97ac57b745b0 100644 --- a/Parser/lexer/lexer.h +++ b/Parser/lexer/lexer.h @@ -3,7 +3,7 @@ #include "state.h" -int _PyLexer_update_fstring_expr(struct tok_state *tok, char cur); +int _PyLexer_update_ftstring_expr(struct tok_state *tok, char cur); int _PyTokenizer_Get(struct tok_state *, struct token *); diff --git a/Parser/tokenizer/file_tokenizer.c b/Parser/tokenizer/file_tokenizer.c index 15fc9348f8ae56..01e473f58a0777 100644 --- a/Parser/tokenizer/file_tokenizer.c +++ b/Parser/tokenizer/file_tokenizer.c @@ -275,7 +275,7 @@ tok_underflow_interactive(struct tok_state *tok) { return 0; } - if (tok->tok_mode_stack_index && !_PyLexer_update_fstring_expr(tok, 0)) { + if (tok->tok_mode_stack_index && !_PyLexer_update_ftstring_expr(tok, 0)) { return 0; } return 1; @@ -322,7 +322,7 @@ tok_underflow_file(struct tok_state *tok) { tok->implicit_newline = 1; } - if (tok->tok_mode_stack_index && !_PyLexer_update_fstring_expr(tok, 0)) { + if (tok->tok_mode_stack_index && !_PyLexer_update_ftstring_expr(tok, 0)) { return 0; } diff --git a/Parser/tokenizer/readline_tokenizer.c b/Parser/tokenizer/readline_tokenizer.c index a2637af9902dd3..22f84c77a12b47 100644 --- a/Parser/tokenizer/readline_tokenizer.c +++ b/Parser/tokenizer/readline_tokenizer.c @@ -90,7 +90,7 @@ tok_underflow_readline(struct tok_state* tok) { tok->implicit_newline = 1; } - if (tok->tok_mode_stack_index && !_PyLexer_update_fstring_expr(tok, 0)) { + if (tok->tok_mode_stack_index && !_PyLexer_update_ftstring_expr(tok, 0)) { return 0; } From 99c3bf4a21072068849dfbc4f520952174546427 Mon Sep 17 00:00:00 2001 From: Dave Peck Date: Thu, 17 Apr 2025 02:16:15 -0700 Subject: [PATCH 43/88] Remove interpolation_compare() and interpolation_hash() (#65) --- Objects/interpolationobject.c | 49 ----------------------------------- 1 file changed, 49 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 62f464ada93e25..703ae40de081be 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -98,53 +98,6 @@ interpolation_repr(interpolationobject *self) self->conversion, self->format_spec); } -static PyObject * -interpolation_compare(interpolationobject *self, PyObject *other, int op) -{ - if (op == Py_LT || op == Py_LE || op == Py_GT || op == Py_GE) { - Py_RETURN_NOTIMPLEMENTED; - } - - if (!PyObject_TypeCheck(other, &_PyInterpolation_Type)) { - return (op == Py_EQ) ? Py_False : Py_True; - } - - interpolationobject *other_i = (interpolationobject *) other; - - int valueeq = PyObject_RichCompareBool(self->value, other_i->value, Py_EQ); - if (valueeq == -1) { - return NULL; - } - int expreq = PyUnicode_Compare(self->expression, other_i->expression); - if (expreq == -1 && PyErr_Occurred()) { - return NULL; - } - int conveq = PyObject_RichCompareBool(self->conversion, other_i->conversion, Py_EQ); // conversion might be Py_None - if (conveq == -1) { - return NULL; - } - int formatspeceq = PyUnicode_Compare(self->format_spec, other_i->format_spec); - if (formatspeceq == -1 && PyErr_Occurred()) { - return NULL; - } - - int eq = valueeq && expreq == 0 && conveq && formatspeceq == 0; - return PyBool_FromLong(op == Py_EQ ? eq : !eq); -} - -static Py_hash_t -interpolation_hash(interpolationobject *self) -{ - PyObject *tuple = PyTuple_Pack(4, self->value, self->expression, self->conversion, self->format_spec); - if (!tuple) { - return -1; - } - - Py_hash_t hash = PyObject_Hash(tuple); - Py_DECREF(tuple); - return hash; -} - static PyMemberDef interpolation_members[] = { {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"}, {"expression", Py_T_OBJECT_EX, offsetof(interpolationobject, expression), Py_READONLY, "Expression"}, @@ -163,8 +116,6 @@ PyTypeObject _PyInterpolation_Type = { .tp_new = (newfunc) interpolation_new, .tp_dealloc = (destructor) interpolation_dealloc, .tp_repr = (reprfunc) interpolation_repr, - .tp_richcompare = (richcmpfunc) interpolation_compare, - .tp_hash = (hashfunc) interpolation_hash, .tp_members = interpolation_members, }; From f09d99f511c74410e5728a1f66482d0db2d62ab7 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Thu, 17 Apr 2025 10:17:42 +0100 Subject: [PATCH 44/88] Add type check macros (#67) --- Include/internal/pycore_interpolation.h | 3 +++ Include/internal/pycore_template.h | 3 +++ Objects/templateobject.c | 11 +++++------ Objects/unicodeobject.c | 2 +- 4 files changed, 12 insertions(+), 7 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 8c1161008a8d69..813bd945411e0b 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -13,6 +13,9 @@ extern "C" { extern PyTypeObject _PyInterpolation_Type; +#define _PyInterpolation_Check(op) PyObject_TypeCheck((op), &_PyInterpolation_Type) +#define _PyInterpolation_CheckExact(op) Py_IS_TYPE((op), &_PyInterpolation_Type) + PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values); extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 9d53e41a08fdc9..972a630c953aec 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -14,6 +14,9 @@ extern "C" { extern PyTypeObject _PyTemplate_Type; extern PyTypeObject _PyTemplateIter_Type; +#define _PyTemplate_Check(op) PyObject_TypeCheck((op), &_PyTemplate_Type) +#define _PyTemplate_CheckExact(op) Py_IS_TYPE((op), &_PyTemplate_Type) + extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); PyAPI_FUNC(PyObject *) _PyTemplate_FromValues(PyObject **values, Py_ssize_t n); diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 201b4c4bb2cad4..ebf46d64015c61 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -85,7 +85,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } last_was_str = 1; } - else if (PyObject_TypeCheck(item, &_PyInterpolation_Type)) { + else if (_PyInterpolation_Check(item)) { if (!last_was_str) { stringslen++; } @@ -134,7 +134,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } last_was_str = 1; } - else if (PyObject_TypeCheck(item, &_PyInterpolation_Type)) { + else if (_PyInterpolation_Check(item)) { if (!last_was_str) { PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } @@ -397,14 +397,13 @@ template_concat_str_template(templateobject *self, PyObject *other) PyObject * _PyTemplate_Concat(PyObject *self, PyObject *other) { - if (PyObject_TypeCheck(self, &_PyTemplate_Type) && - PyObject_TypeCheck(other, &_PyTemplate_Type)) { + if (_PyTemplate_Check(self) && _PyTemplate_Check(other)) { return template_concat_templates((templateobject *) self, (templateobject *) other); } - else if (PyObject_TypeCheck(self, &_PyTemplate_Type) && PyUnicode_Check(other)) { + else if ((_PyTemplate_Check(self)) && PyUnicode_Check(other)) { return template_concat_template_str((templateobject *) self, other); } - else if (PyUnicode_Check(self) && PyObject_TypeCheck(other, &_PyTemplate_Type)) { + else if (PyUnicode_Check(self) && (_PyTemplate_Check(other))) { return template_concat_str_template((templateobject *) other, self); } else { diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index 2c1156cc3c51cf..fca4a1f31fcf20 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -11618,7 +11618,7 @@ PyUnicode_Concat(PyObject *left, PyObject *right) return NULL; if (!PyUnicode_Check(right)) { - if (PyObject_TypeCheck(right, &_PyTemplate_Type)) { + if (_PyTemplate_Check(right)) { // str + tstring is implemented in the tstring type return _PyTemplate_Concat(left, right); } From 878eb69c8f3dc6ca15bda082e540ea79eca15649 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Thu, 17 Apr 2025 10:19:19 +0100 Subject: [PATCH 45/88] t-strings: cosmetics (#66) --- Include/internal/pycore_template.h | 2 -- Lib/string/templatelib.py | 2 +- Lib/test/test_tstring.py | 4 ++-- Modules/_templatelibmodule.c | 4 ++-- Objects/interpolationobject.c | 7 +------ Objects/object.c | 9 ++++----- Objects/templateobject.c | 9 ++------- Objects/unicodeobject.c | 2 +- Python/bytecodes.c | 4 ++-- Python/ceval.c | 4 ++-- Python/jit.c | 4 ++-- Python/pylifecycle.c | 2 +- Tools/jit/template.c | 4 ++-- 13 files changed, 22 insertions(+), 35 deletions(-) diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 972a630c953aec..ccf837fc305d73 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -9,8 +9,6 @@ extern "C" { # error "this header requires Py_BUILD_CORE define" #endif -#include "pycore_stackref.h" // _PyStackRef - extern PyTypeObject _PyTemplate_Type; extern PyTypeObject _PyTemplateIter_Type; diff --git a/Lib/string/templatelib.py b/Lib/string/templatelib.py index 22f7edb68eb83a..54ca4d3475068f 100644 --- a/Lib/string/templatelib.py +++ b/Lib/string/templatelib.py @@ -1,3 +1,3 @@ """Support for template string literals (t-strings).""" -from _templatelib import Template, Interpolation +from _templatelib import Interpolation, Template diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index ba3efbc067e616..9a5550bf8f3b64 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -4,7 +4,7 @@ from string.templatelib import Template, Interpolation -def convert(value, conversion) -> object: +def convert(value, conversion): if conversion == "a": return ascii(value) elif conversion == "r": @@ -14,7 +14,7 @@ def convert(value, conversion) -> object: return value -def f(template) -> str: +def f(template): parts = [] for item in template: match item: diff --git a/Modules/_templatelibmodule.c b/Modules/_templatelibmodule.c index 54d06c85aba65d..3911bb4550cd11 100644 --- a/Modules/_templatelibmodule.c +++ b/Modules/_templatelibmodule.c @@ -1,8 +1,8 @@ /* interpreter-internal types for string.templatelib */ #include "Python.h" -#include "pycore_template.h" // _PyTemplate_Type #include "pycore_interpolation.h" // _PyInterpolation_Type +#include "pycore_template.h" // _PyTemplate_Type static int _templatelib_exec(PyObject *m) @@ -26,7 +26,7 @@ static struct PyModuleDef_Slot _templatelib_slots[] = { static struct PyModuleDef _templatemodule = { .m_base = PyModuleDef_HEAD_INIT, .m_name = "_templatelib", - .m_doc = "Interpreter-internal types for t-string templates.", + .m_doc = "Interpreter types for template string literals (t-strings).", .m_size = 0, .m_slots = _templatelib_slots, }; diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 703ae40de081be..55b5dd009ca8b1 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -1,12 +1,7 @@ /* t-string Interpolation object implementation */ -#include "Python.h" -#include +#include "Python.h" #include "pycore_initconfig.h" // _PyStatus_OK -#include "pycore_stackref.h" // _PyStackRef -#include "pycore_global_objects.h" // _Py_STR -#include "pycore_runtime.h" // _Py_STR - #include "pycore_interpolation.h" static int diff --git a/Objects/object.c b/Objects/object.c index 8e32927e4c98aa..a33a4267d62d65 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -16,7 +16,6 @@ #include "pycore_initconfig.h" // _PyStatus_OK() #include "pycore_instruction_sequence.h" // _PyInstructionSequence_Type #include "pycore_interpolation.h" // _PyInterpolation_Type -#include "pycore_hashtable.h" // _Py_hashtable_new() #include "pycore_list.h" // _PyList_DebugMallocStats() #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_memoryobject.h" // _PyManagedBuffer_Type @@ -27,7 +26,7 @@ #include "pycore_pymem.h" // _PyMem_IsPtrFreed() #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_symtable.h" // PySTEntry_Type -#include "pycore_template.h" // _PyTemplate_Type +#include "pycore_template.h" // _PyTemplate_Type _PyTemplateIter_Type #include "pycore_tuple.h" // _PyTuple_DebugMallocStats() #include "pycore_typeobject.h" // _PyBufferWrapper_Type #include "pycore_typevarobject.h" // _PyTypeAlias_Type @@ -2412,6 +2411,7 @@ static PyTypeObject* static_types[] = { &_PyHamt_CollisionNode_Type, &_PyHamt_Type, &_PyInstructionSequence_Type, + &_PyInterpolation_Type, &_PyLegacyEventHandler_Type, &_PyLineIterator, &_PyManagedBuffer_Type, @@ -2421,6 +2421,8 @@ static PyTypeObject* static_types[] = { &_PyNone_Type, &_PyNotImplemented_Type, &_PyPositionsIterator, + &_PyTemplate_Type, + &_PyTemplateIter_Type, &_PyUnicodeASCIIIter_Type, &_PyUnion_Type, #ifdef _Py_TIER2 @@ -2431,9 +2433,6 @@ static PyTypeObject* static_types[] = { &_PyWeakref_RefType, &_PyTypeAlias_Type, &_PyNoDefault_Type, - &_PyInterpolation_Type, - &_PyTemplate_Type, - &_PyTemplateIter_Type, // subclasses: _PyTypes_FiniTypes() deallocates them before their base // class diff --git a/Objects/templateobject.c b/Objects/templateobject.c index ebf46d64015c61..78b2862bf55c1b 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -1,13 +1,8 @@ /* t-string Template object implementation */ -#include "Python.h" -#include - -#include "pycore_stackref.h" // _PyStackRef -#include "pycore_global_objects.h" // _Py_STR -#include "pycore_runtime.h" // _Py_STR +#include "Python.h" +#include "pycore_interpolation.h" // _PyInterpolation_Check() #include "pycore_template.h" -#include "pycore_interpolation.h" typedef struct { PyObject_HEAD diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index fca4a1f31fcf20..38b33218ef694f 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -56,11 +56,11 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. #include "pycore_pyhash.h" // _Py_HashSecret_t #include "pycore_pylifecycle.h" // _Py_SetFileSystemEncoding() #include "pycore_pystate.h" // _PyInterpreterState_GET() +#include "pycore_template.h" // _PyTemplate_Type #include "pycore_tuple.h" // _PyTuple_FromArray() #include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI #include "pycore_unicodeobject.h" // struct _Py_unicode_state #include "pycore_unicodeobject_generated.h" // _PyUnicode_InitStaticStrings() -#include "pycore_template.h" // _PyTemplate_Type #include "stringlib/eq.h" // unicode_eq() #include // ptrdiff_t diff --git a/Python/bytecodes.c b/Python/bytecodes.c index a550b7a0d11e26..c57370b01a1896 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -16,6 +16,7 @@ #include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS #include "pycore_function.h" #include "pycore_instruments.h" +#include "pycore_interpolation.h" // _PyInterpolation_FromStackRefStealOnSuccess() #include "pycore_intrinsics.h" #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_moduleobject.h" // PyModuleObject @@ -30,10 +31,9 @@ #include "pycore_setobject.h" // _PySet_NextEntry() #include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs #include "pycore_stackref.h" +#include "pycore_template.h" // _PyTemplate_From{List,Values}() #include "pycore_tuple.h" // _PyTuple_ITEMS() #include "pycore_typeobject.h" // _PySuper_Lookup() -#include "pycore_interpolation.h" -#include "pycore_template.h" #include "pycore_dict.h" #include "dictobject.h" diff --git a/Python/ceval.c b/Python/ceval.c index fb0fbbeece080d..0509cf46b0b2aa 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -19,6 +19,7 @@ #include "pycore_import.h" // _PyImport_IsDefaultImportFunc() #include "pycore_instruments.h" #include "pycore_interpframe.h" // _PyFrame_SetStackPointer() +#include "pycore_interpolation.h" // _PyInterpolation_FromStackRefStealOnSuccess() #include "pycore_intrinsics.h" #include "pycore_jit.h" #include "pycore_list.h" // _PyList_GetItemRef() @@ -36,6 +37,7 @@ #include "pycore_setobject.h" // _PySet_Update() #include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs #include "pycore_sysmodule.h" // _PySys_GetOptionalAttrString() +#include "pycore_template.h" // _PyTemplate_From{List,Values}() #include "pycore_traceback.h" // _PyTraceBack_FromFrame #include "pycore_tuple.h" // _PyTuple_ITEMS() #include "pycore_uop_ids.h" // Uops @@ -46,8 +48,6 @@ #include "pydtrace.h" #include "setobject.h" #include "pycore_stackref.h" -#include "pycore_template.h" -#include "pycore_interpolation.h" #include // bool diff --git a/Python/jit.c b/Python/jit.c index d9382d25ac156c..e232cc1f7d9250 100644 --- a/Python/jit.c +++ b/Python/jit.c @@ -12,6 +12,7 @@ #include "pycore_frame.h" #include "pycore_function.h" #include "pycore_interpframe.h" +#include "pycore_interpolation.h" #include "pycore_intrinsics.h" #include "pycore_list.h" #include "pycore_long.h" @@ -21,10 +22,9 @@ #include "pycore_pyerrors.h" #include "pycore_setobject.h" #include "pycore_sliceobject.h" +#include "pycore_template.h" #include "pycore_tuple.h" #include "pycore_unicodeobject.h" -#include "pycore_interpolation.h" -#include "pycore_template.h" #include "pycore_jit.h" diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index e34808b6f02496..1271e6fb908820 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -13,6 +13,7 @@ #include "pycore_freelist.h" // _PyObject_ClearFreeLists() #include "pycore_global_objects_fini_generated.h" // _PyStaticObjects_CheckRefcnt() #include "pycore_initconfig.h" // _PyStatus_OK() +#include "pycore_interpolation.h" // _PyInterpolation_InitTypes() #include "pycore_long.h" // _PyLong_InitTypes() #include "pycore_object.h" // _PyDebug_PrintTotalRefs() #include "pycore_obmalloc.h" // _PyMem_init_obmalloc() @@ -33,7 +34,6 @@ #include "pycore_uniqueid.h" // _PyObject_FinalizeUniqueIdPool() #include "pycore_warnings.h" // _PyWarnings_InitState() #include "pycore_weakref.h" // _PyWeakref_GET_REF() -#include "pycore_interpolation.h" // _PyInterpolation_InitTypes() #include "opcode.h" diff --git a/Tools/jit/template.c b/Tools/jit/template.c index ee23b86b198ae2..68cf75942d85c9 100644 --- a/Tools/jit/template.c +++ b/Tools/jit/template.c @@ -13,6 +13,7 @@ #include "pycore_function.h" #include "pycore_genobject.h" #include "pycore_interpframe.h" +#include "pycore_interpolation.h" #include "pycore_intrinsics.h" #include "pycore_jit.h" #include "pycore_list.h" @@ -25,10 +26,9 @@ #include "pycore_setobject.h" #include "pycore_sliceobject.h" #include "pycore_stackref.h" +#include "pycore_template.h" #include "pycore_tuple.h" #include "pycore_unicodeobject.h" -#include "pycore_interpolation.h" -#include "pycore_template.h" #include "ceval_macros.h" From 7ed73fac62f9f26a633ab22e0200c4019efc1755 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 17 Apr 2025 11:39:58 +0200 Subject: [PATCH 46/88] Implement GC protocol for template and interpolation types --- Objects/interpolationobject.c | 16 +++++++++++++++- Objects/templateobject.c | 30 ++++++++++++++++++++++++++++-- 2 files changed, 43 insertions(+), 3 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 55b5dd009ca8b1..4307444bff59e8 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -77,6 +77,7 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, static void interpolation_dealloc(interpolationobject *self) { + PyObject_GC_UnTrack(self); Py_CLEAR(self->value); Py_CLEAR(self->expression); Py_CLEAR(self->conversion); @@ -84,6 +85,16 @@ interpolation_dealloc(interpolationobject *self) Py_TYPE(self)->tp_free(self); } +static int +interpolation_traverse(interpolationobject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->value); + Py_VISIT(self->expression); + Py_VISIT(self->conversion); + Py_VISIT(self->format_spec); + return 0; +} + static PyObject * interpolation_repr(interpolationobject *self) { @@ -107,11 +118,14 @@ PyTypeObject _PyInterpolation_Type = { .tp_doc = PyDoc_STR("Interpolation object"), .tp_basicsize = sizeof(interpolationobject), .tp_itemsize = 0, - .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_MATCH_SELF, .tp_new = (newfunc) interpolation_new, + .tp_alloc = PyType_GenericAlloc, .tp_dealloc = (destructor) interpolation_dealloc, + .tp_free = PyObject_GC_Del, .tp_repr = (reprfunc) interpolation_repr, .tp_members = interpolation_members, + .tp_traverse = (traverseproc) interpolation_traverse, }; static PyObject * diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 78b2862bf55c1b..cb8adabb60b56d 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -32,18 +32,31 @@ templateiter_next(templateiterobject *self) static void templateiter_dealloc(templateiterobject *self) { + PyObject_GC_UnTrack(self); Py_CLEAR(self->stringsiter); Py_CLEAR(self->interpolationsiter); Py_TYPE(self)->tp_free(self); } +static int +templateiter_traverse(templateiterobject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->stringsiter); + Py_VISIT(self->interpolationsiter); + return 0; +} + PyTypeObject _PyTemplateIter_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "string.templatelib.TemplateIter", .tp_doc = PyDoc_STR("Template iterator object"), .tp_basicsize = sizeof(templateiterobject), .tp_itemsize = 0, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + .tp_alloc = PyType_GenericAlloc, .tp_dealloc = (destructor) templateiter_dealloc, + .tp_free = PyObject_GC_Del, + .tp_traverse = (traverseproc) templateiter_traverse, .tp_iter = PyObject_SelfIter, .tp_iternext = (iternextfunc) templateiter_next, }; @@ -155,11 +168,20 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static void template_dealloc(templateobject *self) { + PyObject_GC_UnTrack(self); Py_CLEAR(self->strings); Py_CLEAR(self->interpolations); Py_TYPE(self)->tp_free(self); } +static int +template_traverse(templateobject *self, visitproc visit, void *arg) +{ + Py_VISIT(self->strings); + Py_VISIT(self->interpolations); + return 0; +} + static PyObject * template_repr(templateobject *self) { @@ -172,7 +194,7 @@ template_repr(templateobject *self) static templateiterobject * template_iter(templateobject *self) { - templateiterobject *iter = PyObject_New(templateiterobject, &_PyTemplateIter_Type); + templateiterobject *iter = PyObject_GC_New(templateiterobject, &_PyTemplateIter_Type); if (iter == NULL) { return NULL; } @@ -193,6 +215,7 @@ template_iter(templateobject *self) iter->stringsiter = stringsiter; iter->interpolationsiter = interpolationsiter; iter->from_strings = 1; + PyObject_GC_Track(iter); return iter; } @@ -456,14 +479,17 @@ PyTypeObject _PyTemplate_Type = { .tp_doc = PyDoc_STR("Template object"), .tp_basicsize = sizeof(templateobject), .tp_itemsize = 0, - .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_as_sequence = &template_as_sequence, .tp_new = (newfunc) template_new, + .tp_alloc = PyType_GenericAlloc, .tp_dealloc = (destructor) template_dealloc, + .tp_free = PyObject_GC_Del, .tp_repr = (reprfunc) template_repr, .tp_members = template_members, .tp_getset = template_getset, .tp_iter = (getiterfunc) template_iter, + .tp_traverse = (traverseproc) template_traverse, }; PyObject * From e88d1114e07d4f736f93b917a0b74ca6617a4ef3 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 17 Apr 2025 14:32:39 +0200 Subject: [PATCH 47/88] Fix test_unparse again! --- Lib/test/test_tstring.py | 8 ++++---- Lib/test/test_unparse.py | 2 +- Parser/action_helpers.c | 29 +++++++++++++++++++++++++++-- 3 files changed, 32 insertions(+), 7 deletions(-) diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 9a5550bf8f3b64..e06e6767a4c652 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -207,7 +207,7 @@ def test_debug_specifier(self): t = t"Value: {value=}" self.assertEqual(t.strings, ("Value: value=", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value=") + self.assertEqual(t.interpolations[0].expression, "value") self.assertEqual(t.interpolations[0].conversion, "r") self.assertEqual(t.interpolations[0].format_spec, "") self.assertEqual(f(t), "Value: value=42") @@ -216,7 +216,7 @@ def test_debug_specifier(self): t = t"Value: {value=:.2f}" self.assertEqual(t.strings, ("Value: value=", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value=") + self.assertEqual(t.interpolations[0].expression, "value") self.assertEqual(t.interpolations[0].conversion, None) self.assertEqual(t.interpolations[0].format_spec, ".2f") self.assertEqual(f(t), "Value: value=42.00") @@ -225,7 +225,7 @@ def test_debug_specifier(self): t = t"Value: {value=!s}" self.assertEqual(t.strings, ("Value: value=", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value=") + self.assertEqual(t.interpolations[0].expression, "value") self.assertEqual(t.interpolations[0].conversion, "s") self.assertEqual(t.interpolations[0].format_spec, "") @@ -233,7 +233,7 @@ def test_debug_specifier(self): t = t"Value: {value = }" self.assertEqual(t.strings, ("Value: value = ", "")) self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value = ") + self.assertEqual(t.interpolations[0].expression, "value") self.assertEqual(t.interpolations[0].conversion, "r") self.assertEqual(t.interpolations[0].format_spec, "") self.assertEqual(f(t), "Value: value = 42") diff --git a/Lib/test/test_unparse.py b/Lib/test/test_unparse.py index 839326f6436809..041a4017a9fb78 100644 --- a/Lib/test/test_unparse.py +++ b/Lib/test/test_unparse.py @@ -918,7 +918,7 @@ class DirectoryTestCase(ASTTestCase): run_always_files = {"test_grammar.py", "test_syntax.py", "test_compile.py", "test_ast.py", "test_asdl_parser.py", "test_fstring.py", "test_patma.py", "test_type_alias.py", "test_type_params.py", - "test_tokenize.py"} + "test_tokenize.py", "test_tstring.py"} _files_to_test = None diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 1d55deef04d93f..1c63b97dac4670 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1475,6 +1475,24 @@ _get_interpolation_conversion(Parser *p, Token *debug, ResultTokenWithMetadata * return -1; } +static PyObject * +_strip_interpolation_expr(PyObject *exprstr) +{ + Py_ssize_t len = PyUnicode_GET_LENGTH(exprstr); + + for (Py_ssize_t i = len - 1; i >= 0; i--) { + Py_UCS4 c = PyUnicode_READ_CHAR(exprstr, i); + if (_PyUnicode_IsWhitespace(c) || c == '=') { + len--; + } + else { + break; + } + } + + return PyUnicode_Substring(exprstr, 0, len); +} + expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, ResultTokenWithMetadata *conversion, ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) { @@ -1485,7 +1503,8 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu char buf[1]; buf[0] = conversion_val; convstr = PyUnicode_FromStringAndSize(buf, 1); - if (convstr == NULL) { + if (convstr == NULL || _PyArena_AddPyObject(arena, convstr) < 0) { + Py_XDECREF(convstr); return NULL; } } @@ -1512,8 +1531,14 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu } assert(exprstr != NULL); + PyObject *final_exprstr = _strip_interpolation_expr(exprstr); + if (!final_exprstr || _PyArena_AddPyObject(arena, final_exprstr) < 0) { + Py_XDECREF(final_exprstr); + return NULL; + } + expr_ty interpolation = _PyAST_Interpolation( - expression, exprstr, convstr, format ? (expr_ty) format->result : NULL, + expression, final_exprstr, convstr, format ? (expr_ty) format->result : NULL, lineno, col_offset, end_lineno, end_col_offset, arena ); From 92fd148af90cdc64d4d7f9b90c726854ff270d80 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 17 Apr 2025 14:35:25 +0200 Subject: [PATCH 48/88] Remove unnecessary tp_flag from interpolation type --- Objects/interpolationobject.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 4307444bff59e8..a3eeaddddec9a9 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -118,7 +118,7 @@ PyTypeObject _PyInterpolation_Type = { .tp_doc = PyDoc_STR("Interpolation object"), .tp_basicsize = sizeof(interpolationobject), .tp_itemsize = 0, - .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | _Py_TPFLAGS_MATCH_SELF, + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_new = (newfunc) interpolation_new, .tp_alloc = PyType_GenericAlloc, .tp_dealloc = (destructor) interpolation_dealloc, From 8f8a414fb43c218804a258f1e78b809101b8c84a Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 17 Apr 2025 16:56:10 +0200 Subject: [PATCH 49/88] Minor fixes (mostly cosmetic) --- Objects/interpolationobject.c | 8 ++--- Objects/templateobject.c | 65 +++++++++++++---------------------- 2 files changed, 28 insertions(+), 45 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index a3eeaddddec9a9..5bc8b424d494c7 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -67,10 +67,10 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, return NULL; } - Py_XSETREF(self->value, Py_NewRef(value)); - Py_XSETREF(self->expression, Py_NewRef(expression)); - Py_XSETREF(self->conversion, Py_NewRef(conversion)); - Py_XSETREF(self->format_spec, Py_NewRef(format_spec)); + self->value = Py_NewRef(value); + self->expression = Py_NewRef(expression); + self->conversion = Py_NewRef(conversion); + self->format_spec = Py_NewRef(format_spec); return (PyObject *) self; } diff --git a/Objects/templateobject.c b/Objects/templateobject.c index cb8adabb60b56d..8d2fa7b4af9305 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -68,15 +68,23 @@ typedef struct { } templateobject; static templateobject * -template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyObject *interpolations) { - if (kwds != NULL) { - PyErr_SetString(PyExc_TypeError, "Template.__new__ only accepts *args arguments"); + templateobject *template = (templateobject *) type->tp_alloc(type, 0); + if (template == NULL) { return NULL; } - templateobject *self = (templateobject *) type->tp_alloc(type, 0); - if (!self) { + template->strings = Py_NewRef(strings); + template->interpolations = Py_NewRef(interpolations); + return template; +} + +static templateobject * +template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + if (kwds != NULL) { + PyErr_SetString(PyExc_TypeError, "Template.__new__ only accepts *args arguments"); return NULL; } @@ -101,7 +109,6 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) last_was_str = 0; } else { - Py_DECREF(self); PyErr_SetString(PyExc_TypeError, "Template.__new__ *args need to be of type 'str' or 'Interpolation'"); return NULL; } @@ -112,13 +119,11 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) PyObject *strings = PyTuple_New(stringslen); if (!strings) { - Py_DECREF(self); return NULL; } PyObject *interpolations = PyTuple_New(interpolationslen); if (!interpolations) { - Py_DECREF(self); Py_DECREF(strings); return NULL; } @@ -133,7 +138,9 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) PyObject *concat = PyUnicode_Concat(laststring, item); Py_DECREF(laststring); if (!concat) { - goto error; + Py_DECREF(strings); + Py_DECREF(interpolations); + return NULL; } PyTuple_SET_ITEM(strings, stringsidx - 1, concat); } @@ -154,15 +161,10 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } - self->strings = strings; - self->interpolations = interpolations; - return self; - -error: - Py_DECREF(self); + templateobject *template = template_from_strings_interpolations(type, strings, interpolations); Py_DECREF(strings); Py_DECREF(interpolations); - return NULL; + return template; } static void @@ -219,19 +221,6 @@ template_iter(templateobject *self) return iter; } -static PyObject * -template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyObject *interpolations) -{ - PyObject *template = type->tp_alloc(type, 0); - if (template == NULL) { - return NULL; - } - - ((templateobject *) template)->strings = Py_NewRef(strings); - ((templateobject *) template)->interpolations = Py_NewRef(interpolations); - return template; -} - static PyObject * template_interpolations_copy(PyObject *interpolations) { Py_ssize_t interpolationslen = PyTuple_GET_SIZE(interpolations); @@ -360,12 +349,10 @@ template_concat_templates(templateobject *self, templateobject *other) return NULL; } - PyObject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); - + templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); Py_DECREF(newstrings); Py_DECREF(newinterpolations); - - return newtemplate; + return (PyObject *) newtemplate; } static PyObject * @@ -382,12 +369,10 @@ template_concat_template_str(templateobject *self, PyObject *other) return NULL; } - PyObject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); - + templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); Py_DECREF(newstrings); Py_DECREF(newinterpolations); - - return newtemplate; + return (PyObject *) newtemplate; } static PyObject * @@ -404,12 +389,10 @@ template_concat_str_template(templateobject *self, PyObject *other) return NULL; } - PyObject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); - + templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); Py_DECREF(newstrings); Py_DECREF(newinterpolations); - - return newtemplate; + return (PyObject *) newtemplate; } PyObject * From 6bfc8886ea8f44144ff533b8014de37e44c7cbdf Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Thu, 17 Apr 2025 17:33:31 +0200 Subject: [PATCH 50/88] Add test for interleaving --- Lib/test/test_tstring.py | 50 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index e06e6767a4c652..e7b4078d6702a6 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -55,6 +55,56 @@ def test_template_basic_creation(self): self.assertEqual(len(t.interpolations), 0) self.assertEqual(f(t), "Hello,\nworld") + def test_template_creation_interleaving(self): + # Should add strings on either side + t = Template(Interpolation("Maria", "name", None, "")) + self.assertEqual(t.strings, ("", "")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Maria") + + # Should prepend empty string + t = Template(Interpolation("Maria", "name", None, ""), " is my name") + self.assertEqual(t.strings, ("", " is my name")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Maria is my name") + + # Should append empty string + t = Template("Hello, ", Interpolation("Maria", "name", None, "")) + self.assertEqual(t.strings, ("Hello, ", "")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Maria") + + # Should concatenate strings + t = Template("Hello", ", ", Interpolation("Maria", "name", None, ""), "!") + self.assertEqual(t.strings, ("Hello, ", "!")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Maria!") + + # Should add strings on either side and in between + t = Template(Interpolation("Maria", "name", None, ""), Interpolation("Python", "language", None, "")) + self.assertEqual(t.strings, ("", "", "")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(t.interpolations[1].value, "Python") + self.assertEqual(t.interpolations[1].expression, "language") + self.assertEqual(t.interpolations[1].conversion, None) + self.assertEqual(t.interpolations[1].format_spec, "") + self.assertEqual(f(t), "MariaPython") + def test_string_representation(self): # Test __repr__ t = t"Hello" From e6da7570a08ae75849e1c33b4439f4328b30c7b4 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Fri, 18 Apr 2025 14:16:44 +0100 Subject: [PATCH 51/88] t-strings: Add more syntax tests (#68) --- Lib/test/test_grammar.py | 6 ++++++ Lib/test/test_syntax.py | 8 +++++++ Lib/test/test_tstring.py | 45 ++++++++++++++++++++++++++-------------- 3 files changed, 43 insertions(+), 16 deletions(-) diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py index 3ea4e47ca50a16..5d9ab0eed74fa6 100644 --- a/Lib/test/test_grammar.py +++ b/Lib/test/test_grammar.py @@ -1506,6 +1506,8 @@ def check(test): check('[None (3, 4)]') check('[True (3, 4)]') check('[... (3, 4)]') + check('[t"{x}" (3, 4)]') + check('[t"x={x}" (3, 4)]') msg=r'is not subscriptable; perhaps you missed a comma\?' check('[{1, 2} [i, j]]') @@ -1528,6 +1530,8 @@ def check(test): check('[f"x={x}" [i, j]]') check('["abc" [i, j]]') check('[b"abc" [i, j]]') + check('[t"{x}" [i, j]]') + check('[t"x={x}" [i, j]]') msg=r'indices must be integers or slices, not tuple;' check('[[1, 2] [3, 4]]') @@ -1548,6 +1552,8 @@ def check(test): check('[[1, 2] [f"{x}"]]') check('[[1, 2] [f"x={x}"]]') check('[[1, 2] ["abc"]]') + check('[[1, 2] [t"{x}"]]') + check('[[1, 2] [t"x={x}"]]') msg=r'indices must be integers or slices, not' check('[[1, 2] [b"abc"]]') check('[[1, 2] [12.3]]') diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index c5408b37fe5629..98655e856fb3cc 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -1735,6 +1735,14 @@ Traceback (most recent call last): SyntaxError: cannot assign to f-string expression here. Maybe you meant '==' instead of '='? +>>> t'{x}' = 42 +Traceback (most recent call last): +SyntaxError: cannot assign to t-string expression here. Maybe you meant '==' instead of '='? + +>>> t'{x}-{y}' = 42 +Traceback (most recent call last): +SyntaxError: cannot assign to t-string expression here. Maybe you meant '==' instead of '='? + >>> (x, y, z=3, d, e) Traceback (most recent call last): SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='? diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index e7b4078d6702a6..266c82243cfe69 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -367,26 +367,39 @@ def test_ast_structure(self): self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) - def test_error_conditions(self): - # Test syntax errors - with self.assertRaisesRegex(SyntaxError, "'{' was never closed"): - eval("t'{") - - with self.assertRaisesRegex(SyntaxError, "t-string: expecting '}'"): - eval("t'{a'") - - with self.assertRaisesRegex(SyntaxError, "t-string: single '}' is not allowed"): - eval("t'}'") - + def test_syntax_errors(self): + for case, err in ( + ("t'", "unterminated t-string literal"), + ("t'''", "unterminated triple-quoted t-string literal"), + ("t''''", "unterminated triple-quoted t-string literal"), + ("t'{", "'{' was never closed"), + ("t'{'", "t-string: expecting '}'"), + ("t'{a'", "t-string: expecting '}'"), + ("t'}'", "t-string: single '}' is not allowed"), + ("t'{}'", "t-string: valid expression required before '}'"), + ("t'{=x}'", "t-string: valid expression required before '='"), + ("t'{!x}'", "t-string: valid expression required before '!'"), + ("t'{:x}'", "t-string: valid expression required before ':'"), + ("t'{x;y}'", "t-string: expecting '=', or '!', or ':', or '}'"), + ("t'{x=y}'", "t-string: expecting '!', or ':', or '}'"), + ("t'{x!s!}'", "t-string: expecting ':' or '}'"), + ("t'{x!s:'", "t-string: expecting '}', or format specs"), + ("t'{x!}'", "t-string: missing conversion character"), + ("t'{x=!}'", "t-string: missing conversion character"), + ("t'{x!z}'", "t-string: invalid conversion character 'z': " + "expected 's', 'r', or 'a'"), + ("t'{lambda:1}'", "t-string: lambda expressions are not allowed " + "without parentheses"), + ("t'{x:{;}}'", "t-string: expecting a valid expression after '{'"), + ): + with self.subTest(case), self.assertRaisesRegex(SyntaxError, err): + eval(case) + + def test_runtime_errors(self): # Test missing variables with self.assertRaises(NameError): eval("t'Hello, {name}'") - # Test invalid conversion - num = 1 - with self.assertRaises(SyntaxError): - eval("t'{num!z}'") - def test_literal_concatenation(self): # Test concatenation of t-string literals t = t"Hello, " t"world" From 58b7e5c858012aa38cc57ac540bb9226a6253e4a Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Sat, 19 Apr 2025 16:20:04 +0100 Subject: [PATCH 52/88] Move string.templatelib specific tests to test_string/test_templatlib.py (#70) --- Lib/test/.ruff.toml | 1 + Lib/test/test_string/__init__.py | 5 ++ Lib/test/test_string/_support.py | 24 ++++++ Lib/test/{ => test_string}/test_string.py | 0 Lib/test/test_string/test_templatelib.py | 78 ++++++++++++++++++ Lib/test/test_tstring.py | 96 +---------------------- 6 files changed, 109 insertions(+), 95 deletions(-) create mode 100644 Lib/test/test_string/__init__.py create mode 100644 Lib/test/test_string/_support.py rename Lib/test/{ => test_string}/test_string.py (100%) create mode 100644 Lib/test/test_string/test_templatelib.py diff --git a/Lib/test/.ruff.toml b/Lib/test/.ruff.toml index 079a6cf2084192..6ca655371cc0e8 100644 --- a/Lib/test/.ruff.toml +++ b/Lib/test/.ruff.toml @@ -9,6 +9,7 @@ extend-exclude = [ "encoded_modules/module_koi8_r.py", # SyntaxError because of t-strings "test_tstring.py", + "test_string/test_templatelib.py", # TODO Fix: F811 Redefinition of unused name "test_buffer.py", "test_dataclasses/__init__.py", diff --git a/Lib/test/test_string/__init__.py b/Lib/test/test_string/__init__.py new file mode 100644 index 00000000000000..4b16ecc31156a5 --- /dev/null +++ b/Lib/test/test_string/__init__.py @@ -0,0 +1,5 @@ +import os +from test.support import load_package_tests + +def load_tests(*args): + return load_package_tests(os.path.dirname(__file__), *args) diff --git a/Lib/test/test_string/_support.py b/Lib/test/test_string/_support.py new file mode 100644 index 00000000000000..fde89ee1b62ae4 --- /dev/null +++ b/Lib/test/test_string/_support.py @@ -0,0 +1,24 @@ +from string.templatelib import Interpolation + + +def convert(value, conversion): + if conversion == "a": + return ascii(value) + elif conversion == "r": + return repr(value) + elif conversion == "s": + return str(value) + return value + + +def f(template): + parts = [] + for item in template: + match item: + case str() as s: + parts.append(s) + case Interpolation(value, _, conversion, format_spec): + value = convert(value, conversion) + value = format(value, format_spec) + parts.append(value) + return "".join(parts) diff --git a/Lib/test/test_string.py b/Lib/test/test_string/test_string.py similarity index 100% rename from Lib/test/test_string.py rename to Lib/test/test_string/test_string.py diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py new file mode 100644 index 00000000000000..677b4c29331b1d --- /dev/null +++ b/Lib/test/test_string/test_templatelib.py @@ -0,0 +1,78 @@ +import unittest +from string.templatelib import Template, Interpolation + +from test.test_string._support import f + + +class TestTemplate(unittest.TestCase): + + def test_basic_creation(self): + # Simple t-string creation + t = t"Hello, world" + self.assertTrue(isinstance(t, Template)) + self.assertEqual(t.strings, ("Hello, world",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "Hello, world") + + # Empty t-string + t = t"" + self.assertEqual(t.strings, ("",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "") + + # Multi-line t-string + t = t"""Hello, +world""" + self.assertEqual(t.strings, ("Hello,\nworld",)) + self.assertEqual(len(t.interpolations), 0) + self.assertEqual(f(t), "Hello,\nworld") + + def test_creation_interleaving(self): + # Should add strings on either side + t = Template(Interpolation("Maria", "name", None, "")) + self.assertEqual(t.strings, ("", "")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Maria") + + # Should prepend empty string + t = Template(Interpolation("Maria", "name", None, ""), " is my name") + self.assertEqual(t.strings, ("", " is my name")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Maria is my name") + + # Should append empty string + t = Template("Hello, ", Interpolation("Maria", "name", None, "")) + self.assertEqual(t.strings, ("Hello, ", "")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Maria") + + # Should concatenate strings + t = Template("Hello", ", ", Interpolation("Maria", "name", None, ""), "!") + self.assertEqual(t.strings, ("Hello, ", "!")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Maria!") + + # Should add strings on either side and in between + t = Template(Interpolation("Maria", "name", None, ""), Interpolation("Python", "language", None, "")) + self.assertEqual(t.strings, ("", "", "")) + self.assertEqual(t.interpolations[0].value, "Maria") + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(t.interpolations[1].value, "Python") + self.assertEqual(t.interpolations[1].expression, "language") + self.assertEqual(t.interpolations[1].conversion, None) + self.assertEqual(t.interpolations[1].format_spec, "") + self.assertEqual(f(t), "MariaPython") diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 266c82243cfe69..517746b9f1d15f 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -1,30 +1,7 @@ import ast import unittest -from string.templatelib import Template, Interpolation - - -def convert(value, conversion): - if conversion == "a": - return ascii(value) - elif conversion == "r": - return repr(value) - elif conversion == "s": - return str(value) - return value - - -def f(template): - parts = [] - for item in template: - match item: - case str() as s: - parts.append(s) - case Interpolation(value, _, conversion, format_spec): - value = convert(value, conversion) - value = format(value, format_spec) - parts.append(value) - return "".join(parts) +from test.test_string._support import f class TestTString(unittest.TestCase): @@ -34,77 +11,6 @@ def assertAllRaise(self, exception_type, regex, error_strings): with self.assertRaisesRegex(exception_type, regex): eval(s) - def test_template_basic_creation(self): - # Simple t-string creation - t = t"Hello, world" - self.assertTrue(isinstance(t, Template)) - self.assertEqual(t.strings, ("Hello, world",)) - self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), "Hello, world") - - # Empty t-string - t = t"" - self.assertEqual(t.strings, ("",)) - self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), "") - - # Multi-line t-string - t = t"""Hello, -world""" - self.assertEqual(t.strings, ("Hello,\nworld",)) - self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), "Hello,\nworld") - - def test_template_creation_interleaving(self): - # Should add strings on either side - t = Template(Interpolation("Maria", "name", None, "")) - self.assertEqual(t.strings, ("", "")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Maria") - - # Should prepend empty string - t = Template(Interpolation("Maria", "name", None, ""), " is my name") - self.assertEqual(t.strings, ("", " is my name")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Maria is my name") - - # Should append empty string - t = Template("Hello, ", Interpolation("Maria", "name", None, "")) - self.assertEqual(t.strings, ("Hello, ", "")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Hello, Maria") - - # Should concatenate strings - t = Template("Hello", ", ", Interpolation("Maria", "name", None, ""), "!") - self.assertEqual(t.strings, ("Hello, ", "!")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Hello, Maria!") - - # Should add strings on either side and in between - t = Template(Interpolation("Maria", "name", None, ""), Interpolation("Python", "language", None, "")) - self.assertEqual(t.strings, ("", "", "")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(t.interpolations[1].value, "Python") - self.assertEqual(t.interpolations[1].expression, "language") - self.assertEqual(t.interpolations[1].conversion, None) - self.assertEqual(t.interpolations[1].format_spec, "") - self.assertEqual(f(t), "MariaPython") - def test_string_representation(self): # Test __repr__ t = t"Hello" From 4c6cb475afa1f9ea6ebf4cc6865f9e3a213e1480 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Sat, 19 Apr 2025 16:21:19 +0100 Subject: [PATCH 53/88] Add more concatenation tests (#71) --- Lib/test/test_tstring.py | 49 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 517746b9f1d15f..6245f417638903 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -333,6 +333,55 @@ def test_literal_concatenation(self): self.assertEqual(t.interpolations[0].format_spec, "") self.assertEqual(f(t), "Hello, Pythonand welcome!") + # Test concatenation with Unicode literal + name = "Python" + t = t"Hello, {name}" u"and welcome!" + self.assertEqual(t.strings, ("Hello, ", "and welcome!")) + self.assertEqual(t.interpolations[0].value, name) + self.assertEqual(t.interpolations[0].expression, "name") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Hello, Pythonand welcome!") + + # Test concatenation with f-string literal + tab = '\t' + t = t"Tab: {tab}. " f"f-tab: {tab}." + self.assertEqual(t.strings, ("Tab: ", ". f-tab: \t.")) + self.assertEqual(t.interpolations[0].value, tab) + self.assertEqual(t.interpolations[0].expression, "tab") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Tab: \t. f-tab: \t.") + + # Test concatenation with raw string literal + tab = '\t' + t = t"Tab: {tab}. " r"Raw tab: \t." + self.assertEqual(t.strings, ("Tab: ", r". Raw tab: \t.")) + self.assertEqual(t.interpolations[0].value, tab) + self.assertEqual(t.interpolations[0].expression, "tab") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Tab: \t. Raw tab: \\t.") + + # Test concatenation with raw f-string literal + tab = '\t' + t = t"Tab: {tab}. " rf"f-tab: {tab}. Raw tab: \t." + self.assertEqual(t.strings, ("Tab: ", ". f-tab: \t. Raw tab: \\t.")) + self.assertEqual(t.interpolations[0].value, tab) + self.assertEqual(t.interpolations[0].expression, "tab") + self.assertEqual(t.interpolations[0].conversion, None) + self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(f(t), "Tab: \t. f-tab: \t. Raw tab: \\t.") + + what = 't' + expected_msg = 'cannot mix bytes and nonbytes literals' + for case in ( + "t'{what}-string literal' b'bytes literal'", + "t'{what}-string literal' br'raw bytes literal'", + ): + with self.assertRaisesRegex(SyntaxError, expected_msg): + eval(case) + def test_triple_quoted(self): # Test triple-quoted t-strings t = t""" From 5782897688200183b052339bba63767bafe161a0 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Sat, 19 Apr 2025 16:29:20 +0100 Subject: [PATCH 54/88] t-strings: Reduce undefined behaviour and general improvements (#72) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Bénédikt Tran <10796600+picnixz@users.noreply.github.com> --- Include/internal/pycore_interpolation.h | 1 - Include/internal/pycore_template.h | 1 - Makefile.pre.in | 4 +- Modules/Setup.bootstrap.in | 2 +- Objects/interpolationobject.c | 32 +++++++++------- Objects/templateobject.c | 50 ++++++++++++++----------- Objects/unicodeobject.c | 2 +- 7 files changed, 51 insertions(+), 41 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 813bd945411e0b..d00c2a517d63e9 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -13,7 +13,6 @@ extern "C" { extern PyTypeObject _PyInterpolation_Type; -#define _PyInterpolation_Check(op) PyObject_TypeCheck((op), &_PyInterpolation_Type) #define _PyInterpolation_CheckExact(op) Py_IS_TYPE((op), &_PyInterpolation_Type) PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values); diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index ccf837fc305d73..d28cdf8da8de90 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -12,7 +12,6 @@ extern "C" { extern PyTypeObject _PyTemplate_Type; extern PyTypeObject _PyTemplateIter_Type; -#define _PyTemplate_Check(op) PyObject_TypeCheck((op), &_PyTemplate_Type) #define _PyTemplate_CheckExact(op) Py_IS_TYPE((op), &_PyTemplate_Type) extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); diff --git a/Makefile.pre.in b/Makefile.pre.in index ca8eea27756198..17034033f4253c 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -542,6 +542,7 @@ OBJECT_OBJS= \ Objects/floatobject.o \ Objects/frameobject.o \ Objects/funcobject.o \ + Objects/interpolationobject.o \ Objects/iterobject.o \ Objects/listobject.o \ Objects/longobject.o \ @@ -558,6 +559,7 @@ OBJECT_OBJS= \ Objects/setobject.o \ Objects/sliceobject.o \ Objects/structseq.o \ + Objects/templateobject.o \ Objects/tupleobject.o \ Objects/typeobject.o \ Objects/typevarobject.o \ @@ -565,8 +567,6 @@ OBJECT_OBJS= \ Objects/unicodectype.o \ Objects/unionobject.o \ Objects/weakrefobject.o \ - Objects/interpolationobject.o \ - Objects/templateobject.o \ @PERF_TRAMPOLINE_OBJ@ ########################################################################## diff --git a/Modules/Setup.bootstrap.in b/Modules/Setup.bootstrap.in index ad44bf8b1e9cc6..a3205f16862c4e 100644 --- a/Modules/Setup.bootstrap.in +++ b/Modules/Setup.bootstrap.in @@ -21,12 +21,12 @@ _io _io/_iomodule.c _io/iobase.c _io/fileio.c _io/bytesio.c _io/bufferedio.c _io itertools itertoolsmodule.c _sre _sre/sre.c _sysconfig _sysconfig.c +_templatelib _templatelibmodule.c _thread _threadmodule.c time timemodule.c _types _typesmodule.c _typing _typingmodule.c _weakref _weakref.c -_templatelib _templatelibmodule.c # commonly used core modules _abc _abc.c diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 5bc8b424d494c7..46ed978b4169eb 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -13,9 +13,8 @@ _conversion_converter(PyObject *arg, PyObject **conversion) if (!PyUnicode_Check(arg)) { PyErr_Format(PyExc_TypeError, - "%.200s() %.200s must be %.50s, not %.50s", - "Interpolation", "argument 'conversion'", "str", - arg == Py_None ? "None" : Py_TYPE(arg)->tp_name); + "Interpolation() argument 'conversion' must be str, not %T", + arg); return 0; } @@ -46,6 +45,9 @@ typedef struct { PyObject *format_spec; } interpolationobject; +#define interpolationobject_CAST(op) \ + (assert(_PyInterpolation_CheckExact(op)), _Py_CAST(interpolationobject*, (op))) + /*[clinic input] @classmethod Interpolation.__new__ as interpolation_new @@ -75,8 +77,9 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, } static void -interpolation_dealloc(interpolationobject *self) +interpolation_dealloc(PyObject *op) { + interpolationobject *self = interpolationobject_CAST(op); PyObject_GC_UnTrack(self); Py_CLEAR(self->value); Py_CLEAR(self->expression); @@ -86,8 +89,9 @@ interpolation_dealloc(interpolationobject *self) } static int -interpolation_traverse(interpolationobject *self, visitproc visit, void *arg) +interpolation_traverse(PyObject *op, visitproc visit, void *arg) { + interpolationobject *self = interpolationobject_CAST(op); Py_VISIT(self->value); Py_VISIT(self->expression); Py_VISIT(self->conversion); @@ -96,11 +100,11 @@ interpolation_traverse(interpolationobject *self, visitproc visit, void *arg) } static PyObject * -interpolation_repr(interpolationobject *self) +interpolation_repr(PyObject *op) { - return PyUnicode_FromFormat("%s(%R, %R, %R, %R)", - _PyType_Name(Py_TYPE(self)), - self->value, self->expression, + interpolationobject *self = interpolationobject_CAST(op); + return PyUnicode_FromFormat("%T(%R, %R, %R, %R)", + self, self->value, self->expression, self->conversion, self->format_spec); } @@ -119,13 +123,13 @@ PyTypeObject _PyInterpolation_Type = { .tp_basicsize = sizeof(interpolationobject), .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, - .tp_new = (newfunc) interpolation_new, + .tp_new = interpolation_new, .tp_alloc = PyType_GenericAlloc, - .tp_dealloc = (destructor) interpolation_dealloc, + .tp_dealloc = interpolation_dealloc, .tp_free = PyObject_GC_Del, - .tp_repr = (reprfunc) interpolation_repr, + .tp_repr = interpolation_repr, .tp_members = interpolation_members, - .tp_traverse = (traverseproc) interpolation_traverse, + .tp_traverse = interpolation_traverse, }; static PyObject * @@ -213,5 +217,5 @@ _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values) PyObject * _PyInterpolation_GetValue(PyObject *interpolation) { - return ((interpolationobject *) interpolation)->value; + return interpolationobject_CAST(interpolation)->value; } diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 8d2fa7b4af9305..37c06660c56d7b 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -1,7 +1,7 @@ /* t-string Template object implementation */ #include "Python.h" -#include "pycore_interpolation.h" // _PyInterpolation_Check() +#include "pycore_interpolation.h" // _PyInterpolation_CheckExact() #include "pycore_template.h" typedef struct { @@ -67,6 +67,9 @@ typedef struct { PyObject *interpolations; } templateobject; +#define templateobject_CAST(op) \ + (assert(_PyTemplate_CheckExact(op)), _Py_CAST(templateobject*, (op))) + static templateobject * template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyObject *interpolations) { @@ -80,7 +83,7 @@ template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyOb return template; } -static templateobject * +static PyObject * template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { if (kwds != NULL) { @@ -101,7 +104,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } last_was_str = 1; } - else if (_PyInterpolation_Check(item)) { + else if (_PyInterpolation_CheckExact(item)) { if (!last_was_str) { stringslen++; } @@ -149,7 +152,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } last_was_str = 1; } - else if (_PyInterpolation_Check(item)) { + else if (_PyInterpolation_CheckExact(item)) { if (!last_was_str) { PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } @@ -164,12 +167,13 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) templateobject *template = template_from_strings_interpolations(type, strings, interpolations); Py_DECREF(strings); Py_DECREF(interpolations); - return template; + return (PyObject *)template; } static void -template_dealloc(templateobject *self) +template_dealloc(PyObject *op) { + templateobject *self = templateobject_CAST(op); PyObject_GC_UnTrack(self); Py_CLEAR(self->strings); Py_CLEAR(self->interpolations); @@ -177,25 +181,28 @@ template_dealloc(templateobject *self) } static int -template_traverse(templateobject *self, visitproc visit, void *arg) +template_traverse(PyObject *op, visitproc visit, void *arg) { + templateobject *self = templateobject_CAST(op); Py_VISIT(self->strings); Py_VISIT(self->interpolations); return 0; } static PyObject * -template_repr(templateobject *self) +template_repr(PyObject *op) { + templateobject *self = templateobject_CAST(op); return PyUnicode_FromFormat("%s(strings=%R, interpolations=%R)", _PyType_Name(Py_TYPE(self)), self->strings, self->interpolations); } -static templateiterobject * -template_iter(templateobject *self) +static PyObject * +template_iter(PyObject *op) { + templateobject *self = templateobject_CAST(op); templateiterobject *iter = PyObject_GC_New(templateiterobject, &_PyTemplateIter_Type); if (iter == NULL) { return NULL; @@ -218,7 +225,7 @@ template_iter(templateobject *self) iter->interpolationsiter = interpolationsiter; iter->from_strings = 1; PyObject_GC_Track(iter); - return iter; + return (PyObject *)iter; } static PyObject * @@ -398,13 +405,13 @@ template_concat_str_template(templateobject *self, PyObject *other) PyObject * _PyTemplate_Concat(PyObject *self, PyObject *other) { - if (_PyTemplate_Check(self) && _PyTemplate_Check(other)) { + if (_PyTemplate_CheckExact(self) && _PyTemplate_CheckExact(other)) { return template_concat_templates((templateobject *) self, (templateobject *) other); } - else if ((_PyTemplate_Check(self)) && PyUnicode_Check(other)) { + else if ((_PyTemplate_CheckExact(self)) && PyUnicode_Check(other)) { return template_concat_template_str((templateobject *) self, other); } - else if (PyUnicode_Check(self) && (_PyTemplate_Check(other))) { + else if (PyUnicode_Check(self) && (_PyTemplate_CheckExact(other))) { return template_concat_str_template((templateobject *) other, self); } else { @@ -413,8 +420,9 @@ _PyTemplate_Concat(PyObject *self, PyObject *other) } static PyObject * -template_values_get(templateobject *self, void *Py_UNUSED(data)) +template_values_get(PyObject *op, void *Py_UNUSED(data)) { + templateobject *self = templateobject_CAST(op); PyObject *values = PyTuple_New(PyTuple_GET_SIZE(self->interpolations)); if (values == NULL) { return NULL; @@ -448,7 +456,7 @@ static PyMemberDef template_members[] = { }; static PyGetSetDef template_getset[] = { - {"values", (getter) template_values_get, NULL, "Values of interpolations", NULL}, + {"values", template_values_get, NULL, "Values of interpolations", NULL}, {NULL}, }; @@ -464,15 +472,15 @@ PyTypeObject _PyTemplate_Type = { .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_as_sequence = &template_as_sequence, - .tp_new = (newfunc) template_new, + .tp_new = template_new, .tp_alloc = PyType_GenericAlloc, - .tp_dealloc = (destructor) template_dealloc, + .tp_dealloc = template_dealloc, .tp_free = PyObject_GC_Del, - .tp_repr = (reprfunc) template_repr, + .tp_repr = template_repr, .tp_members = template_members, .tp_getset = template_getset, - .tp_iter = (getiterfunc) template_iter, - .tp_traverse = (traverseproc) template_traverse, + .tp_iter = template_iter, + .tp_traverse = template_traverse, }; PyObject * diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index 38b33218ef694f..96ffb2df92b3ba 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -11618,7 +11618,7 @@ PyUnicode_Concat(PyObject *left, PyObject *right) return NULL; if (!PyUnicode_Check(right)) { - if (_PyTemplate_Check(right)) { + if (_PyTemplate_CheckExact(right)) { // str + tstring is implemented in the tstring type return _PyTemplate_Concat(left, right); } From fb68d6075148897819914163e0b7c13fdc47cef3 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Mon, 21 Apr 2025 15:17:01 +0100 Subject: [PATCH 55/88] Add ``assertTStringEqual()`` helper (#73) --- Lib/test/test_string/_support.py | 31 ++++ Lib/test/test_string/test_templatelib.py | 83 +++------ Lib/test/test_tstring.py | 225 ++++++++--------------- 3 files changed, 135 insertions(+), 204 deletions(-) diff --git a/Lib/test/test_string/_support.py b/Lib/test/test_string/_support.py index fde89ee1b62ae4..c08392d0aa7945 100644 --- a/Lib/test/test_string/_support.py +++ b/Lib/test/test_string/_support.py @@ -1,6 +1,37 @@ +import unittest from string.templatelib import Interpolation +class TStringTestCase(unittest.TestCase): + def assertTStringEqual(self, t, strings, interpolations): + """Test template string literal equality. + + The *strings* argument must be a tuple of strings equal to *t.strings*. + + The *interpolations* argument must be a sequence of tuples which are + compared against *t.interpolations*. Each tuple consists of + (value, expression, conversion, format_spec), though the final two + items may be omitted, and are assumed to be None and '' respectively. + """ + self.assertEqual(t.strings, strings) + self.assertEqual(len(t.interpolations), len(interpolations)) + + for i, exp in zip(t.interpolations, interpolations, strict=True): + if len(exp) == 4: + actual = (i.value, i.expression, i.conversion, i.format_spec) + self.assertEqual(actual, exp) + continue + + if len(exp) == 3: + self.assertEqual((i.value, i.expression, i.conversion), exp) + self.assertEqual(i.format_spec, '') + continue + + self.assertEqual((i.value, i.expression), exp) + self.assertEqual(i.format_spec, '') + self.assertIsNone(i.conversion) + + def convert(value, conversion): if conversion == "a": return ascii(value) diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py index 677b4c29331b1d..d00560c7e91356 100644 --- a/Lib/test/test_string/test_templatelib.py +++ b/Lib/test/test_string/test_templatelib.py @@ -1,78 +1,55 @@ -import unittest from string.templatelib import Template, Interpolation -from test.test_string._support import f +from test.test_string._support import TStringTestCase, f -class TestTemplate(unittest.TestCase): +class TestTemplate(TStringTestCase): def test_basic_creation(self): # Simple t-string creation - t = t"Hello, world" - self.assertTrue(isinstance(t, Template)) - self.assertEqual(t.strings, ("Hello, world",)) - self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), "Hello, world") + t = t'Hello, world' + self.assertIsInstance(t, Template) + self.assertTStringEqual(t, ('Hello, world',), ()) + self.assertEqual(f(t), 'Hello, world') # Empty t-string - t = t"" - self.assertEqual(t.strings, ("",)) - self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), "") + t = t'' + self.assertTStringEqual(t, ('',), ()) + self.assertEqual(f(t), '') # Multi-line t-string t = t"""Hello, world""" - self.assertEqual(t.strings, ("Hello,\nworld",)) + self.assertEqual(t.strings, ('Hello,\nworld',)) self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), "Hello,\nworld") + self.assertEqual(f(t), 'Hello,\nworld') def test_creation_interleaving(self): # Should add strings on either side - t = Template(Interpolation("Maria", "name", None, "")) - self.assertEqual(t.strings, ("", "")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Maria") + t = Template(Interpolation('Maria', 'name', None, '')) + self.assertTStringEqual(t, ('', ''), [('Maria', 'name')]) + self.assertEqual(f(t), 'Maria') # Should prepend empty string - t = Template(Interpolation("Maria", "name", None, ""), " is my name") - self.assertEqual(t.strings, ("", " is my name")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Maria is my name") + t = Template(Interpolation('Maria', 'name', None, ''), ' is my name') + self.assertTStringEqual(t, ('', ' is my name'), [('Maria', 'name')]) + self.assertEqual(f(t), 'Maria is my name') # Should append empty string - t = Template("Hello, ", Interpolation("Maria", "name", None, "")) - self.assertEqual(t.strings, ("Hello, ", "")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Hello, Maria") + t = Template('Hello, ', Interpolation('Maria', 'name', None, '')) + self.assertTStringEqual(t, ('Hello, ', ''), [('Maria', 'name')]) + self.assertEqual(f(t), 'Hello, Maria') # Should concatenate strings - t = Template("Hello", ", ", Interpolation("Maria", "name", None, ""), "!") - self.assertEqual(t.strings, ("Hello, ", "!")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(f(t), "Hello, Maria!") + t = Template('Hello', ', ', Interpolation('Maria', 'name', None, ''), + '!') + self.assertTStringEqual(t, ('Hello, ', '!'), [('Maria', 'name')]) + self.assertEqual(f(t), 'Hello, Maria!') # Should add strings on either side and in between - t = Template(Interpolation("Maria", "name", None, ""), Interpolation("Python", "language", None, "")) - self.assertEqual(t.strings, ("", "", "")) - self.assertEqual(t.interpolations[0].value, "Maria") - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(t.interpolations[1].value, "Python") - self.assertEqual(t.interpolations[1].expression, "language") - self.assertEqual(t.interpolations[1].conversion, None) - self.assertEqual(t.interpolations[1].format_spec, "") - self.assertEqual(f(t), "MariaPython") + t = Template(Interpolation('Maria', 'name', None, ''), + Interpolation('Python', 'language', None, '')) + self.assertTStringEqual( + t, ('', '', ''), [('Maria', 'name'), ('Python', 'language')] + ) + self.assertEqual(f(t), 'MariaPython') diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 6245f417638903..e4d90cc042ea03 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -1,10 +1,10 @@ import ast import unittest -from test.test_string._support import f +from test.test_string._support import TStringTestCase, f -class TestTString(unittest.TestCase): +class TestTString(TStringTestCase): def assertAllRaise(self, exception_type, regex, error_strings): for s in error_strings: with self.subTest(s=s): @@ -27,48 +27,32 @@ def test_interpolation_basics(self): # Test basic interpolation name = "Python" t = t"Hello, {name}" - self.assertEqual(t.strings, ("Hello, ", "")) - self.assertEqual(t.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) self.assertEqual(f(t), "Hello, Python") # Multiple interpolations first = "Python" last = "Developer" t = t"{first} {last}" - self.assertEqual(t.strings, ("", " ", "")) - self.assertEqual(t.interpolations[0].value, first) - self.assertEqual(t.interpolations[0].expression, "first") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(t.interpolations[1].value, last) - self.assertEqual(t.interpolations[1].expression, "last") - self.assertEqual(t.interpolations[1].conversion, None) - self.assertEqual(t.interpolations[1].format_spec, "") + self.assertTStringEqual( + t, ("", " ", ""), [(first, 'first'), (last, 'last')] + ) self.assertEqual(f(t), "Python Developer") # Interpolation with expressions a = 10 b = 20 t = t"Sum: {a + b}" - self.assertEqual(t.strings, ("Sum: ", "")) - self.assertEqual(t.interpolations[0].value, a + b) - self.assertEqual(t.interpolations[0].expression, "a + b") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Sum: ", ""), [(a + b, "a + b")]) self.assertEqual(f(t), "Sum: 30") # Interpolation with function def square(x): return x * x t = t"Square: {square(5)}" - self.assertEqual(t.strings, ("Square: ", "")) - self.assertEqual(t.interpolations[0].value, square(5)) - self.assertEqual(t.interpolations[0].expression, "square(5)") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Square: ", ""), [(square(5), "square(5)")] + ) self.assertEqual(f(t), "Square: 25") # Test attribute access in expressions @@ -81,75 +65,52 @@ def upper(self): person = Person("Alice") t = t"Name: {person.name}" - self.assertEqual(t.strings, ("Name: ", "")) - self.assertEqual(t.interpolations[0].value, person.name) - self.assertEqual(t.interpolations[0].expression, "person.name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Name: ", ""), [(person.name, "person.name")] + ) self.assertEqual(f(t), "Name: Alice") # Test method calls t = t"Name: {person.upper()}" - self.assertEqual(t.strings, ("Name: ", "")) - self.assertEqual(t.interpolations[0].value, person.upper()) - self.assertEqual(t.interpolations[0].expression, "person.upper()") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Name: ", ""), [(person.upper(), "person.upper()")] + ) self.assertEqual(f(t), "Name: ALICE") # Test dictionary access data = {"name": "Bob", "age": 30} t = t"Name: {data['name']}, Age: {data['age']}" - self.assertEqual(t.strings, ("Name: ", ", Age: ", "")) - self.assertEqual(t.interpolations[0].value, data["name"]) - self.assertEqual(t.interpolations[0].expression, "data['name']") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") - self.assertEqual(t.interpolations[1].value, data["age"]) - self.assertEqual(t.interpolations[1].expression, "data['age']") - self.assertEqual(t.interpolations[1].conversion, None) - self.assertEqual(t.interpolations[1].format_spec, "") + self.assertTStringEqual( + t, ("Name: ", ", Age: ", ""), + [(data["name"], "data['name']"), (data["age"], "data['age']")], + ) self.assertEqual(f(t), "Name: Bob, Age: 30") def test_format_specifiers(self): # Test basic format specifiers value = 3.14159 t = t"Pi: {value:.2f}" - self.assertEqual(t.strings, ("Pi: ", "")) - self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, ".2f") + self.assertTStringEqual( + t, ("Pi: ", ""), [(value, "value", None, ".2f")] + ) self.assertEqual(f(t), "Pi: 3.14") def test_conversions(self): # Test !s conversion (str) obj = object() t = t"Object: {obj!s}" - self.assertEqual(t.strings, ("Object: ", "")) - self.assertEqual(t.interpolations[0].value, obj) - self.assertEqual(t.interpolations[0].expression, "obj") - self.assertEqual(t.interpolations[0].conversion, "s") - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Object: ", ""), [(obj, "obj", "s")]) self.assertEqual(f(t), f"Object: {str(obj)}") # Test !r conversion (repr) t = t"Data: {obj!r}" - self.assertEqual(t.strings, ("Data: ", "")) - self.assertEqual(t.interpolations[0].value, obj) - self.assertEqual(t.interpolations[0].expression, "obj") - self.assertEqual(t.interpolations[0].conversion, "r") - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Data: ", ""), [(obj, "obj", "r")]) self.assertEqual(f(t), f"Data: {repr(obj)}") # Test !a conversion (ascii) text = "Café" t = t"ASCII: {text!a}" - self.assertEqual(t.strings, ("ASCII: ", "")) - self.assertEqual(t.interpolations[0].value, text) - self.assertEqual(t.interpolations[0].expression, "text") - self.assertEqual(t.interpolations[0].conversion, "a") - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("ASCII: ", ""), [(text, "text", "a")]) self.assertEqual(f(t), f"ASCII: {ascii(text)}") # Test !z conversion (error) @@ -161,51 +122,40 @@ def test_debug_specifier(self): # Test debug specifier value = 42 t = t"Value: {value=}" - self.assertEqual(t.strings, ("Value: value=", "")) - self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") - self.assertEqual(t.interpolations[0].conversion, "r") - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Value: value=", ""), [(value, "value", "r")] + ) self.assertEqual(f(t), "Value: value=42") # Test debug specifier with format (conversion default to !r) t = t"Value: {value=:.2f}" - self.assertEqual(t.strings, ("Value: value=", "")) - self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, ".2f") + self.assertTStringEqual( + t, ("Value: value=", ""), [(value, "value", None, ".2f")] + ) self.assertEqual(f(t), "Value: value=42.00") # Test debug specifier with conversion t = t"Value: {value=!s}" - self.assertEqual(t.strings, ("Value: value=", "")) - self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") - self.assertEqual(t.interpolations[0].conversion, "s") - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Value: value=", ""), [(value, "value", "s")] + ) # Test white space in debug specifier t = t"Value: {value = }" - self.assertEqual(t.strings, ("Value: value = ", "")) - self.assertEqual(t.interpolations[0].value, value) - self.assertEqual(t.interpolations[0].expression, "value") - self.assertEqual(t.interpolations[0].conversion, "r") - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Value: value = ", ""), [(value, "value", "r")] + ) self.assertEqual(f(t), "Value: value = 42") def test_raw_tstrings(self): path = r"C:\Users" t = rt"{path}\Documents" - self.assertEqual(t.strings, ("", r"\Documents",)) - self.assertEqual(t.interpolations[0].value, path) - self.assertEqual(t.interpolations[0].expression, "path") + self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) self.assertEqual(f(t), r"C:\Users\Documents") # Test alternative prefix t = tr"{path}\Documents" - self.assertEqual(t.strings, ("", r"\Documents",)) - self.assertEqual(t.interpolations[0].value, path) + self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) def test_template_concatenation(self): @@ -213,15 +163,13 @@ def test_template_concatenation(self): t1 = t"Hello, " t2 = t"world" combined = t1 + t2 - self.assertEqual(combined.strings, ("Hello, world",)) - self.assertEqual(len(combined.interpolations), 0) + self.assertTStringEqual(combined, ("Hello, world",), ()) self.assertEqual(f(combined), "Hello, world") # Test template + string t1 = t"Hello" combined = t1 + ", world" - self.assertEqual(combined.strings, ("Hello, world",)) - self.assertEqual(len(combined.interpolations), 0) + self.assertTStringEqual(combined, ("Hello, world",), ()) self.assertEqual(f(combined), "Hello, world") # Test template + template with interpolation @@ -229,20 +177,12 @@ def test_template_concatenation(self): t1 = t"Hello, " t2 = t"{name}" combined = t1 + t2 - self.assertEqual(combined.strings, ("Hello, ", "")) - self.assertEqual(combined.interpolations[0].value, name) - self.assertEqual(combined.interpolations[0].expression, "name") - self.assertEqual(combined.interpolations[0].conversion, None) - self.assertEqual(combined.interpolations[0].format_spec, "") + self.assertTStringEqual(combined, ("Hello, ", ""), [(name, "name")]) self.assertEqual(f(combined), "Hello, Python") # Test string + template t = "Hello, " + t"{name}" - self.assertEqual(t.strings, ("Hello, ", "")) - self.assertEqual(t.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) self.assertEqual(f(t), "Hello, Python") def test_nested_templates(self): @@ -251,15 +191,16 @@ def test_nested_templates(self): inner = t"{name}" t = t"Language: {inner}" + t_interp = t.interpolations[0] self.assertEqual(t.strings, ("Language: ", "")) - self.assertEqual(t.interpolations[0].value.strings, ("", "")) - self.assertEqual(t.interpolations[0].value.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].value.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].value.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].value.interpolations[0].format_spec, "") - self.assertEqual(t.interpolations[0].expression, "inner") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertEqual(t_interp.value.strings, ("", "")) + self.assertEqual(t_interp.value.interpolations[0].value, name) + self.assertEqual(t_interp.value.interpolations[0].expression, "name") + self.assertEqual(t_interp.value.interpolations[0].conversion, None) + self.assertEqual(t_interp.value.interpolations[0].format_spec, "") + self.assertEqual(t_interp.expression, "inner") + self.assertEqual(t_interp.conversion, None) + self.assertEqual(t_interp.format_spec, "") def test_ast_structure(self): # Test AST structure for simple t-string @@ -309,68 +250,51 @@ def test_runtime_errors(self): def test_literal_concatenation(self): # Test concatenation of t-string literals t = t"Hello, " t"world" - self.assertEqual(t.strings, ("Hello, world",)) - self.assertEqual(len(t.interpolations), 0) + self.assertTStringEqual(t, ("Hello, world",), ()) self.assertEqual(f(t), "Hello, world") # Test concatenation with interpolation name = "Python" t = t"Hello, " t"{name}" - self.assertEqual(t.strings, ("Hello, ", "")) - self.assertEqual(t.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) self.assertEqual(f(t), "Hello, Python") # Test concatenation with string literal name = "Python" t = t"Hello, {name}" "and welcome!" - self.assertEqual(t.strings, ("Hello, ", "and welcome!")) - self.assertEqual(t.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Hello, ", "and welcome!"), [(name, "name")] + ) self.assertEqual(f(t), "Hello, Pythonand welcome!") # Test concatenation with Unicode literal name = "Python" t = t"Hello, {name}" u"and welcome!" - self.assertEqual(t.strings, ("Hello, ", "and welcome!")) - self.assertEqual(t.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Hello, ", "and welcome!"), [(name, "name")] + ) self.assertEqual(f(t), "Hello, Pythonand welcome!") # Test concatenation with f-string literal tab = '\t' t = t"Tab: {tab}. " f"f-tab: {tab}." - self.assertEqual(t.strings, ("Tab: ", ". f-tab: \t.")) - self.assertEqual(t.interpolations[0].value, tab) - self.assertEqual(t.interpolations[0].expression, "tab") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual(t, ("Tab: ", ". f-tab: \t."), [(tab, "tab")]) self.assertEqual(f(t), "Tab: \t. f-tab: \t.") # Test concatenation with raw string literal tab = '\t' t = t"Tab: {tab}. " r"Raw tab: \t." - self.assertEqual(t.strings, ("Tab: ", r". Raw tab: \t.")) - self.assertEqual(t.interpolations[0].value, tab) - self.assertEqual(t.interpolations[0].expression, "tab") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Tab: ", r". Raw tab: \t."), [(tab, "tab")] + ) self.assertEqual(f(t), "Tab: \t. Raw tab: \\t.") # Test concatenation with raw f-string literal tab = '\t' t = t"Tab: {tab}. " rf"f-tab: {tab}. Raw tab: \t." - self.assertEqual(t.strings, ("Tab: ", ". f-tab: \t. Raw tab: \\t.")) - self.assertEqual(t.interpolations[0].value, tab) - self.assertEqual(t.interpolations[0].expression, "tab") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("Tab: ", ". f-tab: \t. Raw tab: \\t."), [(tab, "tab")] + ) self.assertEqual(f(t), "Tab: \t. f-tab: \t. Raw tab: \\t.") what = 't' @@ -388,8 +312,9 @@ def test_triple_quoted(self): Hello, world """ - self.assertEqual(t.strings, ("\n Hello,\n world\n ",)) - self.assertEqual(len(t.interpolations), 0) + self.assertTStringEqual( + t, ("\n Hello,\n world\n ",), () + ) self.assertEqual(f(t), "\n Hello,\n world\n ") # Test triple-quoted with interpolation @@ -398,11 +323,9 @@ def test_triple_quoted(self): Hello, {name} """ - self.assertEqual(t.strings, ("\n Hello,\n ", "\n ")) - self.assertEqual(t.interpolations[0].value, name) - self.assertEqual(t.interpolations[0].expression, "name") - self.assertEqual(t.interpolations[0].conversion, None) - self.assertEqual(t.interpolations[0].format_spec, "") + self.assertTStringEqual( + t, ("\n Hello,\n ", "\n "), [(name, "name")] + ) self.assertEqual(f(t), "\n Hello,\n Python\n ") if __name__ == '__main__': From 174b045514aaf2f5379d7b50d0f6881f2c74f5ac Mon Sep 17 00:00:00 2001 From: Paul Everitt Date: Mon, 21 Apr 2025 10:19:39 -0400 Subject: [PATCH 56/88] Add a what's new entry (#69) Co-authored-by: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Co-authored-by: Lysandros Nikolaou --- Doc/whatsnew/3.14.rst | 70 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/Doc/whatsnew/3.14.rst b/Doc/whatsnew/3.14.rst index 7d469e83dc27ad..0d2407ed02101b 100644 --- a/Doc/whatsnew/3.14.rst +++ b/Doc/whatsnew/3.14.rst @@ -66,6 +66,7 @@ Summary -- release highlights * :ref:`PEP 649: deferred evaluation of annotations ` * :ref:`PEP 741: Python Configuration C API ` +* :ref:`PEP 750: Template Strings ` * :ref:`PEP 758: Allow except and except* expressions without parentheses ` * :ref:`PEP 761: Discontinuation of PGP signatures ` * :ref:`PEP 765: Disallow return/break/continue that exit a finally block ` @@ -92,6 +93,75 @@ If you encounter :exc:`NameError`\s or pickling errors coming out of New features ============ +.. _whatsnew314-pep750: + +PEP 750: Template Strings +------------------------- + +Template string literals (t-strings) are a generalization of f-strings, +using a ``t`` in place of the ``f`` prefix. Instead of evaluating +to :class:`str`, t-strings evaluate to a new :class:`string.templatelib.Template` type: + +.. code-block:: python + + from string.templatelib import Template + + name = "World" + template: Template = t"Hello {name}" + +The template can then be combined with functions that operate on the template's +structure to produce a :class:`str` or a string-like result. +For example, sanitizing input: + +.. code-block:: python + + evil = "" + template = t"

{evil}

" + assert html(template) == "

<script>alert('evil')</script>

" + +As another example, generating HTML attributes from data: + +.. code-block:: python + + attributes = {"src": "shrubbery.jpg", "alt": "looks nice"} + template = t"" + assert html(template) == 'looks nice' + +Unlike f-strings, the ``html`` function has access to template attributes +containing the original information: static strings, interpolations, and values +from the original scope. Unlike existing templating approaches, t-strings build +from the well-known f-string syntax and rules. Template systems thus benefit +from Python tooling as they are much closer to the Python language, syntax, +scoping, and more. + +Writing template handlers is straightforward: + +.. code-block:: python + + from string.templatelib import Template, Interpolation + + def lower_upper(template: Template) -> str: + """Render static parts lowercased and interpolations uppercased.""" + parts: list[str] = [] + for item in template: + if isinstance(item, Interpolation): + parts.append(str(item.value).upper()) + else: + parts.append(item.lower()) + return "".join(parts) + + name = "world" + assert lower_upper(t"HELLO {name}") == "hello WORLD" + +With this in place, developers can write template systems to sanitize SQL, make +safe shell operations, improve logging, tackle modern ideas in web development +(HTML, CSS, etc.), and implement lightweight, custom business DSLs. + +See :pep:`750` for more details. + +(Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, +Lysandros Nikolaou, and Dave Peck in :gh:`132661`.) + .. _whatsnew314-pep768: PEP 768: Safe external debugger interface for CPython From 62ace6865989f7c6adefc106c74e8ad80c877411 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:12:22 +0200 Subject: [PATCH 57/88] Fix repr --- Objects/interpolationobject.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 46ed978b4169eb..6dd163186b1d73 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -103,8 +103,8 @@ static PyObject * interpolation_repr(PyObject *op) { interpolationobject *self = interpolationobject_CAST(op); - return PyUnicode_FromFormat("%T(%R, %R, %R, %R)", - self, self->value, self->expression, + return PyUnicode_FromFormat("%s(%R, %R, %R, %R)", + _PyType_Name(Py_TYPE(self)), self->value, self->expression, self->conversion, self->format_spec); } From 4f6c5df6a98b5d43ebe7075c064cfd3a5fc2cad7 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:30:27 +0200 Subject: [PATCH 58/88] Fix syntax errors in grammar --- Grammar/python.gram | 79 +- Parser/parser.c | 3678 ++++++++++++++++++++++++++----------------- 2 files changed, 2260 insertions(+), 1497 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 2e95101b1ed2d8..16c9414da67f2a 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -929,7 +929,7 @@ fstring_middle[expr_ty]: fstring_replacement_field[expr_ty]: | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { _PyPegen_formatted_value(p, a, debug_expr, conversion, format, rbrace, EXTRA) } - | invalid_replacement_field + | invalid_fstring_replacement_field fstring_conversion[ResultTokenWithMetadata*]: | conv_token="!" conv=NAME { _PyPegen_check_fstring_conversion(p, conv_token, conv) } fstring_full_format_spec[ResultTokenWithMetadata*]: @@ -940,10 +940,19 @@ fstring_format_spec[expr_ty]: fstring[expr_ty]: | a=FSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_joined_str(p, a, (asdl_expr_seq*)b, c) } +tstring_format_spec_replacement_field[expr_ty]: + | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[tstring_full_format_spec] rbrace='}' { + _PyPegen_formatted_value(p, a, debug_expr, conversion, format, rbrace, EXTRA) } + | invalid_tstring_replacement_field +tstring_format_spec[expr_ty]: + | t=FSTRING_MIDDLE { _PyPegen_decoded_constant_from_token(p, t) } + | tstring_format_spec_replacement_field +tstring_full_format_spec[ResultTokenWithMetadata*]: + | colon=':' spec=tstring_format_spec* { _PyPegen_setup_full_format_spec(p, colon, (asdl_expr_seq *) spec, EXTRA) } tstring_replacement_field[expr_ty]: - | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' { + | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[tstring_full_format_spec] rbrace='}' { _PyPegen_interpolation(p, a, debug_expr, conversion, format, rbrace, EXTRA) } - | invalid_replacement_field + | invalid_tstring_replacement_field tstring_middle[expr_ty]: | tstring_replacement_field | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } @@ -1458,39 +1467,49 @@ invalid_starred_expression_unpacking: invalid_starred_expression: | '*' { RAISE_SYNTAX_ERROR("Invalid star expression") } -invalid_replacement_field: - | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before '='", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } - | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before '!'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } - | '{' a=':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before ':'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } - | '{' a='}' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "%c-string: valid expression required before '}'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } - | '{' !annotated_rhs { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting a valid expression after '{'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f')} +invalid_fstring_replacement_field: + | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '='") } + | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '!'") } + | '{' a=':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before ':'") } + | '{' a='}' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '}'") } + | '{' !annotated_rhs { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting a valid expression after '{'") } | '{' annotated_rhs !('=' | '!' | ':' | '}') { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '=', or '!', or ':', or '}'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '=', or '!', or ':', or '}'") } | '{' annotated_rhs '=' !('!' | ':' | '}') { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '!', or ':', or '}'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } - | '{' annotated_rhs '='? invalid_conversion_character + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '!', or ':', or '}'") } + | '{' annotated_rhs '='? invalid_fstring_conversion_character | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting ':' or '}'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting ':' or '}'") } | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '}', or format specs", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '}', or format specs") } | '{' annotated_rhs '='? ['!' NAME] !'}' { - PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: expecting '}'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '}'") } + +invalid_fstring_conversion_character: + | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: missing conversion character") } + | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: invalid conversion character") } + +invalid_tstring_replacement_field: + | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "t-string: valid expression required before '='") } + | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "t-string: valid expression required before '!'") } + | '{' a=':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "t-string: valid expression required before ':'") } + | '{' a='}' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "t-string: valid expression required before '}'") } + | '{' !annotated_rhs { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: expecting a valid expression after '{'") } + | '{' annotated_rhs !('=' | '!' | ':' | '}') { + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: expecting '=', or '!', or ':', or '}'") } + | '{' annotated_rhs '=' !('!' | ':' | '}') { + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: expecting '!', or ':', or '}'") } + | '{' annotated_rhs '='? invalid_tstring_conversion_character + | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') { + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: expecting ':' or '}'") } + | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' { + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: expecting '}', or format specs") } + | '{' annotated_rhs '='? ['!' NAME] !'}' { + PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: expecting '}'") } -invalid_conversion_character: - | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: missing conversion character", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } - | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("%c-string: invalid conversion character", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } +invalid_tstring_conversion_character: + | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: missing conversion character") } + | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("t-string: invalid conversion character") } invalid_arithmetic: | sum ('+'|'-'|'*'|'/'|'%'|'//'|'@') a='not' b=inversion { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "'not' after an operator must be parenthesized") } diff --git a/Parser/parser.c b/Parser/parser.c index 050bf26e0628d7..3c18d170267f75 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -246,276 +246,282 @@ static char *soft_keywords[] = { #define fstring_full_format_spec_type 1159 #define fstring_format_spec_type 1160 #define fstring_type 1161 -#define tstring_replacement_field_type 1162 -#define tstring_middle_type 1163 -#define tstring_type 1164 -#define string_type 1165 -#define strings_type 1166 -#define list_type 1167 -#define tuple_type 1168 -#define set_type 1169 -#define dict_type 1170 -#define double_starred_kvpairs_type 1171 -#define double_starred_kvpair_type 1172 -#define kvpair_type 1173 -#define for_if_clauses_type 1174 -#define for_if_clause_type 1175 -#define listcomp_type 1176 -#define setcomp_type 1177 -#define genexp_type 1178 -#define dictcomp_type 1179 -#define arguments_type 1180 -#define args_type 1181 -#define kwargs_type 1182 -#define starred_expression_type 1183 -#define kwarg_or_starred_type 1184 -#define kwarg_or_double_starred_type 1185 -#define star_targets_type 1186 -#define star_targets_list_seq_type 1187 -#define star_targets_tuple_seq_type 1188 -#define star_target_type 1189 -#define target_with_star_atom_type 1190 -#define star_atom_type 1191 -#define single_target_type 1192 -#define single_subscript_attribute_target_type 1193 -#define t_primary_type 1194 // Left-recursive -#define t_lookahead_type 1195 -#define del_targets_type 1196 -#define del_target_type 1197 -#define del_t_atom_type 1198 -#define type_expressions_type 1199 -#define func_type_comment_type 1200 -#define invalid_arguments_type 1201 -#define invalid_kwarg_type 1202 -#define expression_without_invalid_type 1203 -#define invalid_legacy_expression_type 1204 -#define invalid_type_param_type 1205 -#define invalid_expression_type 1206 -#define invalid_named_expression_type 1207 -#define invalid_assignment_type 1208 -#define invalid_ann_assign_target_type 1209 -#define invalid_del_stmt_type 1210 -#define invalid_block_type 1211 -#define invalid_comprehension_type 1212 -#define invalid_dict_comprehension_type 1213 -#define invalid_parameters_type 1214 -#define invalid_default_type 1215 -#define invalid_star_etc_type 1216 -#define invalid_kwds_type 1217 -#define invalid_parameters_helper_type 1218 -#define invalid_lambda_parameters_type 1219 -#define invalid_lambda_parameters_helper_type 1220 -#define invalid_lambda_star_etc_type 1221 -#define invalid_lambda_kwds_type 1222 -#define invalid_double_type_comments_type 1223 -#define invalid_with_item_type 1224 -#define invalid_for_if_clause_type 1225 -#define invalid_for_target_type 1226 -#define invalid_group_type 1227 -#define invalid_import_type 1228 -#define invalid_import_from_targets_type 1229 -#define invalid_with_stmt_type 1230 -#define invalid_with_stmt_indent_type 1231 -#define invalid_try_stmt_type 1232 -#define invalid_except_stmt_type 1233 -#define invalid_except_star_stmt_type 1234 -#define invalid_finally_stmt_type 1235 -#define invalid_except_stmt_indent_type 1236 -#define invalid_except_star_stmt_indent_type 1237 -#define invalid_match_stmt_type 1238 -#define invalid_case_block_type 1239 -#define invalid_as_pattern_type 1240 -#define invalid_class_pattern_type 1241 -#define invalid_class_argument_pattern_type 1242 -#define invalid_if_stmt_type 1243 -#define invalid_elif_stmt_type 1244 -#define invalid_else_stmt_type 1245 -#define invalid_while_stmt_type 1246 -#define invalid_for_stmt_type 1247 -#define invalid_def_raw_type 1248 -#define invalid_class_def_raw_type 1249 -#define invalid_double_starred_kvpairs_type 1250 -#define invalid_kvpair_type 1251 -#define invalid_starred_expression_unpacking_type 1252 -#define invalid_starred_expression_type 1253 -#define invalid_replacement_field_type 1254 -#define invalid_conversion_character_type 1255 -#define invalid_arithmetic_type 1256 -#define invalid_factor_type 1257 -#define invalid_type_params_type 1258 -#define _loop0_1_type 1259 -#define _loop1_2_type 1260 -#define _loop0_3_type 1261 -#define _gather_4_type 1262 -#define _tmp_5_type 1263 -#define _tmp_6_type 1264 -#define _tmp_7_type 1265 -#define _tmp_8_type 1266 -#define _tmp_9_type 1267 -#define _tmp_10_type 1268 -#define _tmp_11_type 1269 -#define _loop1_12_type 1270 -#define _tmp_13_type 1271 -#define _loop0_14_type 1272 -#define _gather_15_type 1273 -#define _tmp_16_type 1274 -#define _tmp_17_type 1275 -#define _loop0_18_type 1276 -#define _loop1_19_type 1277 -#define _loop0_20_type 1278 -#define _gather_21_type 1279 -#define _tmp_22_type 1280 -#define _loop0_23_type 1281 -#define _gather_24_type 1282 -#define _loop1_25_type 1283 -#define _tmp_26_type 1284 -#define _tmp_27_type 1285 -#define _loop0_28_type 1286 -#define _loop0_29_type 1287 -#define _loop1_30_type 1288 -#define _loop1_31_type 1289 -#define _loop0_32_type 1290 -#define _loop1_33_type 1291 -#define _loop0_34_type 1292 -#define _gather_35_type 1293 -#define _tmp_36_type 1294 -#define _loop1_37_type 1295 -#define _loop1_38_type 1296 -#define _loop1_39_type 1297 -#define _loop0_40_type 1298 -#define _gather_41_type 1299 -#define _tmp_42_type 1300 -#define _tmp_43_type 1301 -#define _tmp_44_type 1302 -#define _loop0_45_type 1303 -#define _gather_46_type 1304 -#define _loop0_47_type 1305 -#define _gather_48_type 1306 -#define _tmp_49_type 1307 -#define _loop0_50_type 1308 -#define _gather_51_type 1309 -#define _loop0_52_type 1310 -#define _gather_53_type 1311 -#define _loop0_54_type 1312 -#define _gather_55_type 1313 -#define _loop1_56_type 1314 -#define _loop1_57_type 1315 -#define _loop0_58_type 1316 -#define _gather_59_type 1317 -#define _loop1_60_type 1318 -#define _loop1_61_type 1319 -#define _loop1_62_type 1320 -#define _tmp_63_type 1321 -#define _loop0_64_type 1322 -#define _gather_65_type 1323 -#define _tmp_66_type 1324 -#define _tmp_67_type 1325 -#define _tmp_68_type 1326 -#define _tmp_69_type 1327 -#define _tmp_70_type 1328 -#define _loop0_71_type 1329 -#define _loop0_72_type 1330 -#define _loop1_73_type 1331 -#define _loop1_74_type 1332 -#define _loop0_75_type 1333 -#define _loop1_76_type 1334 -#define _loop0_77_type 1335 -#define _loop0_78_type 1336 -#define _loop0_79_type 1337 -#define _loop1_80_type 1338 -#define _tmp_81_type 1339 -#define _loop0_82_type 1340 -#define _gather_83_type 1341 -#define _loop1_84_type 1342 -#define _loop0_85_type 1343 -#define _tmp_86_type 1344 -#define _loop0_87_type 1345 -#define _gather_88_type 1346 -#define _tmp_89_type 1347 -#define _loop0_90_type 1348 -#define _gather_91_type 1349 -#define _loop0_92_type 1350 -#define _gather_93_type 1351 -#define _loop0_94_type 1352 -#define _loop0_95_type 1353 -#define _gather_96_type 1354 -#define _loop1_97_type 1355 -#define _tmp_98_type 1356 -#define _loop0_99_type 1357 -#define _gather_100_type 1358 -#define _loop0_101_type 1359 -#define _gather_102_type 1360 -#define _tmp_103_type 1361 -#define _tmp_104_type 1362 -#define _loop0_105_type 1363 -#define _gather_106_type 1364 -#define _tmp_107_type 1365 -#define _tmp_108_type 1366 -#define _tmp_109_type 1367 -#define _tmp_110_type 1368 -#define _tmp_111_type 1369 -#define _loop1_112_type 1370 -#define _tmp_113_type 1371 -#define _tmp_114_type 1372 -#define _tmp_115_type 1373 -#define _tmp_116_type 1374 -#define _tmp_117_type 1375 -#define _loop0_118_type 1376 -#define _loop0_119_type 1377 -#define _tmp_120_type 1378 -#define _tmp_121_type 1379 -#define _tmp_122_type 1380 -#define _tmp_123_type 1381 -#define _tmp_124_type 1382 -#define _tmp_125_type 1383 -#define _tmp_126_type 1384 -#define _tmp_127_type 1385 -#define _tmp_128_type 1386 -#define _loop0_129_type 1387 -#define _gather_130_type 1388 -#define _tmp_131_type 1389 -#define _tmp_132_type 1390 -#define _tmp_133_type 1391 -#define _tmp_134_type 1392 -#define _loop0_135_type 1393 -#define _gather_136_type 1394 -#define _loop0_137_type 1395 -#define _gather_138_type 1396 -#define _loop0_139_type 1397 -#define _gather_140_type 1398 -#define _tmp_141_type 1399 -#define _loop0_142_type 1400 -#define _tmp_143_type 1401 -#define _tmp_144_type 1402 -#define _tmp_145_type 1403 -#define _tmp_146_type 1404 -#define _tmp_147_type 1405 -#define _tmp_148_type 1406 -#define _tmp_149_type 1407 -#define _tmp_150_type 1408 -#define _tmp_151_type 1409 -#define _tmp_152_type 1410 -#define _tmp_153_type 1411 -#define _tmp_154_type 1412 -#define _tmp_155_type 1413 -#define _tmp_156_type 1414 -#define _tmp_157_type 1415 -#define _tmp_158_type 1416 -#define _tmp_159_type 1417 -#define _tmp_160_type 1418 -#define _tmp_161_type 1419 -#define _tmp_162_type 1420 -#define _tmp_163_type 1421 -#define _tmp_164_type 1422 -#define _tmp_165_type 1423 -#define _tmp_166_type 1424 -#define _tmp_167_type 1425 -#define _tmp_168_type 1426 -#define _loop0_169_type 1427 -#define _tmp_170_type 1428 -#define _tmp_171_type 1429 -#define _tmp_172_type 1430 -#define _tmp_173_type 1431 +#define tstring_format_spec_replacement_field_type 1162 +#define tstring_format_spec_type 1163 +#define tstring_full_format_spec_type 1164 +#define tstring_replacement_field_type 1165 +#define tstring_middle_type 1166 +#define tstring_type 1167 +#define string_type 1168 +#define strings_type 1169 +#define list_type 1170 +#define tuple_type 1171 +#define set_type 1172 +#define dict_type 1173 +#define double_starred_kvpairs_type 1174 +#define double_starred_kvpair_type 1175 +#define kvpair_type 1176 +#define for_if_clauses_type 1177 +#define for_if_clause_type 1178 +#define listcomp_type 1179 +#define setcomp_type 1180 +#define genexp_type 1181 +#define dictcomp_type 1182 +#define arguments_type 1183 +#define args_type 1184 +#define kwargs_type 1185 +#define starred_expression_type 1186 +#define kwarg_or_starred_type 1187 +#define kwarg_or_double_starred_type 1188 +#define star_targets_type 1189 +#define star_targets_list_seq_type 1190 +#define star_targets_tuple_seq_type 1191 +#define star_target_type 1192 +#define target_with_star_atom_type 1193 +#define star_atom_type 1194 +#define single_target_type 1195 +#define single_subscript_attribute_target_type 1196 +#define t_primary_type 1197 // Left-recursive +#define t_lookahead_type 1198 +#define del_targets_type 1199 +#define del_target_type 1200 +#define del_t_atom_type 1201 +#define type_expressions_type 1202 +#define func_type_comment_type 1203 +#define invalid_arguments_type 1204 +#define invalid_kwarg_type 1205 +#define expression_without_invalid_type 1206 +#define invalid_legacy_expression_type 1207 +#define invalid_type_param_type 1208 +#define invalid_expression_type 1209 +#define invalid_named_expression_type 1210 +#define invalid_assignment_type 1211 +#define invalid_ann_assign_target_type 1212 +#define invalid_del_stmt_type 1213 +#define invalid_block_type 1214 +#define invalid_comprehension_type 1215 +#define invalid_dict_comprehension_type 1216 +#define invalid_parameters_type 1217 +#define invalid_default_type 1218 +#define invalid_star_etc_type 1219 +#define invalid_kwds_type 1220 +#define invalid_parameters_helper_type 1221 +#define invalid_lambda_parameters_type 1222 +#define invalid_lambda_parameters_helper_type 1223 +#define invalid_lambda_star_etc_type 1224 +#define invalid_lambda_kwds_type 1225 +#define invalid_double_type_comments_type 1226 +#define invalid_with_item_type 1227 +#define invalid_for_if_clause_type 1228 +#define invalid_for_target_type 1229 +#define invalid_group_type 1230 +#define invalid_import_type 1231 +#define invalid_import_from_targets_type 1232 +#define invalid_with_stmt_type 1233 +#define invalid_with_stmt_indent_type 1234 +#define invalid_try_stmt_type 1235 +#define invalid_except_stmt_type 1236 +#define invalid_except_star_stmt_type 1237 +#define invalid_finally_stmt_type 1238 +#define invalid_except_stmt_indent_type 1239 +#define invalid_except_star_stmt_indent_type 1240 +#define invalid_match_stmt_type 1241 +#define invalid_case_block_type 1242 +#define invalid_as_pattern_type 1243 +#define invalid_class_pattern_type 1244 +#define invalid_class_argument_pattern_type 1245 +#define invalid_if_stmt_type 1246 +#define invalid_elif_stmt_type 1247 +#define invalid_else_stmt_type 1248 +#define invalid_while_stmt_type 1249 +#define invalid_for_stmt_type 1250 +#define invalid_def_raw_type 1251 +#define invalid_class_def_raw_type 1252 +#define invalid_double_starred_kvpairs_type 1253 +#define invalid_kvpair_type 1254 +#define invalid_starred_expression_unpacking_type 1255 +#define invalid_starred_expression_type 1256 +#define invalid_fstring_replacement_field_type 1257 +#define invalid_fstring_conversion_character_type 1258 +#define invalid_tstring_replacement_field_type 1259 +#define invalid_tstring_conversion_character_type 1260 +#define invalid_arithmetic_type 1261 +#define invalid_factor_type 1262 +#define invalid_type_params_type 1263 +#define _loop0_1_type 1264 +#define _loop1_2_type 1265 +#define _loop0_3_type 1266 +#define _gather_4_type 1267 +#define _tmp_5_type 1268 +#define _tmp_6_type 1269 +#define _tmp_7_type 1270 +#define _tmp_8_type 1271 +#define _tmp_9_type 1272 +#define _tmp_10_type 1273 +#define _tmp_11_type 1274 +#define _loop1_12_type 1275 +#define _tmp_13_type 1276 +#define _loop0_14_type 1277 +#define _gather_15_type 1278 +#define _tmp_16_type 1279 +#define _tmp_17_type 1280 +#define _loop0_18_type 1281 +#define _loop1_19_type 1282 +#define _loop0_20_type 1283 +#define _gather_21_type 1284 +#define _tmp_22_type 1285 +#define _loop0_23_type 1286 +#define _gather_24_type 1287 +#define _loop1_25_type 1288 +#define _tmp_26_type 1289 +#define _tmp_27_type 1290 +#define _loop0_28_type 1291 +#define _loop0_29_type 1292 +#define _loop1_30_type 1293 +#define _loop1_31_type 1294 +#define _loop0_32_type 1295 +#define _loop1_33_type 1296 +#define _loop0_34_type 1297 +#define _gather_35_type 1298 +#define _tmp_36_type 1299 +#define _loop1_37_type 1300 +#define _loop1_38_type 1301 +#define _loop1_39_type 1302 +#define _loop0_40_type 1303 +#define _gather_41_type 1304 +#define _tmp_42_type 1305 +#define _tmp_43_type 1306 +#define _tmp_44_type 1307 +#define _loop0_45_type 1308 +#define _gather_46_type 1309 +#define _loop0_47_type 1310 +#define _gather_48_type 1311 +#define _tmp_49_type 1312 +#define _loop0_50_type 1313 +#define _gather_51_type 1314 +#define _loop0_52_type 1315 +#define _gather_53_type 1316 +#define _loop0_54_type 1317 +#define _gather_55_type 1318 +#define _loop1_56_type 1319 +#define _loop1_57_type 1320 +#define _loop0_58_type 1321 +#define _gather_59_type 1322 +#define _loop1_60_type 1323 +#define _loop1_61_type 1324 +#define _loop1_62_type 1325 +#define _tmp_63_type 1326 +#define _loop0_64_type 1327 +#define _gather_65_type 1328 +#define _tmp_66_type 1329 +#define _tmp_67_type 1330 +#define _tmp_68_type 1331 +#define _tmp_69_type 1332 +#define _tmp_70_type 1333 +#define _loop0_71_type 1334 +#define _loop0_72_type 1335 +#define _loop1_73_type 1336 +#define _loop1_74_type 1337 +#define _loop0_75_type 1338 +#define _loop1_76_type 1339 +#define _loop0_77_type 1340 +#define _loop0_78_type 1341 +#define _loop0_79_type 1342 +#define _loop0_80_type 1343 +#define _loop1_81_type 1344 +#define _tmp_82_type 1345 +#define _loop0_83_type 1346 +#define _gather_84_type 1347 +#define _loop1_85_type 1348 +#define _loop0_86_type 1349 +#define _tmp_87_type 1350 +#define _loop0_88_type 1351 +#define _gather_89_type 1352 +#define _tmp_90_type 1353 +#define _loop0_91_type 1354 +#define _gather_92_type 1355 +#define _loop0_93_type 1356 +#define _gather_94_type 1357 +#define _loop0_95_type 1358 +#define _loop0_96_type 1359 +#define _gather_97_type 1360 +#define _loop1_98_type 1361 +#define _tmp_99_type 1362 +#define _loop0_100_type 1363 +#define _gather_101_type 1364 +#define _loop0_102_type 1365 +#define _gather_103_type 1366 +#define _tmp_104_type 1367 +#define _tmp_105_type 1368 +#define _loop0_106_type 1369 +#define _gather_107_type 1370 +#define _tmp_108_type 1371 +#define _tmp_109_type 1372 +#define _tmp_110_type 1373 +#define _tmp_111_type 1374 +#define _tmp_112_type 1375 +#define _loop1_113_type 1376 +#define _tmp_114_type 1377 +#define _tmp_115_type 1378 +#define _tmp_116_type 1379 +#define _tmp_117_type 1380 +#define _tmp_118_type 1381 +#define _loop0_119_type 1382 +#define _loop0_120_type 1383 +#define _tmp_121_type 1384 +#define _tmp_122_type 1385 +#define _tmp_123_type 1386 +#define _tmp_124_type 1387 +#define _tmp_125_type 1388 +#define _tmp_126_type 1389 +#define _tmp_127_type 1390 +#define _tmp_128_type 1391 +#define _tmp_129_type 1392 +#define _loop0_130_type 1393 +#define _gather_131_type 1394 +#define _tmp_132_type 1395 +#define _tmp_133_type 1396 +#define _tmp_134_type 1397 +#define _tmp_135_type 1398 +#define _loop0_136_type 1399 +#define _gather_137_type 1400 +#define _loop0_138_type 1401 +#define _gather_139_type 1402 +#define _loop0_140_type 1403 +#define _gather_141_type 1404 +#define _tmp_142_type 1405 +#define _loop0_143_type 1406 +#define _tmp_144_type 1407 +#define _tmp_145_type 1408 +#define _tmp_146_type 1409 +#define _tmp_147_type 1410 +#define _tmp_148_type 1411 +#define _tmp_149_type 1412 +#define _tmp_150_type 1413 +#define _tmp_151_type 1414 +#define _tmp_152_type 1415 +#define _tmp_153_type 1416 +#define _tmp_154_type 1417 +#define _tmp_155_type 1418 +#define _tmp_156_type 1419 +#define _tmp_157_type 1420 +#define _tmp_158_type 1421 +#define _tmp_159_type 1422 +#define _tmp_160_type 1423 +#define _tmp_161_type 1424 +#define _tmp_162_type 1425 +#define _tmp_163_type 1426 +#define _tmp_164_type 1427 +#define _tmp_165_type 1428 +#define _tmp_166_type 1429 +#define _tmp_167_type 1430 +#define _tmp_168_type 1431 +#define _tmp_169_type 1432 +#define _loop0_170_type 1433 +#define _tmp_171_type 1434 +#define _tmp_172_type 1435 +#define _tmp_173_type 1436 +#define _tmp_174_type 1437 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -679,6 +685,9 @@ static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p); static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p); static expr_ty fstring_format_spec_rule(Parser *p); static expr_ty fstring_rule(Parser *p); +static expr_ty tstring_format_spec_replacement_field_rule(Parser *p); +static expr_ty tstring_format_spec_rule(Parser *p); +static ResultTokenWithMetadata* tstring_full_format_spec_rule(Parser *p); static expr_ty tstring_replacement_field_rule(Parser *p); static expr_ty tstring_middle_rule(Parser *p); static expr_ty tstring_rule(Parser *p); @@ -771,8 +780,10 @@ static void *invalid_double_starred_kvpairs_rule(Parser *p); static void *invalid_kvpair_rule(Parser *p); static void *invalid_starred_expression_unpacking_rule(Parser *p); static void *invalid_starred_expression_rule(Parser *p); -static void *invalid_replacement_field_rule(Parser *p); -static void *invalid_conversion_character_rule(Parser *p); +static void *invalid_fstring_replacement_field_rule(Parser *p); +static void *invalid_fstring_conversion_character_rule(Parser *p); +static void *invalid_tstring_replacement_field_rule(Parser *p); +static void *invalid_tstring_conversion_character_rule(Parser *p); static void *invalid_arithmetic_rule(Parser *p); static void *invalid_factor_rule(Parser *p); static void *invalid_type_params_rule(Parser *p); @@ -855,47 +866,47 @@ static asdl_seq *_loop1_76_rule(Parser *p); static asdl_seq *_loop0_77_rule(Parser *p); static asdl_seq *_loop0_78_rule(Parser *p); static asdl_seq *_loop0_79_rule(Parser *p); -static asdl_seq *_loop1_80_rule(Parser *p); -static void *_tmp_81_rule(Parser *p); -static asdl_seq *_loop0_82_rule(Parser *p); -static asdl_seq *_gather_83_rule(Parser *p); -static asdl_seq *_loop1_84_rule(Parser *p); -static asdl_seq *_loop0_85_rule(Parser *p); -static void *_tmp_86_rule(Parser *p); -static asdl_seq *_loop0_87_rule(Parser *p); -static asdl_seq *_gather_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 asdl_seq *_loop0_92_rule(Parser *p); -static asdl_seq *_gather_93_rule(Parser *p); -static asdl_seq *_loop0_94_rule(Parser *p); +static asdl_seq *_loop0_80_rule(Parser *p); +static asdl_seq *_loop1_81_rule(Parser *p); +static void *_tmp_82_rule(Parser *p); +static asdl_seq *_loop0_83_rule(Parser *p); +static asdl_seq *_gather_84_rule(Parser *p); +static asdl_seq *_loop1_85_rule(Parser *p); +static asdl_seq *_loop0_86_rule(Parser *p); +static void *_tmp_87_rule(Parser *p); +static asdl_seq *_loop0_88_rule(Parser *p); +static asdl_seq *_gather_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 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 *_loop1_97_rule(Parser *p); -static void *_tmp_98_rule(Parser *p); -static asdl_seq *_loop0_99_rule(Parser *p); -static asdl_seq *_gather_100_rule(Parser *p); -static asdl_seq *_loop0_101_rule(Parser *p); -static asdl_seq *_gather_102_rule(Parser *p); -static void *_tmp_103_rule(Parser *p); +static asdl_seq *_loop0_96_rule(Parser *p); +static asdl_seq *_gather_97_rule(Parser *p); +static asdl_seq *_loop1_98_rule(Parser *p); +static void *_tmp_99_rule(Parser *p); +static asdl_seq *_loop0_100_rule(Parser *p); +static asdl_seq *_gather_101_rule(Parser *p); +static asdl_seq *_loop0_102_rule(Parser *p); +static asdl_seq *_gather_103_rule(Parser *p); static void *_tmp_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 void *_tmp_105_rule(Parser *p); +static asdl_seq *_loop0_106_rule(Parser *p); +static asdl_seq *_gather_107_rule(Parser *p); static void *_tmp_108_rule(Parser *p); static void *_tmp_109_rule(Parser *p); static void *_tmp_110_rule(Parser *p); static void *_tmp_111_rule(Parser *p); -static asdl_seq *_loop1_112_rule(Parser *p); -static void *_tmp_113_rule(Parser *p); +static void *_tmp_112_rule(Parser *p); +static asdl_seq *_loop1_113_rule(Parser *p); static void *_tmp_114_rule(Parser *p); static void *_tmp_115_rule(Parser *p); static void *_tmp_116_rule(Parser *p); static void *_tmp_117_rule(Parser *p); -static asdl_seq *_loop0_118_rule(Parser *p); +static void *_tmp_118_rule(Parser *p); static asdl_seq *_loop0_119_rule(Parser *p); -static void *_tmp_120_rule(Parser *p); +static asdl_seq *_loop0_120_rule(Parser *p); static void *_tmp_121_rule(Parser *p); static void *_tmp_122_rule(Parser *p); static void *_tmp_123_rule(Parser *p); @@ -904,21 +915,21 @@ static void *_tmp_125_rule(Parser *p); static void *_tmp_126_rule(Parser *p); static void *_tmp_127_rule(Parser *p); static void *_tmp_128_rule(Parser *p); -static asdl_seq *_loop0_129_rule(Parser *p); -static asdl_seq *_gather_130_rule(Parser *p); -static void *_tmp_131_rule(Parser *p); +static void *_tmp_129_rule(Parser *p); +static asdl_seq *_loop0_130_rule(Parser *p); +static asdl_seq *_gather_131_rule(Parser *p); static void *_tmp_132_rule(Parser *p); static void *_tmp_133_rule(Parser *p); static void *_tmp_134_rule(Parser *p); -static asdl_seq *_loop0_135_rule(Parser *p); -static asdl_seq *_gather_136_rule(Parser *p); -static asdl_seq *_loop0_137_rule(Parser *p); -static asdl_seq *_gather_138_rule(Parser *p); -static asdl_seq *_loop0_139_rule(Parser *p); -static asdl_seq *_gather_140_rule(Parser *p); -static void *_tmp_141_rule(Parser *p); -static asdl_seq *_loop0_142_rule(Parser *p); -static void *_tmp_143_rule(Parser *p); +static void *_tmp_135_rule(Parser *p); +static asdl_seq *_loop0_136_rule(Parser *p); +static asdl_seq *_gather_137_rule(Parser *p); +static asdl_seq *_loop0_138_rule(Parser *p); +static asdl_seq *_gather_139_rule(Parser *p); +static asdl_seq *_loop0_140_rule(Parser *p); +static asdl_seq *_gather_141_rule(Parser *p); +static void *_tmp_142_rule(Parser *p); +static asdl_seq *_loop0_143_rule(Parser *p); static void *_tmp_144_rule(Parser *p); static void *_tmp_145_rule(Parser *p); static void *_tmp_146_rule(Parser *p); @@ -944,11 +955,12 @@ static void *_tmp_165_rule(Parser *p); static void *_tmp_166_rule(Parser *p); static void *_tmp_167_rule(Parser *p); static void *_tmp_168_rule(Parser *p); -static asdl_seq *_loop0_169_rule(Parser *p); -static void *_tmp_170_rule(Parser *p); +static void *_tmp_169_rule(Parser *p); +static asdl_seq *_loop0_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 void *_tmp_174_rule(Parser *p); // file: statements? $ @@ -16070,7 +16082,7 @@ fstring_middle_rule(Parser *p) // fstring_replacement_field: // | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' -// | invalid_replacement_field +// | invalid_fstring_replacement_field static expr_ty fstring_replacement_field_rule(Parser *p) { @@ -16140,24 +16152,24 @@ fstring_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c%s fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); } - if (p->call_invalid_rules) { // invalid_replacement_field + if (p->call_invalid_rules) { // invalid_fstring_replacement_field if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); - void *invalid_replacement_field_var; + D(fprintf(stderr, "%*c> fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_fstring_replacement_field")); + void *invalid_fstring_replacement_field_var; if ( - (invalid_replacement_field_var = invalid_replacement_field_rule(p)) // invalid_replacement_field + (invalid_fstring_replacement_field_var = invalid_fstring_replacement_field_rule(p)) // invalid_fstring_replacement_field ) { - D(fprintf(stderr, "%*c+ fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); - _res = invalid_replacement_field_var; + D(fprintf(stderr, "%*c+ fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_fstring_replacement_field")); + _res = invalid_fstring_replacement_field_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_replacement_field")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_fstring_replacement_field")); } _res = NULL; done: @@ -16386,9 +16398,232 @@ fstring_rule(Parser *p) return _res; } +// tstring_format_spec_replacement_field: +// | '{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}' +// | invalid_tstring_replacement_field +static expr_ty +tstring_format_spec_replacement_field_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 + { // '{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_format_spec_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}'")); + Token * _literal; + expr_ty a; + void *conversion; + void *debug_expr; + void *format; + Token * rbrace; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = annotated_rhs_rule(p)) // annotated_rhs + && + (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (conversion = fstring_conversion_rule(p), !p->error_indicator) // fstring_conversion? + && + (format = tstring_full_format_spec_rule(p), !p->error_indicator) // tstring_full_format_spec? + && + (rbrace = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ tstring_format_spec_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}'")); + 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 = _PyPegen_formatted_value ( p , a , debug_expr , conversion , format , rbrace , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_format_spec_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}'")); + } + if (p->call_invalid_rules) { // invalid_tstring_replacement_field + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_format_spec_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_tstring_replacement_field")); + void *invalid_tstring_replacement_field_var; + if ( + (invalid_tstring_replacement_field_var = invalid_tstring_replacement_field_rule(p)) // invalid_tstring_replacement_field + ) + { + D(fprintf(stderr, "%*c+ tstring_format_spec_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_tstring_replacement_field")); + _res = invalid_tstring_replacement_field_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_format_spec_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_tstring_replacement_field")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// tstring_format_spec: FSTRING_MIDDLE | tstring_format_spec_replacement_field +static expr_ty +tstring_format_spec_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; + { // FSTRING_MIDDLE + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + Token * t; + if ( + (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' + ) + { + D(fprintf(stderr, "%*c+ tstring_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + _res = _PyPegen_decoded_constant_from_token ( p , t ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); + } + { // tstring_format_spec_replacement_field + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec_replacement_field")); + expr_ty tstring_format_spec_replacement_field_var; + if ( + (tstring_format_spec_replacement_field_var = tstring_format_spec_replacement_field_rule(p)) // tstring_format_spec_replacement_field + ) + { + D(fprintf(stderr, "%*c+ tstring_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring_format_spec_replacement_field")); + _res = tstring_format_spec_replacement_field_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_format_spec_replacement_field")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// tstring_full_format_spec: ':' tstring_format_spec* +static ResultTokenWithMetadata* +tstring_full_format_spec_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + ResultTokenWithMetadata* _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 + { // ':' tstring_format_spec* + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> tstring_full_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' tstring_format_spec*")); + Token * colon; + asdl_seq * spec; + if ( + (colon = _PyPegen_expect_token(p, 11)) // token=':' + && + (spec = _loop0_79_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*")); + 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 = _PyPegen_setup_full_format_spec ( p , colon , ( asdl_expr_seq* ) spec , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s tstring_full_format_spec[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' tstring_format_spec*")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // tstring_replacement_field: -// | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' -// | invalid_replacement_field +// | '{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}' +// | invalid_tstring_replacement_field static expr_ty tstring_replacement_field_rule(Parser *p) { @@ -16410,12 +16645,12 @@ tstring_replacement_field_rule(Parser *p) 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 - { // '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}' + { // '{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}'")); Token * _literal; expr_ty a; void *conversion; @@ -16431,12 +16666,12 @@ tstring_replacement_field_rule(Parser *p) && (conversion = fstring_conversion_rule(p), !p->error_indicator) // fstring_conversion? && - (format = fstring_full_format_spec_rule(p), !p->error_indicator) // fstring_full_format_spec? + (format = tstring_full_format_spec_rule(p), !p->error_indicator) // tstring_full_format_spec? && (rbrace = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -16456,26 +16691,26 @@ tstring_replacement_field_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? tstring_full_format_spec? '}'")); } - if (p->call_invalid_rules) { // invalid_replacement_field + if (p->call_invalid_rules) { // invalid_tstring_replacement_field if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); - void *invalid_replacement_field_var; + D(fprintf(stderr, "%*c> tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_tstring_replacement_field")); + void *invalid_tstring_replacement_field_var; if ( - (invalid_replacement_field_var = invalid_replacement_field_rule(p)) // invalid_replacement_field + (invalid_tstring_replacement_field_var = invalid_tstring_replacement_field_rule(p)) // invalid_tstring_replacement_field ) { - D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field")); - _res = invalid_replacement_field_var; + D(fprintf(stderr, "%*c+ tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_tstring_replacement_field")); + _res = invalid_tstring_replacement_field_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_replacement_field")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_tstring_replacement_field")); } _res = NULL; done: @@ -16574,7 +16809,7 @@ tstring_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' && - (b = _loop0_79_rule(p)) // tstring_middle* + (b = _loop0_80_rule(p)) // tstring_middle* && (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' ) @@ -16676,7 +16911,7 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((fstring | string | tstring))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_80_rule(p)) // ((fstring | string | tstring))+ + (a = (asdl_expr_seq*)_loop1_81_rule(p)) // ((fstring | string | tstring))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string | tstring))+")); @@ -16809,7 +17044,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_81_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_82_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -17024,7 +17259,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_83_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_84_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -17183,7 +17418,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_84_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_85_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+")); @@ -17248,7 +17483,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_85_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_86_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))*")); @@ -17291,7 +17526,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_85_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_86_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))*")); @@ -17570,7 +17805,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_86_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_87_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -17819,9 +18054,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_89_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_89_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_90_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]")); @@ -17911,11 +18146,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_91_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_92_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_93_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_94_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+")); @@ -17937,13 +18172,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_91_var; + asdl_seq * _gather_92_var; if ( - (_gather_91_var = _gather_91_rule(p)) // ','.kwarg_or_starred+ + (_gather_92_var = _gather_92_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_91_var; + _res = _gather_92_var; goto done; } p->mark = _mark; @@ -17956,13 +18191,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_93_var; + asdl_seq * _gather_94_var; if ( - (_gather_93_var = _gather_93_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_94_var = _gather_94_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_93_var; + _res = _gather_94_var; goto done; } p->mark = _mark; @@ -18373,7 +18608,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_94_rule(p)) // ((',' star_target))* + (b = _loop0_95_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18429,7 +18664,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_96_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_97_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18479,7 +18714,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_97_rule(p)) // ((',' star_target))+ + (b = _loop1_98_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18567,7 +18802,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_98_rule(p)) // !'*' star_target + (a = _tmp_99_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); @@ -19490,7 +19725,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_100_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_101_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19848,7 +20083,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_102_rule(p)) // ','.expression+ + (a = _gather_103_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19887,7 +20122,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_102_rule(p)) // ','.expression+ + (a = _gather_103_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -19920,7 +20155,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_102_rule(p)) // ','.expression+ + (a = _gather_103_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20040,7 +20275,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_102_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_103_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); @@ -20091,7 +20326,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_103_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_104_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -20177,15 +20412,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_106_var; - void *_tmp_104_var; + asdl_seq * _gather_107_var; + void *_tmp_105_var; Token * a; if ( - (_tmp_104_var = _tmp_104_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs + (_tmp_105_var = _tmp_105_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs && (a = _PyPegen_expect_token(p, 12)) // token=',' && - (_gather_106_var = _gather_106_rule(p)) // ','.(starred_expression !'=')+ + (_gather_107_var = _gather_107_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 !'=')+")); @@ -20219,7 +20454,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_107_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_108_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]")); @@ -20279,13 +20514,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_108_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_109_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_109_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_110_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); @@ -20423,7 +20658,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_110_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_111_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -20483,7 +20718,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_111_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_112_rule, p) && (a = expression_rule(p)) // expression && @@ -20830,7 +21065,7 @@ invalid_expression_rule(Parser *p) if ( (string_var = _PyPegen_string_token(p)) // STRING && - (a = _loop1_112_rule(p)) // ((!STRING expression_without_invalid))+ + (a = _loop1_113_rule(p)) // ((!STRING expression_without_invalid))+ && (string_var_1 = _PyPegen_string_token(p)) // STRING ) @@ -20857,7 +21092,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_113_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -20893,7 +21128,7 @@ invalid_expression_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_114_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_115_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); @@ -20956,7 +21191,7 @@ invalid_expression_rule(Parser *p) expr_ty b; stmt_ty c; if ( - (a = (stmt_ty)_tmp_115_rule(p)) // pass_stmt | break_stmt | continue_stmt + (a = (stmt_ty)_tmp_116_rule(p)) // pass_stmt | break_stmt | continue_stmt && (_keyword = _PyPegen_expect_token(p, 677)) // token='if' && @@ -21085,7 +21320,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_116_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_117_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); @@ -21111,7 +21346,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_117_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_118_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -21119,7 +21354,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_116_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_117_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 !('=' | ':=')")); @@ -21199,7 +21434,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_118_var; + asdl_seq * _loop0_119_var; expr_ty a; expr_ty expression_var; if ( @@ -21207,7 +21442,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_118_var = _loop0_118_rule(p)) // star_named_expressions* + (_loop0_119_var = _loop0_119_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -21264,10 +21499,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_119_var; + asdl_seq * _loop0_120_var; expr_ty a; if ( - (_loop0_119_var = _loop0_119_rule(p)) // ((star_targets '='))* + (_loop0_120_var = _loop0_120_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -21294,10 +21529,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_119_var; + asdl_seq * _loop0_120_var; expr_ty a; if ( - (_loop0_119_var = _loop0_119_rule(p)) // ((star_targets '='))* + (_loop0_120_var = _loop0_120_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -21553,11 +21788,11 @@ invalid_comprehension_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); - void *_tmp_120_var; + void *_tmp_121_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_120_var = _tmp_120_rule(p)) // '[' | '(' | '{' + (_tmp_121_var = _tmp_121_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -21584,12 +21819,12 @@ invalid_comprehension_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); Token * _literal; - void *_tmp_121_var; + void *_tmp_122_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_121_var = _tmp_121_rule(p)) // '[' | '{' + (_tmp_122_var = _tmp_122_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21619,12 +21854,12 @@ invalid_comprehension_rule(Parser *p) 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_121_var; + void *_tmp_122_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_121_var = _tmp_121_rule(p)) // '[' | '{' + (_tmp_122_var = _tmp_122_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -21760,10 +21995,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_32_var; - void *_tmp_122_var; + void *_tmp_123_var; Token * a; if ( - (_tmp_122_var = _tmp_122_rule(p)) // slash_no_default | slash_with_default + (_tmp_123_var = _tmp_123_rule(p)) // slash_no_default | slash_with_default && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && @@ -21865,16 +22100,16 @@ invalid_parameters_rule(Parser *p) asdl_seq * _loop0_32_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_123_var; + void *_tmp_124_var; Token * a; if ( - (_opt_var = _tmp_122_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_123_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_123_var = _tmp_123_rule(p)) // ',' | param_no_default + (_tmp_124_var = _tmp_124_rule(p)) // ',' | param_no_default && (_loop0_32_var_1 = _loop0_32_rule(p)) // param_maybe_default* && @@ -21953,7 +22188,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_124_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_125_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); @@ -21998,12 +22233,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_125_var; + void *_tmp_126_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_125_var = _tmp_125_rule(p)) // ')' | ',' (')' | '**') + (_tmp_126_var = _tmp_126_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); @@ -22087,19 +22322,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_32_var; - void *_tmp_126_var; - void *_tmp_126_var_1; + void *_tmp_127_var; + void *_tmp_127_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_126_var = _tmp_126_rule(p)) // param_no_default | ',' + (_tmp_127_var = _tmp_127_rule(p)) // param_no_default | ',' && (_loop0_32_var = _loop0_32_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_126_var_1 = _tmp_126_rule(p)) // param_no_default | ',' + (_tmp_127_var_1 = _tmp_127_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 | ',')")); @@ -22214,7 +22449,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_127_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_128_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); @@ -22351,10 +22586,10 @@ 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* '/'")); asdl_seq * _loop0_75_var; - void *_tmp_128_var; + void *_tmp_129_var; Token * a; if ( - (_tmp_128_var = _tmp_128_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_129_var = _tmp_129_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -22414,7 +22649,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_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_130_var; + asdl_seq * _gather_131_var; asdl_seq * _loop0_71_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -22425,7 +22660,7 @@ invalid_lambda_parameters_rule(Parser *p) && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_130_var = _gather_130_rule(p)) // ','.lambda_param+ + (_gather_131_var = _gather_131_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -22456,16 +22691,16 @@ invalid_lambda_parameters_rule(Parser *p) asdl_seq * _loop0_75_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_131_var; + void *_tmp_132_var; Token * a; if ( - (_opt_var = _tmp_128_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_129_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && (_loop0_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_131_var = _tmp_131_rule(p)) // ',' | lambda_param_no_default + (_tmp_132_var = _tmp_132_rule(p)) // ',' | lambda_param_no_default && (_loop0_75_var_1 = _loop0_75_rule(p)) // lambda_param_maybe_default* && @@ -22608,11 +22843,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_132_var; + void *_tmp_133_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_132_var = _tmp_132_rule(p)) // ':' | ',' (':' | '**') + (_tmp_133_var = _tmp_133_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); @@ -22666,19 +22901,19 @@ 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_75_var; - void *_tmp_133_var; - void *_tmp_133_var_1; + void *_tmp_134_var; + void *_tmp_134_var_1; Token * a; if ( (_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_75_var = _loop0_75_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_133_var_1 = _tmp_133_rule(p)) // lambda_param_no_default | ',' + (_tmp_134_var_1 = _tmp_134_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 | ',')")); @@ -22796,7 +23031,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_127_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_128_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -22946,13 +23181,13 @@ invalid_for_if_clause_rule(Parser *p) Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_134_var; + void *_tmp_135_var; if ( (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? && (_keyword = _PyPegen_expect_token(p, 687)) // token='for' && - (_tmp_134_var = _tmp_134_rule(p)) // bitwise_or ((',' bitwise_or))* ','? + (_tmp_135_var = _tmp_135_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 688) // token='in' ) @@ -23127,14 +23362,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_136_var; + asdl_seq * _gather_137_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( (a = _PyPegen_expect_token(p, 631)) // token='import' && - (_gather_136_var = _gather_136_rule(p)) // ','.dotted_name+ + (_gather_137_var = _gather_137_rule(p)) // ','.dotted_name+ && (_keyword = _PyPegen_expect_token(p, 630)) // token='from' && @@ -23281,7 +23516,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_138_var; + asdl_seq * _gather_139_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23291,7 +23526,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 642)) // token='with' && - (_gather_138_var = _gather_138_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_139_var = _gather_139_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -23315,7 +23550,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_140_var; + asdl_seq * _gather_141_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -23331,7 +23566,7 @@ invalid_with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_140_var = _gather_140_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_141_var = _gather_141_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23380,7 +23615,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_138_var; + asdl_seq * _gather_139_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23391,7 +23626,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (a = _PyPegen_expect_token(p, 642)) // token='with' && - (_gather_138_var = _gather_138_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_139_var = _gather_139_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -23419,7 +23654,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_140_var; + asdl_seq * _gather_141_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -23436,7 +23671,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_140_var = _gather_140_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_141_var = _gather_141_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23533,7 +23768,7 @@ invalid_try_stmt_rule(Parser *p) && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_141_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_142_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); @@ -23558,7 +23793,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_142_var; + asdl_seq * _loop0_143_var; asdl_seq * _loop1_37_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23570,7 +23805,7 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_142_var = _loop0_142_rule(p)) // block* + (_loop0_143_var = _loop0_143_rule(p)) // block* && (_loop1_37_var = _loop1_37_rule(p)) // except_block+ && @@ -23607,7 +23842,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_142_var; + asdl_seq * _loop0_143_var; asdl_seq * _loop1_38_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -23617,13 +23852,13 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_142_var = _loop0_142_rule(p)) // block* + (_loop0_143_var = _loop0_143_rule(p)) // block* && (_loop1_38_var = _loop1_38_rule(p)) // except_star_block+ && (a = _PyPegen_expect_token(p, 672)) // token='except' && - (_opt_var = _tmp_143_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_144_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -23912,14 +24147,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_144_var; + void *_tmp_145_var; Token * a; if ( (a = _PyPegen_expect_token(p, 672)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_144_var = _tmp_144_rule(p)) // NEWLINE | ':' + (_tmp_145_var = _tmp_145_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_star_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); @@ -24516,7 +24751,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_145_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_146_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -25215,11 +25450,11 @@ 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")); - asdl_seq * _gather_83_var; + asdl_seq * _gather_84_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_83_var = _gather_83_rule(p)) // ','.double_starred_kvpair+ + (_gather_84_var = _gather_84_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -25227,7 +25462,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); - _res = _PyPegen_dummy_name(p, _gather_83_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_84_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -25280,7 +25515,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_146_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_147_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -25390,7 +25625,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_146_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_147_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -25507,7 +25742,7 @@ invalid_starred_expression_rule(Parser *p) return _res; } -// invalid_replacement_field: +// invalid_fstring_replacement_field: // | '{' '=' // | '{' '!' // | '{' ':' @@ -25515,12 +25750,12 @@ invalid_starred_expression_rule(Parser *p) // | '{' !annotated_rhs // | '{' annotated_rhs !('=' | '!' | ':' | '}') // | '{' annotated_rhs '=' !('!' | ':' | '}') -// | '{' annotated_rhs '='? invalid_conversion_character +// | '{' annotated_rhs '='? invalid_fstring_conversion_character // | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') // | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' // | '{' annotated_rhs '='? ['!' NAME] !'}' static void * -invalid_replacement_field_rule(Parser *p) +invalid_fstring_replacement_field_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -25536,7 +25771,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '='")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '='")); Token * _literal; Token * a; if ( @@ -25545,8 +25780,8 @@ invalid_replacement_field_rule(Parser *p) (a = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '='")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before '='" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '='")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '='" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25555,7 +25790,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '='")); } { // '{' '!' @@ -25563,7 +25798,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '!'")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '!'")); Token * _literal; Token * a; if ( @@ -25572,8 +25807,8 @@ invalid_replacement_field_rule(Parser *p) (a = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '!'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before '!'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '!'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '!'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25582,7 +25817,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '!'")); } { // '{' ':' @@ -25590,7 +25825,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' ':'")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' ':'")); Token * _literal; Token * a; if ( @@ -25599,8 +25834,8 @@ invalid_replacement_field_rule(Parser *p) (a = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' ':'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before ':'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' ':'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before ':'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25609,7 +25844,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' ':'")); } { // '{' '}' @@ -25617,7 +25852,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'")); Token * _literal; Token * a; if ( @@ -25626,8 +25861,8 @@ invalid_replacement_field_rule(Parser *p) (a = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "%c-string: valid expression required before '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '}'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25636,7 +25871,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'")); } { // '{' !annotated_rhs @@ -25644,7 +25879,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' @@ -25652,8 +25887,8 @@ invalid_replacement_field_rule(Parser *p) _PyPegen_lookahead(0, (void *(*)(Parser *)) annotated_rhs_rule, p) ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting a valid expression after '{'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting a valid expression after '{'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25662,7 +25897,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' !annotated_rhs")); } { // '{' annotated_rhs !('=' | '!' | ':' | '}') @@ -25670,7 +25905,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); Token * _literal; expr_ty annotated_rhs_var; if ( @@ -25678,11 +25913,11 @@ invalid_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_147_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_148_rule, p) ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '=', or '!', or ':', or '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '=', or '!', or ':', or '}'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25691,7 +25926,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); } { // '{' annotated_rhs '=' !('!' | ':' | '}') @@ -25699,7 +25934,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); Token * _literal; Token * _literal_1; expr_ty annotated_rhs_var; @@ -25710,11 +25945,453 @@ invalid_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_149_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '!', or ':', or '}'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); + } + { // '{' annotated_rhs '='? invalid_fstring_conversion_character + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_fstring_conversion_character")); + Token * _literal; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + expr_ty annotated_rhs_var; + void *invalid_fstring_conversion_character_var; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs + && + (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (invalid_fstring_conversion_character_var = invalid_fstring_conversion_character_rule(p)) // invalid_fstring_conversion_character + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_fstring_conversion_character")); + _res = _PyPegen_dummy_name(p, _literal, annotated_rhs_var, _opt_var, invalid_fstring_conversion_character_var); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? invalid_fstring_conversion_character")); + } + { // '{' annotated_rhs '='? ['!' NAME] !(':' | '}') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); + Token * _literal; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *_opt_var_1; + UNUSED(_opt_var_1); // Silence compiler warnings + expr_ty annotated_rhs_var; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs + && + (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (_opt_var_1 = _tmp_150_rule(p), !p->error_indicator) // ['!' NAME] + && + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_151_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting ':' or '}'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); + } + { // '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' + if (p->error_indicator) { + p->level--; + return NULL; + } + 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_77_var; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *_opt_var_1; + UNUSED(_opt_var_1); // Silence compiler warnings + expr_ty annotated_rhs_var; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs + && + (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (_opt_var_1 = _tmp_150_rule(p), !p->error_indicator) // ['!' NAME] + && + (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' + && + (_loop0_77_var = _loop0_77_rule(p)) // fstring_format_spec* + && + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '}', or format specs" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); + } + { // '{' annotated_rhs '='? ['!' NAME] !'}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); + Token * _literal; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *_opt_var_1; + UNUSED(_opt_var_1); // Silence compiler warnings + expr_ty annotated_rhs_var; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs + && + (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? + && + (_opt_var_1 = _tmp_150_rule(p), !p->error_indicator) // ['!' NAME] + && + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '}'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// invalid_fstring_conversion_character: '!' &(':' | '}') | '!' !NAME +static void * +invalid_fstring_conversion_character_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; + { // '!' &(':' | '}') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_fstring_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 54)) // token='!' + && + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_151_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: missing conversion character" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_conversion_character[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' &(':' | '}')")); + } + { // '!' !NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_fstring_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 54)) // token='!' + && + _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_fstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: invalid conversion character" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_fstring_conversion_character[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' !NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// invalid_tstring_replacement_field: +// | '{' '=' +// | '{' '!' +// | '{' ':' +// | '{' '}' +// | '{' !annotated_rhs +// | '{' annotated_rhs !('=' | '!' | ':' | '}') +// | '{' annotated_rhs '=' !('!' | ':' | '}') +// | '{' annotated_rhs '='? invalid_tstring_conversion_character +// | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') +// | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' +// | '{' annotated_rhs '='? ['!' NAME] !'}' +static void * +invalid_tstring_replacement_field_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; + { // '{' '=' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '='")); + Token * _literal; + Token * a; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = _PyPegen_expect_token(p, 22)) // token='=' + ) + { + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '='")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "t-string: valid expression required before '='" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '='")); + } + { // '{' '!' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '!'")); + Token * _literal; + Token * a; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = _PyPegen_expect_token(p, 54)) // token='!' + ) + { + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '!'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "t-string: valid expression required before '!'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '!'")); + } + { // '{' ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' ':'")); + Token * _literal; + Token * a; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' ':'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "t-string: valid expression required before ':'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' ':'")); + } + { // '{' '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'")); + Token * _literal; + Token * a; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (a = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "t-string: valid expression required before '}'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'")); + } + { // '{' !annotated_rhs + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + _PyPegen_lookahead(0, (void *(*)(Parser *)) annotated_rhs_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs")); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: expecting a valid expression after '{'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' !annotated_rhs")); + } + { // '{' annotated_rhs !('=' | '!' | ':' | '}') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); + Token * _literal; + expr_ty annotated_rhs_var; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs + && _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_148_rule, p) ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '!', or ':', or '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: expecting '=', or '!', or ':', or '}'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); + } + { // '{' annotated_rhs '=' !('!' | ':' | '}') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); + Token * _literal; + Token * _literal_1; + expr_ty annotated_rhs_var; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs + && + (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' + && + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_149_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: expecting '!', or ':', or '}'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25723,20 +26400,20 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); } - { // '{' annotated_rhs '='? invalid_conversion_character + { // '{' annotated_rhs '='? invalid_tstring_conversion_character if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_conversion_character")); + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_tstring_conversion_character")); Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty annotated_rhs_var; - void *invalid_conversion_character_var; + void *invalid_tstring_conversion_character_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && @@ -25744,23 +26421,23 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (invalid_conversion_character_var = invalid_conversion_character_rule(p)) // invalid_conversion_character + (invalid_tstring_conversion_character_var = invalid_tstring_conversion_character_rule(p)) // invalid_tstring_conversion_character ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_conversion_character")); - _res = _PyPegen_dummy_name(p, _literal, annotated_rhs_var, _opt_var, invalid_conversion_character_var); + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_tstring_conversion_character")); + _res = _PyPegen_dummy_name(p, _literal, annotated_rhs_var, _opt_var, invalid_tstring_conversion_character_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? invalid_conversion_character")); + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? invalid_tstring_conversion_character")); } { // '{' annotated_rhs '='? ['!' NAME] !(':' | '}') if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -25774,13 +26451,13 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_149_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_150_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_150_rule, p) + _PyPegen_lookahead(0, (void *(*)(Parser *)) _tmp_151_rule, p) ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting ':' or '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: expecting ':' or '}'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25789,7 +26466,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); } { // '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' @@ -25797,7 +26474,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); + 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_77_var; @@ -25813,7 +26490,7 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_149_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_150_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25822,8 +26499,8 @@ invalid_replacement_field_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '}', or format specs" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: expecting '}', or format specs" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25832,7 +26509,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); } { // '{' annotated_rhs '='? ['!' NAME] !'}' @@ -25840,7 +26517,7 @@ invalid_replacement_field_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); + D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -25854,13 +26531,13 @@ invalid_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_149_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_150_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) { - D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); - _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: expecting '}'" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); + _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: expecting '}'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25869,7 +26546,7 @@ invalid_replacement_field_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_tstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'")); } _res = NULL; @@ -25878,9 +26555,9 @@ invalid_replacement_field_rule(Parser *p) return _res; } -// invalid_conversion_character: '!' &(':' | '}') | '!' !NAME +// invalid_tstring_conversion_character: '!' &(':' | '}') | '!' !NAME static void * -invalid_conversion_character_rule(Parser *p) +invalid_tstring_conversion_character_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -25896,16 +26573,16 @@ invalid_conversion_character_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); + D(fprintf(stderr, "%*c> invalid_tstring_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_150_rule, p) + _PyPegen_lookahead(1, (void *(*)(Parser *)) _tmp_151_rule, p) ) { - D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: missing conversion character" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_tstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: missing conversion character" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25914,7 +26591,7 @@ invalid_conversion_character_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_conversion_character[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_tstring_conversion_character[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' &(':' | '}')")); } { // '!' !NAME @@ -25922,7 +26599,7 @@ invalid_conversion_character_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); + D(fprintf(stderr, "%*c> invalid_tstring_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' @@ -25930,8 +26607,8 @@ invalid_conversion_character_rule(Parser *p) _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p) ) { - D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); - _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "%c-string: invalid conversion character" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + D(fprintf(stderr, "%*c+ invalid_tstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' !NAME")); + _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "t-string: invalid conversion character" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -25940,7 +26617,7 @@ invalid_conversion_character_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_conversion_character[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_tstring_conversion_character[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' !NAME")); } _res = NULL; @@ -25968,14 +26645,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_151_var; + void *_tmp_152_var; Token * a; expr_ty b; expr_ty sum_var; if ( (sum_var = sum_rule(p)) // sum && - (_tmp_151_var = _tmp_151_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' + (_tmp_152_var = _tmp_152_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && (a = _PyPegen_expect_token(p, 696)) // token='not' && @@ -26020,11 +26697,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_152_var; + void *_tmp_153_var; Token * a; expr_ty b; if ( - (_tmp_152_var = _tmp_152_rule(p)) // '+' | '-' | '~' + (_tmp_153_var = _tmp_153_rule(p)) // '+' | '-' | '~' && (a = _PyPegen_expect_token(p, 696)) // token='not' && @@ -26798,12 +27475,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_153_var; + void *_tmp_154_var; while ( - (_tmp_153_var = _tmp_153_rule(p)) // star_targets '=' + (_tmp_154_var = _tmp_154_rule(p)) // star_targets '=' ) { - _res = _tmp_153_var; + _res = _tmp_154_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -27136,12 +27813,12 @@ _loop0_18_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_154_var; + void *_tmp_155_var; while ( - (_tmp_154_var = _tmp_154_rule(p)) // '.' | '...' + (_tmp_155_var = _tmp_155_rule(p)) // '.' | '...' ) { - _res = _tmp_154_var; + _res = _tmp_155_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -27203,12 +27880,12 @@ _loop1_19_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_154_var; + void *_tmp_155_var; while ( - (_tmp_154_var = _tmp_154_rule(p)) // '.' | '...' + (_tmp_155_var = _tmp_155_rule(p)) // '.' | '...' ) { - _res = _tmp_154_var; + _res = _tmp_155_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -27555,12 +28232,12 @@ _loop1_25_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); - void *_tmp_155_var; + void *_tmp_156_var; while ( - (_tmp_155_var = _tmp_155_rule(p)) // '@' named_expression NEWLINE + (_tmp_156_var = _tmp_156_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_155_var; + _res = _tmp_156_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29588,12 +30265,12 @@ _loop1_57_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); - void *_tmp_156_var; + void *_tmp_157_var; while ( - (_tmp_156_var = _tmp_156_rule(p)) // ',' star_expression + (_tmp_157_var = _tmp_157_rule(p)) // ',' star_expression ) { - _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 *)); @@ -29777,12 +30454,12 @@ _loop1_60_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); - void *_tmp_157_var; + void *_tmp_158_var; while ( - (_tmp_157_var = _tmp_157_rule(p)) // 'or' conjunction + (_tmp_158_var = _tmp_158_rule(p)) // 'or' conjunction ) { - _res = _tmp_157_var; + _res = _tmp_158_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29849,12 +30526,12 @@ _loop1_61_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); - void *_tmp_158_var; + void *_tmp_159_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // 'and' inversion + (_tmp_159_var = _tmp_159_rule(p)) // 'and' inversion ) { - _res = _tmp_158_var; + _res = _tmp_159_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -30041,7 +30718,7 @@ _loop0_64_rule(Parser *p) while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_159_rule(p)) // slice | starred_expression + (elem = _tmp_160_rule(p)) // slice | starred_expression ) { _res = elem; @@ -30106,7 +30783,7 @@ _gather_65_rule(Parser *p) void *elem; asdl_seq * seq; if ( - (elem = _tmp_159_rule(p)) // slice | starred_expression + (elem = _tmp_160_rule(p)) // slice | starred_expression && (seq = _loop0_64_rule(p)) // _loop0_64 ) @@ -31007,7 +31684,7 @@ _loop0_78_rule(Parser *p) return _seq; } -// _loop0_79: tstring_middle +// _loop0_79: tstring_format_spec static asdl_seq * _loop0_79_rule(Parser *p) { @@ -31029,18 +31706,18 @@ _loop0_79_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // tstring_middle + { // tstring_format_spec if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); - expr_ty tstring_middle_var; + D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec")); + expr_ty tstring_format_spec_var; while ( - (tstring_middle_var = tstring_middle_rule(p)) // tstring_middle + (tstring_format_spec_var = tstring_format_spec_rule(p)) // tstring_format_spec ) { - _res = tstring_middle_var; + _res = tstring_format_spec_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31058,7 +31735,7 @@ _loop0_79_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_middle")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -31074,9 +31751,9 @@ _loop0_79_rule(Parser *p) return _seq; } -// _loop1_80: (fstring | string | tstring) +// _loop0_80: tstring_middle static asdl_seq * -_loop1_80_rule(Parser *p) +_loop0_80_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31096,256 +31773,18 @@ _loop1_80_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // (fstring | string | tstring) - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string | tstring)")); - void *_tmp_160_var; - while ( - (_tmp_160_var = _tmp_160_rule(p)) // fstring | string | tstring - ) - { - _res = _tmp_160_var; - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string | tstring)")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _tmp_81: star_named_expression ',' star_named_expressions? -static void * -_tmp_81_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; - { // star_named_expression ',' star_named_expressions? - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); - Token * _literal; - expr_ty y; - void *z; - if ( - (y = star_named_expression_rule(p)) // star_named_expression - && - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? - ) - { - D(fprintf(stderr, "%*c+ _tmp_81[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); - _res = _PyPegen_seq_insert_in_front ( p , y , z ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_81[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop0_82: ',' double_starred_kvpair -static asdl_seq * -_loop0_82_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; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // ',' double_starred_kvpair - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); - Token * _literal; - KeyValuePair* elem; - while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair - ) - { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_82[%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); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _gather_83: double_starred_kvpair _loop0_82 -static asdl_seq * -_gather_83_rule(Parser *p) -{ - if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // double_starred_kvpair _loop0_82 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); - KeyValuePair* elem; - asdl_seq * seq; - if ( - (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair - && - (seq = _loop0_82_rule(p)) // _loop0_82 - ) - { - D(fprintf(stderr, "%*c+ _gather_83[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_82")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_83[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_82")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop1_84: for_if_clause -static asdl_seq * -_loop1_84_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; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // for_if_clause + { // tstring_middle if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); - comprehension_ty for_if_clause_var; + D(fprintf(stderr, "%*c> _loop0_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); + expr_ty tstring_middle_var; while ( - (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause + (tstring_middle_var = tstring_middle_rule(p)) // tstring_middle ) { - _res = for_if_clause_var; + _res = tstring_middle_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31362,13 +31801,8 @@ _loop1_84_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_84[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_80[%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); if (!_seq) { @@ -31384,9 +31818,9 @@ _loop1_84_rule(Parser *p) return _seq; } -// _loop0_85: ('if' disjunction) +// _loop1_81: (fstring | string | tstring) static asdl_seq * -_loop0_85_rule(Parser *p) +_loop1_81_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31406,15 +31840,15 @@ _loop0_85_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ('if' disjunction) + { // (fstring | string | tstring) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string | tstring)")); void *_tmp_161_var; while ( - (_tmp_161_var = _tmp_161_rule(p)) // 'if' disjunction + (_tmp_161_var = _tmp_161_rule(p)) // fstring | string | tstring ) { _res = _tmp_161_var; @@ -31434,7 +31868,317 @@ _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 _loop1_81[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string | tstring)")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _tmp_82: star_named_expression ',' star_named_expressions? +static void * +_tmp_82_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; + { // star_named_expression ',' star_named_expressions? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + Token * _literal; + expr_ty y; + void *z; + if ( + (y = star_named_expression_rule(p)) // star_named_expression + && + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? + ) + { + D(fprintf(stderr, "%*c+ _tmp_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + _res = _PyPegen_seq_insert_in_front ( p , y , z ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_82[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_83: ',' double_starred_kvpair +static asdl_seq * +_loop0_83_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; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // ',' double_starred_kvpair + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); + Token * _literal; + KeyValuePair* elem; + while ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_83[%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); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_84: double_starred_kvpair _loop0_83 +static asdl_seq * +_gather_84_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // double_starred_kvpair _loop0_83 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_83")); + KeyValuePair* elem; + asdl_seq * seq; + if ( + (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair + && + (seq = _loop0_83_rule(p)) // _loop0_83 + ) + { + D(fprintf(stderr, "%*c+ _gather_84[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_83")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_84[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_83")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop1_85: for_if_clause +static asdl_seq * +_loop1_85_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; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // for_if_clause + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_85[%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 + ) + { + _res = for_if_clause_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop1_85[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop0_86: ('if' disjunction) +static asdl_seq * +_loop0_86_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; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // ('if' disjunction) + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + void *_tmp_162_var; + while ( + (_tmp_162_var = _tmp_162_rule(p)) // 'if' disjunction + ) + { + _res = _tmp_162_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_86[%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); @@ -31451,9 +32195,9 @@ _loop0_85_rule(Parser *p) return _seq; } -// _tmp_86: assignment_expression | expression !':=' +// _tmp_87: assignment_expression | expression !':=' static void * -_tmp_86_rule(Parser *p) +_tmp_87_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31469,18 +32213,18 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_87[%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_86[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_87[%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_86[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } { // expression !':=' @@ -31488,7 +32232,7 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -31496,12 +32240,12 @@ _tmp_86_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_86[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_87[%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_86[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } _res = NULL; @@ -31510,9 +32254,9 @@ _tmp_86_rule(Parser *p) return _res; } -// _loop0_87: ',' (starred_expression | (assignment_expression | expression !':=') !'=') +// _loop0_88: ',' (starred_expression | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_87_rule(Parser *p) +_loop0_88_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31537,13 +32281,13 @@ _loop0_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_88[%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_162_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_163_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -31569,7 +32313,7 @@ _loop0_87_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_87[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_88[%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); @@ -31586,10 +32330,10 @@ _loop0_87_rule(Parser *p) return _seq; } -// _gather_88: -// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 +// _gather_89: +// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88 static asdl_seq * -_gather_88_rule(Parser *p) +_gather_89_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31600,27 +32344,27 @@ _gather_88_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87 + { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); + D(fprintf(stderr, "%*c> _gather_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_162_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_163_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_87_rule(p)) // _loop0_87 + (seq = _loop0_88_rule(p)) // _loop0_88 ) { - D(fprintf(stderr, "%*c+ _gather_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); + D(fprintf(stderr, "%*c+ _gather_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_88[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_87")); + D(fprintf(stderr, "%*c%s _gather_89[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88")); } _res = NULL; done: @@ -31628,9 +32372,9 @@ _gather_88_rule(Parser *p) return _res; } -// _tmp_89: ',' kwargs +// _tmp_90: ',' kwargs 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); @@ -31646,7 +32390,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, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -31655,7 +32399,7 @@ _tmp_89_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); _res = k; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31665,7 +32409,7 @@ _tmp_89_rule(Parser *p) 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, "',' kwargs")); } _res = NULL; @@ -31674,9 +32418,9 @@ _tmp_89_rule(Parser *p) return _res; } -// _loop0_90: ',' kwarg_or_starred +// _loop0_91: ',' kwarg_or_starred 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); @@ -31701,7 +32445,7 @@ _loop0_90_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31733,7 +32477,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, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31750,9 +32494,9 @@ _loop0_90_rule(Parser *p) return _seq; } -// _gather_91: kwarg_or_starred _loop0_90 +// _gather_92: kwarg_or_starred _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); @@ -31763,27 +32507,27 @@ _gather_91_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_90 + { // kwarg_or_starred _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, "kwarg_or_starred _loop0_90")); + D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_91")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (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, "kwarg_or_starred _loop0_90")); + D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _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, "kwarg_or_starred _loop0_90")); + D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_91")); } _res = NULL; done: @@ -31791,9 +32535,9 @@ _gather_91_rule(Parser *p) return _res; } -// _loop0_92: ',' kwarg_or_double_starred +// _loop0_93: ',' kwarg_or_double_starred static asdl_seq * -_loop0_92_rule(Parser *p) +_loop0_93_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31818,7 +32562,7 @@ _loop0_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -31850,7 +32594,7 @@ _loop0_92_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_92[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_93[%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); @@ -31867,9 +32611,9 @@ _loop0_92_rule(Parser *p) return _seq; } -// _gather_93: kwarg_or_double_starred _loop0_92 +// _gather_94: kwarg_or_double_starred _loop0_93 static asdl_seq * -_gather_93_rule(Parser *p) +_gather_94_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31880,27 +32624,27 @@ _gather_93_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_92 + { // kwarg_or_double_starred _loop0_93 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); + D(fprintf(stderr, "%*c> _gather_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_93")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_92_rule(p)) // _loop0_92 + (seq = _loop0_93_rule(p)) // _loop0_93 ) { - D(fprintf(stderr, "%*c+ _gather_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_92")); + D(fprintf(stderr, "%*c+ _gather_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_93")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_93[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_92")); + D(fprintf(stderr, "%*c%s _gather_94[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_93")); } _res = NULL; done: @@ -31908,9 +32652,9 @@ _gather_93_rule(Parser *p) return _res; } -// _loop0_94: (',' star_target) +// _loop0_95: (',' star_target) static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_95_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31935,13 +32679,13 @@ _loop0_94_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_163_var; + D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_164_var; while ( - (_tmp_163_var = _tmp_163_rule(p)) // ',' star_target + (_tmp_164_var = _tmp_164_rule(p)) // ',' star_target ) { - _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 *)); @@ -31958,7 +32702,7 @@ _loop0_94_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_94[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_95[%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); @@ -31975,9 +32719,9 @@ _loop0_94_rule(Parser *p) return _seq; } -// _loop0_95: ',' star_target +// _loop0_96: ',' star_target 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); @@ -32002,7 +32746,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, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -32034,7 +32778,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, "',' star_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32051,9 +32795,9 @@ _loop0_95_rule(Parser *p) return _seq; } -// _gather_96: star_target _loop0_95 +// _gather_97: star_target _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); @@ -32064,27 +32808,27 @@ _gather_96_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_95 + { // star_target _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, "star_target _loop0_95")); + D(fprintf(stderr, "%*c> _gather_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_96")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (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, "star_target _loop0_95")); + D(fprintf(stderr, "%*c+ _gather_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _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, "star_target _loop0_95")); + D(fprintf(stderr, "%*c%s _gather_97[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_96")); } _res = NULL; done: @@ -32092,9 +32836,9 @@ _gather_96_rule(Parser *p) return _res; } -// _loop1_97: (',' star_target) +// _loop1_98: (',' star_target) static asdl_seq * -_loop1_97_rule(Parser *p) +_loop1_98_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32119,13 +32863,13 @@ _loop1_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_163_var; + D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_164_var; while ( - (_tmp_163_var = _tmp_163_rule(p)) // ',' star_target + (_tmp_164_var = _tmp_164_rule(p)) // ',' star_target ) { - _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 *)); @@ -32142,7 +32886,7 @@ _loop1_97_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_97[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_98[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -32164,9 +32908,9 @@ _loop1_97_rule(Parser *p) return _seq; } -// _tmp_98: !'*' star_target +// _tmp_99: !'*' star_target static void * -_tmp_98_rule(Parser *p) +_tmp_99_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32182,7 +32926,7 @@ _tmp_98_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_99[%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='*' @@ -32190,12 +32934,12 @@ _tmp_98_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_98[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_99[%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_98[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_99[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); } _res = NULL; @@ -32204,9 +32948,9 @@ _tmp_98_rule(Parser *p) return _res; } -// _loop0_99: ',' del_target +// _loop0_100: ',' del_target static asdl_seq * -_loop0_99_rule(Parser *p) +_loop0_100_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32231,7 +32975,7 @@ _loop0_99_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -32263,7 +33007,7 @@ _loop0_99_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_99[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_100[%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); @@ -32280,9 +33024,9 @@ _loop0_99_rule(Parser *p) return _seq; } -// _gather_100: del_target _loop0_99 +// _gather_101: del_target _loop0_100 static asdl_seq * -_gather_100_rule(Parser *p) +_gather_101_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32293,27 +33037,27 @@ _gather_100_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_99 + { // del_target _loop0_100 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_99")); + D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_100")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_99_rule(p)) // _loop0_99 + (seq = _loop0_100_rule(p)) // _loop0_100 ) { - D(fprintf(stderr, "%*c+ _gather_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_99")); + D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_100")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_100[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_99")); + D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_100")); } _res = NULL; done: @@ -32321,9 +33065,9 @@ _gather_100_rule(Parser *p) return _res; } -// _loop0_101: ',' expression +// _loop0_102: ',' expression static asdl_seq * -_loop0_101_rule(Parser *p) +_loop0_102_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32348,7 +33092,7 @@ _loop0_101_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -32380,7 +33124,7 @@ _loop0_101_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_101[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_102[%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); @@ -32397,9 +33141,9 @@ _loop0_101_rule(Parser *p) return _seq; } -// _gather_102: expression _loop0_101 +// _gather_103: expression _loop0_102 static asdl_seq * -_gather_102_rule(Parser *p) +_gather_103_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32410,27 +33154,27 @@ _gather_102_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_101 + { // expression _loop0_102 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); + D(fprintf(stderr, "%*c> _gather_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_102")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_101_rule(p)) // _loop0_101 + (seq = _loop0_102_rule(p)) // _loop0_102 ) { - D(fprintf(stderr, "%*c+ _gather_102[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_101")); + D(fprintf(stderr, "%*c+ _gather_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_102")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_102[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_101")); + D(fprintf(stderr, "%*c%s _gather_103[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_102")); } _res = NULL; done: @@ -32438,9 +33182,9 @@ _gather_102_rule(Parser *p) return _res; } -// _tmp_103: NEWLINE INDENT +// _tmp_104: NEWLINE INDENT static void * -_tmp_103_rule(Parser *p) +_tmp_104_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32456,7 +33200,7 @@ _tmp_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -32465,12 +33209,12 @@ _tmp_103_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_104[%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_103[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); } _res = NULL; @@ -32479,11 +33223,11 @@ _tmp_103_rule(Parser *p) return _res; } -// _tmp_104: +// _tmp_105: // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) // | kwargs static void * -_tmp_104_rule(Parser *p) +_tmp_105_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32499,18 +33243,18 @@ _tmp_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - void *_tmp_164_var; + D(fprintf(stderr, "%*c> _tmp_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + void *_tmp_165_var; if ( - (_tmp_164_var = _tmp_164_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs + (_tmp_165_var = _tmp_165_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - _res = _tmp_164_var; + D(fprintf(stderr, "%*c+ _tmp_105[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + _res = _tmp_165_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_105[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } { // kwargs @@ -32518,18 +33262,18 @@ _tmp_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c> _tmp_105[%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_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c+ _tmp_105[%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_104[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_105[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); } _res = NULL; @@ -32538,9 +33282,9 @@ _tmp_104_rule(Parser *p) return _res; } -// _loop0_105: ',' (starred_expression !'=') +// _loop0_106: ',' (starred_expression !'=') static asdl_seq * -_loop0_105_rule(Parser *p) +_loop0_106_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32565,13 +33309,13 @@ _loop0_105_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); + D(fprintf(stderr, "%*c> _loop0_106[%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_165_rule(p)) // starred_expression !'=' + (elem = _tmp_166_rule(p)) // starred_expression !'=' ) { _res = elem; @@ -32597,7 +33341,7 @@ _loop0_105_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_106[%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); @@ -32614,9 +33358,9 @@ _loop0_105_rule(Parser *p) return _seq; } -// _gather_106: (starred_expression !'=') _loop0_105 +// _gather_107: (starred_expression !'=') _loop0_106 static asdl_seq * -_gather_106_rule(Parser *p) +_gather_107_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32627,27 +33371,27 @@ _gather_106_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression !'=') _loop0_105 + { // (starred_expression !'=') _loop0_106 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_105")); + D(fprintf(stderr, "%*c> _gather_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_106")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_165_rule(p)) // starred_expression !'=' + (elem = _tmp_166_rule(p)) // starred_expression !'=' && - (seq = _loop0_105_rule(p)) // _loop0_105 + (seq = _loop0_106_rule(p)) // _loop0_106 ) { - D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_105")); + D(fprintf(stderr, "%*c+ _gather_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_106")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_105")); + D(fprintf(stderr, "%*c%s _gather_107[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_106")); } _res = NULL; done: @@ -32655,9 +33399,9 @@ _gather_106_rule(Parser *p) return _res; } -// _tmp_107: args | expression for_if_clauses +// _tmp_108: args | expression for_if_clauses 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); @@ -32673,18 +33417,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, "args")); + D(fprintf(stderr, "%*c> _tmp_108[%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_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c+ _tmp_108[%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_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, "args")); } { // expression for_if_clauses @@ -32692,7 +33436,7 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_108[%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 ( @@ -32701,12 +33445,12 @@ _tmp_107_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_108[%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_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, "expression for_if_clauses")); } _res = NULL; @@ -32715,9 +33459,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _tmp_108: args ',' +// _tmp_109: args ',' static void * -_tmp_108_rule(Parser *p) +_tmp_109_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32733,7 +33477,7 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -32742,12 +33486,12 @@ _tmp_108_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_109[%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_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','")); } _res = NULL; @@ -32756,9 +33500,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _tmp_109: ',' | ')' +// _tmp_110: ',' | ')' static void * -_tmp_109_rule(Parser *p) +_tmp_110_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32774,18 +33518,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -32793,18 +33537,18 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } _res = NULL; @@ -32813,9 +33557,9 @@ _tmp_109_rule(Parser *p) return _res; } -// _tmp_110: 'True' | 'False' | 'None' +// _tmp_111: 'True' | 'False' | 'None' 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); @@ -32831,18 +33575,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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 619)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; 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, "'True'")); } { // 'False' @@ -32850,18 +33594,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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 621)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; 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, "'False'")); } { // 'None' @@ -32869,18 +33613,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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 620)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; 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, "'None'")); } _res = NULL; @@ -32889,9 +33633,9 @@ _tmp_110_rule(Parser *p) return _res; } -// _tmp_111: NAME '=' +// _tmp_112: NAME '=' 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); @@ -32907,7 +33651,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, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -32916,12 +33660,12 @@ _tmp_111_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_112[%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_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, "NAME '='")); } _res = NULL; @@ -32930,9 +33674,9 @@ _tmp_111_rule(Parser *p) return _res; } -// _loop1_112: (!STRING expression_without_invalid) +// _loop1_113: (!STRING expression_without_invalid) static asdl_seq * -_loop1_112_rule(Parser *p) +_loop1_113_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32957,13 +33701,13 @@ _loop1_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); - void *_tmp_166_var; + D(fprintf(stderr, "%*c> _loop1_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); + void *_tmp_167_var; while ( - (_tmp_166_var = _tmp_166_rule(p)) // !STRING expression_without_invalid + (_tmp_167_var = _tmp_167_rule(p)) // !STRING expression_without_invalid ) { - _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 *)); @@ -32980,7 +33724,7 @@ _loop1_112_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_112[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_113[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(!STRING expression_without_invalid)")); } if (_n == 0 || p->error_indicator) { @@ -33002,9 +33746,9 @@ _loop1_112_rule(Parser *p) return _seq; } -// _tmp_113: NAME STRING | SOFT_KEYWORD +// _tmp_114: NAME STRING | SOFT_KEYWORD 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); @@ -33020,7 +33764,7 @@ _tmp_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -33029,12 +33773,12 @@ _tmp_113_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_114[%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_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, "NAME STRING")); } { // SOFT_KEYWORD @@ -33042,18 +33786,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, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_114[%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_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_114[%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_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, "SOFT_KEYWORD")); } _res = NULL; @@ -33062,9 +33806,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: 'else' | ':' +// _tmp_115: 'else' | ':' 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); @@ -33080,18 +33824,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 680)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); _res = _keyword; 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, "'else'")); } { // ':' @@ -33099,18 +33843,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _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, "':'")); } _res = NULL; @@ -33119,9 +33863,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _tmp_115: pass_stmt | break_stmt | continue_stmt +// _tmp_116: pass_stmt | break_stmt | continue_stmt static void * -_tmp_115_rule(Parser *p) +_tmp_116_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33137,18 +33881,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pass_stmt")); + D(fprintf(stderr, "%*c> _tmp_116[%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_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pass_stmt")); + D(fprintf(stderr, "%*c+ _tmp_116[%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_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pass_stmt")); } { // break_stmt @@ -33156,18 +33900,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "break_stmt")); + D(fprintf(stderr, "%*c> _tmp_116[%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_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "break_stmt")); + D(fprintf(stderr, "%*c+ _tmp_116[%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_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "break_stmt")); } { // continue_stmt @@ -33175,18 +33919,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "continue_stmt")); + D(fprintf(stderr, "%*c> _tmp_116[%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_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "continue_stmt")); + D(fprintf(stderr, "%*c+ _tmp_116[%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_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "continue_stmt")); } _res = NULL; @@ -33195,9 +33939,9 @@ _tmp_115_rule(Parser *p) return _res; } -// _tmp_116: '=' | ':=' +// _tmp_117: '=' | ':=' 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); @@ -33213,18 +33957,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, "'='")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; 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, "'='")); } { // ':=' @@ -33232,18 +33976,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, "':='")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); _res = _literal; 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, "':='")); } _res = NULL; @@ -33252,9 +33996,9 @@ _tmp_116_rule(Parser *p) return _res; } -// _tmp_117: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_118: list | tuple | genexp | 'True' | 'None' | 'False' 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); @@ -33270,18 +34014,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, "list")); + D(fprintf(stderr, "%*c> _tmp_118[%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_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c+ _tmp_118[%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_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, "list")); } { // tuple @@ -33289,18 +34033,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, "tuple")); + D(fprintf(stderr, "%*c> _tmp_118[%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_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_118[%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_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, "tuple")); } { // genexp @@ -33308,18 +34052,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, "genexp")); + D(fprintf(stderr, "%*c> _tmp_118[%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_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_118[%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_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, "genexp")); } { // 'True' @@ -33327,18 +34071,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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 619)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _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, "'True'")); } { // 'None' @@ -33346,18 +34090,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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 620)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _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, "'None'")); } { // 'False' @@ -33365,18 +34109,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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 621)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _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, "'False'")); } _res = NULL; @@ -33385,9 +34129,9 @@ _tmp_117_rule(Parser *p) return _res; } -// _loop0_118: star_named_expressions +// _loop0_119: star_named_expressions static asdl_seq * -_loop0_118_rule(Parser *p) +_loop0_119_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33412,7 +34156,7 @@ _loop0_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_119[%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 @@ -33435,7 +34179,7 @@ _loop0_118_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_119[%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); @@ -33452,9 +34196,9 @@ _loop0_118_rule(Parser *p) return _seq; } -// _loop0_119: (star_targets '=') +// _loop0_120: (star_targets '=') static asdl_seq * -_loop0_119_rule(Parser *p) +_loop0_120_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33479,13 +34223,13 @@ _loop0_119_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_153_var; + D(fprintf(stderr, "%*c> _loop0_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); + void *_tmp_154_var; while ( - (_tmp_153_var = _tmp_153_rule(p)) // star_targets '=' + (_tmp_154_var = _tmp_154_rule(p)) // star_targets '=' ) { - _res = _tmp_153_var; + _res = _tmp_154_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33502,7 +34246,7 @@ _loop0_119_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_119[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_120[%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); @@ -33519,9 +34263,9 @@ _loop0_119_rule(Parser *p) return _seq; } -// _tmp_120: '[' | '(' | '{' +// _tmp_121: '[' | '(' | '{' 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); @@ -33537,18 +34281,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, "'['")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; 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, "'['")); } { // '(' @@ -33556,18 +34300,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, "'('")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); _res = _literal; 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, "'('")); } { // '{' @@ -33575,18 +34319,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, "'{'")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; 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, "'{'")); } _res = NULL; @@ -33595,9 +34339,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _tmp_121: '[' | '{' +// _tmp_122: '[' | '{' static void * -_tmp_121_rule(Parser *p) +_tmp_122_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33613,18 +34357,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); } { // '{' @@ -33632,18 +34376,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); } _res = NULL; @@ -33652,9 +34396,9 @@ _tmp_121_rule(Parser *p) return _res; } -// _tmp_122: slash_no_default | slash_with_default +// _tmp_123: slash_no_default | slash_with_default static void * -_tmp_122_rule(Parser *p) +_tmp_123_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33670,18 +34414,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_123[%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_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_123[%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_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); } { // slash_with_default @@ -33689,18 +34433,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_123[%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_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_123[%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_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); } _res = NULL; @@ -33709,9 +34453,9 @@ _tmp_122_rule(Parser *p) return _res; } -// _tmp_123: ',' | param_no_default +// _tmp_124: ',' | param_no_default 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); @@ -33727,18 +34471,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, 12)) // 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, "','")); } { // param_no_default @@ -33746,18 +34490,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_124[%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_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_124[%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_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, "param_no_default")); } _res = NULL; @@ -33766,9 +34510,9 @@ _tmp_123_rule(Parser *p) return _res; } -// _tmp_124: ')' | ',' +// _tmp_125: ')' | ',' 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); @@ -33784,18 +34528,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, "')'")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; 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, "')'")); } { // ',' @@ -33803,18 +34547,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, "','")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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, "','")); } _res = NULL; @@ -33823,9 +34567,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _tmp_125: ')' | ',' (')' | '**') +// _tmp_126: ')' | ',' (')' | '**') 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); @@ -33841,18 +34585,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, 8)) // 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, "')'")); } { // ',' (')' | '**') @@ -33860,21 +34604,21 @@ _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; - void *_tmp_167_var; + void *_tmp_168_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_167_var = _tmp_167_rule(p)) // ')' | '**' + (_tmp_168_var = _tmp_168_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_167_var); + D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_168_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, "',' (')' | '**')")); } _res = NULL; @@ -33883,9 +34627,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _tmp_126: param_no_default | ',' +// _tmp_127: param_no_default | ',' 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); @@ -33901,18 +34645,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_127[%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_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_127[%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_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, "param_no_default")); } { // ',' @@ -33920,18 +34664,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; @@ -33940,9 +34684,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); @@ -33958,18 +34702,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, 16)) // 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, "'*'")); } { // '**' @@ -33977,18 +34721,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, 35)) // 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, "'**'")); } { // '/' @@ -33996,18 +34740,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, 17)) // 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, "'/'")); } _res = NULL; @@ -34016,9 +34760,9 @@ _tmp_127_rule(Parser *p) return _res; } -// _tmp_128: lambda_slash_no_default | lambda_slash_with_default +// _tmp_129: lambda_slash_no_default | lambda_slash_with_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); @@ -34034,18 +34778,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, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_129[%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_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_129[%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_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, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -34053,18 +34797,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, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_129[%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_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_129[%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_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, "lambda_slash_with_default")); } _res = NULL; @@ -34073,9 +34817,9 @@ _tmp_128_rule(Parser *p) return _res; } -// _loop0_129: ',' lambda_param +// _loop0_130: ',' lambda_param static asdl_seq * -_loop0_129_rule(Parser *p) +_loop0_130_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34100,7 +34844,7 @@ _loop0_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -34132,7 +34876,7 @@ _loop0_129_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_129[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_130[%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); @@ -34149,9 +34893,9 @@ _loop0_129_rule(Parser *p) return _seq; } -// _gather_130: lambda_param _loop0_129 +// _gather_131: lambda_param _loop0_130 static asdl_seq * -_gather_130_rule(Parser *p) +_gather_131_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34162,27 +34906,27 @@ _gather_130_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_129 + { // lambda_param _loop0_130 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_129")); + D(fprintf(stderr, "%*c> _gather_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_130")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_129_rule(p)) // _loop0_129 + (seq = _loop0_130_rule(p)) // _loop0_130 ) { - D(fprintf(stderr, "%*c+ _gather_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_129")); + D(fprintf(stderr, "%*c+ _gather_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_130")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_130[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_129")); + D(fprintf(stderr, "%*c%s _gather_131[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_130")); } _res = NULL; done: @@ -34190,9 +34934,9 @@ _gather_130_rule(Parser *p) return _res; } -// _tmp_131: ',' | lambda_param_no_default +// _tmp_132: ',' | lambda_param_no_default static void * -_tmp_131_rule(Parser *p) +_tmp_132_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34208,18 +34952,18 @@ _tmp_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // lambda_param_no_default @@ -34227,18 +34971,18 @@ _tmp_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_132[%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_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_132[%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_131[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } _res = NULL; @@ -34247,9 +34991,9 @@ _tmp_131_rule(Parser *p) return _res; } -// _tmp_132: ':' | ',' (':' | '**') +// _tmp_133: ':' | ',' (':' | '**') static void * -_tmp_132_rule(Parser *p) +_tmp_133_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34265,18 +35009,18 @@ _tmp_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // ',' (':' | '**') @@ -34284,21 +35028,21 @@ _tmp_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); Token * _literal; - void *_tmp_168_var; + void *_tmp_169_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_168_var = _tmp_168_rule(p)) // ':' | '**' + (_tmp_169_var = _tmp_169_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_168_var); + D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_169_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); } _res = NULL; @@ -34307,9 +35051,9 @@ _tmp_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); @@ -34325,18 +35069,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")); } { // ',' @@ -34344,18 +35088,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, "','")); } _res = NULL; @@ -34364,9 +35108,9 @@ _tmp_133_rule(Parser *p) return _res; } -// _tmp_134: bitwise_or ((',' bitwise_or))* ','? +// _tmp_135: bitwise_or ((',' bitwise_or))* ','? 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); @@ -34382,25 +35126,25 @@ _tmp_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - asdl_seq * _loop0_169_var; + D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + asdl_seq * _loop0_170_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_169_var = _loop0_169_rule(p)) // ((',' bitwise_or))* + (_loop0_170_var = _loop0_170_rule(p)) // ((',' bitwise_or))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) { - D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_169_var, _opt_var); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_170_var, _opt_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, "bitwise_or ((',' bitwise_or))* ','?")); } _res = NULL; @@ -34409,9 +35153,9 @@ _tmp_134_rule(Parser *p) return _res; } -// _loop0_135: ',' dotted_name +// _loop0_136: ',' dotted_name static asdl_seq * -_loop0_135_rule(Parser *p) +_loop0_136_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34436,7 +35180,7 @@ _loop0_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -34468,7 +35212,7 @@ _loop0_135_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_135[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_136[%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); @@ -34485,9 +35229,9 @@ _loop0_135_rule(Parser *p) return _seq; } -// _gather_136: dotted_name _loop0_135 +// _gather_137: dotted_name _loop0_136 static asdl_seq * -_gather_136_rule(Parser *p) +_gather_137_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34498,27 +35242,27 @@ _gather_136_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_135 + { // dotted_name _loop0_136 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_135")); + D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_136")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_135_rule(p)) // _loop0_135 + (seq = _loop0_136_rule(p)) // _loop0_136 ) { - D(fprintf(stderr, "%*c+ _gather_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_135")); + D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_136")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_136[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_135")); + D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_136")); } _res = NULL; done: @@ -34526,9 +35270,9 @@ _gather_136_rule(Parser *p) return _res; } -// _loop0_137: ',' (expression ['as' star_target]) +// _loop0_138: ',' (expression ['as' star_target]) 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); @@ -34553,13 +35297,13 @@ _loop0_137_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_138[%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_170_rule(p)) // expression ['as' star_target] + (elem = _tmp_171_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -34585,7 +35329,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, "',' (expression ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34602,9 +35346,9 @@ _loop0_137_rule(Parser *p) return _seq; } -// _gather_138: (expression ['as' star_target]) _loop0_137 +// _gather_139: (expression ['as' star_target]) _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); @@ -34615,27 +35359,27 @@ _gather_138_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_137 + { // (expression ['as' star_target]) _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, "(expression ['as' star_target]) _loop0_137")); + D(fprintf(stderr, "%*c> _gather_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_138")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_170_rule(p)) // expression ['as' star_target] + (elem = _tmp_171_rule(p)) // expression ['as' star_target] && - (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, "(expression ['as' star_target]) _loop0_137")); + D(fprintf(stderr, "%*c+ _gather_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _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, "(expression ['as' star_target]) _loop0_137")); + D(fprintf(stderr, "%*c%s _gather_139[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_138")); } _res = NULL; done: @@ -34643,9 +35387,9 @@ _gather_138_rule(Parser *p) return _res; } -// _loop0_139: ',' (expressions ['as' star_target]) +// _loop0_140: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_139_rule(Parser *p) +_loop0_140_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34670,13 +35414,13 @@ _loop0_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_140[%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_171_rule(p)) // expressions ['as' star_target] + (elem = _tmp_172_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -34702,7 +35446,7 @@ _loop0_139_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_139[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_140[%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); @@ -34719,9 +35463,9 @@ _loop0_139_rule(Parser *p) return _seq; } -// _gather_140: (expressions ['as' star_target]) _loop0_139 +// _gather_141: (expressions ['as' star_target]) _loop0_140 static asdl_seq * -_gather_140_rule(Parser *p) +_gather_141_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34732,27 +35476,27 @@ _gather_140_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_139 + { // (expressions ['as' star_target]) _loop0_140 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_139")); + D(fprintf(stderr, "%*c> _gather_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_140")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_171_rule(p)) // expressions ['as' star_target] + (elem = _tmp_172_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_139_rule(p)) // _loop0_139 + (seq = _loop0_140_rule(p)) // _loop0_140 ) { - D(fprintf(stderr, "%*c+ _gather_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_139")); + D(fprintf(stderr, "%*c+ _gather_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_140")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_140[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_139")); + D(fprintf(stderr, "%*c%s _gather_141[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_140")); } _res = NULL; done: @@ -34760,9 +35504,9 @@ _gather_140_rule(Parser *p) return _res; } -// _tmp_141: 'except' | 'finally' +// _tmp_142: 'except' | 'finally' static void * -_tmp_141_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34778,18 +35522,18 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 672)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } { // 'finally' @@ -34797,18 +35541,18 @@ _tmp_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 668)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } _res = NULL; @@ -34817,9 +35561,9 @@ _tmp_141_rule(Parser *p) return _res; } -// _loop0_142: block +// _loop0_143: block 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); @@ -34844,7 +35588,7 @@ _loop0_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); + D(fprintf(stderr, "%*c> _loop0_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -34867,7 +35611,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, "block")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34884,9 +35628,9 @@ _loop0_142_rule(Parser *p) return _seq; } -// _tmp_143: expression ['as' NAME] +// _tmp_144: expression ['as' NAME] static void * -_tmp_143_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34902,7 +35646,7 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_144[%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; @@ -34912,12 +35656,12 @@ _tmp_143_rule(Parser *p) (_opt_var = _tmp_22_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_144[%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_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]")); } _res = NULL; @@ -34926,9 +35670,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: NEWLINE | ':' +// _tmp_145: NEWLINE | ':' 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); @@ -34944,18 +35688,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, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_145[%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_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_145[%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_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, "NEWLINE")); } { // ':' @@ -34963,18 +35707,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } _res = NULL; @@ -34983,9 +35727,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _tmp_145: positional_patterns ',' +// _tmp_146: positional_patterns ',' static void * -_tmp_145_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35001,7 +35745,7 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -35010,12 +35754,12 @@ _tmp_145_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_146[%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_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); } _res = NULL; @@ -35024,9 +35768,9 @@ _tmp_145_rule(Parser *p) return _res; } -// _tmp_146: '}' | ',' +// _tmp_147: '}' | ',' 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); @@ -35042,18 +35786,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; 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, "'}'")); } { // ',' @@ -35061,18 +35805,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; 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, "','")); } _res = NULL; @@ -35081,9 +35825,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: '=' | '!' | ':' | '}' +// _tmp_148: '=' | '!' | ':' | '}' 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); @@ -35099,18 +35843,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, 22)) // 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, "'='")); } { // '!' @@ -35118,18 +35862,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, 54)) // 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, "'!'")); } { // ':' @@ -35137,18 +35881,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, "':'")); } { // '}' @@ -35156,18 +35900,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, 26)) // 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; @@ -35176,9 +35920,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: '!' | ':' | '}' +// _tmp_149: '!' | ':' | '}' 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); @@ -35194,18 +35938,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _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, "'!'")); } { // ':' @@ -35213,18 +35957,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _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, "':'")); } { // '}' @@ -35232,18 +35976,18 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _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, "'}'")); } _res = NULL; @@ -35252,9 +35996,9 @@ _tmp_148_rule(Parser *p) return _res; } -// _tmp_149: '!' NAME +// _tmp_150: '!' NAME 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); @@ -35270,7 +36014,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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -35279,12 +36023,12 @@ _tmp_149_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_150[%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_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, "'!' NAME")); } _res = NULL; @@ -35293,9 +36037,9 @@ _tmp_149_rule(Parser *p) return _res; } -// _tmp_150: ':' | '}' +// _tmp_151: ':' | '}' 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); @@ -35311,18 +36055,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } { // '}' @@ -35330,18 +36074,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; 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, "'}'")); } _res = NULL; @@ -35350,9 +36094,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); @@ -35368,18 +36112,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, 14)) // 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, "'+'")); } { // '-' @@ -35387,18 +36131,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, 15)) // 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, "'-'")); } { // '*' @@ -35406,18 +36150,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, 16)) // 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, "'*'")); } { // '/' @@ -35425,18 +36169,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, 17)) // 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, "'/'")); } { // '%' @@ -35444,18 +36188,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, 24)) // 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, "'%'")); } { // '//' @@ -35463,18 +36207,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, 47)) // 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, "'//'")); } { // '@' @@ -35482,18 +36226,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, 49)) // 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; @@ -35502,9 +36246,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); @@ -35520,18 +36264,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, 14)) // 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, "'+'")); } { // '-' @@ -35539,18 +36283,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, 15)) // 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, "'-'")); } { // '~' @@ -35558,18 +36302,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, 31)) // 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; @@ -35578,9 +36322,9 @@ _tmp_152_rule(Parser *p) return _res; } -// _tmp_153: star_targets '=' +// _tmp_154: star_targets '=' 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); @@ -35596,7 +36340,7 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -35605,7 +36349,7 @@ _tmp_153_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35615,7 +36359,7 @@ _tmp_153_rule(Parser *p) 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, "star_targets '='")); } _res = NULL; @@ -35624,9 +36368,9 @@ _tmp_153_rule(Parser *p) return _res; } -// _tmp_154: '.' | '...' +// _tmp_155: '.' | '...' 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); @@ -35642,18 +36386,18 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); _res = _literal; 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, "'.'")); } { // '...' @@ -35661,18 +36405,18 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 52)) // token='...' ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); _res = _literal; 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, "'...'")); } _res = NULL; @@ -35681,9 +36425,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _tmp_155: '@' named_expression NEWLINE +// _tmp_156: '@' named_expression NEWLINE 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); @@ -35699,7 +36443,7 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -35711,7 +36455,7 @@ _tmp_155_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); _res = f; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35721,7 +36465,7 @@ _tmp_155_rule(Parser *p) 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, "'@' named_expression NEWLINE")); } _res = NULL; @@ -35730,9 +36474,9 @@ _tmp_155_rule(Parser *p) return _res; } -// _tmp_156: ',' star_expression +// _tmp_157: ',' star_expression 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); @@ -35748,7 +36492,7 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -35757,7 +36501,7 @@ _tmp_156_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35767,7 +36511,7 @@ _tmp_156_rule(Parser *p) 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, "',' star_expression")); } _res = NULL; @@ -35776,9 +36520,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: 'or' conjunction +// _tmp_158: 'or' conjunction 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); @@ -35794,7 +36538,7 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -35803,7 +36547,7 @@ _tmp_157_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35813,7 +36557,7 @@ _tmp_157_rule(Parser *p) 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, "'or' conjunction")); } _res = NULL; @@ -35822,9 +36566,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: 'and' inversion +// _tmp_159: 'and' inversion 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); @@ -35840,7 +36584,7 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -35849,7 +36593,7 @@ _tmp_158_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35859,7 +36603,7 @@ _tmp_158_rule(Parser *p) 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, "'and' inversion")); } _res = NULL; @@ -35868,9 +36612,9 @@ _tmp_158_rule(Parser *p) return _res; } -// _tmp_159: slice | starred_expression +// _tmp_160: slice | starred_expression 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); @@ -35886,18 +36630,18 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c> _tmp_160[%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_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c+ _tmp_160[%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_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, "slice")); } { // starred_expression @@ -35905,18 +36649,18 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_160[%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_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_160[%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_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, "starred_expression")); } _res = NULL; @@ -35925,9 +36669,9 @@ _tmp_159_rule(Parser *p) return _res; } -// _tmp_160: fstring | string | tstring +// _tmp_161: fstring | string | tstring 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); @@ -35943,18 +36687,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, "fstring")); + D(fprintf(stderr, "%*c> _tmp_161[%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_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_161[%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_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, "fstring")); } { // string @@ -35962,18 +36706,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, "string")); + D(fprintf(stderr, "%*c> _tmp_161[%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_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c+ _tmp_161[%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_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, "string")); } { // tstring @@ -35981,18 +36725,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, "tstring")); + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); expr_ty tstring_var; if ( (tstring_var = tstring_rule(p)) // tstring ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring")); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring")); _res = tstring_var; 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, "tstring")); } _res = NULL; @@ -36001,9 +36745,9 @@ _tmp_160_rule(Parser *p) return _res; } -// _tmp_161: 'if' disjunction +// _tmp_162: 'if' disjunction 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); @@ -36019,7 +36763,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, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -36028,7 +36772,7 @@ _tmp_161_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -36038,7 +36782,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, "'if' disjunction")); } _res = NULL; @@ -36047,9 +36791,9 @@ _tmp_161_rule(Parser *p) return _res; } -// _tmp_162: starred_expression | (assignment_expression | expression !':=') !'=' +// _tmp_163: starred_expression | (assignment_expression | 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); @@ -36065,18 +36809,18 @@ _tmp_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_163[%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_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_163[%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_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, "starred_expression")); } { // (assignment_expression | expression !':=') !'=' @@ -36084,20 +36828,20 @@ _tmp_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - void *_tmp_86_var; + D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + void *_tmp_87_var; if ( - (_tmp_86_var = _tmp_86_rule(p)) // assignment_expression | expression !':=' + (_tmp_87_var = _tmp_87_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_86_var; + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_87_var; 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, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -36106,9 +36850,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: ',' star_target +// _tmp_164: ',' star_target 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); @@ -36124,7 +36868,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, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -36133,7 +36877,7 @@ _tmp_163_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -36143,7 +36887,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, "',' star_target")); } _res = NULL; @@ -36152,10 +36896,10 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: +// _tmp_165: // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs 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); @@ -36171,24 +36915,24 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - asdl_seq * _gather_88_var; + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + asdl_seq * _gather_89_var; Token * _literal; asdl_seq* kwargs_var; if ( - (_gather_88_var = _gather_88_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (_gather_89_var = _gather_89_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_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - _res = _PyPegen_dummy_name(p, _gather_88_var, _literal, kwargs_var); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + _res = _PyPegen_dummy_name(p, _gather_89_var, _literal, kwargs_var); 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, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); } _res = NULL; @@ -36197,9 +36941,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _tmp_165: starred_expression !'=' +// _tmp_166: 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); @@ -36215,7 +36959,7 @@ _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 @@ -36223,12 +36967,12 @@ _tmp_165_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - 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; @@ -36237,9 +36981,9 @@ _tmp_165_rule(Parser *p) return _res; } -// _tmp_166: !STRING expression_without_invalid +// _tmp_167: !STRING expression_without_invalid 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); @@ -36255,7 +36999,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, "!STRING expression_without_invalid")); + D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); expr_ty expression_without_invalid_var; if ( _PyPegen_lookahead(0, (void *(*)(Parser *)) _PyPegen_string_token, p) @@ -36263,12 +37007,12 @@ _tmp_166_rule(Parser *p) (expression_without_invalid_var = expression_without_invalid_rule(p)) // expression_without_invalid ) { - D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); + D(fprintf(stderr, "%*c+ _tmp_167[%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_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, "!STRING expression_without_invalid")); } _res = NULL; @@ -36277,9 +37021,9 @@ _tmp_166_rule(Parser *p) return _res; } -// _tmp_167: ')' | '**' +// _tmp_168: ')' | '**' 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); @@ -36295,18 +37039,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, "')'")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; 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, "')'")); } { // '**' @@ -36314,18 +37058,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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } _res = NULL; @@ -36334,9 +37078,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _tmp_168: ':' | '**' +// _tmp_169: ':' | '**' 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); @@ -36352,18 +37096,18 @@ _tmp_168_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; 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, "':'")); } { // '**' @@ -36371,18 +37115,18 @@ _tmp_168_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; 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, "'**'")); } _res = NULL; @@ -36391,9 +37135,9 @@ _tmp_168_rule(Parser *p) return _res; } -// _loop0_169: (',' bitwise_or) +// _loop0_170: (',' bitwise_or) static asdl_seq * -_loop0_169_rule(Parser *p) +_loop0_170_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36418,13 +37162,13 @@ _loop0_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); - void *_tmp_172_var; + D(fprintf(stderr, "%*c> _loop0_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); + void *_tmp_173_var; while ( - (_tmp_172_var = _tmp_172_rule(p)) // ',' bitwise_or + (_tmp_173_var = _tmp_173_rule(p)) // ',' bitwise_or ) { - _res = _tmp_172_var; + _res = _tmp_173_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36441,7 +37185,7 @@ _loop0_169_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_169[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_170[%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); @@ -36458,9 +37202,9 @@ _loop0_169_rule(Parser *p) return _seq; } -// _tmp_170: expression ['as' star_target] +// _tmp_171: expression ['as' star_target] 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); @@ -36476,22 +37220,22 @@ _tmp_170_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_171[%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_173_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_174_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_171[%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_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, "expression ['as' star_target]")); } _res = NULL; @@ -36500,9 +37244,9 @@ _tmp_170_rule(Parser *p) return _res; } -// _tmp_171: expressions ['as' star_target] +// _tmp_172: expressions ['as' star_target] 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); @@ -36518,22 +37262,22 @@ _tmp_171_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_172[%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_173_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_174_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_172[%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_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, "expressions ['as' star_target]")); } _res = NULL; @@ -36542,9 +37286,9 @@ _tmp_171_rule(Parser *p) return _res; } -// _tmp_172: ',' bitwise_or +// _tmp_173: ',' bitwise_or 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); @@ -36560,7 +37304,7 @@ _tmp_172_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); Token * _literal; expr_ty bitwise_or_var; if ( @@ -36569,12 +37313,12 @@ _tmp_172_rule(Parser *p) (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c+ _tmp_173[%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_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, "',' bitwise_or")); } _res = NULL; @@ -36583,9 +37327,9 @@ _tmp_172_rule(Parser *p) return _res; } -// _tmp_173: 'as' star_target +// _tmp_174: 'as' star_target 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); @@ -36601,7 +37345,7 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( @@ -36610,12 +37354,12 @@ _tmp_173_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_174[%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_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, "'as' star_target")); } _res = NULL; From e84778a1c46473a0b78460a86a62572effdc57f6 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:31:59 +0200 Subject: [PATCH 59/88] Rename f helper to fstring --- Lib/test/test_string/_support.py | 2 +- Lib/test/test_string/test_templatelib.py | 18 ++++---- Lib/test/test_tstring.py | 58 ++++++++++++------------ 3 files changed, 39 insertions(+), 39 deletions(-) diff --git a/Lib/test/test_string/_support.py b/Lib/test/test_string/_support.py index c08392d0aa7945..fcdfd47f91e6e4 100644 --- a/Lib/test/test_string/_support.py +++ b/Lib/test/test_string/_support.py @@ -42,7 +42,7 @@ def convert(value, conversion): return value -def f(template): +def fstring(template): parts = [] for item in template: match item: diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py index d00560c7e91356..6030da99b75d0d 100644 --- a/Lib/test/test_string/test_templatelib.py +++ b/Lib/test/test_string/test_templatelib.py @@ -1,6 +1,6 @@ from string.templatelib import Template, Interpolation -from test.test_string._support import TStringTestCase, f +from test.test_string._support import TStringTestCase, fstring class TestTemplate(TStringTestCase): @@ -10,41 +10,41 @@ def test_basic_creation(self): t = t'Hello, world' self.assertIsInstance(t, Template) self.assertTStringEqual(t, ('Hello, world',), ()) - self.assertEqual(f(t), 'Hello, world') + self.assertEqual(fstring(t), 'Hello, world') # Empty t-string t = t'' self.assertTStringEqual(t, ('',), ()) - self.assertEqual(f(t), '') + self.assertEqual(fstring(t), '') # Multi-line t-string t = t"""Hello, world""" self.assertEqual(t.strings, ('Hello,\nworld',)) self.assertEqual(len(t.interpolations), 0) - self.assertEqual(f(t), 'Hello,\nworld') + self.assertEqual(fstring(t), 'Hello,\nworld') def test_creation_interleaving(self): # Should add strings on either side t = Template(Interpolation('Maria', 'name', None, '')) self.assertTStringEqual(t, ('', ''), [('Maria', 'name')]) - self.assertEqual(f(t), 'Maria') + self.assertEqual(fstring(t), 'Maria') # Should prepend empty string t = Template(Interpolation('Maria', 'name', None, ''), ' is my name') self.assertTStringEqual(t, ('', ' is my name'), [('Maria', 'name')]) - self.assertEqual(f(t), 'Maria is my name') + self.assertEqual(fstring(t), 'Maria is my name') # Should append empty string t = Template('Hello, ', Interpolation('Maria', 'name', None, '')) self.assertTStringEqual(t, ('Hello, ', ''), [('Maria', 'name')]) - self.assertEqual(f(t), 'Hello, Maria') + self.assertEqual(fstring(t), 'Hello, Maria') # Should concatenate strings t = Template('Hello', ', ', Interpolation('Maria', 'name', None, ''), '!') self.assertTStringEqual(t, ('Hello, ', '!'), [('Maria', 'name')]) - self.assertEqual(f(t), 'Hello, Maria!') + self.assertEqual(fstring(t), 'Hello, Maria!') # Should add strings on either side and in between t = Template(Interpolation('Maria', 'name', None, ''), @@ -52,4 +52,4 @@ def test_creation_interleaving(self): self.assertTStringEqual( t, ('', '', ''), [('Maria', 'name'), ('Python', 'language')] ) - self.assertEqual(f(t), 'MariaPython') + self.assertEqual(fstring(t), 'MariaPython') diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index e4d90cc042ea03..829b79cce3e5fe 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -1,7 +1,7 @@ import ast import unittest -from test.test_string._support import TStringTestCase, f +from test.test_string._support import TStringTestCase, fstring class TestTString(TStringTestCase): @@ -28,7 +28,7 @@ def test_interpolation_basics(self): name = "Python" t = t"Hello, {name}" self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) - self.assertEqual(f(t), "Hello, Python") + self.assertEqual(fstring(t), "Hello, Python") # Multiple interpolations first = "Python" @@ -37,14 +37,14 @@ def test_interpolation_basics(self): self.assertTStringEqual( t, ("", " ", ""), [(first, 'first'), (last, 'last')] ) - self.assertEqual(f(t), "Python Developer") + self.assertEqual(fstring(t), "Python Developer") # Interpolation with expressions a = 10 b = 20 t = t"Sum: {a + b}" self.assertTStringEqual(t, ("Sum: ", ""), [(a + b, "a + b")]) - self.assertEqual(f(t), "Sum: 30") + self.assertEqual(fstring(t), "Sum: 30") # Interpolation with function def square(x): @@ -53,7 +53,7 @@ def square(x): self.assertTStringEqual( t, ("Square: ", ""), [(square(5), "square(5)")] ) - self.assertEqual(f(t), "Square: 25") + self.assertEqual(fstring(t), "Square: 25") # Test attribute access in expressions class Person: @@ -68,14 +68,14 @@ def upper(self): self.assertTStringEqual( t, ("Name: ", ""), [(person.name, "person.name")] ) - self.assertEqual(f(t), "Name: Alice") + self.assertEqual(fstring(t), "Name: Alice") # Test method calls t = t"Name: {person.upper()}" self.assertTStringEqual( t, ("Name: ", ""), [(person.upper(), "person.upper()")] ) - self.assertEqual(f(t), "Name: ALICE") + self.assertEqual(fstring(t), "Name: ALICE") # Test dictionary access data = {"name": "Bob", "age": 30} @@ -84,7 +84,7 @@ def upper(self): t, ("Name: ", ", Age: ", ""), [(data["name"], "data['name']"), (data["age"], "data['age']")], ) - self.assertEqual(f(t), "Name: Bob, Age: 30") + self.assertEqual(fstring(t), "Name: Bob, Age: 30") def test_format_specifiers(self): # Test basic format specifiers @@ -93,25 +93,25 @@ def test_format_specifiers(self): self.assertTStringEqual( t, ("Pi: ", ""), [(value, "value", None, ".2f")] ) - self.assertEqual(f(t), "Pi: 3.14") + self.assertEqual(fstring(t), "Pi: 3.14") def test_conversions(self): # Test !s conversion (str) obj = object() t = t"Object: {obj!s}" self.assertTStringEqual(t, ("Object: ", ""), [(obj, "obj", "s")]) - self.assertEqual(f(t), f"Object: {str(obj)}") + self.assertEqual(fstring(t), f"Object: {str(obj)}") # Test !r conversion (repr) t = t"Data: {obj!r}" self.assertTStringEqual(t, ("Data: ", ""), [(obj, "obj", "r")]) - self.assertEqual(f(t), f"Data: {repr(obj)}") + self.assertEqual(fstring(t), f"Data: {repr(obj)}") # Test !a conversion (ascii) text = "Café" t = t"ASCII: {text!a}" self.assertTStringEqual(t, ("ASCII: ", ""), [(text, "text", "a")]) - self.assertEqual(f(t), f"ASCII: {ascii(text)}") + self.assertEqual(fstring(t), f"ASCII: {ascii(text)}") # Test !z conversion (error) num = 1 @@ -125,14 +125,14 @@ def test_debug_specifier(self): self.assertTStringEqual( t, ("Value: value=", ""), [(value, "value", "r")] ) - self.assertEqual(f(t), "Value: value=42") + self.assertEqual(fstring(t), "Value: value=42") # Test debug specifier with format (conversion default to !r) t = t"Value: {value=:.2f}" self.assertTStringEqual( t, ("Value: value=", ""), [(value, "value", None, ".2f")] ) - self.assertEqual(f(t), "Value: value=42.00") + self.assertEqual(fstring(t), "Value: value=42.00") # Test debug specifier with conversion t = t"Value: {value=!s}" @@ -145,13 +145,13 @@ def test_debug_specifier(self): self.assertTStringEqual( t, ("Value: value = ", ""), [(value, "value", "r")] ) - self.assertEqual(f(t), "Value: value = 42") + self.assertEqual(fstring(t), "Value: value = 42") def test_raw_tstrings(self): path = r"C:\Users" t = rt"{path}\Documents" self.assertTStringEqual(t, ("", r"\Documents"), [(path, "path")]) - self.assertEqual(f(t), r"C:\Users\Documents") + self.assertEqual(fstring(t), r"C:\Users\Documents") # Test alternative prefix t = tr"{path}\Documents" @@ -164,13 +164,13 @@ def test_template_concatenation(self): t2 = t"world" combined = t1 + t2 self.assertTStringEqual(combined, ("Hello, world",), ()) - self.assertEqual(f(combined), "Hello, world") + self.assertEqual(fstring(combined), "Hello, world") # Test template + string t1 = t"Hello" combined = t1 + ", world" self.assertTStringEqual(combined, ("Hello, world",), ()) - self.assertEqual(f(combined), "Hello, world") + self.assertEqual(fstring(combined), "Hello, world") # Test template + template with interpolation name = "Python" @@ -178,12 +178,12 @@ def test_template_concatenation(self): t2 = t"{name}" combined = t1 + t2 self.assertTStringEqual(combined, ("Hello, ", ""), [(name, "name")]) - self.assertEqual(f(combined), "Hello, Python") + self.assertEqual(fstring(combined), "Hello, Python") # Test string + template t = "Hello, " + t"{name}" self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) - self.assertEqual(f(t), "Hello, Python") + self.assertEqual(fstring(t), "Hello, Python") def test_nested_templates(self): # Test a template inside another template expression @@ -251,13 +251,13 @@ def test_literal_concatenation(self): # Test concatenation of t-string literals t = t"Hello, " t"world" self.assertTStringEqual(t, ("Hello, world",), ()) - self.assertEqual(f(t), "Hello, world") + self.assertEqual(fstring(t), "Hello, world") # Test concatenation with interpolation name = "Python" t = t"Hello, " t"{name}" self.assertTStringEqual(t, ("Hello, ", ""), [(name, "name")]) - self.assertEqual(f(t), "Hello, Python") + self.assertEqual(fstring(t), "Hello, Python") # Test concatenation with string literal name = "Python" @@ -265,7 +265,7 @@ def test_literal_concatenation(self): self.assertTStringEqual( t, ("Hello, ", "and welcome!"), [(name, "name")] ) - self.assertEqual(f(t), "Hello, Pythonand welcome!") + self.assertEqual(fstring(t), "Hello, Pythonand welcome!") # Test concatenation with Unicode literal name = "Python" @@ -273,13 +273,13 @@ def test_literal_concatenation(self): self.assertTStringEqual( t, ("Hello, ", "and welcome!"), [(name, "name")] ) - self.assertEqual(f(t), "Hello, Pythonand welcome!") + self.assertEqual(fstring(t), "Hello, Pythonand welcome!") # Test concatenation with f-string literal tab = '\t' t = t"Tab: {tab}. " f"f-tab: {tab}." self.assertTStringEqual(t, ("Tab: ", ". f-tab: \t."), [(tab, "tab")]) - self.assertEqual(f(t), "Tab: \t. f-tab: \t.") + self.assertEqual(fstring(t), "Tab: \t. f-tab: \t.") # Test concatenation with raw string literal tab = '\t' @@ -287,7 +287,7 @@ def test_literal_concatenation(self): self.assertTStringEqual( t, ("Tab: ", r". Raw tab: \t."), [(tab, "tab")] ) - self.assertEqual(f(t), "Tab: \t. Raw tab: \\t.") + self.assertEqual(fstring(t), "Tab: \t. Raw tab: \\t.") # Test concatenation with raw f-string literal tab = '\t' @@ -295,7 +295,7 @@ def test_literal_concatenation(self): self.assertTStringEqual( t, ("Tab: ", ". f-tab: \t. Raw tab: \\t."), [(tab, "tab")] ) - self.assertEqual(f(t), "Tab: \t. f-tab: \t. Raw tab: \\t.") + self.assertEqual(fstring(t), "Tab: \t. f-tab: \t. Raw tab: \\t.") what = 't' expected_msg = 'cannot mix bytes and nonbytes literals' @@ -315,7 +315,7 @@ def test_triple_quoted(self): self.assertTStringEqual( t, ("\n Hello,\n world\n ",), () ) - self.assertEqual(f(t), "\n Hello,\n world\n ") + self.assertEqual(fstring(t), "\n Hello,\n world\n ") # Test triple-quoted with interpolation name = "Python" @@ -326,7 +326,7 @@ def test_triple_quoted(self): self.assertTStringEqual( t, ("\n Hello,\n ", "\n "), [(name, "name")] ) - self.assertEqual(f(t), "\n Hello,\n Python\n ") + self.assertEqual(fstring(t), "\n Hello,\n Python\n ") if __name__ == '__main__': unittest.main() From 8b24ff375442e102d071ceb334fd4e554cbb19d5 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:38:01 +0200 Subject: [PATCH 60/88] Use Py_BuildValue and add error checking for _PyType_GetDict --- Objects/interpolationobject.c | 47 ++++++----------------------------- 1 file changed, 8 insertions(+), 39 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 6dd163186b1d73..e75278395598fe 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -132,53 +132,22 @@ PyTypeObject _PyInterpolation_Type = { .tp_traverse = interpolation_traverse, }; -static PyObject * -_get_match_args(void) -{ - PyObject *value = NULL, *expression = NULL, *conversion = NULL, *format_spec = NULL; - PyObject *tuple = NULL; - - value = PyUnicode_FromString("value"); - if (!value) { - goto error; - } - expression = PyUnicode_FromString("expression"); - if (!expression) { - goto error; - } - conversion = PyUnicode_FromString("conversion"); - if (!conversion) { - goto error; - } - format_spec = PyUnicode_FromString("format_spec"); - if (!format_spec) { - goto error; - } - - tuple = PyTuple_Pack(4, value, expression, conversion, format_spec); - -error: - Py_XDECREF(value); - Py_XDECREF(expression); - Py_XDECREF(conversion); - Py_XDECREF(format_spec); - return tuple; - -} - PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp) { - PyObject *tuple = _get_match_args(); + PyObject *tuple = Py_BuildValue("(ssss)", "value", "expression", "conversion", "format_spec"); if (!tuple) { goto error; } - int status = PyDict_SetItemString(_PyType_GetDict(&_PyInterpolation_Type), - "__match_args__", - tuple); - Py_DECREF(tuple); + PyObject *dict = _PyType_GetDict(&_PyInterpolation_Type); + if (!dict) { + Py_DECREF(tuple); + goto error; + } + int status = PyDict_SetItemString(dict, "__match_args__", tuple); + Py_DECREF(tuple); if (status < 0) { goto error; } From 23444df35a5d20abac8642fd44aa6d90d7dd24e7 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:40:40 +0200 Subject: [PATCH 61/88] Return a strong ref from _PyInterpolation_GetValue --- Include/internal/pycore_interpolation.h | 2 +- Objects/interpolationobject.c | 4 ++-- Objects/templateobject.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index d00c2a517d63e9..1e599a972ccedc 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -18,7 +18,7 @@ extern PyTypeObject _PyInterpolation_Type; PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values); extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); -extern PyObject *_PyInterpolation_GetValue(PyObject *interpolation); +extern PyObject *_PyInterpolation_GetValueRef(PyObject *interpolation); #ifdef __cplusplus } diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index e75278395598fe..fb9c61fefa93ec 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -184,7 +184,7 @@ _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values) } PyObject * -_PyInterpolation_GetValue(PyObject *interpolation) +_PyInterpolation_GetValueRef(PyObject *interpolation) { - return interpolationobject_CAST(interpolation)->value; + return Py_NewRef(interpolationobject_CAST(interpolation)->value); } diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 37c06660c56d7b..a634bb14833ec0 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -437,7 +437,7 @@ template_values_get(PyObject *op, void *Py_UNUSED(data)) PyObject *item; Py_ssize_t index = 0; while ((item = PyIter_Next(interpolationsiter))) { - PyTuple_SET_ITEM(values, index++, Py_NewRef(_PyInterpolation_GetValue(item))); + PyTuple_SET_ITEM(values, index++, _PyInterpolation_GetValueRef(item)); Py_DECREF(item); } From 19aad93da760085001c1a6bf4763329829986be7 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:48:30 +0200 Subject: [PATCH 62/88] Remove unnecessary function for template concatenation --- Objects/templateobject.c | 55 +++------------------------------------- 1 file changed, 3 insertions(+), 52 deletions(-) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index a634bb14833ec0..627077a1bb4990 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -228,41 +228,6 @@ template_iter(PyObject *op) return (PyObject *)iter; } -static PyObject * -template_interpolations_copy(PyObject *interpolations) { - Py_ssize_t interpolationslen = PyTuple_GET_SIZE(interpolations); - PyObject *newinterpolations = PyTuple_New(interpolationslen); - if (!newinterpolations) { - return NULL; - } - - for (Py_ssize_t i = 0; i < interpolationslen; i++) { - PyTuple_SET_ITEM(newinterpolations, i, Py_NewRef(PyTuple_GET_ITEM(interpolations, i))); - } - return newinterpolations; -} - -static PyObject * -template_interpolations_concat(PyObject *left, PyObject *right) { - Py_ssize_t leftlen = PyTuple_GET_SIZE(left); - Py_ssize_t rightlen = PyTuple_GET_SIZE(right); - Py_ssize_t interpolationslen = leftlen + rightlen; - - PyObject *newinterpolations = PyTuple_New(interpolationslen); - if (!newinterpolations) { - return NULL; - } - - Py_ssize_t index = 0; - for (Py_ssize_t i = 0; i < leftlen; i++) { - PyTuple_SET_ITEM(newinterpolations, index++, Py_NewRef(PyTuple_GET_ITEM(left, i))); - } - for (Py_ssize_t i = 0; i < rightlen; i++) { - PyTuple_SET_ITEM(newinterpolations, index++, Py_NewRef(PyTuple_GET_ITEM(right, i))); - } - return newinterpolations; -} - static PyObject * template_strings_append_str(PyObject *strings, PyObject *str) { @@ -350,7 +315,7 @@ template_concat_templates(templateobject *self, templateobject *other) return NULL; } - PyObject *newinterpolations = template_interpolations_concat(self->interpolations, other->interpolations); + PyObject *newinterpolations = PySequence_Concat(self->interpolations, other->interpolations); if (newinterpolations == NULL) { Py_DECREF(newstrings); return NULL; @@ -370,15 +335,8 @@ template_concat_template_str(templateobject *self, PyObject *other) return NULL; } - PyObject *newinterpolations = template_interpolations_copy(self->interpolations); - if (newinterpolations == NULL) { - Py_DECREF(newstrings); - return NULL; - } - - templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, self->interpolations); Py_DECREF(newstrings); - Py_DECREF(newinterpolations); return (PyObject *) newtemplate; } @@ -390,15 +348,8 @@ template_concat_str_template(templateobject *self, PyObject *other) return NULL; } - PyObject *newinterpolations = template_interpolations_copy(self->interpolations); - if (newinterpolations == NULL) { - Py_DECREF(newstrings); - return NULL; - } - - templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, self->interpolations); Py_DECREF(newstrings); - Py_DECREF(newinterpolations); return (PyObject *) newtemplate; } From adbc10938129dd7db68cfdfe5a1c30ea27d84bb1 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:52:20 +0200 Subject: [PATCH 63/88] Formatting --- Objects/interpolationobject.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index fb9c61fefa93ec..d4586cb487fca6 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -170,13 +170,15 @@ _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values) if (PyStackRef_IsNull(values[2])) { interpolation->conversion = Py_NewRef(Py_None); - } else { + } + else { interpolation->conversion = PyStackRef_AsPyObjectSteal(values[2]); } if (PyStackRef_IsNull(values[3])) { interpolation->format_spec = Py_NewRef(&_Py_STR(empty)); - } else { + } + else { interpolation->format_spec = PyStackRef_AsPyObjectSteal(values[3]); } From a5e3bde5a17cffc7a78baf4362345d7483239613 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 16:53:58 +0200 Subject: [PATCH 64/88] Add versionadded directive to TSTRING_START docs --- Doc/library/token.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Doc/library/token.rst b/Doc/library/token.rst index e671bce554ba30..c1ca746acdb126 100644 --- a/Doc/library/token.rst +++ b/Doc/library/token.rst @@ -140,6 +140,8 @@ The token constants are: The token string includes the prefix and the opening quote(s), but none of the contents of the literal. + .. versionadded:: next + .. data:: ENDMARKER Token value that indicates the end of input. From c8a948250ad0887baba3124f9181b191b3618ae4 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 18:46:57 +0200 Subject: [PATCH 65/88] Add TOK_GET_STRING_PREFIX macro and change tstring field to enum --- Grammar/python.gram | 2 +- Parser/action_helpers.c | 17 +++++++++-------- Parser/lexer/lexer.c | 31 +++++++++++++++++-------------- Parser/lexer/state.h | 7 ++++++- Parser/parser.c | 2 +- Parser/pegen.h | 1 + 6 files changed, 35 insertions(+), 25 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 16c9414da67f2a..65cae7443c4d21 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -1225,7 +1225,7 @@ invalid_expression: RAISE_SYNTAX_ERROR_KNOWN_LOCATION (a, "expected expression before 'if', but statement is given") } | a='lambda' [lambda_params] b=':' &FSTRING_MIDDLE { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "%c-string: lambda expressions are not allowed without parentheses", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f') } + TOK_GET_STRING_PREFIX(p->tok)) } invalid_named_expression(memo): | a=expression ':=' expression { diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 1c63b97dac4670..d78d23ef211cc0 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -966,7 +966,7 @@ _PyPegen_check_fstring_conversion(Parser *p, Token* conv_token, expr_ty conv) return RAISE_SYNTAX_ERROR_KNOWN_RANGE( conv_token, conv, "%c-string: conversion type must come right after the exclamanation mark", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f' + TOK_GET_STRING_PREFIX(p->tok) ); } @@ -975,7 +975,7 @@ _PyPegen_check_fstring_conversion(Parser *p, Token* conv_token, expr_ty conv) !(first == 's' || first == 'r' || first == 'a')) { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(conv, "%c-string: invalid conversion character %R: expected 's', 'r', or 'a'", - TOK_GET_MODE(p->tok)->tstring ? 't' : 'f', + TOK_GET_STRING_PREFIX(p->tok), conv->v.Name.id); return NULL; } @@ -1295,7 +1295,7 @@ _PyPegen_decode_fstring_part(Parser* p, int is_raw, expr_ty constant, Token* tok } static asdl_expr_seq * -_get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b, int tstring) +_get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b, enum string_kind_t string_kind) { Py_ssize_t n_items = asdl_seq_LEN(raw_expressions); Py_ssize_t total_items = n_items; @@ -1329,8 +1329,9 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b asdl_expr_seq *values = item->v.JoinedStr.values; if (asdl_seq_LEN(values) != 2) { PyErr_Format(PyExc_SystemError, - tstring ? "unexpected TemplateStr node without debug data in t-string at line %d" - : "unexpected JoinedStr node without debug data in f-string at line %d", + string_kind == TSTRING + ? "unexpected TemplateStr node without debug data in t-string at line %d" + : "unexpected JoinedStr node without debug data in f-string at line %d", item->lineno); return NULL; } @@ -1340,7 +1341,7 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b asdl_seq_SET(seq, index++, first); expr_ty second = asdl_seq_GET(values, 1); - assert((tstring && second->kind == Interpolation_kind) || second->kind == FormattedValue_kind); + assert((string_kind == TSTRING && second->kind == Interpolation_kind) || second->kind == FormattedValue_kind); asdl_seq_SET(seq, index++, second); continue; @@ -1382,7 +1383,7 @@ _get_resized_exprs(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b expr_ty _PyPegen_template_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token *b) { - asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b, 1); + asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b, TSTRING); return _PyAST_TemplateStr(resized_exprs, a->lineno, a->col_offset, b->end_lineno, b->end_col_offset, p->arena); @@ -1391,7 +1392,7 @@ _PyPegen_template_str(Parser *p, Token *a, asdl_expr_seq *raw_expressions, Token expr_ty _PyPegen_joined_str(Parser *p, Token* a, asdl_expr_seq* raw_expressions, Token*b) { - asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b, 0); + asdl_expr_seq *resized_exprs = _get_resized_exprs(p, a, raw_expressions, b, FSTRING); return _PyAST_JoinedStr(resized_exprs, a->lineno, a->col_offset, b->end_lineno, b->end_col_offset, p->arena); diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index 794b0e5bc81838..66ec5c201b8c36 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -38,6 +38,7 @@ static inline tokenizer_mode* TOK_NEXT_MODE(struct tok_state* tok) { #define TOK_NEXT_MODE(tok) (&(tok->tok_mode_stack[++tok->tok_mode_stack_index])) #endif +#define TOK_GET_STRING_PREFIX(tok) (TOK_GET_MODE(tok)->string_kind == TSTRING ? 't' : 'f') #define MAKE_TOKEN(token_type) _PyLexer_token_setup(tok, token, token_type, p_start, p_end) #define MAKE_TYPE_COMMENT_TOKEN(token_type, col_offset, end_col_offset) (\ _PyLexer_type_comment_token_setup(tok, token, token_type, col_offset, end_col_offset, p_start, p_end)) @@ -113,7 +114,7 @@ set_ftstring_expr(struct tok_state* tok, struct token *token, char c) { assert(c == '}' || c == ':' || c == '!'); tokenizer_mode *tok_mode = TOK_GET_MODE(tok); - if (!(tok_mode->f_string_debug || tok_mode->tstring) || token->metadata) { + if (!(tok_mode->f_string_debug || tok_mode->string_kind == TSTRING) || token->metadata) { return 0; } PyObject *res = NULL; @@ -993,12 +994,12 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t the_current_tok->in_format_spec = 0; the_current_tok->f_string_debug = 0; - int tstring = 0; + enum string_kind_t string_kind = FSTRING; switch (*tok->start) { case 'T': case 't': the_current_tok->f_string_raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; - tstring = 1; + string_kind = TSTRING; break; case 'F': case 'f': @@ -1007,16 +1008,18 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t case 'R': case 'r': the_current_tok->f_string_raw = 1; - tstring = Py_TOLOWER(*(tok->start + 1)) == 't'; + if (Py_TOLOWER(*(tok->start + 1)) == 't') { + string_kind = TSTRING; + } break; default: Py_UNREACHABLE(); } - the_current_tok->tstring = tstring; + the_current_tok->string_kind = TSTRING; the_current_tok->curly_bracket_depth = 0; the_current_tok->curly_bracket_expr_start_depth = -1; - return tstring ? MAKE_TOKEN(TSTRING_START) : MAKE_TOKEN(FSTRING_START); + return string_kind == TSTRING ? MAKE_TOKEN(TSTRING_START) : MAKE_TOKEN(FSTRING_START); } letter_quote: @@ -1079,7 +1082,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t if (the_current_tok->f_string_quote == quote && the_current_tok->f_string_quote_size == quote_size) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, - "%c-string: expecting '}'", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); + "%c-string: expecting '}'", TOK_GET_STRING_PREFIX(tok))); } } @@ -1209,7 +1212,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t case '}': if (INSIDE_FSTRING(tok) && !current_tok->curly_bracket_depth && c == '}') { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, - "%c-string: single '}' is not allowed", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); + "%c-string: single '}' is not allowed", TOK_GET_STRING_PREFIX(tok))); } if (!tok->tok_extra_tokens && !tok->level) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "unmatched '%c'", c)); @@ -1230,7 +1233,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t int previous_bracket = current_tok->curly_bracket_depth - 1; if (previous_bracket == current_tok->curly_bracket_expr_start_depth) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, - "%c-string: unmatched '%c'", TOK_GET_MODE(tok)->tstring ? 't' : 'f', c)); + "%c-string: unmatched '%c'", TOK_GET_STRING_PREFIX(tok), c)); } } if (tok->parenlinenostack[tok->level] != tok->lineno) { @@ -1252,7 +1255,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t current_tok->curly_bracket_depth--; if (current_tok->curly_bracket_depth < 0) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "%c-string: unmatched '%c'", - TOK_GET_MODE(tok)->tstring ? 't' : 'f', c)); + TOK_GET_STRING_PREFIX(tok), c)); } if (c == '}' && current_tok->curly_bracket_depth == current_tok->curly_bracket_expr_start_depth) { current_tok->curly_bracket_expr_start_depth--; @@ -1303,7 +1306,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct current_tok->curly_bracket_expr_start_depth++; if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, - "%c-string: expressions nested too deeply", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); + "%c-string: expressions nested too deeply", TOK_GET_STRING_PREFIX(tok))); } TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE; return tok_get_normal_mode(tok, current_tok, token); @@ -1383,7 +1386,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct _PyTokenizer_syntaxerror(tok, "unterminated triple-quoted %c-string literal" " (detected at line %d)", - TOK_GET_MODE(tok)->tstring ? 't' : 'f', start); + TOK_GET_STRING_PREFIX(tok), start); if (c != '\n') { tok->done = E_EOFS; } @@ -1392,7 +1395,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct else { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "unterminated %c-string literal (detected at" - " line %d)", TOK_GET_MODE(tok)->tstring ? 't' : 'f', start)); + " line %d)", TOK_GET_STRING_PREFIX(tok), start)); } } @@ -1414,7 +1417,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct current_tok->curly_bracket_expr_start_depth++; if (current_tok->curly_bracket_expr_start_depth >= MAX_EXPR_NESTING) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, - "%c-string: expressions nested too deeply", TOK_GET_MODE(tok)->tstring ? 't' : 'f')); + "%c-string: expressions nested too deeply", TOK_GET_STRING_PREFIX(tok))); } TOK_GET_MODE(tok)->kind = TOK_REGULAR_MODE; current_tok->in_format_spec = 0; diff --git a/Parser/lexer/state.h b/Parser/lexer/state.h index 022dcef9dd5e07..b8b5fea89cc97f 100644 --- a/Parser/lexer/state.h +++ b/Parser/lexer/state.h @@ -36,6 +36,11 @@ enum tokenizer_mode_kind_t { TOK_FSTRING_MODE, }; +enum string_kind_t { + FSTRING, + TSTRING, +}; + #define MAX_EXPR_NESTING 3 typedef struct _tokenizer_mode { @@ -60,7 +65,7 @@ typedef struct _tokenizer_mode { int f_string_debug; int in_format_spec; - int tstring; + enum string_kind_t string_kind; } tokenizer_mode; /* Tokenizer state */ diff --git a/Parser/parser.c b/Parser/parser.c index 3c18d170267f75..7e962e71a74fcf 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -21236,7 +21236,7 @@ invalid_expression_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE")); - _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "%c-string: lambda expressions are not allowed without parentheses" , TOK_GET_MODE ( p -> tok ) -> tstring ? 't' : 'f' ); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "%c-string: lambda expressions are not allowed without parentheses" , TOK_GET_STRING_PREFIX ( p -> tok ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; diff --git a/Parser/pegen.h b/Parser/pegen.h index ee7c4cb767fa34..196b0b1af9c8db 100644 --- a/Parser/pegen.h +++ b/Parser/pegen.h @@ -27,6 +27,7 @@ #define CURRENT_POS (-5) #define TOK_GET_MODE(tok) (&(tok->tok_mode_stack[tok->tok_mode_stack_index])) +#define TOK_GET_STRING_PREFIX(tok) (TOK_GET_MODE(tok)->string_kind == TSTRING ? 't' : 'f') typedef struct _memo { int type; From a78c082900cb388533440534871e23208906f4ff Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 19:56:27 +0200 Subject: [PATCH 66/88] Minor fixes to lexer and Makefile --- Makefile.pre.in | 1 + Parser/lexer/lexer.c | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile.pre.in b/Makefile.pre.in index 16f03f7e4f7ffa..0c0d71ea7359aa 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -2638,6 +2638,7 @@ TESTSUBDIRS= idlelib/idle_test \ test/test_peg_generator \ test/test_pydoc \ test/test_pyrepl \ + test/test_string \ test/test_sqlite3 \ test/test_tkinter \ test/test_tomllib \ diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index a1f6d32a1eeff0..63f38d767f3cb4 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -1016,7 +1016,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t Py_UNREACHABLE(); } - the_current_tok->string_kind = TSTRING; + the_current_tok->string_kind = string_kind; the_current_tok->curly_bracket_depth = 0; the_current_tok->curly_bracket_expr_start_depth = -1; return string_kind == TSTRING ? MAKE_TOKEN(TSTRING_START) : MAKE_TOKEN(FSTRING_START); From 173e456ccbe38b55429cf5bab9349e5d5c59a406 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Mon, 21 Apr 2025 20:02:18 +0200 Subject: [PATCH 67/88] Rename fields in tokenizer mode to not be f-string specific --- Parser/lexer/buffer.c | 8 +++--- Parser/lexer/lexer.c | 62 +++++++++++++++++++++---------------------- Parser/lexer/state.c | 2 +- Parser/lexer/state.h | 18 ++++++------- 4 files changed, 45 insertions(+), 45 deletions(-) diff --git a/Parser/lexer/buffer.c b/Parser/lexer/buffer.c index f6502bf8f7f2d1..63aa1ea2ad4f60 100644 --- a/Parser/lexer/buffer.c +++ b/Parser/lexer/buffer.c @@ -13,8 +13,8 @@ _PyLexer_remember_fstring_buffers(struct tok_state *tok) for (index = tok->tok_mode_stack_index; index >= 0; --index) { mode = &(tok->tok_mode_stack[index]); - mode->f_string_start_offset = mode->f_string_start - tok->buf; - mode->f_string_multi_line_start_offset = mode->f_string_multi_line_start - tok->buf; + mode->start_offset = mode->start - tok->buf; + mode->multi_line_start_offset = mode->multi_line_start - tok->buf; } } @@ -27,8 +27,8 @@ _PyLexer_restore_fstring_buffers(struct tok_state *tok) for (index = tok->tok_mode_stack_index; index >= 0; --index) { mode = &(tok->tok_mode_stack[index]); - mode->f_string_start = tok->buf + mode->f_string_start_offset; - mode->f_string_multi_line_start = tok->buf + mode->f_string_multi_line_start_offset; + mode->start = tok->buf + mode->start_offset; + mode->multi_line_start = tok->buf + mode->multi_line_start_offset; } } diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index 63f38d767f3cb4..6c35777755b607 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -114,7 +114,7 @@ set_ftstring_expr(struct tok_state* tok, struct token *token, char c) { assert(c == '}' || c == ':' || c == '!'); tokenizer_mode *tok_mode = TOK_GET_MODE(tok); - if (!(tok_mode->f_string_debug || tok_mode->string_kind == TSTRING) || token->metadata) { + if (!(tok_mode->in_debug || tok_mode->string_kind == TSTRING) || token->metadata) { return 0; } PyObject *res = NULL; @@ -981,33 +981,33 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t } tokenizer_mode *the_current_tok = TOK_NEXT_MODE(tok); the_current_tok->kind = TOK_FSTRING_MODE; - the_current_tok->f_string_quote = quote; - the_current_tok->f_string_quote_size = quote_size; - the_current_tok->f_string_start = tok->start; - the_current_tok->f_string_multi_line_start = tok->line_start; - the_current_tok->f_string_line_start = tok->lineno; - the_current_tok->f_string_start_offset = -1; - the_current_tok->f_string_multi_line_start_offset = -1; + the_current_tok->quote = quote; + the_current_tok->quote_size = quote_size; + the_current_tok->start = tok->start; + the_current_tok->multi_line_start = tok->line_start; + the_current_tok->first_line = tok->lineno; + the_current_tok->start_offset = -1; + the_current_tok->multi_line_start_offset = -1; the_current_tok->last_expr_buffer = NULL; the_current_tok->last_expr_size = 0; the_current_tok->last_expr_end = -1; the_current_tok->in_format_spec = 0; - the_current_tok->f_string_debug = 0; + the_current_tok->in_debug = 0; enum string_kind_t string_kind = FSTRING; switch (*tok->start) { case 'T': case 't': - the_current_tok->f_string_raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; + the_current_tok->raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; string_kind = TSTRING; break; case 'F': case 'f': - the_current_tok->f_string_raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; + the_current_tok->raw = Py_TOLOWER(*(tok->start + 1)) == 'r'; break; case 'R': case 'r': - the_current_tok->f_string_raw = 1; + the_current_tok->raw = 1; if (Py_TOLOWER(*(tok->start + 1)) == 't') { string_kind = TSTRING; } @@ -1079,8 +1079,8 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t * and if it is, then this must be a missing '}' token * so raise the proper error */ tokenizer_mode *the_current_tok = TOK_GET_MODE(tok); - if (the_current_tok->f_string_quote == quote && - the_current_tok->f_string_quote_size == quote_size) { + if (the_current_tok->quote == quote && + the_current_tok->quote_size == quote_size) { return MAKE_TOKEN(_PyTokenizer_syntaxerror(tok, "%c-string: expecting '}'", TOK_GET_STRING_PREFIX(tok))); } @@ -1153,7 +1153,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t int cursor = current_tok->curly_bracket_depth - (c != '{'); int in_format_spec = current_tok->in_format_spec; int cursor_in_format_with_debug = - cursor == 1 && (current_tok->f_string_debug || in_format_spec); + cursor == 1 && (current_tok->in_debug || in_format_spec); int cursor_valid = cursor == 0 || cursor_in_format_with_debug; if ((cursor_valid) && !_PyLexer_update_ftstring_expr(tok, c)) { return MAKE_TOKEN(ENDMARKER); @@ -1261,7 +1261,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t current_tok->curly_bracket_expr_start_depth--; current_tok->kind = TOK_FSTRING_MODE; current_tok->in_format_spec = 0; - current_tok->f_string_debug = 0; + current_tok->in_debug = 0; } } break; @@ -1274,7 +1274,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t } if( c == '=' && INSIDE_FSTRING_EXPR(current_tok)) { - current_tok->f_string_debug = 1; + current_tok->in_debug = 1; } /* Punctuation character */ @@ -1317,9 +1317,9 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct } // Check if we are at the end of the string - for (int i = 0; i < current_tok->f_string_quote_size; i++) { + for (int i = 0; i < current_tok->quote_size; i++) { int quote = tok_nextc(tok); - if (quote != current_tok->f_string_quote) { + if (quote != current_tok->quote) { tok_backup(tok, quote); goto f_string_middle; } @@ -1342,7 +1342,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct // TODO: This is a bit of a hack, but it works for now. We need to find a better way to handle // this. tok->multi_line_start = tok->line_start; - while (end_quote_size != current_tok->f_string_quote_size) { + while (end_quote_size != current_tok->quote_size) { int c = tok_nextc(tok); if (tok->done == E_ERROR || tok->done == E_DECODE) { return MAKE_TOKEN(ERRORTOKEN); @@ -1353,7 +1353,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct INSIDE_FSTRING_EXPR(current_tok) ); - if (c == EOF || (current_tok->f_string_quote_size == 1 && c == '\n')) { + if (c == EOF || (current_tok->quote_size == 1 && c == '\n')) { if (tok->decoding_erred) { return MAKE_TOKEN(ERRORTOKEN); } @@ -1362,7 +1362,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct // it means that the format spec ends here and we should // return to the regular mode. if (in_format_spec && c == '\n') { - if (current_tok->f_string_quote_size == 1) { + if (current_tok->quote_size == 1) { return MAKE_TOKEN( _PyTokenizer_syntaxerror( tok, @@ -1382,15 +1382,15 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct // shift the tok_state's location into // the start of string, and report the error // from the initial quote character - tok->cur = (char *)current_tok->f_string_start; + tok->cur = (char *)current_tok->start; tok->cur++; - tok->line_start = current_tok->f_string_multi_line_start; + tok->line_start = current_tok->multi_line_start; int start = tok->lineno; tokenizer_mode *the_current_tok = TOK_GET_MODE(tok); - tok->lineno = the_current_tok->f_string_line_start; + tok->lineno = the_current_tok->first_line; - if (current_tok->f_string_quote_size == 3) { + if (current_tok->quote_size == 3) { _PyTokenizer_syntaxerror(tok, "unterminated triple-quoted %c-string literal" " (detected at line %d)", @@ -1407,7 +1407,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct } } - if (c == current_tok->f_string_quote) { + if (c == current_tok->quote) { end_quote_size += 1; continue; } else { @@ -1470,7 +1470,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct // brace. We have to restore and return the control back // to the loop for the next iteration. if (peek == '{' || peek == '}') { - if (!current_tok->f_string_raw) { + if (!current_tok->raw) { if (_PyTokenizer_warn_invalid_escape_sequence(tok, peek)) { return MAKE_TOKEN(ERRORTOKEN); } @@ -1479,7 +1479,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct continue; } - if (!current_tok->f_string_raw) { + if (!current_tok->raw) { if (peek == 'N') { /* Handle named unicode escapes (\N{BULLET}) */ peek = tok_nextc(tok); @@ -1497,8 +1497,8 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct // Backup the f-string quotes to emit a final FSTRING_MIDDLE and // add the quotes to the FSTRING_END in the next tokenizer iteration. - for (int i = 0; i < current_tok->f_string_quote_size; i++) { - tok_backup(tok, current_tok->f_string_quote); + for (int i = 0; i < current_tok->quote_size; i++) { + tok_backup(tok, current_tok->quote); } p_start = tok->start; p_end = tok->cur; diff --git a/Parser/lexer/state.c b/Parser/lexer/state.c index 1665debea30b30..2de9004fe084f2 100644 --- a/Parser/lexer/state.c +++ b/Parser/lexer/state.c @@ -54,7 +54,7 @@ _PyTokenizer_tok_new(void) tok->tok_extra_tokens = 0; tok->comment_newline = 0; tok->implicit_newline = 0; - tok->tok_mode_stack[0] = (tokenizer_mode){.kind =TOK_REGULAR_MODE, .f_string_quote='\0', .f_string_quote_size = 0, .f_string_debug=0}; + tok->tok_mode_stack[0] = (tokenizer_mode){.kind =TOK_REGULAR_MODE, .quote='\0', .quote_size = 0, .in_debug=0}; tok->tok_mode_stack_index = 0; #ifdef Py_DEBUG tok->debug = _Py_GetConfig()->parser_debug; diff --git a/Parser/lexer/state.h b/Parser/lexer/state.h index b8b5fea89cc97f..5e8cac7249b21c 100644 --- a/Parser/lexer/state.h +++ b/Parser/lexer/state.h @@ -49,20 +49,20 @@ typedef struct _tokenizer_mode { int curly_bracket_depth; int curly_bracket_expr_start_depth; - char f_string_quote; - int f_string_quote_size; - int f_string_raw; - const char* f_string_start; - const char* f_string_multi_line_start; - int f_string_line_start; + char quote; + int quote_size; + int raw; + const char* start; + const char* multi_line_start; + int first_line; - Py_ssize_t f_string_start_offset; - Py_ssize_t f_string_multi_line_start_offset; + Py_ssize_t start_offset; + Py_ssize_t multi_line_start_offset; Py_ssize_t last_expr_size; Py_ssize_t last_expr_end; char* last_expr_buffer; - int f_string_debug; + int in_debug; int in_format_spec; enum string_kind_t string_kind; From a595cccfefe98aed528c47c5893c2a39fcffb255 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 09:35:06 +0200 Subject: [PATCH 68/88] Nit: return result instead of -1 --- Python/ast_unparse.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index bd297c4f255328..6fd8a906bd198a 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -668,7 +668,7 @@ append_templatestr(PyUnicodeWriter *writer, expr_ty e) int result = -1; PyObject *body = build_ftstring_body(e->v.TemplateStr.values, 0); if (!body) { - return -1; + return result; } if (-1 != append_charp(writer, "t") && From 2282ccc7164e71251406e80fc82f58d40e0263b7 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 10:07:36 +0200 Subject: [PATCH 69/88] Move AST test to test_ast --- Lib/test/test_ast/test_ast.py | 19 +++++++++++++++++++ Lib/test/test_tstring.py | 12 ------------ 2 files changed, 19 insertions(+), 12 deletions(-) diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py index dd459487afef1c..eeac7c21eda98f 100644 --- a/Lib/test/test_ast/test_ast.py +++ b/Lib/test/test_ast/test_ast.py @@ -880,6 +880,25 @@ def f(): for src in srcs: ast.parse(src) + def test_tstring(self): + # Test AST structure for simple t-string + tree = ast.parse('t"Hello"') + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) + + # Test AST for t-string with interpolation + tree = ast.parse('t"Hello {name}"') + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) + self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) + + # Test AST for implicit concat of t-string with f-string + tree = ast.parse('t"Hello {name}" f"{name}"') + self.assertIsInstance(tree.body[0].value, ast.TemplateStr) + self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) + self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) + self.assertIsInstance(tree.body[0].value.values[2], ast.FormattedValue) + class CopyTests(unittest.TestCase): """Test copying and pickling AST nodes.""" diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 829b79cce3e5fe..70de5c0bc89aba 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -202,18 +202,6 @@ def test_nested_templates(self): self.assertEqual(t_interp.conversion, None) self.assertEqual(t_interp.format_spec, "") - def test_ast_structure(self): - # Test AST structure for simple t-string - tree = ast.parse('t"Hello"') - self.assertIsInstance(tree.body[0].value, ast.TemplateStr) - self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) - - # Test AST for t-string with interpolation - tree = ast.parse('t"Hello {name}"') - self.assertIsInstance(tree.body[0].value, ast.TemplateStr) - self.assertIsInstance(tree.body[0].value.values[0], ast.Constant) - self.assertIsInstance(tree.body[0].value.values[1], ast.Interpolation) - def test_syntax_errors(self): for case, err in ( ("t'", "unterminated t-string literal"), From 53fc9952f9c299c7408d615eb57cb8e079c78e89 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 10:59:51 +0200 Subject: [PATCH 70/88] Fix unparsing implicit concat of t-strings with f-strings --- Lib/_ast_unparse.py | 33 ++++++++++++--- Lib/test/support/ast_helper.py | 3 ++ Lib/test/test_unparse.py | 9 ++++ Python/ast_unparse.c | 76 ++++++++++++++++++++++++++++++++-- 4 files changed, 112 insertions(+), 9 deletions(-) diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py index 2c37082b263aaf..840822470684c4 100644 --- a/Lib/_ast_unparse.py +++ b/Lib/_ast_unparse.py @@ -573,7 +573,7 @@ def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES): quote_type = quote_types[0] self.write(f"{quote_type}{string}{quote_type}") - def _ftstring_helper(self, node, ftstring_parts): + def _ftstring_helper(self, ftstring_parts): new_ftstring_parts = [] quote_types = list(_ALL_QUOTES) fallback_to_repr = False @@ -615,22 +615,43 @@ def _ftstring_helper(self, node, ftstring_parts): quote_type = quote_types[0] self.write(f"{quote_type}{value}{quote_type}") - def _write_ftstring(self, node, prefix): + def _write_ftstring(self, values, prefix): self.write(prefix) fstring_parts = [] - for value in node.values: + for value in values: with self.buffered() as buffer: self._write_ftstring_inner(value) fstring_parts.append( ("".join(buffer), isinstance(value, Constant)) ) - self._ftstring_helper(node, fstring_parts) + self._ftstring_helper(fstring_parts) + + def _tstring_helper(self, node): + last_idx = 0 + for i, value in enumerate(node.values): + # This can happen if we have an implicit concat of a t-string + # with an f-string + if isinstance(value, FormattedValue): + if i > last_idx: + # Write t-string until here + self._write_ftstring(node.values[last_idx:i], "t") + self.write(" ") + # Write f-string with the current formatted value + self._write_ftstring([node.values[i]], "f") + if i + 1 < len(node.values): + # Only add a space if there are more values after this + self.write(" ") + last_idx = i + 1 + + if last_idx < len(node.values): + # Write t-string from last_idx to end + self._write_ftstring(node.values[last_idx:], "t") def visit_JoinedStr(self, node): - self._write_ftstring(node, "f") + self._write_ftstring(node.values, "f") def visit_TemplateStr(self, node): - self._write_ftstring(node, "t") + self._tstring_helper(node) def _write_ftstring_inner(self, node, is_format_spec=False): if isinstance(node, JoinedStr): diff --git a/Lib/test/support/ast_helper.py b/Lib/test/support/ast_helper.py index 8a0415b6aae33c..173d299afee491 100644 --- a/Lib/test/support/ast_helper.py +++ b/Lib/test/support/ast_helper.py @@ -16,6 +16,9 @@ def traverse_compare(a, b, missing=object()): self.fail(f"{type(a)!r} is not {type(b)!r}") if isinstance(a, ast.AST): for field in a._fields: + if isinstance(a, ast.Constant) and field == "kind": + # Skip the 'kind' field for ast.Constant + continue value1 = getattr(a, field, missing) value2 = getattr(b, field, missing) # Singletons are equal by definition, so further diff --git a/Lib/test/test_unparse.py b/Lib/test/test_unparse.py index 041a4017a9fb78..d3af7a8489e650 100644 --- a/Lib/test/test_unparse.py +++ b/Lib/test/test_unparse.py @@ -202,6 +202,15 @@ def test_fstrings_pep701(self): self.check_ast_roundtrip('f" something { my_dict["key"] } something else "') self.check_ast_roundtrip('f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}"') + def test_tstrings(self): + self.check_ast_roundtrip("t'foo'") + self.check_ast_roundtrip("t'foo {bar}'") + self.check_ast_roundtrip("t'foo {bar!s:.2f}'") + self.check_ast_roundtrip("t'foo {bar}' f'{bar}'") + self.check_ast_roundtrip("f'{bar}' t'foo {bar}'") + self.check_ast_roundtrip("t'foo {bar}' fr'\\hello {bar}'") + self.check_ast_roundtrip("t'foo {bar}' u'bar'") + def test_strings(self): self.check_ast_roundtrip("u'foo'") self.check_ast_roundtrip("r'foo'") diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index 6fd8a906bd198a..819b67b24d81a8 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -663,15 +663,27 @@ build_ftstring_body(asdl_expr_seq *values, bool is_format_spec) } static int -append_templatestr(PyUnicodeWriter *writer, expr_ty e) +_write_values_subarray(PyUnicodeWriter *writer, asdl_expr_seq *values, Py_ssize_t first_idx, + Py_ssize_t last_idx, char prefix, PyArena *arena) { int result = -1; - PyObject *body = build_ftstring_body(e->v.TemplateStr.values, 0); + + asdl_expr_seq *new_values = _Py_asdl_expr_seq_new(last_idx - first_idx + 1, arena); + if (!new_values) { + return result; + } + + Py_ssize_t j = 0; + for (Py_ssize_t i = first_idx; i <= last_idx; ++i) { + asdl_seq_SET(new_values, j++, asdl_seq_GET(values, i)); + } + + PyObject *body = build_ftstring_body(new_values, false); if (!body) { return result; } - if (-1 != append_charp(writer, "t") && + if (-1 != append_char(writer, prefix) && -1 != append_repr(writer, body)) { result = 0; @@ -680,6 +692,64 @@ append_templatestr(PyUnicodeWriter *writer, expr_ty e) return result; } +static int +append_templatestr(PyUnicodeWriter *writer, expr_ty e) +{ + PyArena *arena = _PyArena_New(); + if (!arena) { + return -1; + } + + Py_ssize_t last_idx = 0; + Py_ssize_t len = asdl_seq_LEN(e->v.TemplateStr.values); + for (Py_ssize_t i = 0; i < len; i++) { + expr_ty value = asdl_seq_GET(e->v.TemplateStr.values, i); + + // Handle implicit concat of t-strings with f-strings + if (value->kind == FormattedValue_kind) { + if (i > last_idx) { + // Create a new TemplateStr with the values between last_idx and i + // and append it to the writer. + if (_write_values_subarray(writer, e->v.TemplateStr.values, + last_idx, i - 1, 't', arena) == -1) { + goto error; + } + + if (append_charp(writer, " ") == -1) { + goto error; + } + } + + // Append the FormattedValue to the writer. + if (_write_values_subarray(writer, e->v.TemplateStr.values, + i, i, 'f', arena) == -1) { + goto error; + } + + if (i + 1 < len) { + if (append_charp(writer, " ") == -1) { + goto error; + } + } + + last_idx = i + 1; + } + } + + if (last_idx < len) { + if (_write_values_subarray(writer, e->v.TemplateStr.values, + last_idx, len - 1, 't', arena) == -1) { + goto error; + } + } + + return 0; + +error: + _PyArena_Free(arena); + return -1; +} + static int append_joinedstr(PyUnicodeWriter *writer, expr_ty e, bool is_format_spec) { From 58da4e0baf6fd4557cf1f20928494c5bd16d004f Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 11:08:00 +0200 Subject: [PATCH 71/88] Update CODEOWNERS --- .github/CODEOWNERS | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index cc2a88999f9130..024184789471c4 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -321,11 +321,7 @@ Lib/test/test__colorize.py @hugovk Modules/_xxtestfuzz/ @ammaraskar # t-strings -Include/internal/pycore_interpolation.h @lysnikolaou -Include/internal/pycore_template.h @lysnikolaou -Objects/interpolationobject.c @lysnikolaou -Objects/clinic/interpolationobject.c.h @lysnikolaou -Objects/templateobject.c @lysnikolaou -Modules/_templatelibmodule.c @lysnikolaou -Lib/string/templatelib.py @lysnikolaou -Lib/test/test_tstring.py @lysnikolaou +**/*interpolationobject* @lysnikolaou +**/*templateobject* @lysnikolaou +**/*templatelib* @lysnikolaou +**/*tstring* @lysnikolaou \ No newline at end of file From 3e10c49fa9f4adc24306ea142c46327bbeb6c419 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 11:17:28 +0200 Subject: [PATCH 72/88] Clean up test_tstring --- Lib/test/test_tstring.py | 7 ------- 1 file changed, 7 deletions(-) diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 70de5c0bc89aba..2421247d555ddb 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -1,16 +1,9 @@ -import ast import unittest from test.test_string._support import TStringTestCase, fstring class TestTString(TStringTestCase): - def assertAllRaise(self, exception_type, regex, error_strings): - for s in error_strings: - with self.subTest(s=s): - with self.assertRaisesRegex(exception_type, regex): - eval(s) - def test_string_representation(self): # Test __repr__ t = t"Hello" From 2addef70426e8dac76cb294145d6b7e1488c5898 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 12:10:47 +0200 Subject: [PATCH 73/88] Add new tokens TSTRING_MIDDLE & TSTRING_END --- Doc/library/token.rst | 24 ++ Grammar/Tokens | 4 +- Grammar/python.gram | 11 +- Include/internal/pycore_token.h | 19 +- Lib/token.py | 18 +- Lib/tokenize.py | 4 +- Parser/lexer/lexer.c | 14 +- Parser/parser.c | 438 +++++++++++++++++--------------- Parser/string_parser.c | 3 +- Parser/token.c | 4 +- 10 files changed, 305 insertions(+), 234 deletions(-) diff --git a/Doc/library/token.rst b/Doc/library/token.rst index c1ca746acdb126..91e884b4b90ecd 100644 --- a/Doc/library/token.rst +++ b/Doc/library/token.rst @@ -142,6 +142,30 @@ The token constants are: .. versionadded:: next +.. data:: TSTRING_MIDDLE + + Token value used for literal text inside a t-string literal + including format specifications. + + .. impl-detail:: + + Replacement fields (that is, the non-literal parts of f-strings) use + the same tokens as other expressions, and are delimited by + :data:`LBRACE`, :data:`RBRACE`, :data:`EXCLAMATION` and :data:`COLON` + tokens. + + .. versionadded:: next + +.. data:: TSTRING_END + + Token value used to indicate the end of a t-string. + + .. impl-detail:: + + The token string contains the closing quote(s). + + .. versionadded:: next + .. data:: ENDMARKER Token value that indicates the end of input. diff --git a/Grammar/Tokens b/Grammar/Tokens index fdbce45d1e6e71..e40a4437afb009 100644 --- a/Grammar/Tokens +++ b/Grammar/Tokens @@ -60,9 +60,11 @@ TYPE_IGNORE TYPE_COMMENT SOFT_KEYWORD FSTRING_START -TSTRING_START FSTRING_MIDDLE FSTRING_END +TSTRING_START +TSTRING_MIDDLE +TSTRING_END COMMENT NL ERRORTOKEN diff --git a/Grammar/python.gram b/Grammar/python.gram index 65cae7443c4d21..7994e719a45177 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -945,7 +945,7 @@ tstring_format_spec_replacement_field[expr_ty]: _PyPegen_formatted_value(p, a, debug_expr, conversion, format, rbrace, EXTRA) } | invalid_tstring_replacement_field tstring_format_spec[expr_ty]: - | t=FSTRING_MIDDLE { _PyPegen_decoded_constant_from_token(p, t) } + | t=TSTRING_MIDDLE { _PyPegen_decoded_constant_from_token(p, t) } | tstring_format_spec_replacement_field tstring_full_format_spec[ResultTokenWithMetadata*]: | colon=':' spec=tstring_format_spec* { _PyPegen_setup_full_format_spec(p, colon, (asdl_expr_seq *) spec, EXTRA) } @@ -955,9 +955,9 @@ tstring_replacement_field[expr_ty]: | invalid_tstring_replacement_field tstring_middle[expr_ty]: | tstring_replacement_field - | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } + | t=TSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) } tstring[expr_ty] (memo): - | a=TSTRING_START b=tstring_middle* c=FSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } + | a=TSTRING_START b=tstring_middle* c=TSTRING_END { _PyPegen_template_str(p, a, (asdl_expr_seq*)b, c) } string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) } strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string|tstring)+ { _PyPegen_concatenate_strings(p, a, EXTRA) } @@ -1224,8 +1224,9 @@ invalid_expression: | a[stmt_ty]=(pass_stmt|break_stmt|continue_stmt) 'if' b=disjunction 'else' c=simple_stmt { RAISE_SYNTAX_ERROR_KNOWN_LOCATION (a, "expected expression before 'if', but statement is given") } | a='lambda' [lambda_params] b=':' &FSTRING_MIDDLE { - RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "%c-string: lambda expressions are not allowed without parentheses", - TOK_GET_STRING_PREFIX(p->tok)) } + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "f-string: lambda expressions are not allowed without parentheses") } + | a='lambda' [lambda_params] b=':' &TSTRING_MIDDLE { + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "t-string: lambda expressions are not allowed without parentheses") } invalid_named_expression(memo): | a=expression ':=' expression { diff --git a/Include/internal/pycore_token.h b/Include/internal/pycore_token.h index d8e1de1f324db4..5de1f719a2f1a2 100644 --- a/Include/internal/pycore_token.h +++ b/Include/internal/pycore_token.h @@ -73,13 +73,15 @@ extern "C" { #define TYPE_COMMENT 57 #define SOFT_KEYWORD 58 #define FSTRING_START 59 -#define TSTRING_START 60 -#define FSTRING_MIDDLE 61 -#define FSTRING_END 62 -#define COMMENT 63 -#define NL 64 -#define ERRORTOKEN 65 -#define N_TOKENS 67 +#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 NT_OFFSET 256 /* Special definitions for cooperation with parser */ @@ -92,7 +94,8 @@ extern "C" { (x) == INDENT || \ (x) == DEDENT) #define ISSTRINGLIT(x) ((x) == STRING || \ - (x) == FSTRING_MIDDLE) + (x) == FSTRING_MIDDLE || \ + (x) == TSTRING_MIDDLE) // Export these 4 symbols for 'test_peg_generator' diff --git a/Lib/token.py b/Lib/token.py index 6e7bb0c425b966..a1fde61cd8a070 100644 --- a/Lib/token.py +++ b/Lib/token.py @@ -64,15 +64,17 @@ TYPE_COMMENT = 57 SOFT_KEYWORD = 58 FSTRING_START = 59 -TSTRING_START = 60 -FSTRING_MIDDLE = 61 -FSTRING_END = 62 -COMMENT = 63 -NL = 64 +FSTRING_MIDDLE = 60 +FSTRING_END = 61 +TSTRING_START = 62 +TSTRING_MIDDLE = 63 +TSTRING_END = 64 +COMMENT = 65 +NL = 66 # These aren't used by the C tokenizer but are needed for tokenize.py -ERRORTOKEN = 65 -ENCODING = 66 -N_TOKENS = 67 +ERRORTOKEN = 67 +ENCODING = 68 +N_TOKENS = 69 # Special definitions for cooperation with parser NT_OFFSET = 256 diff --git a/Lib/tokenize.py b/Lib/tokenize.py index 7afacff7381f1c..2ea8a43a303d9e 100644 --- a/Lib/tokenize.py +++ b/Lib/tokenize.py @@ -251,7 +251,7 @@ def untokenize(self, iterable): self.tokens.append(indent) self.prev_col = len(indent) startline = False - elif tok_type == FSTRING_MIDDLE: + elif tok_type in (FSTRING_MIDDLE, TSTRING_MIDDLE): if '{' in token or '}' in token: token = self.escape_brackets(token) last_line = token.splitlines()[-1] @@ -308,7 +308,7 @@ def compat(self, token, iterable): elif startline and indents: toks_append(indents[-1]) startline = False - elif toknum == FSTRING_MIDDLE: + elif toknum in (FSTRING_MIDDLE, TSTRING_MIDDLE): tokval = self.escape_brackets(tokval) # Insert a space between two consecutive brackets if we are in an f-string diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c index 6c35777755b607..436ef6cd6cfa72 100644 --- a/Parser/lexer/lexer.c +++ b/Parser/lexer/lexer.c @@ -38,6 +38,8 @@ static inline tokenizer_mode* TOK_NEXT_MODE(struct tok_state* tok) { #define TOK_NEXT_MODE(tok) (&(tok->tok_mode_stack[++tok->tok_mode_stack_index])) #endif +#define FTSTRING_MIDDLE(tok_mode) (tok_mode->string_kind == TSTRING ? TSTRING_MIDDLE : FSTRING_MIDDLE) +#define FTSTRING_END(tok_mode) (tok_mode->string_kind == TSTRING ? TSTRING_END : FSTRING_END) #define TOK_GET_STRING_PREFIX(tok) (TOK_GET_MODE(tok)->string_kind == TSTRING ? 't' : 'f') #define MAKE_TOKEN(token_type) _PyLexer_token_setup(tok, token, token_type, p_start, p_end) #define MAKE_TYPE_COMMENT_TOKEN(token_type, col_offset, end_col_offset) (\ @@ -1335,7 +1337,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct p_start = tok->start; p_end = tok->cur; tok->tok_mode_stack_index--; - return MAKE_TOKEN(FSTRING_END); + return MAKE_TOKEN(FTSTRING_END(current_tok)); f_string_middle: @@ -1375,7 +1377,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct current_tok->in_format_spec = 0; p_start = tok->start; p_end = tok->cur; - return MAKE_TOKEN(FSTRING_MIDDLE); + return MAKE_TOKEN(FTSTRING_MIDDLE(current_tok)); } assert(tok->multi_line_start != NULL); @@ -1435,12 +1437,12 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct p_start = tok->start; p_end = tok->cur - 1; } - return MAKE_TOKEN(FSTRING_MIDDLE); + return MAKE_TOKEN(FTSTRING_MIDDLE(current_tok)); } else if (c == '}') { if (unicode_escape) { p_start = tok->start; p_end = tok->cur; - return MAKE_TOKEN(FSTRING_MIDDLE); + return MAKE_TOKEN(FTSTRING_MIDDLE(current_tok)); } int peek = tok_nextc(tok); @@ -1460,7 +1462,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct p_start = tok->start; p_end = tok->cur; } - return MAKE_TOKEN(FSTRING_MIDDLE); + return MAKE_TOKEN(FTSTRING_MIDDLE(current_tok)); } else if (c == '\\') { int peek = tok_nextc(tok); if (peek == '\r') { @@ -1502,7 +1504,7 @@ tok_get_fstring_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct } p_start = tok->start; p_end = tok->cur; - return MAKE_TOKEN(FSTRING_MIDDLE); + return MAKE_TOKEN(FTSTRING_MIDDLE(current_tok)); } static int diff --git a/Parser/parser.c b/Parser/parser.c index 7e962e71a74fcf..fb339135532966 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -21,54 +21,54 @@ static KeywordToken *reserved_keywords[] = { (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) { - {"if", 677}, - {"as", 675}, - {"in", 688}, + {"if", 678}, + {"as", 676}, + {"in", 689}, {"or", 586}, {"is", 594}, {NULL, -1}, }, (KeywordToken[]) { - {"del", 622}, - {"def", 692}, - {"for", 687}, - {"try", 651}, + {"del", 623}, + {"def", 693}, + {"for", 688}, + {"try", 652}, {"and", 587}, - {"not", 696}, + {"not", 697}, {NULL, -1}, }, (KeywordToken[]) { - {"from", 630}, + {"from", 631}, {"pass", 526}, - {"with", 642}, - {"elif", 679}, - {"else", 680}, - {"None", 620}, - {"True", 619}, + {"with", 643}, + {"elif", 680}, + {"else", 681}, + {"None", 621}, + {"True", 620}, {NULL, -1}, }, (KeywordToken[]) { {"raise", 525}, {"yield", 585}, {"break", 527}, - {"async", 691}, - {"class", 694}, - {"while", 682}, - {"False", 621}, + {"async", 692}, + {"class", 695}, + {"while", 683}, + {"False", 622}, {"await", 595}, {NULL, -1}, }, (KeywordToken[]) { {"return", 522}, - {"import", 631}, + {"import", 632}, {"assert", 532}, {"global", 529}, - {"except", 672}, - {"lambda", 618}, + {"except", 673}, + {"lambda", 619}, {NULL, -1}, }, (KeywordToken[]) { - {"finally", 668}, + {"finally", 669}, {NULL, -1}, }, (KeywordToken[]) { @@ -1687,7 +1687,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt")); stmt_ty del_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 622) // token='del' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 623) // token='del' && (del_stmt_var = del_stmt_rule(p)) // del_stmt ) @@ -1883,7 +1883,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt")); stmt_ty if_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 677) // token='if' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 678) // token='if' && (if_stmt_var = if_stmt_rule(p)) // if_stmt ) @@ -1967,7 +1967,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt")); stmt_ty try_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 651) // token='try' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 652) // token='try' && (try_stmt_var = try_stmt_rule(p)) // try_stmt ) @@ -1988,7 +1988,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt")); stmt_ty while_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 682) // token='while' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 683) // token='while' && (while_stmt_var = while_stmt_rule(p)) // while_stmt ) @@ -3156,7 +3156,7 @@ del_stmt_rule(Parser *p) Token * _keyword; asdl_expr_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='del' + (_keyword = _PyPegen_expect_token(p, 623)) // token='del' && (a = del_targets_rule(p)) // del_targets && @@ -3445,7 +3445,7 @@ import_name_rule(Parser *p) Token * _keyword; asdl_alias_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 631)) // token='import' + (_keyword = _PyPegen_expect_token(p, 632)) // token='import' && (a = dotted_as_names_rule(p)) // dotted_as_names ) @@ -3514,13 +3514,13 @@ import_from_rule(Parser *p) expr_ty b; asdl_alias_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 630)) // token='from' + (_keyword = _PyPegen_expect_token(p, 631)) // token='from' && (a = _loop0_18_rule(p)) // (('.' | '...'))* && (b = dotted_name_rule(p)) // dotted_name && - (_keyword_1 = _PyPegen_expect_token(p, 631)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 632)) // token='import' && (c = import_from_targets_rule(p)) // import_from_targets ) @@ -3558,11 +3558,11 @@ import_from_rule(Parser *p) asdl_seq * a; asdl_alias_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 630)) // token='from' + (_keyword = _PyPegen_expect_token(p, 631)) // token='from' && (a = _loop1_19_rule(p)) // (('.' | '...'))+ && - (_keyword_1 = _PyPegen_expect_token(p, 631)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 632)) // token='import' && (b = import_from_targets_rule(p)) // import_from_targets ) @@ -4311,7 +4311,7 @@ class_def_raw_rule(Parser *p) asdl_stmt_seq* c; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 694)) // token='class' + (_keyword = _PyPegen_expect_token(p, 695)) // token='class' && (a = _PyPegen_name_token(p)) // NAME && @@ -4478,7 +4478,7 @@ function_def_raw_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 692)) // token='def' + (_keyword = _PyPegen_expect_token(p, 693)) // token='def' && (n = _PyPegen_name_token(p)) // NAME && @@ -4539,9 +4539,9 @@ function_def_raw_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 692)) // token='def' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='def' && (n = _PyPegen_name_token(p)) // NAME && @@ -5879,7 +5879,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -5924,7 +5924,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -6019,7 +6019,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 680)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -6064,7 +6064,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 680)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -6145,7 +6145,7 @@ else_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 680)) // token='else' + (_keyword = _PyPegen_expect_token(p, 681)) // token='else' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -6224,7 +6224,7 @@ while_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 682)) // token='while' + (_keyword = _PyPegen_expect_token(p, 683)) // token='while' && (a = named_expression_rule(p)) // named_expression && @@ -6324,11 +6324,11 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword = _PyPegen_expect_token(p, 688)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='in' && (_cut_var = 1) && @@ -6386,13 +6386,13 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 688)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 689)) // token='in' && (_cut_var = 1) && @@ -6521,7 +6521,7 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword = _PyPegen_expect_token(p, 643)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -6572,7 +6572,7 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword = _PyPegen_expect_token(p, 643)) // token='with' && (a = (asdl_withitem_seq*)_gather_35_rule(p)) // ','.with_item+ && @@ -6621,9 +6621,9 @@ with_stmt_rule(Parser *p) asdl_withitem_seq* a; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -6673,9 +6673,9 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='with' && (a = (asdl_withitem_seq*)_gather_35_rule(p)) // ','.with_item+ && @@ -6761,7 +6761,7 @@ with_item_rule(Parser *p) if ( (e = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (t = star_target_rule(p)) // star_target && @@ -6886,7 +6886,7 @@ try_stmt_rule(Parser *p) asdl_stmt_seq* b; asdl_stmt_seq* f; if ( - (_keyword = _PyPegen_expect_token(p, 651)) // token='try' + (_keyword = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -6930,7 +6930,7 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 651)) // token='try' + (_keyword = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -6978,7 +6978,7 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 651)) // token='try' + (_keyword = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7076,7 +7076,7 @@ except_block_rule(Parser *p) asdl_stmt_seq* b; expr_ty e; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (e = expressions_rule(p)) // expressions && @@ -7120,11 +7120,11 @@ except_block_rule(Parser *p) expr_ty e; expr_ty t; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (e = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 676)) // token='as' && (t = _PyPegen_name_token(p)) // NAME && @@ -7165,7 +7165,7 @@ except_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -7276,7 +7276,7 @@ except_star_block_rule(Parser *p) asdl_stmt_seq* b; expr_ty e; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -7323,13 +7323,13 @@ except_star_block_rule(Parser *p) expr_ty e; expr_ty t; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (e = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 676)) // token='as' && (t = _PyPegen_name_token(p)) // NAME && @@ -7427,7 +7427,7 @@ finally_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 669)) // token='finally' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7735,7 +7735,7 @@ guard_rule(Parser *p) Token * _keyword; expr_ty guard; if ( - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (guard = named_expression_rule(p)) // named_expression ) @@ -7930,7 +7930,7 @@ as_pattern_rule(Parser *p) if ( (pattern = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (target = pattern_capture_target_rule(p)) // pattern_capture_target ) @@ -8364,7 +8364,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='None' + (_keyword = _PyPegen_expect_token(p, 621)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -8397,7 +8397,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 619)) // token='True' + (_keyword = _PyPegen_expect_token(p, 620)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -8430,7 +8430,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='False' + (_keyword = _PyPegen_expect_token(p, 622)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -8558,7 +8558,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='None' + (_keyword = _PyPegen_expect_token(p, 621)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -8591,7 +8591,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 619)) // token='True' + (_keyword = _PyPegen_expect_token(p, 620)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -8624,7 +8624,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='False' + (_keyword = _PyPegen_expect_token(p, 622)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -11227,11 +11227,11 @@ expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 680)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 681)) // token='else' && (c = expression_rule(p)) // expression ) @@ -11337,7 +11337,7 @@ yield_expr_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 585)) // token='yield' && - (_keyword_1 = _PyPegen_expect_token(p, 630)) // token='from' + (_keyword_1 = _PyPegen_expect_token(p, 631)) // token='from' && (a = expression_rule(p)) // expression ) @@ -12113,7 +12113,7 @@ inversion_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 696)) // token='not' + (_keyword = _PyPegen_expect_token(p, 697)) // token='not' && (a = inversion_rule(p)) // inversion ) @@ -12767,9 +12767,9 @@ notin_bitwise_or_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 696)) // token='not' + (_keyword = _PyPegen_expect_token(p, 697)) // token='not' && - (_keyword_1 = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='in' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -12815,7 +12815,7 @@ in_bitwise_or_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword = _PyPegen_expect_token(p, 689)) // token='in' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -12864,7 +12864,7 @@ isnot_bitwise_or_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 594)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 696)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 697)) // token='not' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -14770,7 +14770,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 619)) // token='True' + (_keyword = _PyPegen_expect_token(p, 620)) // token='True' ) { D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -14803,7 +14803,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='False' + (_keyword = _PyPegen_expect_token(p, 622)) // token='False' ) { D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -14836,7 +14836,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='None' + (_keyword = _PyPegen_expect_token(p, 621)) // token='None' ) { D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -15104,7 +15104,7 @@ lambdef_rule(Parser *p) void *a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 618)) // token='lambda' + (_keyword = _PyPegen_expect_token(p, 619)) // token='lambda' && (a = lambda_params_rule(p), !p->error_indicator) // lambda_params? && @@ -16495,7 +16495,7 @@ tstring_format_spec_replacement_field_rule(Parser *p) return _res; } -// tstring_format_spec: FSTRING_MIDDLE | tstring_format_spec_replacement_field +// tstring_format_spec: TSTRING_MIDDLE | tstring_format_spec_replacement_field static expr_ty tstring_format_spec_rule(Parser *p) { @@ -16508,18 +16508,18 @@ tstring_format_spec_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; - { // FSTRING_MIDDLE + { // TSTRING_MIDDLE if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c> tstring_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_MIDDLE")); Token * t; if ( - (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' + (t = _PyPegen_expect_token(p, TSTRING_MIDDLE)) // token='TSTRING_MIDDLE' ) { - D(fprintf(stderr, "%*c+ tstring_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c+ tstring_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_MIDDLE")); _res = _PyPegen_decoded_constant_from_token ( p , t ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -16530,7 +16530,7 @@ tstring_format_spec_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_MIDDLE")); } { // tstring_format_spec_replacement_field if (p->error_indicator) { @@ -16718,7 +16718,7 @@ tstring_replacement_field_rule(Parser *p) return _res; } -// tstring_middle: tstring_replacement_field | FSTRING_MIDDLE +// tstring_middle: tstring_replacement_field | TSTRING_MIDDLE static expr_ty tstring_middle_rule(Parser *p) { @@ -16750,18 +16750,18 @@ tstring_middle_rule(Parser *p) D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_replacement_field")); } - { // FSTRING_MIDDLE + { // TSTRING_MIDDLE if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c> tstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_MIDDLE")); Token * t; if ( - (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' + (t = _PyPegen_expect_token(p, TSTRING_MIDDLE)) // token='TSTRING_MIDDLE' ) { - D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c+ tstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_MIDDLE")); _res = _PyPegen_constant_from_token ( p , t ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -16772,7 +16772,7 @@ tstring_middle_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_MIDDLE")); } _res = NULL; done: @@ -16780,7 +16780,7 @@ tstring_middle_rule(Parser *p) return _res; } -// tstring: TSTRING_START tstring_middle* FSTRING_END +// tstring: TSTRING_START tstring_middle* TSTRING_END static expr_ty tstring_rule(Parser *p) { @@ -16797,12 +16797,12 @@ tstring_rule(Parser *p) return _res; } int _mark = p->mark; - { // TSTRING_START tstring_middle* FSTRING_END + { // TSTRING_START tstring_middle* TSTRING_END if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + D(fprintf(stderr, "%*c> tstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* TSTRING_END")); Token * a; asdl_seq * b; Token * c; @@ -16811,10 +16811,10 @@ tstring_rule(Parser *p) && (b = _loop0_80_rule(p)) // tstring_middle* && - (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' + (c = _PyPegen_expect_token(p, TSTRING_END)) // token='TSTRING_END' ) { - D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + D(fprintf(stderr, "%*c+ tstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TSTRING_START tstring_middle* TSTRING_END")); _res = _PyPegen_template_str ( p , a , ( asdl_expr_seq* ) b , c ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -16825,7 +16825,7 @@ tstring_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tstring[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START tstring_middle* FSTRING_END")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START tstring_middle* TSTRING_END")); } _res = NULL; done: @@ -17471,13 +17471,13 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 688)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 689)) // token='in' && (_cut_var = 1) && @@ -17516,11 +17516,11 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword = _PyPegen_expect_token(p, 688)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='in' && (_cut_var = 1) && @@ -20821,11 +20821,11 @@ expression_without_invalid_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 680)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 681)) // token='else' && (c = expression_rule(p)) // expression ) @@ -21041,6 +21041,7 @@ invalid_type_param_rule(Parser *p) // | disjunction 'if' disjunction 'else' !expression // | (pass_stmt | break_stmt | continue_stmt) 'if' disjunction 'else' simple_stmt // | 'lambda' lambda_params? ':' &FSTRING_MIDDLE +// | 'lambda' lambda_params? ':' &TSTRING_MIDDLE static void * invalid_expression_rule(Parser *p) { @@ -21124,7 +21125,7 @@ invalid_expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (b = disjunction_rule(p)) // disjunction && @@ -21157,11 +21158,11 @@ invalid_expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 680)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 681)) // token='else' && _PyPegen_lookahead(0, (void *(*)(Parser *)) expression_rule, p) ) @@ -21193,11 +21194,11 @@ invalid_expression_rule(Parser *p) if ( (a = (stmt_ty)_tmp_116_rule(p)) // pass_stmt | break_stmt | continue_stmt && - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 680)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 681)) // token='else' && (c = simple_stmt_rule(p)) // simple_stmt ) @@ -21226,7 +21227,7 @@ invalid_expression_rule(Parser *p) Token * a; Token * b; if ( - (a = _PyPegen_expect_token(p, 618)) // token='lambda' + (a = _PyPegen_expect_token(p, 619)) // token='lambda' && (_opt_var = lambda_params_rule(p), !p->error_indicator) // lambda_params? && @@ -21236,7 +21237,7 @@ invalid_expression_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE")); - _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "%c-string: lambda expressions are not allowed without parentheses" , TOK_GET_STRING_PREFIX ( p -> tok ) ); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "f-string: lambda expressions are not allowed without parentheses" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -21248,6 +21249,39 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE")); } + { // 'lambda' lambda_params? ':' &TSTRING_MIDDLE + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &TSTRING_MIDDLE")); + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + Token * a; + Token * b; + if ( + (a = _PyPegen_expect_token(p, 619)) // token='lambda' + && + (_opt_var = lambda_params_rule(p), !p->error_indicator) // lambda_params? + && + (b = _PyPegen_expect_token(p, 11)) // token=':' + && + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, TSTRING_MIDDLE) // token=TSTRING_MIDDLE + ) + { + D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &TSTRING_MIDDLE")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "t-string: lambda expressions are not allowed without parentheses" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' &TSTRING_MIDDLE")); + } _res = NULL; done: p->level--; @@ -21697,7 +21731,7 @@ invalid_del_stmt_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='del' + (_keyword = _PyPegen_expect_token(p, 623)) // token='del' && (a = star_expressions_rule(p)) // star_expressions ) @@ -23133,7 +23167,7 @@ invalid_with_item_rule(Parser *p) if ( (expression_var = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (a = expression_rule(p)) // expression && @@ -23183,13 +23217,13 @@ invalid_for_if_clause_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings void *_tmp_135_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword = _PyPegen_expect_token(p, 688)) // token='for' && (_tmp_135_var = _tmp_135_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && - _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 688) // token='in' + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 689) // token='in' ) { D(fprintf(stderr, "%*c+ invalid_for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'")); @@ -23235,9 +23269,9 @@ invalid_for_target_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings expr_ty a; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword = _PyPegen_expect_token(p, 688)) // token='for' && (a = star_expressions_rule(p)) // star_expressions ) @@ -23367,11 +23401,11 @@ invalid_import_rule(Parser *p) Token * a; expr_ty dotted_name_var; if ( - (a = _PyPegen_expect_token(p, 631)) // token='import' + (a = _PyPegen_expect_token(p, 632)) // token='import' && (_gather_137_var = _gather_137_rule(p)) // ','.dotted_name+ && - (_keyword = _PyPegen_expect_token(p, 630)) // token='from' + (_keyword = _PyPegen_expect_token(p, 631)) // token='from' && (dotted_name_var = dotted_name_rule(p)) // dotted_name ) @@ -23398,7 +23432,7 @@ invalid_import_rule(Parser *p) Token * _keyword; Token * token; if ( - (_keyword = _PyPegen_expect_token(p, 631)) // token='import' + (_keyword = _PyPegen_expect_token(p, 632)) // token='import' && (token = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -23522,9 +23556,9 @@ invalid_with_stmt_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword = _PyPegen_expect_token(p, 643)) // token='with' && (_gather_139_var = _gather_139_rule(p)) // ','.(expression ['as' star_target])+ && @@ -23560,9 +23594,9 @@ invalid_with_stmt_rule(Parser *p) UNUSED(_opt_var_1); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword = _PyPegen_expect_token(p, 643)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -23622,9 +23656,9 @@ invalid_with_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 642)) // token='with' + (a = _PyPegen_expect_token(p, 643)) // token='with' && (_gather_139_var = _gather_139_rule(p)) // ','.(expression ['as' star_target])+ && @@ -23665,9 +23699,9 @@ invalid_with_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 642)) // token='with' + (a = _PyPegen_expect_token(p, 643)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -23730,7 +23764,7 @@ invalid_try_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 651)) // token='try' + (a = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -23762,7 +23796,7 @@ invalid_try_stmt_rule(Parser *p) Token * _literal; asdl_stmt_seq* block_var; if ( - (_keyword = _PyPegen_expect_token(p, 651)) // token='try' + (_keyword = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -23801,7 +23835,7 @@ invalid_try_stmt_rule(Parser *p) Token * b; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 651)) // token='try' + (_keyword = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -23809,7 +23843,7 @@ invalid_try_stmt_rule(Parser *p) && (_loop1_37_var = _loop1_37_rule(p)) // except_block+ && - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (b = _PyPegen_expect_token(p, 16)) // token='*' && @@ -23848,7 +23882,7 @@ invalid_try_stmt_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings Token * a; if ( - (_keyword = _PyPegen_expect_token(p, 651)) // token='try' + (_keyword = _PyPegen_expect_token(p, 652)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -23856,7 +23890,7 @@ invalid_try_stmt_rule(Parser *p) && (_loop1_38_var = _loop1_38_rule(p)) // except_star_block+ && - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (_opt_var = _tmp_144_rule(p), !p->error_indicator) // [expression ['as' NAME]] && @@ -23913,7 +23947,7 @@ invalid_except_stmt_rule(Parser *p) expr_ty expressions_var; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (a = expression_rule(p)) // expression && @@ -23921,7 +23955,7 @@ invalid_except_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 676)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -23953,7 +23987,7 @@ invalid_except_stmt_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (expression_var = expression_rule(p)) // expression && @@ -23984,7 +24018,7 @@ invalid_except_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -24013,11 +24047,11 @@ invalid_except_stmt_rule(Parser *p) expr_ty a; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (expression_var = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 676)) // token='as' && (a = expression_rule(p)) // expression ) @@ -24073,7 +24107,7 @@ invalid_except_star_stmt_rule(Parser *p) expr_ty expressions_var; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24083,7 +24117,7 @@ invalid_except_star_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 676)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -24116,7 +24150,7 @@ invalid_except_star_stmt_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24150,7 +24184,7 @@ invalid_except_star_stmt_rule(Parser *p) void *_tmp_145_var; Token * a; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24182,13 +24216,13 @@ invalid_except_star_stmt_rule(Parser *p) expr_ty a; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (expression_var = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 676)) // token='as' && (a = expression_rule(p)) // expression ) @@ -24235,7 +24269,7 @@ invalid_finally_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 668)) // token='finally' + (a = _PyPegen_expect_token(p, 669)) // token='finally' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -24291,7 +24325,7 @@ invalid_except_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (expression_var = expression_rule(p)) // expression && @@ -24327,7 +24361,7 @@ invalid_except_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -24383,7 +24417,7 @@ invalid_except_star_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 672)) // token='except' + (a = _PyPegen_expect_token(p, 673)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24622,7 +24656,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (a = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' ) @@ -24652,7 +24686,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (a = expression_rule(p)) // expression ) @@ -24804,7 +24838,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -24835,7 +24869,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty a_1; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 677)) // token='if' + (a = _PyPegen_expect_token(p, 678)) // token='if' && (a_1 = named_expression_rule(p)) // named_expression && @@ -24890,7 +24924,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 680)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -24921,7 +24955,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 679)) // token='elif' + (a = _PyPegen_expect_token(p, 680)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -24974,7 +25008,7 @@ invalid_else_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 680)) // token='else' + (a = _PyPegen_expect_token(p, 681)) // token='else' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25027,7 +25061,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 682)) // token='while' + (_keyword = _PyPegen_expect_token(p, 683)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25058,7 +25092,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 682)) // token='while' + (a = _PyPegen_expect_token(p, 683)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25117,13 +25151,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword = _PyPegen_expect_token(p, 688)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -25158,13 +25192,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 687)) // token='for' + (a = _PyPegen_expect_token(p, 688)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword = _PyPegen_expect_token(p, 688)) // token='in' + (_keyword = _PyPegen_expect_token(p, 689)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -25230,9 +25264,9 @@ invalid_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 692)) // token='def' + (a = _PyPegen_expect_token(p, 693)) // token='def' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -25289,9 +25323,9 @@ invalid_def_raw_rule(Parser *p) asdl_stmt_seq* block_var; expr_ty name_var; if ( - (_opt_var = _PyPegen_expect_token(p, 691), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 692), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 692)) // token='def' + (_keyword = _PyPegen_expect_token(p, 693)) // token='def' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -25355,7 +25389,7 @@ invalid_class_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 694)) // token='class' + (_keyword = _PyPegen_expect_token(p, 695)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -25394,7 +25428,7 @@ invalid_class_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 694)) // token='class' + (a = _PyPegen_expect_token(p, 695)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -26654,7 +26688,7 @@ invalid_arithmetic_rule(Parser *p) && (_tmp_152_var = _tmp_152_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && - (a = _PyPegen_expect_token(p, 696)) // token='not' + (a = _PyPegen_expect_token(p, 697)) // token='not' && (b = inversion_rule(p)) // inversion ) @@ -26703,7 +26737,7 @@ invalid_factor_rule(Parser *p) if ( (_tmp_153_var = _tmp_153_rule(p)) // '+' | '-' | '~' && - (a = _PyPegen_expect_token(p, 696)) // token='not' + (a = _PyPegen_expect_token(p, 697)) // token='not' && (b = factor_rule(p)) // factor ) @@ -27050,7 +27084,7 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 631)) // token='import' + (_keyword = _PyPegen_expect_token(p, 632)) // token='import' ) { D(fprintf(stderr, "%*c+ _tmp_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'")); @@ -27069,7 +27103,7 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 630)) // token='from' + (_keyword = _PyPegen_expect_token(p, 631)) // token='from' ) { D(fprintf(stderr, "%*c+ _tmp_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'")); @@ -27107,7 +27141,7 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 692)) // token='def' + (_keyword = _PyPegen_expect_token(p, 693)) // token='def' ) { D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'")); @@ -27145,7 +27179,7 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'")); @@ -27183,7 +27217,7 @@ _tmp_7_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 694)) // token='class' + (_keyword = _PyPegen_expect_token(p, 695)) // token='class' ) { D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'")); @@ -27240,7 +27274,7 @@ _tmp_8_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 642)) // token='with' + (_keyword = _PyPegen_expect_token(p, 643)) // token='with' ) { D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'")); @@ -27259,7 +27293,7 @@ _tmp_8_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'")); @@ -27297,7 +27331,7 @@ _tmp_9_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 687)) // token='for' + (_keyword = _PyPegen_expect_token(p, 688)) // token='for' ) { D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'")); @@ -27316,7 +27350,7 @@ _tmp_9_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='async' + (_keyword = _PyPegen_expect_token(p, 692)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'")); @@ -27541,7 +27575,7 @@ _tmp_13_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 630)) // token='from' + (_keyword = _PyPegen_expect_token(p, 631)) // token='from' && (z = expression_rule(p)) // expression ) @@ -28063,7 +28097,7 @@ _tmp_22_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) @@ -33578,7 +33612,7 @@ _tmp_111_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 619)) // token='True' + (_keyword = _PyPegen_expect_token(p, 620)) // token='True' ) { D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -33597,7 +33631,7 @@ _tmp_111_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='False' + (_keyword = _PyPegen_expect_token(p, 622)) // token='False' ) { D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -33616,7 +33650,7 @@ _tmp_111_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='None' + (_keyword = _PyPegen_expect_token(p, 621)) // token='None' ) { D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -33827,7 +33861,7 @@ _tmp_115_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 680)) // token='else' + (_keyword = _PyPegen_expect_token(p, 681)) // token='else' ) { D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); @@ -34074,7 +34108,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 619)) // token='True' + (_keyword = _PyPegen_expect_token(p, 620)) // token='True' ) { D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -34093,7 +34127,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='None' + (_keyword = _PyPegen_expect_token(p, 621)) // token='None' ) { D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -34112,7 +34146,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='False' + (_keyword = _PyPegen_expect_token(p, 622)) // token='False' ) { D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -35525,7 +35559,7 @@ _tmp_142_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 672)) // token='except' + (_keyword = _PyPegen_expect_token(p, 673)) // token='except' ) { D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); @@ -35544,7 +35578,7 @@ _tmp_142_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 669)) // token='finally' ) { D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); @@ -36767,7 +36801,7 @@ _tmp_162_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 677)) // token='if' + (_keyword = _PyPegen_expect_token(p, 678)) // token='if' && (z = disjunction_rule(p)) // disjunction ) @@ -37349,7 +37383,7 @@ _tmp_174_rule(Parser *p) Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 675)) // token='as' + (_keyword = _PyPegen_expect_token(p, 676)) // token='as' && (star_target_var = star_target_rule(p)) // star_target ) diff --git a/Parser/string_parser.c b/Parser/string_parser.c index 9b557e94d00431..d3631b114c5a3c 100644 --- a/Parser/string_parser.c +++ b/Parser/string_parser.c @@ -19,7 +19,8 @@ warn_invalid_escape_sequence(Parser *p, const char* buffer, const char *first_in return 0; } unsigned char c = (unsigned char)*first_invalid_escape; - if ((t->type == FSTRING_MIDDLE || t->type == FSTRING_END) && (c == '{' || c == '}')) { + if ((t->type == FSTRING_MIDDLE || t->type == FSTRING_END || t->type == TSTRING_MIDDLE || t->type == TSTRING_END) + && (c == '{' || c == '}')) { // in this case the tokenizer has already emitted a warning, // see Parser/tokenizer/helpers.c:warn_invalid_escape_sequence return 0; diff --git a/Parser/token.c b/Parser/token.c index 5c76730f6aa4f1..a6e7ce35dfad85 100644 --- a/Parser/token.c +++ b/Parser/token.c @@ -66,9 +66,11 @@ const char * const _PyParser_TokenNames[] = { "TYPE_COMMENT", "SOFT_KEYWORD", "FSTRING_START", - "TSTRING_START", "FSTRING_MIDDLE", "FSTRING_END", + "TSTRING_START", + "TSTRING_MIDDLE", + "TSTRING_END", "COMMENT", "NL", "", From 06c15de76881e3c6d0b5aaeafc14194e610e049f Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 13:55:31 +0200 Subject: [PATCH 74/88] Make Interpolation.conversion an int and change bytecode def --- Include/internal/pycore_ast.h | 4 +- Include/internal/pycore_interpolation.h | 3 +- Include/internal/pycore_opcode_metadata.h | 4 +- Include/internal/pycore_uop_metadata.h | 4 +- Include/opcode_ids.h | 86 +++++++++++------------ Lib/_opcode_metadata.py | 86 +++++++++++------------ Objects/interpolationobject.c | 38 ++++++---- Parser/Python.asdl | 2 +- Parser/action_helpers.c | 12 +--- Python/Python-ast.c | 30 +++----- Python/ast_unparse.c | 55 ++++++++------- Python/bytecodes.c | 25 +++++-- Python/codegen.c | 25 ++++--- Python/executor_cases.c.h | 47 +++++++++++-- Python/generated_cases.c.h | 46 ++++++++++-- Python/opcode_targets.h | 6 +- Python/optimizer_cases.c.h | 4 +- 17 files changed, 285 insertions(+), 192 deletions(-) diff --git a/Include/internal/pycore_ast.h b/Include/internal/pycore_ast.h index 3c7798dc5d7edd..60367202bab637 100644 --- a/Include/internal/pycore_ast.h +++ b/Include/internal/pycore_ast.h @@ -463,7 +463,7 @@ struct _expr { struct { expr_ty value; constant str; - constant conversion; + int conversion; expr_ty format_spec; } Interpolation; @@ -832,7 +832,7 @@ expr_ty _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * expr_ty _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); -expr_ty _PyAST_Interpolation(expr_ty value, constant str, constant conversion, +expr_ty _PyAST_Interpolation(expr_ty value, constant str, int conversion, expr_ty format_spec, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index 1e599a972ccedc..d0fe729f44b23a 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -15,7 +15,8 @@ extern PyTypeObject _PyInterpolation_Type; #define _PyInterpolation_CheckExact(op) Py_IS_TYPE((op), &_PyInterpolation_Type) -PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values); +PyAPI_FUNC(PyObject *) _PyInterpolation_Build(PyObject *value, PyObject *str, + int conversion, PyObject *format_spec); extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *interp); extern PyObject *_PyInterpolation_GetValueRef(PyObject *interpolation); diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index ba89fc11d01103..3c91d32bb5cb81 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -68,7 +68,7 @@ int _PyOpcode_num_popped(int opcode, int oparg) { case BINARY_SLICE: return 3; case BUILD_INTERPOLATION: - return 4; + return 2 + (oparg & 1); case BUILD_LIST: return oparg; case BUILD_MAP: @@ -1089,7 +1089,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_INTERPOLATION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_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 }, [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index bfd1afa635c741..d7944d69b686a7 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -150,7 +150,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_BUILD_INTERPOLATION] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, + [_BUILD_INTERPOLATION] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, @@ -861,7 +861,7 @@ int _PyUop_num_popped(int opcode, int oparg) case _BUILD_STRING: return oparg; case _BUILD_INTERPOLATION: - return 4; + return 2 + (oparg & 1); case _BUILD_TEMPLATE: return oparg; case _BUILD_TEMPLATE_LIST: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 26a865490f9f6c..670f0c740fc4af 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -12,50 +12,50 @@ extern "C" { /* Instruction opcodes for compiled code */ #define CACHE 0 #define BINARY_SLICE 1 -#define BUILD_INTERPOLATION 2 +#define BUILD_TEMPLATE_LIST 2 #define BINARY_OP_INPLACE_ADD_UNICODE 3 -#define BUILD_TEMPLATE_LIST 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 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_ITER 16 #define RESERVED 17 -#define GET_ITER 18 -#define GET_LEN 19 -#define GET_YIELD_FROM_ITER 20 -#define INTERPRETER_EXIT 21 -#define LOAD_BUILD_CLASS 22 -#define LOAD_LOCALS 23 -#define MAKE_FUNCTION 24 -#define MATCH_KEYS 25 -#define MATCH_MAPPING 26 -#define MATCH_SEQUENCE 27 -#define NOP 28 -#define NOT_TAKEN 29 -#define POP_EXCEPT 30 -#define POP_ITER 31 -#define POP_TOP 32 -#define PUSH_EXC_INFO 33 -#define PUSH_NULL 34 -#define RETURN_GENERATOR 35 -#define RETURN_VALUE 36 -#define SETUP_ANNOTATIONS 37 -#define STORE_SLICE 38 -#define STORE_SUBSCR 39 -#define TO_BOOL 40 -#define UNARY_INVERT 41 -#define UNARY_NEGATIVE 42 -#define UNARY_NOT 43 -#define WITH_EXCEPT_START 44 -#define BINARY_OP 45 +#define GET_LEN 18 +#define GET_YIELD_FROM_ITER 19 +#define INTERPRETER_EXIT 20 +#define LOAD_BUILD_CLASS 21 +#define LOAD_LOCALS 22 +#define MAKE_FUNCTION 23 +#define MATCH_KEYS 24 +#define MATCH_MAPPING 25 +#define MATCH_SEQUENCE 26 +#define NOP 27 +#define NOT_TAKEN 28 +#define POP_EXCEPT 29 +#define POP_ITER 30 +#define POP_TOP 31 +#define PUSH_EXC_INFO 32 +#define PUSH_NULL 33 +#define RETURN_GENERATOR 34 +#define RETURN_VALUE 35 +#define SETUP_ANNOTATIONS 36 +#define STORE_SLICE 37 +#define STORE_SUBSCR 38 +#define TO_BOOL 39 +#define UNARY_INVERT 40 +#define UNARY_NEGATIVE 41 +#define UNARY_NOT 42 +#define WITH_EXCEPT_START 43 +#define BINARY_OP 44 +#define BUILD_INTERPOLATION 45 #define BUILD_LIST 46 #define BUILD_MAP 47 #define BUILD_SET 48 @@ -248,7 +248,7 @@ extern "C" { #define SETUP_WITH 264 #define STORE_FAST_MAYBE_NULL 265 -#define HAVE_ARGUMENT 44 +#define HAVE_ARGUMENT 43 #define MIN_SPECIALIZED_OPCODE 129 #define MIN_INSTRUMENTED_OPCODE 234 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index fd3c5a19ef0b2b..032d5cb606aa90 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -215,48 +215,48 @@ 'INSTRUMENTED_LINE': 254, 'ENTER_EXECUTOR': 255, 'BINARY_SLICE': 1, - 'BUILD_INTERPOLATION': 2, - 'BUILD_TEMPLATE_LIST': 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_ITER': 18, - 'GET_LEN': 19, - 'GET_YIELD_FROM_ITER': 20, - 'INTERPRETER_EXIT': 21, - 'LOAD_BUILD_CLASS': 22, - 'LOAD_LOCALS': 23, - 'MAKE_FUNCTION': 24, - 'MATCH_KEYS': 25, - 'MATCH_MAPPING': 26, - 'MATCH_SEQUENCE': 27, - 'NOP': 28, - 'NOT_TAKEN': 29, - 'POP_EXCEPT': 30, - 'POP_ITER': 31, - 'POP_TOP': 32, - 'PUSH_EXC_INFO': 33, - 'PUSH_NULL': 34, - 'RETURN_GENERATOR': 35, - 'RETURN_VALUE': 36, - 'SETUP_ANNOTATIONS': 37, - 'STORE_SLICE': 38, - 'STORE_SUBSCR': 39, - 'TO_BOOL': 40, - 'UNARY_INVERT': 41, - 'UNARY_NEGATIVE': 42, - 'UNARY_NOT': 43, - 'WITH_EXCEPT_START': 44, - 'BINARY_OP': 45, + 'BUILD_TEMPLATE_LIST': 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_ITER': 16, + 'GET_LEN': 18, + 'GET_YIELD_FROM_ITER': 19, + 'INTERPRETER_EXIT': 20, + 'LOAD_BUILD_CLASS': 21, + 'LOAD_LOCALS': 22, + 'MAKE_FUNCTION': 23, + 'MATCH_KEYS': 24, + 'MATCH_MAPPING': 25, + 'MATCH_SEQUENCE': 26, + 'NOP': 27, + 'NOT_TAKEN': 28, + 'POP_EXCEPT': 29, + 'POP_ITER': 30, + 'POP_TOP': 31, + 'PUSH_EXC_INFO': 32, + 'PUSH_NULL': 33, + 'RETURN_GENERATOR': 34, + 'RETURN_VALUE': 35, + 'SETUP_ANNOTATIONS': 36, + 'STORE_SLICE': 37, + 'STORE_SUBSCR': 38, + 'TO_BOOL': 39, + 'UNARY_INVERT': 40, + 'UNARY_NEGATIVE': 41, + 'UNARY_NOT': 42, + 'WITH_EXCEPT_START': 43, + 'BINARY_OP': 44, + 'BUILD_INTERPOLATION': 45, 'BUILD_LIST': 46, 'BUILD_MAP': 47, 'BUILD_SET': 48, @@ -365,5 +365,5 @@ 'STORE_FAST_MAYBE_NULL': 265, } -HAVE_ARGUMENT = 44 +HAVE_ARGUMENT = 43 MIN_INSTRUMENTED_OPCODE = 234 diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index d4586cb487fca6..381c2c62f4eaf7 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -158,28 +158,38 @@ _PyInterpolation_InitTypes(PyInterpreterState *interp) } PyObject * -_PyInterpolation_FromStackRefStealOnSuccess(_PyStackRef *values) +_PyInterpolation_Build(PyObject *value, PyObject *str, int conversion, PyObject *format_spec) { - interpolationobject *interpolation = (interpolationobject *) _PyInterpolation_Type.tp_alloc(&_PyInterpolation_Type, 0); + interpolationobject *interpolation = + (interpolationobject *) _PyInterpolation_Type.tp_alloc(&_PyInterpolation_Type, 0); if (!interpolation) { return NULL; } - interpolation->value = PyStackRef_AsPyObjectSteal(values[0]); - interpolation->expression = PyStackRef_AsPyObjectSteal(values[1]); + interpolation->value = Py_NewRef(value); + interpolation->expression = Py_NewRef(str); + interpolation->format_spec = Py_NewRef(format_spec); - if (PyStackRef_IsNull(values[2])) { - interpolation->conversion = Py_NewRef(Py_None); + if (conversion == 0) { + interpolation->conversion = Py_None; } else { - interpolation->conversion = PyStackRef_AsPyObjectSteal(values[2]); - } - - if (PyStackRef_IsNull(values[3])) { - interpolation->format_spec = Py_NewRef(&_Py_STR(empty)); - } - else { - interpolation->format_spec = PyStackRef_AsPyObjectSteal(values[3]); + switch (conversion) { + case FVC_ASCII: + interpolation->conversion = _Py_LATIN1_CHR('a'); + break; + case FVC_REPR: + interpolation->conversion = _Py_LATIN1_CHR('r'); + break; + case FVC_STR: + interpolation->conversion = _Py_LATIN1_CHR('s'); + break; + default: + PyErr_SetString(PyExc_SystemError, + "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'"); + Py_DECREF(interpolation); + return NULL; + } } return (PyObject *) interpolation; diff --git a/Parser/Python.asdl b/Parser/Python.asdl index 0be4efc6687b90..db61d8b1f66467 100644 --- a/Parser/Python.asdl +++ b/Parser/Python.asdl @@ -78,7 +78,7 @@ module Python | Compare(expr left, cmpop* ops, expr* comparators) | Call(expr func, expr* args, keyword* keywords) | FormattedValue(expr value, int conversion, expr? format_spec) - | Interpolation(expr value, constant str, constant? conversion, expr? format_spec) + | Interpolation(expr value, constant str, int conversion, expr? format_spec) | JoinedStr(expr* values) | TemplateStr(expr* values) | Constant(constant value, string? kind) diff --git a/Parser/action_helpers.c b/Parser/action_helpers.c index 4793b560d24265..3bcc0870882a29 100644 --- a/Parser/action_helpers.c +++ b/Parser/action_helpers.c @@ -1498,17 +1498,7 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu ResultTokenWithMetadata *format, Token *closing_brace, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) { - constant convstr = NULL; int conversion_val = _get_interpolation_conversion(p, debug, conversion, format); - if (conversion_val >= 0) { - char buf[1]; - buf[0] = conversion_val; - convstr = PyUnicode_FromStringAndSize(buf, 1); - if (convstr == NULL || _PyArena_AddPyObject(arena, convstr) < 0) { - Py_XDECREF(convstr); - return NULL; - } - } /* Find the non whitespace token after the "=" */ int debug_end_line, debug_end_offset; @@ -1539,7 +1529,7 @@ expr_ty _PyPegen_interpolation(Parser *p, expr_ty expression, Token *debug, Resu } expr_ty interpolation = _PyAST_Interpolation( - expression, final_exprstr, convstr, format ? (expr_ty) format->result : NULL, + expression, final_exprstr, conversion_val, format ? (expr_ty) format->result : NULL, lineno, col_offset, end_lineno, end_col_offset, arena ); diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 215bb625350a7a..94d9a76d28306e 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -3212,13 +3212,8 @@ add_ast_annotations(struct ast_state *state) } } { - PyObject *type = (PyObject *)&PyBaseObject_Type; - type = _Py_union_type_or(type, Py_None); - cond = type != NULL; - if (!cond) { - Py_DECREF(Interpolation_annotations); - return 0; - } + PyObject *type = (PyObject *)&PyLong_Type; + Py_INCREF(type); cond = PyDict_SetItemString(Interpolation_annotations, "conversion", type) == 0; Py_DECREF(type); @@ -6379,7 +6374,7 @@ init_types(void *arg) " | Compare(expr left, cmpop* ops, expr* comparators)\n" " | Call(expr func, expr* args, keyword* keywords)\n" " | FormattedValue(expr value, int conversion, expr? format_spec)\n" - " | Interpolation(expr value, constant str, constant? conversion, expr? format_spec)\n" + " | Interpolation(expr value, constant str, int conversion, expr? format_spec)\n" " | JoinedStr(expr* values)\n" " | TemplateStr(expr* values)\n" " | Constant(constant value, string? kind)\n" @@ -6479,11 +6474,8 @@ init_types(void *arg) state->Interpolation_type = make_type(state, "Interpolation", state->expr_type, Interpolation_fields, 4, - "Interpolation(expr value, constant str, constant? conversion, expr? format_spec)"); + "Interpolation(expr value, constant str, int conversion, expr? format_spec)"); if (!state->Interpolation_type) return -1; - if (PyObject_SetAttr(state->Interpolation_type, state->conversion, Py_None) - == -1) - return -1; if (PyObject_SetAttr(state->Interpolation_type, state->format_spec, Py_None) == -1) return -1; @@ -8169,7 +8161,7 @@ _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int } expr_ty -_PyAST_Interpolation(expr_ty value, constant str, constant conversion, expr_ty +_PyAST_Interpolation(expr_ty value, constant str, int conversion, expr_ty format_spec, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena) { @@ -9866,7 +9858,7 @@ ast2obj_expr(struct ast_state *state, void* _o) if (PyObject_SetAttr(result, state->str, value) == -1) goto failed; Py_DECREF(value); - value = ast2obj_constant(state, o->v.Interpolation.conversion); + value = ast2obj_int(state, o->v.Interpolation.conversion); if (!value) goto failed; if (PyObject_SetAttr(result, state->conversion, value) == -1) goto failed; @@ -15015,7 +15007,7 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (isinstance) { expr_ty value; constant str; - constant conversion; + int conversion; expr_ty format_spec; if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { @@ -15055,16 +15047,16 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (PyObject_GetOptionalAttr(obj, state->conversion, &tmp) < 0) { return -1; } - if (tmp == NULL || tmp == Py_None) { - Py_CLEAR(tmp); - conversion = NULL; + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"conversion\" missing from Interpolation"); + return -1; } else { int res; if (_Py_EnterRecursiveCall(" while traversing 'Interpolation' node")) { goto failed; } - res = obj2ast_constant(state, tmp, &conversion, arena); + res = obj2ast_int(state, tmp, &conversion, arena); _Py_LeaveRecursiveCall(); if (res != 0) goto failed; Py_CLEAR(tmp); diff --git a/Python/ast_unparse.c b/Python/ast_unparse.c index 819b67b24d81a8..c121ec096aebf4 100644 --- a/Python/ast_unparse.c +++ b/Python/ast_unparse.c @@ -800,6 +800,33 @@ append_interpolation_value(PyUnicodeWriter *writer, expr_ty e) return 0; } +static int +append_interpolation_conversion(PyUnicodeWriter *writer, int conversion) +{ + if (conversion < 0) { + return 0; + } + + const char *conversion_str; + switch (conversion) { + case 'a': + conversion_str = "!a"; + break; + case 'r': + conversion_str = "!r"; + break; + case 's': + conversion_str = "!s"; + break; + default: + PyErr_SetString(PyExc_SystemError, + "unknown f-value conversion kind"); + return -1; + } + APPEND_STR(conversion_str); + return 0; +} + static int append_interpolation_format_spec(PyUnicodeWriter *writer, expr_ty e) { @@ -820,11 +847,8 @@ append_interpolation(PyUnicodeWriter *writer, expr_ty e) return -1; } - if (e->v.Interpolation.conversion) { - APPEND_STR("!"); - if (-1 == PyUnicodeWriter_WriteStr(writer, e->v.Interpolation.conversion)) { - return -1; - } + if (-1 == append_interpolation_conversion(writer, e->v.Interpolation.conversion)) { + return -1; } if (-1 == append_interpolation_format_spec(writer, e->v.Interpolation.format_spec)) { @@ -837,29 +861,12 @@ append_interpolation(PyUnicodeWriter *writer, expr_ty e) static int append_formattedvalue(PyUnicodeWriter *writer, expr_ty e) { - const char *conversion; - if (-1 == append_interpolation_value(writer, e->v.FormattedValue.value)) { return -1; } - if (e->v.FormattedValue.conversion > 0) { - switch (e->v.FormattedValue.conversion) { - case 'a': - conversion = "!a"; - break; - case 'r': - conversion = "!r"; - break; - case 's': - conversion = "!s"; - break; - default: - PyErr_SetString(PyExc_SystemError, - "unknown f-value conversion kind"); - return -1; - } - APPEND_STR(conversion); + if (-1 == append_interpolation_conversion(writer, e->v.FormattedValue.conversion)) { + return -1; } if (-1 == append_interpolation_format_spec(writer, e->v.FormattedValue.format_spec)) { diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 39b67fe5ed83fe..c8ff2a9024b604 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1914,12 +1914,27 @@ dummy_func( str = PyStackRef_FromPyObjectSteal(str_o); } - inst(BUILD_INTERPOLATION, (values[4] -- interpolation)) { - PyObject *interpolation_o = _PyInterpolation_FromStackRefStealOnSuccess(values); - if (interpolation_o == NULL) { - ERROR_NO_POP(); + inst(BUILD_INTERPOLATION, (value, str, format[oparg & 1] -- interpolation)) { + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + PyObject *str_o = PyStackRef_AsPyObjectBorrow(str); + int conversion = oparg >> 2; + PyObject *format_o; + if (oparg & 1) { + format_o = PyStackRef_AsPyObjectBorrow(format[0]); } - INPUTS_DEAD(); + else { + format_o = &_Py_STR(empty); + } + PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o); + if (oparg & 1) { + PyStackRef_CLOSE(format[0]); + } + else { + DEAD(format); + } + PyStackRef_CLOSE(str); + PyStackRef_CLOSE(value); + ERROR_IF(interpolation_o == NULL, error); interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); } diff --git a/Python/codegen.c b/Python/codegen.c index ef44ad2cef0bef..fca95af044263c 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -4092,21 +4092,26 @@ codegen_interpolation(compiler *c, expr_ty e) VISIT(c, expr, e->v.Interpolation.value); ADDOP_LOAD_CONST(c, loc, e->v.Interpolation.str); - if (e->v.Interpolation.conversion) { - ADDOP_LOAD_CONST(c, loc, e->v.Interpolation.conversion); - } - else { - ADDOP(c, loc, PUSH_NULL); - } - + int oparg = 2; if (e->v.Interpolation.format_spec) { + oparg++; VISIT(c, expr, e->v.Interpolation.format_spec); } - else { - ADDOP(c, loc, PUSH_NULL); + + int conversion = e->v.Interpolation.conversion; + if (conversion != -1) { + switch (conversion) { + case 's': oparg |= FVC_STR << 2; break; + case 'r': oparg |= FVC_REPR << 2; break; + case 'a': oparg |= FVC_ASCII << 2; break; + default: + PyErr_Format(PyExc_SystemError, + "Unrecognized conversion character %d", conversion); + return ERROR; + } } - ADDOP(c, loc, BUILD_INTERPOLATION); + ADDOP_I(c, loc, BUILD_INTERPOLATION, oparg); return SUCCESS; } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index bb6d7774102ac6..c78052a0a5930a 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2605,16 +2605,53 @@ } case _BUILD_INTERPOLATION: { - _PyStackRef *values; + _PyStackRef *format; + _PyStackRef str; + _PyStackRef value; _PyStackRef interpolation; - values = &stack_pointer[-4]; - PyObject *interpolation_o = _PyInterpolation_FromStackRefStealOnSuccess(values); + oparg = CURRENT_OPARG(); + format = &stack_pointer[-(oparg & 1)]; + str = stack_pointer[-1 - (oparg & 1)]; + value = stack_pointer[-2 - (oparg & 1)]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + PyObject *str_o = PyStackRef_AsPyObjectBorrow(str); + int conversion = oparg >> 2; + PyObject *format_o; + if (oparg & 1) { + format_o = PyStackRef_AsPyObjectBorrow(format[0]); + } + else { + format_o = &_Py_STR(empty); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (oparg & 1) { + stack_pointer += -(oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(format[0]); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + stack_pointer += -(oparg & 1); + } + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(str); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); if (interpolation_o == NULL) { JUMP_TO_ERROR(); } interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); - stack_pointer[-4] = interpolation; - stack_pointer += -3; + stack_pointer[0] = interpolation; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 9600c3c6a2f88a..eb5bd3b33ba6d4 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1096,16 +1096,52 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(BUILD_INTERPOLATION); - _PyStackRef *values; + _PyStackRef value; + _PyStackRef str; + _PyStackRef *format; _PyStackRef interpolation; - values = &stack_pointer[-4]; - PyObject *interpolation_o = _PyInterpolation_FromStackRefStealOnSuccess(values); + format = &stack_pointer[-(oparg & 1)]; + str = stack_pointer[-1 - (oparg & 1)]; + value = stack_pointer[-2 - (oparg & 1)]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + PyObject *str_o = PyStackRef_AsPyObjectBorrow(str); + int conversion = oparg >> 2; + PyObject *format_o; + if (oparg & 1) { + format_o = PyStackRef_AsPyObjectBorrow(format[0]); + } + else { + format_o = &_Py_STR(empty); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (oparg & 1) { + stack_pointer += -(oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(format[0]); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + stack_pointer += -(oparg & 1); + } + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(str); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); if (interpolation_o == NULL) { JUMP_TO_LABEL(error); } interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); - stack_pointer[-4] = interpolation; - stack_pointer += -3; + stack_pointer[0] = interpolation; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 211f128caf8276..fe8f5eb9d3ce12 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -2,9 +2,8 @@ static void *opcode_targets[256] = { &&TARGET_CACHE, &&TARGET_BINARY_SLICE, - &&TARGET_BUILD_INTERPOLATION, - &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, &&TARGET_BUILD_TEMPLATE_LIST, + &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, &&TARGET_CALL_FUNCTION_EX, &&TARGET_CHECK_EG_MATCH, &&TARGET_CHECK_EXC_MATCH, @@ -17,8 +16,8 @@ static void *opcode_targets[256] = { &&TARGET_FORMAT_WITH_SPEC, &&TARGET_GET_AITER, &&TARGET_GET_ANEXT, - &&TARGET_RESERVED, &&TARGET_GET_ITER, + &&TARGET_RESERVED, &&TARGET_GET_LEN, &&TARGET_GET_YIELD_FROM_ITER, &&TARGET_INTERPRETER_EXIT, @@ -46,6 +45,7 @@ static void *opcode_targets[256] = { &&TARGET_UNARY_NOT, &&TARGET_WITH_EXCEPT_START, &&TARGET_BINARY_OP, + &&TARGET_BUILD_INTERPOLATION, &&TARGET_BUILD_LIST, &&TARGET_BUILD_MAP, &&TARGET_BUILD_SET, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index e378c9ece6aa90..5b851b8db64f75 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -1022,8 +1022,8 @@ case _BUILD_INTERPOLATION: { JitOptSymbol *interpolation; interpolation = sym_new_not_null(ctx); - stack_pointer[-4] = interpolation; - stack_pointer += -3; + stack_pointer[-2 - (oparg & 1)] = interpolation; + stack_pointer += -1 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); break; } From f57647e47e4b910e0b12225aea718d0222df727f Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 15:11:06 +0200 Subject: [PATCH 75/88] Fix ast_unparse and token generator --- Lib/_ast_unparse.py | 17 +++++------------ Tools/build/generate_token.py | 3 ++- 2 files changed, 7 insertions(+), 13 deletions(-) diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py index 840822470684c4..32cb81398b13f9 100644 --- a/Lib/_ast_unparse.py +++ b/Lib/_ast_unparse.py @@ -679,31 +679,24 @@ def _unparse_interpolation_value(self, inner): unparser.set_precedence(_Precedence.TEST.next(), inner) return unparser.visit(inner) - def _write_fstring_conversion(self, node): - if node.conversion != -1: - self.write(f"!{chr(node.conversion)}") - - def _write_tstring_conversion(self, node): - if node.conversion is not None: - self.write(f"!{node.conversion}") - - def _write_interpolation(self, node, write_conversion): + def _write_interpolation(self, node): with self.delimit("{", "}"): expr = self._unparse_interpolation_value(node.value) if expr.startswith("{"): # Separate pair of opening brackets as "{ {" self.write(" ") self.write(expr) - write_conversion(node) + if node.conversion != -1: + self.write(f"!{chr(node.conversion)}") if node.format_spec: self.write(":") self._write_ftstring_inner(node.format_spec, is_format_spec=True) def visit_FormattedValue(self, node): - self._write_interpolation(node, self._write_fstring_conversion) + self._write_interpolation(node) def visit_Interpolation(self, node): - self._write_interpolation(node, self._write_tstring_conversion) + self._write_interpolation(node) def visit_Name(self, node): self.write(node.id) diff --git a/Tools/build/generate_token.py b/Tools/build/generate_token.py index 7316333dcd452e..a64806763f3fce 100755 --- a/Tools/build/generate_token.py +++ b/Tools/build/generate_token.py @@ -87,7 +87,8 @@ def update_file(file, content): (x) == INDENT || \\ (x) == DEDENT) #define ISSTRINGLIT(x) ((x) == STRING || \\ - (x) == FSTRING_MIDDLE) + (x) == FSTRING_MIDDLE || \\ + (x) == TSTRING_MIDDLE) // Export these 4 symbols for 'test_peg_generator' From a21391a3c22fe5d6af7f625e0dc5cef1c9702481 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 15:11:21 +0200 Subject: [PATCH 76/88] Let compiler build template tuples --- Include/internal/pycore_opcode_metadata.h | 13 +- Include/internal/pycore_template.h | 3 +- Include/internal/pycore_uop_ids.h | 1 - Include/internal/pycore_uop_metadata.h | 8 +- Include/opcode_ids.h | 143 +++++++++++----------- Lib/_opcode_metadata.py | 143 +++++++++++----------- Objects/interpolationobject.c | 7 +- Objects/templateobject.c | 59 +++------ Programs/test_frozenmain.h | 26 ++-- Python/bytecodes.c | 23 +--- Python/codegen.c | 51 ++++++-- Python/executor_cases.c.h | 55 ++------- Python/generated_cases.c.h | 61 ++------- Python/opcode_targets.h | 7 +- Python/optimizer_cases.c.h | 11 +- 15 files changed, 255 insertions(+), 356 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 3c91d32bb5cb81..71f0294a07a7e5 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -80,9 +80,7 @@ int _PyOpcode_num_popped(int opcode, int oparg) { case BUILD_STRING: return oparg; case BUILD_TEMPLATE: - return oparg; - case BUILD_TEMPLATE_LIST: - return 1; + return 2; case BUILD_TUPLE: return oparg; case CACHE: @@ -566,8 +564,6 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 1; case BUILD_TEMPLATE: return 1; - case BUILD_TEMPLATE_LIST: - return 1; case BUILD_TUPLE: return 1; case CACHE: @@ -1095,8 +1091,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [BUILD_TEMPLATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_TEMPLATE_LIST] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TEMPLATE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, @@ -1346,7 +1341,6 @@ _PyOpcode_macro_expansion[256] = { [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, OPARG_SIMPLE, 0 } } }, [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, OPARG_SIMPLE, 0 } } }, [BUILD_TEMPLATE] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE, OPARG_SIMPLE, 0 } } }, - [BUILD_TEMPLATE_LIST] = { .nuops = 1, .uops = { { _BUILD_TEMPLATE_LIST, OPARG_SIMPLE, 0 } } }, [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, OPARG_SIMPLE, 0 } } }, [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 4, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_AND_ALLOCATE_OBJECT, 2, 1 }, { _CREATE_INIT_FRAME, OPARG_SIMPLE, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { _CHECK_PEP_523, OPARG_SIMPLE, 1 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, OPARG_SIMPLE, 1 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, OPARG_SIMPLE, 1 }, { _CHECK_FUNCTION_VERSION, 2, 1 }, { _CHECK_FUNCTION_EXACT_ARGS, OPARG_SIMPLE, 3 }, { _CHECK_STACK_SPACE, OPARG_SIMPLE, 3 }, { _INIT_CALL_PY_EXACT_ARGS, OPARG_SIMPLE, 3 }, { _SAVE_RETURN_OFFSET, OPARG_SAVE_RETURN_OFFSET, 3 }, { _PUSH_FRAME, OPARG_SIMPLE, 3 } } }, @@ -1535,7 +1529,6 @@ const char *_PyOpcode_OpName[266] = { [BUILD_SLICE] = "BUILD_SLICE", [BUILD_STRING] = "BUILD_STRING", [BUILD_TEMPLATE] = "BUILD_TEMPLATE", - [BUILD_TEMPLATE_LIST] = "BUILD_TEMPLATE_LIST", [BUILD_TUPLE] = "BUILD_TUPLE", [CACHE] = "CACHE", [CALL] = "CALL", @@ -1803,7 +1796,6 @@ const uint8_t _PyOpcode_Deopt[256] = { [BUILD_SLICE] = BUILD_SLICE, [BUILD_STRING] = BUILD_STRING, [BUILD_TEMPLATE] = BUILD_TEMPLATE, - [BUILD_TEMPLATE_LIST] = BUILD_TEMPLATE_LIST, [BUILD_TUPLE] = BUILD_TUPLE, [CACHE] = CACHE, [CALL] = CALL, @@ -2012,6 +2004,7 @@ const uint8_t _PyOpcode_Deopt[256] = { #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ + case 121: \ case 122: \ case 123: \ case 124: \ diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index d28cdf8da8de90..45bece72ac532a 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -16,8 +16,7 @@ extern PyTypeObject _PyTemplateIter_Type; extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); -PyAPI_FUNC(PyObject *) _PyTemplate_FromValues(PyObject **values, Py_ssize_t n); -PyAPI_FUNC(PyObject *) _PyTemplate_FromList(PyObject *list); +PyAPI_FUNC(PyObject *) _PyTemplate_Build(PyObject *strings, PyObject *interpolations); #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 66e586d37080c9..db606c4269fe85 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -35,7 +35,6 @@ extern "C" { #define _BUILD_SLICE BUILD_SLICE #define _BUILD_STRING BUILD_STRING #define _BUILD_TEMPLATE BUILD_TEMPLATE -#define _BUILD_TEMPLATE_LIST BUILD_TEMPLATE_LIST #define _BUILD_TUPLE BUILD_TUPLE #define _CALL_BUILTIN_CLASS 319 #define _CALL_BUILTIN_FAST 320 diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index d7944d69b686a7..6c939b097f5132 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -151,8 +151,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_BUILD_INTERPOLATION] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BUILD_TEMPLATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BUILD_TEMPLATE_LIST] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TEMPLATE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -336,7 +335,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BUILD_SLICE] = "_BUILD_SLICE", [_BUILD_STRING] = "_BUILD_STRING", [_BUILD_TEMPLATE] = "_BUILD_TEMPLATE", - [_BUILD_TEMPLATE_LIST] = "_BUILD_TEMPLATE_LIST", [_BUILD_TUPLE] = "_BUILD_TUPLE", [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", @@ -863,9 +861,7 @@ int _PyUop_num_popped(int opcode, int oparg) case _BUILD_INTERPOLATION: return 2 + (oparg & 1); case _BUILD_TEMPLATE: - return oparg; - case _BUILD_TEMPLATE_LIST: - return 1; + return 2; case _BUILD_TUPLE: return oparg; case _BUILD_LIST: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 670f0c740fc4af..865ac0c3b27077 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -12,7 +12,7 @@ extern "C" { /* Instruction opcodes for compiled code */ #define CACHE 0 #define BINARY_SLICE 1 -#define BUILD_TEMPLATE_LIST 2 +#define BUILD_TEMPLATE 2 #define BINARY_OP_INPLACE_ADD_UNICODE 3 #define CALL_FUNCTION_EX 4 #define CHECK_EG_MATCH 5 @@ -61,77 +61,76 @@ extern "C" { #define BUILD_SET 48 #define BUILD_SLICE 49 #define BUILD_STRING 50 -#define BUILD_TEMPLATE 51 -#define BUILD_TUPLE 52 -#define CALL 53 -#define CALL_INTRINSIC_1 54 -#define CALL_INTRINSIC_2 55 -#define CALL_KW 56 -#define COMPARE_OP 57 -#define CONTAINS_OP 58 -#define CONVERT_VALUE 59 -#define COPY 60 -#define COPY_FREE_VARS 61 -#define DELETE_ATTR 62 -#define DELETE_DEREF 63 -#define DELETE_FAST 64 -#define DELETE_GLOBAL 65 -#define DELETE_NAME 66 -#define DICT_MERGE 67 -#define DICT_UPDATE 68 -#define END_ASYNC_FOR 69 -#define EXTENDED_ARG 70 -#define FOR_ITER 71 -#define GET_AWAITABLE 72 -#define IMPORT_FROM 73 -#define IMPORT_NAME 74 -#define IS_OP 75 -#define JUMP_BACKWARD 76 -#define JUMP_BACKWARD_NO_INTERRUPT 77 -#define JUMP_FORWARD 78 -#define LIST_APPEND 79 -#define LIST_EXTEND 80 -#define LOAD_ATTR 81 -#define LOAD_COMMON_CONSTANT 82 -#define LOAD_CONST 83 -#define LOAD_DEREF 84 -#define LOAD_FAST 85 -#define LOAD_FAST_AND_CLEAR 86 -#define LOAD_FAST_BORROW 87 -#define LOAD_FAST_BORROW_LOAD_FAST_BORROW 88 -#define LOAD_FAST_CHECK 89 -#define LOAD_FAST_LOAD_FAST 90 -#define LOAD_FROM_DICT_OR_DEREF 91 -#define LOAD_FROM_DICT_OR_GLOBALS 92 -#define LOAD_GLOBAL 93 -#define LOAD_NAME 94 -#define LOAD_SMALL_INT 95 -#define LOAD_SPECIAL 96 -#define LOAD_SUPER_ATTR 97 -#define MAKE_CELL 98 -#define MAP_ADD 99 -#define MATCH_CLASS 100 -#define POP_JUMP_IF_FALSE 101 -#define POP_JUMP_IF_NONE 102 -#define POP_JUMP_IF_NOT_NONE 103 -#define POP_JUMP_IF_TRUE 104 -#define RAISE_VARARGS 105 -#define RERAISE 106 -#define SEND 107 -#define SET_ADD 108 -#define SET_FUNCTION_ATTRIBUTE 109 -#define SET_UPDATE 110 -#define STORE_ATTR 111 -#define STORE_DEREF 112 -#define STORE_FAST 113 -#define STORE_FAST_LOAD_FAST 114 -#define STORE_FAST_STORE_FAST 115 -#define STORE_GLOBAL 116 -#define STORE_NAME 117 -#define SWAP 118 -#define UNPACK_EX 119 -#define UNPACK_SEQUENCE 120 -#define YIELD_VALUE 121 +#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 DELETE_GLOBAL 64 +#define DELETE_NAME 65 +#define DICT_MERGE 66 +#define DICT_UPDATE 67 +#define END_ASYNC_FOR 68 +#define EXTENDED_ARG 69 +#define FOR_ITER 70 +#define GET_AWAITABLE 71 +#define IMPORT_FROM 72 +#define IMPORT_NAME 73 +#define IS_OP 74 +#define JUMP_BACKWARD 75 +#define JUMP_BACKWARD_NO_INTERRUPT 76 +#define JUMP_FORWARD 77 +#define LIST_APPEND 78 +#define LIST_EXTEND 79 +#define LOAD_ATTR 80 +#define LOAD_COMMON_CONSTANT 81 +#define LOAD_CONST 82 +#define LOAD_DEREF 83 +#define LOAD_FAST 84 +#define LOAD_FAST_AND_CLEAR 85 +#define LOAD_FAST_BORROW 86 +#define LOAD_FAST_BORROW_LOAD_FAST_BORROW 87 +#define LOAD_FAST_CHECK 88 +#define LOAD_FAST_LOAD_FAST 89 +#define LOAD_FROM_DICT_OR_DEREF 90 +#define LOAD_FROM_DICT_OR_GLOBALS 91 +#define LOAD_GLOBAL 92 +#define LOAD_NAME 93 +#define LOAD_SMALL_INT 94 +#define LOAD_SPECIAL 95 +#define LOAD_SUPER_ATTR 96 +#define MAKE_CELL 97 +#define MAP_ADD 98 +#define MATCH_CLASS 99 +#define POP_JUMP_IF_FALSE 100 +#define POP_JUMP_IF_NONE 101 +#define POP_JUMP_IF_NOT_NONE 102 +#define POP_JUMP_IF_TRUE 103 +#define RAISE_VARARGS 104 +#define RERAISE 105 +#define SEND 106 +#define SET_ADD 107 +#define SET_FUNCTION_ATTRIBUTE 108 +#define SET_UPDATE 109 +#define STORE_ATTR 110 +#define STORE_DEREF 111 +#define STORE_FAST 112 +#define STORE_FAST_LOAD_FAST 113 +#define STORE_FAST_STORE_FAST 114 +#define STORE_GLOBAL 115 +#define STORE_NAME 116 +#define SWAP 117 +#define UNPACK_EX 118 +#define UNPACK_SEQUENCE 119 +#define YIELD_VALUE 120 #define RESUME 128 #define BINARY_OP_ADD_FLOAT 129 #define BINARY_OP_ADD_INT 130 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 032d5cb606aa90..7ee69f4458d985 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -215,7 +215,7 @@ 'INSTRUMENTED_LINE': 254, 'ENTER_EXECUTOR': 255, 'BINARY_SLICE': 1, - 'BUILD_TEMPLATE_LIST': 2, + 'BUILD_TEMPLATE': 2, 'CALL_FUNCTION_EX': 4, 'CHECK_EG_MATCH': 5, 'CHECK_EXC_MATCH': 6, @@ -262,77 +262,76 @@ 'BUILD_SET': 48, 'BUILD_SLICE': 49, 'BUILD_STRING': 50, - 'BUILD_TEMPLATE': 51, - 'BUILD_TUPLE': 52, - 'CALL': 53, - 'CALL_INTRINSIC_1': 54, - 'CALL_INTRINSIC_2': 55, - 'CALL_KW': 56, - 'COMPARE_OP': 57, - 'CONTAINS_OP': 58, - 'CONVERT_VALUE': 59, - 'COPY': 60, - 'COPY_FREE_VARS': 61, - 'DELETE_ATTR': 62, - 'DELETE_DEREF': 63, - 'DELETE_FAST': 64, - 'DELETE_GLOBAL': 65, - 'DELETE_NAME': 66, - 'DICT_MERGE': 67, - 'DICT_UPDATE': 68, - 'END_ASYNC_FOR': 69, - 'EXTENDED_ARG': 70, - 'FOR_ITER': 71, - 'GET_AWAITABLE': 72, - 'IMPORT_FROM': 73, - 'IMPORT_NAME': 74, - 'IS_OP': 75, - 'JUMP_BACKWARD': 76, - 'JUMP_BACKWARD_NO_INTERRUPT': 77, - 'JUMP_FORWARD': 78, - 'LIST_APPEND': 79, - 'LIST_EXTEND': 80, - 'LOAD_ATTR': 81, - 'LOAD_COMMON_CONSTANT': 82, - 'LOAD_CONST': 83, - 'LOAD_DEREF': 84, - 'LOAD_FAST': 85, - 'LOAD_FAST_AND_CLEAR': 86, - 'LOAD_FAST_BORROW': 87, - 'LOAD_FAST_BORROW_LOAD_FAST_BORROW': 88, - 'LOAD_FAST_CHECK': 89, - 'LOAD_FAST_LOAD_FAST': 90, - 'LOAD_FROM_DICT_OR_DEREF': 91, - 'LOAD_FROM_DICT_OR_GLOBALS': 92, - 'LOAD_GLOBAL': 93, - 'LOAD_NAME': 94, - 'LOAD_SMALL_INT': 95, - 'LOAD_SPECIAL': 96, - 'LOAD_SUPER_ATTR': 97, - 'MAKE_CELL': 98, - 'MAP_ADD': 99, - 'MATCH_CLASS': 100, - 'POP_JUMP_IF_FALSE': 101, - 'POP_JUMP_IF_NONE': 102, - 'POP_JUMP_IF_NOT_NONE': 103, - 'POP_JUMP_IF_TRUE': 104, - 'RAISE_VARARGS': 105, - 'RERAISE': 106, - 'SEND': 107, - 'SET_ADD': 108, - 'SET_FUNCTION_ATTRIBUTE': 109, - 'SET_UPDATE': 110, - 'STORE_ATTR': 111, - 'STORE_DEREF': 112, - 'STORE_FAST': 113, - 'STORE_FAST_LOAD_FAST': 114, - 'STORE_FAST_STORE_FAST': 115, - 'STORE_GLOBAL': 116, - 'STORE_NAME': 117, - 'SWAP': 118, - 'UNPACK_EX': 119, - 'UNPACK_SEQUENCE': 120, - 'YIELD_VALUE': 121, + '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, + 'DELETE_GLOBAL': 64, + 'DELETE_NAME': 65, + 'DICT_MERGE': 66, + 'DICT_UPDATE': 67, + 'END_ASYNC_FOR': 68, + 'EXTENDED_ARG': 69, + 'FOR_ITER': 70, + 'GET_AWAITABLE': 71, + 'IMPORT_FROM': 72, + 'IMPORT_NAME': 73, + 'IS_OP': 74, + 'JUMP_BACKWARD': 75, + 'JUMP_BACKWARD_NO_INTERRUPT': 76, + 'JUMP_FORWARD': 77, + 'LIST_APPEND': 78, + 'LIST_EXTEND': 79, + 'LOAD_ATTR': 80, + 'LOAD_COMMON_CONSTANT': 81, + 'LOAD_CONST': 82, + 'LOAD_DEREF': 83, + 'LOAD_FAST': 84, + 'LOAD_FAST_AND_CLEAR': 85, + 'LOAD_FAST_BORROW': 86, + 'LOAD_FAST_BORROW_LOAD_FAST_BORROW': 87, + 'LOAD_FAST_CHECK': 88, + 'LOAD_FAST_LOAD_FAST': 89, + 'LOAD_FROM_DICT_OR_DEREF': 90, + 'LOAD_FROM_DICT_OR_GLOBALS': 91, + 'LOAD_GLOBAL': 92, + 'LOAD_NAME': 93, + 'LOAD_SMALL_INT': 94, + 'LOAD_SPECIAL': 95, + 'LOAD_SUPER_ATTR': 96, + 'MAKE_CELL': 97, + 'MAP_ADD': 98, + 'MATCH_CLASS': 99, + 'POP_JUMP_IF_FALSE': 100, + 'POP_JUMP_IF_NONE': 101, + 'POP_JUMP_IF_NOT_NONE': 102, + 'POP_JUMP_IF_TRUE': 103, + 'RAISE_VARARGS': 104, + 'RERAISE': 105, + 'SEND': 106, + 'SET_ADD': 107, + 'SET_FUNCTION_ATTRIBUTE': 108, + 'SET_UPDATE': 109, + 'STORE_ATTR': 110, + 'STORE_DEREF': 111, + 'STORE_FAST': 112, + 'STORE_FAST_LOAD_FAST': 113, + 'STORE_FAST_STORE_FAST': 114, + 'STORE_GLOBAL': 115, + 'STORE_NAME': 116, + 'SWAP': 117, + 'UNPACK_EX': 118, + 'UNPACK_SEQUENCE': 119, + 'YIELD_VALUE': 120, 'INSTRUMENTED_END_FOR': 234, 'INSTRUMENTED_POP_ITER': 235, 'INSTRUMENTED_END_SEND': 236, diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 381c2c62f4eaf7..7cf121c240137e 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -64,7 +64,7 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, PyObject *format_spec) /*[clinic end generated code: output=6488e288765bc1a9 input=d91711024068528c]*/ { - interpolationobject *self = (interpolationobject *) type->tp_alloc(type, 0); + interpolationobject *self = PyObject_GC_New(interpolationobject, type); if (!self) { return NULL; } @@ -73,6 +73,7 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, self->expression = Py_NewRef(expression); self->conversion = Py_NewRef(conversion); self->format_spec = Py_NewRef(format_spec); + PyObject_GC_Track(self); return (PyObject *) self; } @@ -160,8 +161,7 @@ _PyInterpolation_InitTypes(PyInterpreterState *interp) PyObject * _PyInterpolation_Build(PyObject *value, PyObject *str, int conversion, PyObject *format_spec) { - interpolationobject *interpolation = - (interpolationobject *) _PyInterpolation_Type.tp_alloc(&_PyInterpolation_Type, 0); + interpolationobject *interpolation = PyObject_GC_New(interpolationobject, &_PyInterpolation_Type); if (!interpolation) { return NULL; } @@ -192,6 +192,7 @@ _PyInterpolation_Build(PyObject *value, PyObject *str, int conversion, PyObject } } + PyObject_GC_Track(interpolation); return (PyObject *) interpolation; } diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 627077a1bb4990..72ee11b0b0b18b 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -70,19 +70,6 @@ typedef struct { #define templateobject_CAST(op) \ (assert(_PyTemplate_CheckExact(op)), _Py_CAST(templateobject*, (op))) -static templateobject * -template_from_strings_interpolations(PyTypeObject *type, PyObject *strings, PyObject *interpolations) -{ - templateobject *template = (templateobject *) type->tp_alloc(type, 0); - if (template == NULL) { - return NULL; - } - - template->strings = Py_NewRef(strings); - template->interpolations = Py_NewRef(interpolations); - return template; -} - static PyObject * template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { @@ -164,10 +151,10 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } - templateobject *template = template_from_strings_interpolations(type, strings, interpolations); + PyObject *template = _PyTemplate_Build(strings, interpolations); Py_DECREF(strings); Py_DECREF(interpolations); - return (PyObject *)template; + return template; } static void @@ -321,10 +308,10 @@ template_concat_templates(templateobject *self, templateobject *other) return NULL; } - templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, newinterpolations); + PyObject *newtemplate = _PyTemplate_Build(newstrings, newinterpolations); Py_DECREF(newstrings); Py_DECREF(newinterpolations); - return (PyObject *) newtemplate; + return newtemplate; } static PyObject * @@ -335,9 +322,9 @@ template_concat_template_str(templateobject *self, PyObject *other) return NULL; } - templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, self->interpolations); + PyObject *newtemplate = _PyTemplate_Build(newstrings, self->interpolations); Py_DECREF(newstrings); - return (PyObject *) newtemplate; + return newtemplate; } static PyObject * @@ -348,9 +335,9 @@ template_concat_str_template(templateobject *self, PyObject *other) return NULL; } - templateobject *newtemplate = template_from_strings_interpolations(Py_TYPE(self), newstrings, self->interpolations); + PyObject *newtemplate = _PyTemplate_Build(newstrings, self->interpolations); Py_DECREF(newstrings); - return (PyObject *) newtemplate; + return newtemplate; } PyObject * @@ -435,31 +422,15 @@ PyTypeObject _PyTemplate_Type = { }; PyObject * -_PyTemplate_FromValues(PyObject **values, Py_ssize_t oparg) +_PyTemplate_Build(PyObject *strings, PyObject *interpolations) { - PyObject *tuple = PyTuple_New(oparg); - if (!tuple) { - return NULL; - } - - for (Py_ssize_t i = 0; i < oparg; i++) { - PyTuple_SET_ITEM(tuple, i, Py_NewRef(values[i])); - } - - PyObject *template = (PyObject *) template_new(&_PyTemplate_Type, tuple, NULL); - Py_DECREF(tuple); - return template; -} - -PyObject * -_PyTemplate_FromList(PyObject *list) -{ - PyObject *tuple = PyList_AsTuple(list); - if (!tuple) { + templateobject *template = PyObject_GC_New(templateobject, &_PyTemplate_Type); + if (template == NULL) { return NULL; } - PyObject *template = (PyObject *) template_new(&_PyTemplate_Type, tuple, NULL); - Py_DECREF(tuple); - return template; + template->strings = Py_NewRef(strings); + template->interpolations = Py_NewRef(interpolations); + PyObject_GC_Track(template); + return (PyObject *) template; } diff --git a/Programs/test_frozenmain.h b/Programs/test_frozenmain.h index d056e08df464e7..b7d23f57018525 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,8,0,0, - 0,0,0,0,0,243,184,0,0,0,128,0,95,0,83,1, - 74,0,117,0,95,0,83,1,74,1,117,1,94,2,34,0, - 83,2,53,1,0,0,0,0,0,0,32,0,94,2,34,0, - 83,3,94,0,81,6,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,53,2,0,0,0,0,0,0, - 32,0,94,1,81,8,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,34,0,53,0,0,0,0,0, - 0,0,83,4,45,26,0,0,0,0,0,0,0,0,0,0, - 117,5,83,7,18,0,71,24,0,0,117,6,94,2,34,0, - 83,5,94,6,13,0,83,6,94,5,94,6,45,26,0,0, - 0,0,0,0,0,0,0,0,13,0,50,4,53,1,0,0, - 0,0,0,0,32,0,76,26,0,0,10,0,31,0,83,1, - 36,0,41,8,233,0,0,0,0,78,122,18,70,114,111,122, + 0,0,0,0,0,243,184,0,0,0,128,0,94,0,82,1, + 73,0,116,0,94,0,82,1,73,1,116,1,93,2,33,0, + 82,2,52,1,0,0,0,0,0,0,31,0,93,2,33,0, + 82,3,93,0,80,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, + 31,0,93,1,80,8,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,33,0,52,0,0,0,0,0, + 0,0,82,4,44,26,0,0,0,0,0,0,0,0,0,0, + 116,5,82,7,16,0,70,24,0,0,116,6,93,2,33,0, + 82,5,93,6,12,0,82,6,93,5,93,6,44,26,0,0, + 0,0,0,0,0,0,0,0,12,0,50,4,52,1,0,0, + 0,0,0,0,31,0,75,26,0,0,9,0,30,0,82,1, + 35,0,41,8,233,0,0,0,0,78,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,41,5,218, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index c8ff2a9024b604..b6ec3a225a2863 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1938,23 +1938,12 @@ dummy_func( interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); } - inst(BUILD_TEMPLATE, (pieces[oparg] -- template)) { - STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o); - if (CONVERSION_FAILED(pieces_o)) { - DECREF_INPUTS(); - ERROR_IF(true, error); - } - PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); - STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); - DECREF_INPUTS(); - ERROR_IF(template_o == NULL, error); - template = PyStackRef_FromPyObjectSteal(template_o); - } - - inst(BUILD_TEMPLATE_LIST, (list -- template)) { - PyObject *list_o = PyStackRef_AsPyObjectBorrow(list); - PyObject *template_o = _PyTemplate_FromList(list_o); - PyStackRef_CLOSE(list); + inst(BUILD_TEMPLATE, (strings, interpolations -- template)) { + PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings); + PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations); + PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o); + PyStackRef_CLOSE(interpolations); + PyStackRef_CLOSE(strings); ERROR_IF(template_o == NULL, error); template = PyStackRef_FromPyObjectSteal(template_o); } diff --git a/Python/codegen.c b/Python/codegen.c index fca95af044263c..6b3f982a45bca1 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -4039,19 +4039,52 @@ static int codegen_template_str(compiler *c, expr_ty e) { location loc = LOC(e); + expr_ty value; + Py_ssize_t value_count = asdl_seq_LEN(e->v.TemplateStr.values); - if (value_count > _PY_STACK_USE_GUIDELINE) { - ADDOP_I(c, loc, BUILD_LIST, 0); - for (Py_ssize_t i = 0; i < asdl_seq_LEN(e->v.TemplateStr.values); i++) { - VISIT(c, expr, asdl_seq_GET(e->v.TemplateStr.values, i)); - ADDOP_I(c, loc, LIST_APPEND, 1); + int last_was_interpolation = 1; + Py_ssize_t stringslen = 0; + for (Py_ssize_t i = 0; i < value_count; i++) { + value = asdl_seq_GET(e->v.TemplateStr.values, i); + if (value->kind == Interpolation_kind) { + if (last_was_interpolation) { + ADDOP_LOAD_CONST(c, loc, Py_NewRef(&_Py_STR(empty))); + stringslen++; + } + last_was_interpolation = 1; + } + else { + VISIT(c, expr, value); + Py_ssize_t j; + for (j = i + 1; j < value_count; j++) { + value = asdl_seq_GET(e->v.TemplateStr.values, j); + if (value->kind == Interpolation_kind) { + break; + } + VISIT(c, expr, value); + ADDOP_INPLACE(c, loc, Add); + } + i = j - 1; + stringslen++; + last_was_interpolation = 0; } - ADDOP(c, loc, BUILD_TEMPLATE_LIST); } - else { - VISIT_SEQ(c, expr, e->v.TemplateStr.values); - ADDOP_I(c, loc, BUILD_TEMPLATE, value_count); + if (last_was_interpolation) { + ADDOP_LOAD_CONST(c, loc, Py_NewRef(&_Py_STR(empty))); + stringslen++; + } + ADDOP_I(c, loc, BUILD_TUPLE, stringslen); + + Py_ssize_t interpolationslen = 0; + for (Py_ssize_t i = 0; i < value_count; i++) { + value = asdl_seq_GET(e->v.TemplateStr.values, i); + if (value->kind == Interpolation_kind) { + VISIT(c, expr, value); + interpolationslen++; + } } + ADDOP_I(c, loc, BUILD_TUPLE, interpolationslen); + ADDOP(c, loc, BUILD_TEMPLATE); return SUCCESS; } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index c78052a0a5930a..a9580b55baf489 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2657,58 +2657,25 @@ } case _BUILD_TEMPLATE: { - _PyStackRef *pieces; + _PyStackRef interpolations; + _PyStackRef strings; _PyStackRef template; - oparg = CURRENT_OPARG(); - pieces = &stack_pointer[-oparg]; - STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o); - if (CONVERSION_FAILED(pieces_o)) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp; - for (int _i = oparg; --_i >= 0;) { - tmp = pieces[_i]; - pieces[_i] = PyStackRef_NULL; - PyStackRef_CLOSE(tmp); - } - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - JUMP_TO_ERROR(); - } + interpolations = stack_pointer[-1]; + strings = stack_pointer[-2]; + PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings); + PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); + PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o); stack_pointer = _PyFrame_GetStackPointer(frame); - STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp; - for (int _i = oparg; --_i >= 0;) { - tmp = pieces[_i]; - pieces[_i] = PyStackRef_NULL; - PyStackRef_CLOSE(tmp); - } + PyStackRef_CLOSE(interpolations); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - if (template_o == NULL) { - JUMP_TO_ERROR(); - } - template = PyStackRef_FromPyObjectSteal(template_o); - stack_pointer[0] = template; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - break; - } - - case _BUILD_TEMPLATE_LIST: { - _PyStackRef list; - _PyStackRef template; - list = stack_pointer[-1]; - PyObject *list_o = PyStackRef_AsPyObjectBorrow(list); - PyObject *template_o = _PyTemplate_FromList(list_o); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(list); + PyStackRef_CLOSE(strings); stack_pointer = _PyFrame_GetStackPointer(frame); if (template_o == NULL) { JUMP_TO_ERROR(); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index eb5bd3b33ba6d4..522f2eb1b7f9fd 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1369,64 +1369,25 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(BUILD_TEMPLATE); - _PyStackRef *pieces; + _PyStackRef strings; + _PyStackRef interpolations; _PyStackRef template; - pieces = &stack_pointer[-oparg]; - STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o); - if (CONVERSION_FAILED(pieces_o)) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp; - for (int _i = oparg; --_i >= 0;) { - tmp = pieces[_i]; - pieces[_i] = PyStackRef_NULL; - PyStackRef_CLOSE(tmp); - } - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - JUMP_TO_LABEL(error); - } + interpolations = stack_pointer[-1]; + strings = stack_pointer[-2]; + PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings); + PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *template_o = _PyTemplate_FromValues(pieces_o, oparg); + PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o); stack_pointer = _PyFrame_GetStackPointer(frame); - STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp; - for (int _i = oparg; --_i >= 0;) { - tmp = pieces[_i]; - pieces[_i] = PyStackRef_NULL; - PyStackRef_CLOSE(tmp); - } + PyStackRef_CLOSE(interpolations); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - if (template_o == NULL) { - JUMP_TO_LABEL(error); - } - template = PyStackRef_FromPyObjectSteal(template_o); - stack_pointer[0] = template; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - DISPATCH(); - } - - TARGET(BUILD_TEMPLATE_LIST) { - #if Py_TAIL_CALL_INTERP - int opcode = BUILD_TEMPLATE_LIST; - (void)(opcode); - #endif - frame->instr_ptr = next_instr; - next_instr += 1; - INSTRUCTION_STATS(BUILD_TEMPLATE_LIST); - _PyStackRef list; - _PyStackRef template; - list = stack_pointer[-1]; - PyObject *list_o = PyStackRef_AsPyObjectBorrow(list); - PyObject *template_o = _PyTemplate_FromList(list_o); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(list); + PyStackRef_CLOSE(strings); stack_pointer = _PyFrame_GetStackPointer(frame); if (template_o == NULL) { JUMP_TO_LABEL(error); diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index fe8f5eb9d3ce12..debaab98f00a8e 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -2,7 +2,7 @@ static void *opcode_targets[256] = { &&TARGET_CACHE, &&TARGET_BINARY_SLICE, - &&TARGET_BUILD_TEMPLATE_LIST, + &&TARGET_BUILD_TEMPLATE, &&TARGET_BINARY_OP_INPLACE_ADD_UNICODE, &&TARGET_CALL_FUNCTION_EX, &&TARGET_CHECK_EG_MATCH, @@ -51,7 +51,6 @@ static void *opcode_targets[256] = { &&TARGET_BUILD_SET, &&TARGET_BUILD_SLICE, &&TARGET_BUILD_STRING, - &&TARGET_BUILD_TEMPLATE, &&TARGET_BUILD_TUPLE, &&TARGET_CALL, &&TARGET_CALL_INTRINSIC_1, @@ -128,6 +127,7 @@ static void *opcode_targets[256] = { &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, + &&_unknown_opcode, &&TARGET_RESUME, &&TARGET_BINARY_OP_ADD_FLOAT, &&TARGET_BINARY_OP_ADD_INT, @@ -292,7 +292,6 @@ Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_BUILD_SET(TAIL_CALL_PARAMS); Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_BUILD_SLICE(TAIL_CALL_PARAMS); Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_BUILD_STRING(TAIL_CALL_PARAMS); Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_BUILD_TEMPLATE(TAIL_CALL_PARAMS); -Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_BUILD_TEMPLATE_LIST(TAIL_CALL_PARAMS); Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_BUILD_TUPLE(TAIL_CALL_PARAMS); Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_CACHE(TAIL_CALL_PARAMS); Py_PRESERVE_NONE_CC static PyObject *_TAIL_CALL_CALL(TAIL_CALL_PARAMS); @@ -531,7 +530,6 @@ static py_tail_call_funcptr INSTRUCTION_TABLE[256] = { [BUILD_SLICE] = _TAIL_CALL_BUILD_SLICE, [BUILD_STRING] = _TAIL_CALL_BUILD_STRING, [BUILD_TEMPLATE] = _TAIL_CALL_BUILD_TEMPLATE, - [BUILD_TEMPLATE_LIST] = _TAIL_CALL_BUILD_TEMPLATE_LIST, [BUILD_TUPLE] = _TAIL_CALL_BUILD_TUPLE, [CACHE] = _TAIL_CALL_CACHE, [CALL] = _TAIL_CALL_CALL, @@ -735,6 +733,7 @@ static py_tail_call_funcptr INSTRUCTION_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, + [121] = _TAIL_CALL_UNKNOWN_OPCODE, [122] = _TAIL_CALL_UNKNOWN_OPCODE, [123] = _TAIL_CALL_UNKNOWN_OPCODE, [124] = _TAIL_CALL_UNKNOWN_OPCODE, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 5b851b8db64f75..adb9e1b1c3f2fa 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -1031,19 +1031,12 @@ case _BUILD_TEMPLATE: { JitOptSymbol *template; template = sym_new_not_null(ctx); - stack_pointer[-oparg] = template; - stack_pointer += 1 - oparg; + stack_pointer[-2] = template; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } - case _BUILD_TEMPLATE_LIST: { - JitOptSymbol *template; - template = sym_new_not_null(ctx); - stack_pointer[-1] = template; - break; - } - case _BUILD_TUPLE: { JitOptSymbol **values; JitOptSymbol *tup; From 1dca6046873b881d964f33f10503c17ebe91f2e9 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 15:29:26 +0200 Subject: [PATCH 77/88] Add tp_clear slot and remove UB casts --- Include/internal/pycore_template.h | 1 + Objects/interpolationobject.c | 12 +++++++-- Objects/templateobject.c | 42 +++++++++++++++++++++++------- 3 files changed, 43 insertions(+), 12 deletions(-) diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h index 45bece72ac532a..f2f8bf9912d3f6 100644 --- a/Include/internal/pycore_template.h +++ b/Include/internal/pycore_template.h @@ -13,6 +13,7 @@ extern PyTypeObject _PyTemplate_Type; extern PyTypeObject _PyTemplateIter_Type; #define _PyTemplate_CheckExact(op) Py_IS_TYPE((op), &_PyTemplate_Type) +#define _PyTemplateIter_CheckExact(op) Py_IS_TYPE((op), &_PyTemplateIter_Type) extern PyObject *_PyTemplate_Concat(PyObject *self, PyObject *other); diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 7cf121c240137e..40d33738757be5 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -79,14 +79,21 @@ interpolation_new_impl(PyTypeObject *type, PyObject *value, static void interpolation_dealloc(PyObject *op) +{ + PyObject_GC_UnTrack(op); + Py_TYPE(op)->tp_clear(op); + Py_TYPE(op)->tp_free(op); +} + +static int +interpolation_clear(PyObject *op) { interpolationobject *self = interpolationobject_CAST(op); - PyObject_GC_UnTrack(self); Py_CLEAR(self->value); Py_CLEAR(self->expression); Py_CLEAR(self->conversion); Py_CLEAR(self->format_spec); - Py_TYPE(self)->tp_free(self); + return 0; } static int @@ -127,6 +134,7 @@ PyTypeObject _PyInterpolation_Type = { .tp_new = interpolation_new, .tp_alloc = PyType_GenericAlloc, .tp_dealloc = interpolation_dealloc, + .tp_clear = interpolation_clear, .tp_free = PyObject_GC_Del, .tp_repr = interpolation_repr, .tp_members = interpolation_members, diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 72ee11b0b0b18b..34c566ffa9ad6b 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -11,9 +11,13 @@ typedef struct { int from_strings; } templateiterobject; +#define templateiterobject_CAST(op) \ + (assert(_PyTemplateIter_CheckExact(op)), _Py_CAST(templateiterobject*, (op))) + static PyObject * -templateiter_next(templateiterobject *self) +templateiter_next(PyObject *op) { + templateiterobject *self = templateiterobject_CAST(op); PyObject *item; if (self->from_strings) { item = PyIter_Next(self->stringsiter); @@ -30,17 +34,26 @@ templateiter_next(templateiterobject *self) } static void -templateiter_dealloc(templateiterobject *self) +templateiter_dealloc(PyObject *op) +{ + PyObject_GC_UnTrack(op); + Py_TYPE(op)->tp_clear(op); + Py_TYPE(op)->tp_free(op); +} + +static int +templateiter_clear(PyObject *op) { - PyObject_GC_UnTrack(self); + templateiterobject *self = templateiterobject_CAST(op); Py_CLEAR(self->stringsiter); Py_CLEAR(self->interpolationsiter); - Py_TYPE(self)->tp_free(self); + return 0; } static int -templateiter_traverse(templateiterobject *self, visitproc visit, void *arg) +templateiter_traverse(PyObject *op, visitproc visit, void *arg) { + templateiterobject *self = templateiterobject_CAST(op); Py_VISIT(self->stringsiter); Py_VISIT(self->interpolationsiter); return 0; @@ -54,11 +67,12 @@ PyTypeObject _PyTemplateIter_Type = { .tp_itemsize = 0, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, .tp_alloc = PyType_GenericAlloc, - .tp_dealloc = (destructor) templateiter_dealloc, + .tp_dealloc = templateiter_dealloc, + .tp_clear = templateiter_clear, .tp_free = PyObject_GC_Del, - .tp_traverse = (traverseproc) templateiter_traverse, + .tp_traverse = templateiter_traverse, .tp_iter = PyObject_SelfIter, - .tp_iternext = (iternextfunc) templateiter_next, + .tp_iternext = templateiter_next, }; typedef struct { @@ -159,12 +173,19 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static void template_dealloc(PyObject *op) +{ + PyObject_GC_UnTrack(op); + Py_TYPE(op)->tp_clear(op); + Py_TYPE(op)->tp_free(op); +} + +static int +template_clear(PyObject *op) { templateobject *self = templateobject_CAST(op); - PyObject_GC_UnTrack(self); Py_CLEAR(self->strings); Py_CLEAR(self->interpolations); - Py_TYPE(self)->tp_free(self); + return 0; } static int @@ -413,6 +434,7 @@ PyTypeObject _PyTemplate_Type = { .tp_new = template_new, .tp_alloc = PyType_GenericAlloc, .tp_dealloc = template_dealloc, + .tp_clear = template_clear, .tp_free = PyObject_GC_Del, .tp_repr = template_repr, .tp_members = template_members, From 011ca830c3d45538fa8ba92d84626bfc9af8000d Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 15:30:09 +0200 Subject: [PATCH 78/88] Apply Hugo's suggestions from code review Co-authored-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com> --- Doc/whatsnew/3.14.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Doc/whatsnew/3.14.rst b/Doc/whatsnew/3.14.rst index 986d4b9cc49722..9f7f3177ff9cf1 100644 --- a/Doc/whatsnew/3.14.rst +++ b/Doc/whatsnew/3.14.rst @@ -100,7 +100,7 @@ PEP 750: Template Strings Template string literals (t-strings) are a generalization of f-strings, using a ``t`` in place of the ``f`` prefix. Instead of evaluating -to :class:`str`, t-strings evaluate to a new :class:`string.templatelib.Template` type: +to :class:`str`, t-strings evaluate to a new :class:`!string.templatelib.Template` type: .. code-block:: python @@ -155,7 +155,7 @@ Writing template handlers is straightforward: With this in place, developers can write template systems to sanitize SQL, make safe shell operations, improve logging, tackle modern ideas in web development -(HTML, CSS, etc.), and implement lightweight, custom business DSLs. +(HTML, CSS, and so on), and implement lightweight, custom business DSLs. See :pep:`750` for more details. From 1379756d6e4cf9bf34ba6c52f2bf6ee81368712d Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 15:30:41 +0200 Subject: [PATCH 79/88] Add empty line to CODEOWNERS --- .github/CODEOWNERS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 024184789471c4..1d68b109de24f5 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -324,4 +324,4 @@ Modules/_xxtestfuzz/ @ammaraskar **/*interpolationobject* @lysnikolaou **/*templateobject* @lysnikolaou **/*templatelib* @lysnikolaou -**/*tstring* @lysnikolaou \ No newline at end of file +**/*tstring* @lysnikolaou From 4d1f2a54d4e5dc0b7262813a63618b4beb605603 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 22 Apr 2025 15:37:27 +0200 Subject: [PATCH 80/88] Add news blurb --- .../2025-04-22-15-37-05.gh-issue-132661.XE_A42.rst | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 Misc/NEWS.d/next/Core_and_Builtins/2025-04-22-15-37-05.gh-issue-132661.XE_A42.rst diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2025-04-22-15-37-05.gh-issue-132661.XE_A42.rst b/Misc/NEWS.d/next/Core_and_Builtins/2025-04-22-15-37-05.gh-issue-132661.XE_A42.rst new file mode 100644 index 00000000000000..666e8de943b349 --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2025-04-22-15-37-05.gh-issue-132661.XE_A42.rst @@ -0,0 +1,3 @@ +Implement :pep:`750` (Template Strings). Add new syntax for t-strings and +implement new internal :class:`!string.templatelib.Template` and +:class:`!string.templatelib.Interpolation` types. From 884273909b43af6f136d0ffc550f0753bd04d434 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+AA-Turner@users.noreply.github.com> Date: Wed, 23 Apr 2025 10:35:06 +0100 Subject: [PATCH 81/88] t-strings: Various changes (#74) --- Doc/library/token.rst | 6 +++--- Doc/whatsnew/3.14.rst | 3 ++- Include/internal/pycore_interpolation.h | 2 -- Lib/_ast_unparse.py | 16 ++++++++-------- Lib/tokenize.py | 4 ++-- Objects/interpolationobject.c | 3 ++- Objects/templateobject.c | 3 +++ Objects/unicodeobject.c | 2 +- Python/bytecodes.c | 4 ++-- Python/ceval.c | 4 ++-- Tools/cases_generator/analyzer.py | 2 -- 11 files changed, 25 insertions(+), 24 deletions(-) diff --git a/Doc/library/token.rst b/Doc/library/token.rst index 91e884b4b90ecd..b49b22fd61cc54 100644 --- a/Doc/library/token.rst +++ b/Doc/library/token.rst @@ -133,7 +133,7 @@ The token constants are: .. data:: TSTRING_START - Token value used to indicate the beginning of a t-string literal. + Token value used to indicate the beginning of a template string literal. .. impl-detail:: @@ -144,7 +144,7 @@ The token constants are: .. data:: TSTRING_MIDDLE - Token value used for literal text inside a t-string literal + Token value used for literal text inside a template string literal including format specifications. .. impl-detail:: @@ -158,7 +158,7 @@ The token constants are: .. data:: TSTRING_END - Token value used to indicate the end of a t-string. + Token value used to indicate the end of a template string literal. .. impl-detail:: diff --git a/Doc/whatsnew/3.14.rst b/Doc/whatsnew/3.14.rst index 9f7f3177ff9cf1..f7b49c159d14f2 100644 --- a/Doc/whatsnew/3.14.rst +++ b/Doc/whatsnew/3.14.rst @@ -160,7 +160,8 @@ safe shell operations, improve logging, tackle modern ideas in web development See :pep:`750` for more details. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, -Lysandros Nikolaou, and Dave Peck in :gh:`132661`.) +Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, +and Pablo Galindo Salgado in :gh:`132661`.) .. _whatsnew314-pep768: diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h index d0fe729f44b23a..dd610c1609c209 100644 --- a/Include/internal/pycore_interpolation.h +++ b/Include/internal/pycore_interpolation.h @@ -9,8 +9,6 @@ extern "C" { # error "this header requires Py_BUILD_CORE define" #endif -#include "pycore_stackref.h" // _PyStackRef - extern PyTypeObject _PyInterpolation_Type; #define _PyInterpolation_CheckExact(op) Py_IS_TYPE((op), &_PyInterpolation_Type) diff --git a/Lib/_ast_unparse.py b/Lib/_ast_unparse.py index 32cb81398b13f9..0b669edb2ffec6 100644 --- a/Lib/_ast_unparse.py +++ b/Lib/_ast_unparse.py @@ -573,11 +573,11 @@ def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES): quote_type = quote_types[0] self.write(f"{quote_type}{string}{quote_type}") - def _ftstring_helper(self, ftstring_parts): - new_ftstring_parts = [] + def _ftstring_helper(self, parts): + new_parts = [] quote_types = list(_ALL_QUOTES) fallback_to_repr = False - for value, is_constant in ftstring_parts: + for value, is_constant in parts: if is_constant: value, new_quote_types = self._str_literal_helper( value, @@ -596,22 +596,22 @@ def _ftstring_helper(self, ftstring_parts): new_quote_types = [q for q in quote_types if q not in value] if new_quote_types: quote_types = new_quote_types - new_ftstring_parts.append(value) + new_parts.append(value) if fallback_to_repr: # If we weren't able to find a quote type that works for all parts # of the JoinedStr, fallback to using repr and triple single quotes. quote_types = ["'''"] - new_ftstring_parts.clear() - for value, is_constant in ftstring_parts: + new_parts.clear() + for value, is_constant in parts: if is_constant: value = repr('"' + value) # force repr to use single quotes expected_prefix = "'\"" assert value.startswith(expected_prefix), repr(value) value = value[len(expected_prefix):-1] - new_ftstring_parts.append(value) + new_parts.append(value) - value = "".join(new_ftstring_parts) + value = "".join(new_parts) quote_type = quote_types[0] self.write(f"{quote_type}{value}{quote_type}") diff --git a/Lib/tokenize.py b/Lib/tokenize.py index 2ea8a43a303d9e..edb1ed8bdb8c9c 100644 --- a/Lib/tokenize.py +++ b/Lib/tokenize.py @@ -251,7 +251,7 @@ def untokenize(self, iterable): self.tokens.append(indent) self.prev_col = len(indent) startline = False - elif tok_type in (FSTRING_MIDDLE, TSTRING_MIDDLE): + elif tok_type in {FSTRING_MIDDLE, TSTRING_MIDDLE}: if '{' in token or '}' in token: token = self.escape_brackets(token) last_line = token.splitlines()[-1] @@ -308,7 +308,7 @@ def compat(self, token, iterable): elif startline and indents: toks_append(indents[-1]) startline = False - elif toknum in (FSTRING_MIDDLE, TSTRING_MIDDLE): + elif toknum in {FSTRING_MIDDLE, TSTRING_MIDDLE}: tokval = self.escape_brackets(tokval) # Insert a space between two consecutive brackets if we are in an f-string diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 40d33738757be5..75f0861e0fa856 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -1,8 +1,9 @@ /* t-string Interpolation object implementation */ #include "Python.h" -#include "pycore_initconfig.h" // _PyStatus_OK +#include "pycore_initconfig.h" // _PyStatus_OK #include "pycore_interpolation.h" +#include "pycore_typeobject.h" // _PyType_GetDict static int _conversion_converter(PyObject *arg, PyObject **conversion) diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 34c566ffa9ad6b..4892d464da947e 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -2,6 +2,7 @@ #include "Python.h" #include "pycore_interpolation.h" // _PyInterpolation_CheckExact() +#include "pycore_runtime.h" // _Py_STR() #include "pycore_template.h" typedef struct { @@ -155,6 +156,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } else if (_PyInterpolation_CheckExact(item)) { if (!last_was_str) { + _Py_DECLARE_STR(empty, ""); PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } PyTuple_SET_ITEM(interpolations, interpolationsidx++, Py_NewRef(item)); @@ -162,6 +164,7 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) } } if (!last_was_str) { + _Py_DECLARE_STR(empty, ""); PyTuple_SET_ITEM(strings, stringsidx++, &_Py_STR(empty)); } diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index a3ed0265aa39dd..311b7f3c2d1ab3 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -56,7 +56,7 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. #include "pycore_pyhash.h" // _Py_HashSecret_t #include "pycore_pylifecycle.h" // _Py_SetFileSystemEncoding() #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "pycore_template.h" // _PyTemplate_Type +#include "pycore_template.h" // _PyTemplate_Concat() #include "pycore_tuple.h" // _PyTuple_FromArray() #include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI #include "pycore_unicodeobject.h" // struct _Py_unicode_state diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b6ec3a225a2863..c46190ccd72dd2 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -16,7 +16,7 @@ #include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS #include "pycore_function.h" #include "pycore_instruments.h" -#include "pycore_interpolation.h" // _PyInterpolation_FromStackRefStealOnSuccess() +#include "pycore_interpolation.h" // _PyInterpolation_Build() #include "pycore_intrinsics.h" #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_moduleobject.h" // PyModuleObject @@ -31,7 +31,7 @@ #include "pycore_setobject.h" // _PySet_NextEntry() #include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs #include "pycore_stackref.h" -#include "pycore_template.h" // _PyTemplate_From{List,Values}() +#include "pycore_template.h" // _PyTemplate_Build() #include "pycore_tuple.h" // _PyTuple_ITEMS() #include "pycore_typeobject.h" // _PySuper_Lookup() diff --git a/Python/ceval.c b/Python/ceval.c index daffaf6306ba90..e252fac28004a5 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -19,7 +19,7 @@ #include "pycore_import.h" // _PyImport_IsDefaultImportFunc() #include "pycore_instruments.h" #include "pycore_interpframe.h" // _PyFrame_SetStackPointer() -#include "pycore_interpolation.h" // _PyInterpolation_FromStackRefStealOnSuccess() +#include "pycore_interpolation.h" // _PyInterpolation_Build() #include "pycore_intrinsics.h" #include "pycore_jit.h" #include "pycore_list.h" // _PyList_GetItemRef() @@ -37,7 +37,7 @@ #include "pycore_setobject.h" // _PySet_Update() #include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs #include "pycore_sysmodule.h" // _PySys_GetOptionalAttrString() -#include "pycore_template.h" // _PyTemplate_From{List,Values}() +#include "pycore_template.h" // _PyTemplate_Build() #include "pycore_traceback.h" // _PyTraceBack_FromFrame #include "pycore_tuple.h" // _PyTuple_ITEMS() #include "pycore_uop_ids.h" // Uops diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index fbb0008aae02a0..a217d7136a5401 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -630,7 +630,6 @@ def has_error_without_pop(op: parser.CodeDef) -> bool: "_PyFrame_StackPush", "_PyFunction_SetVersion", "_PyGen_GetGeneratorFromFrame", - "_PyInterpolation_FromStackRefStealOnSuccess", "_PyInterpreterState_GET", "_PyList_AppendTakeRef", "_PyList_ITEMS", @@ -649,7 +648,6 @@ def has_error_without_pop(op: parser.CodeDef) -> bool: "_PyObject_InlineValues", "_PyObject_IsUniquelyReferenced", "_PyObject_ManagedDictPointer", - "_PyTemplate_FromList", "_PyThreadState_HasStackSpace", "_PyTuple_FromStackRefStealOnSuccess", "_PyTuple_ITEMS", From 051e8eb6bc475927ef4935c771b4c6b2d0ca170d Mon Sep 17 00:00:00 2001 From: sobolevn Date: Wed, 23 Apr 2025 17:41:33 +0300 Subject: [PATCH 82/88] Add pickle support for tstrings (#75) --- Lib/string/templatelib.py | 20 ++++++++ Lib/test/test_string/_support.py | 4 +- Lib/test/test_string/test_templatelib.py | 58 +++++++++++++++++++++++- Lib/test/test_tstring.py | 4 +- Objects/interpolationobject.c | 17 +++++++ Objects/templateobject.c | 37 ++++++++++++++- 6 files changed, 132 insertions(+), 8 deletions(-) diff --git a/Lib/string/templatelib.py b/Lib/string/templatelib.py index 54ca4d3475068f..c843fd7ae58b74 100644 --- a/Lib/string/templatelib.py +++ b/Lib/string/templatelib.py @@ -1,3 +1,23 @@ """Support for template string literals (t-strings).""" from _templatelib import Interpolation, Template + +__all__ = [ + "Interpolation", + "Template", +] + +def _template_unpickle(*args): + import itertools + + if len(args) != 2: + raise ValueError('Template expects tuple of length 2 to unpickle') + + strings, interpolations = args + parts = [] + for string, interpolation in itertools.zip_longest(strings, interpolations): + if string is not None: + parts.append(string) + if interpolation is not None: + parts.append(interpolation) + return Template(*parts) diff --git a/Lib/test/test_string/_support.py b/Lib/test/test_string/_support.py index fcdfd47f91e6e4..eaa3354a559246 100644 --- a/Lib/test/test_string/_support.py +++ b/Lib/test/test_string/_support.py @@ -2,7 +2,7 @@ from string.templatelib import Interpolation -class TStringTestCase(unittest.TestCase): +class TStringBaseCase: def assertTStringEqual(self, t, strings, interpolations): """Test template string literal equality. @@ -23,7 +23,7 @@ def assertTStringEqual(self, t, strings, interpolations): continue if len(exp) == 3: - self.assertEqual((i.value, i.expression, i.conversion), exp) + self.assertEqual((i.value, i.expression, i.conversion), exp) self.assertEqual(i.format_spec, '') continue diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py index 6030da99b75d0d..aa3cb5ce43252d 100644 --- a/Lib/test/test_string/test_templatelib.py +++ b/Lib/test/test_string/test_templatelib.py @@ -1,9 +1,22 @@ +import pickle +import unittest from string.templatelib import Template, Interpolation -from test.test_string._support import TStringTestCase, fstring +from test.test_string._support import TStringBaseCase, fstring -class TestTemplate(TStringTestCase): +class TestTemplate(unittest.TestCase, TStringBaseCase): + + def test_common(self): + self.assertEqual(type(t'').__name__, 'Template') + self.assertEqual(type(t'').__qualname__, 'Template') + self.assertEqual(type(t'').__module__, 'string.templatelib') + + a = 'a' + i = t'{a}'.interpolations[0] + self.assertEqual(type(i).__name__, 'Interpolation') + self.assertEqual(type(i).__qualname__, 'Interpolation') + self.assertEqual(type(i).__module__, 'string.templatelib') def test_basic_creation(self): # Simple t-string creation @@ -53,3 +66,44 @@ def test_creation_interleaving(self): t, ('', '', ''), [('Maria', 'name'), ('Python', 'language')] ) self.assertEqual(fstring(t), 'MariaPython') + + def test_pickle_template(self): + user = 'test' + for template in ( + t'', + t"No values", + t'With inter {user}', + t'With ! {user!r}', + t'With format {1 / 0.3:.2f}', + Template(), + Template('a'), + Template(Interpolation('Nikita', 'name', None, '')), + Template('a', Interpolation('Nikita', 'name', 'r', '')), + ): + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + with self.subTest(proto=proto, template=template): + pickled = pickle.dumps(template, protocol=proto) + unpickled = pickle.loads(pickled) + + self.assertEqual(unpickled.values, template.values) + self.assertEqual(fstring(unpickled), fstring(template)) + + def test_pickle_interpolation(self): + for interpolation in ( + Interpolation('Nikita', 'name', None, ''), + Interpolation('Nikita', 'name', 'r', ''), + Interpolation(1/3, 'x', None, '.2f'), + ): + for proto in range(pickle.HIGHEST_PROTOCOL + 1): + with self.subTest(proto=proto, interpolation=interpolation): + pickled = pickle.dumps(interpolation, protocol=proto) + unpickled = pickle.loads(pickled) + + self.assertEqual(unpickled.value, interpolation.value) + self.assertEqual(unpickled.expression, interpolation.expression) + self.assertEqual(unpickled.conversion, interpolation.conversion) + self.assertEqual(unpickled.format_spec, interpolation.format_spec) + + +if __name__ == '__main__': + unittest.main() diff --git a/Lib/test/test_tstring.py b/Lib/test/test_tstring.py index 2421247d555ddb..e72a1ea54176d5 100644 --- a/Lib/test/test_tstring.py +++ b/Lib/test/test_tstring.py @@ -1,9 +1,9 @@ import unittest -from test.test_string._support import TStringTestCase, fstring +from test.test_string._support import TStringBaseCase, fstring -class TestTString(TStringTestCase): +class TestTString(unittest.TestCase, TStringBaseCase): def test_string_representation(self): # Test __repr__ t = t"Hello" diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 75f0861e0fa856..93b0c50ce724d2 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -125,6 +125,22 @@ static PyMemberDef interpolation_members[] = { {NULL} }; +static PyObject* +interpolation_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ + interpolationobject *self = interpolationobject_CAST(op); + return Py_BuildValue("(O(OOOO))", (PyObject *)Py_TYPE(op), + self->value, self->expression, + self->conversion, self->format_spec); +} + +static PyMethodDef interpolation_methods[] = { + {"__reduce__", interpolation_reduce, METH_VARARGS, + PyDoc_STR("__reduce__() -> (cls, state)")}, + + {NULL, NULL}, +}; + PyTypeObject _PyInterpolation_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "string.templatelib.Interpolation", @@ -139,6 +155,7 @@ PyTypeObject _PyInterpolation_Type = { .tp_free = PyObject_GC_Del, .tp_repr = interpolation_repr, .tp_members = interpolation_members, + .tp_methods = interpolation_methods, .tp_traverse = interpolation_traverse, }; diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 4892d464da947e..5afcfbab2da9f5 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -114,7 +114,10 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds) last_was_str = 0; } else { - PyErr_SetString(PyExc_TypeError, "Template.__new__ *args need to be of type 'str' or 'Interpolation'"); + PyErr_Format( + PyExc_TypeError, + "Template.__new__ *args need to be of type 'str' or 'Interpolation', got %T", + item); return NULL; } } @@ -418,7 +421,8 @@ static PyMemberDef template_members[] = { }; static PyGetSetDef template_getset[] = { - {"values", template_values_get, NULL, "Values of interpolations", NULL}, + {"values", template_values_get, NULL, + PyDoc_STR("Values of interpolations"), NULL}, {NULL}, }; @@ -426,6 +430,34 @@ static PySequenceMethods template_as_sequence = { .sq_concat = _PyTemplate_Concat, }; +static PyObject* +template_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) +{ + PyObject *mod = PyImport_ImportModule("string.templatelib"); + if (mod == NULL) { + return NULL; + } + PyObject *func = PyObject_GetAttrString(mod, "_template_unpickle"); + Py_DECREF(mod); + if (func == NULL) { + return NULL; + } + + templateobject *self = templateobject_CAST(op); + PyObject *result = Py_BuildValue("O(OO)", + func, + self->strings, + self->interpolations); + + Py_DECREF(func); + return result; +} + +static PyMethodDef template_methods[] = { + {"__reduce__", template_reduce, METH_NOARGS, NULL}, + {NULL, NULL}, +}; + PyTypeObject _PyTemplate_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "string.templatelib.Template", @@ -441,6 +473,7 @@ PyTypeObject _PyTemplate_Type = { .tp_free = PyObject_GC_Del, .tp_repr = template_repr, .tp_members = template_members, + .tp_methods = template_methods, .tp_getset = template_getset, .tp_iter = template_iter, .tp_traverse = template_traverse, From ce784962e01489de29ce7c6602db892d118e0ae5 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 23 Apr 2025 21:31:49 +0200 Subject: [PATCH 83/88] Address feedback; fix template_values_get and conversion --- Lib/test/test_string/test_templatelib.py | 13 +++++++++++++ Objects/interpolationobject.c | 1 + Objects/templateobject.c | 21 +++++---------------- 3 files changed, 19 insertions(+), 16 deletions(-) diff --git a/Lib/test/test_string/test_templatelib.py b/Lib/test/test_string/test_templatelib.py index aa3cb5ce43252d..5cf187828510c4 100644 --- a/Lib/test/test_string/test_templatelib.py +++ b/Lib/test/test_string/test_templatelib.py @@ -67,6 +67,19 @@ def test_creation_interleaving(self): ) self.assertEqual(fstring(t), 'MariaPython') + def test_template_values(self): + t = t'Hello, world' + self.assertEqual(t.values, ()) + + name = "Lys" + t = t'Hello, {name}' + self.assertEqual(t.values, ("Lys",)) + + country = "GR" + age = 0 + t = t'Hello, {name}, {age} from {country}' + self.assertEqual(t.values, ("Lys", 0, "GR")) + def test_pickle_template(self): user = 'test' for template in ( diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 93b0c50ce724d2..4b04f188a4a070 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -195,6 +195,7 @@ _PyInterpolation_Build(PyObject *value, PyObject *str, int conversion, PyObject interpolation->value = Py_NewRef(value); interpolation->expression = Py_NewRef(str); interpolation->format_spec = Py_NewRef(format_spec); + interpolation->conversion = NULL; if (conversion == 0) { interpolation->conversion = Py_None; diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 5afcfbab2da9f5..688dd2c1b3bc74 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -388,29 +388,18 @@ static PyObject * template_values_get(PyObject *op, void *Py_UNUSED(data)) { templateobject *self = templateobject_CAST(op); + + Py_ssize_t len = PyTuple_GET_SIZE(self->interpolations); PyObject *values = PyTuple_New(PyTuple_GET_SIZE(self->interpolations)); if (values == NULL) { return NULL; } - PyObject *interpolationsiter = PyObject_GetIter(self->interpolations); - if (interpolationsiter == NULL) { - Py_DECREF(values); - return NULL; - } - - PyObject *item; - Py_ssize_t index = 0; - while ((item = PyIter_Next(interpolationsiter))) { - PyTuple_SET_ITEM(values, index++, _PyInterpolation_GetValueRef(item)); - Py_DECREF(item); + for (Py_ssize_t i = 0; i < len; i++) { + PyObject *item = PyTuple_GET_ITEM(self->interpolations, i); + PyTuple_SET_ITEM(values, i, _PyInterpolation_GetValueRef(item)); } - Py_DECREF(interpolationsiter); - if (PyErr_Occurred()) { - Py_DECREF(values); - return NULL; - } return values; } From 0303c25963187d5dc3afbc652493af97f56d46f9 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 25 Apr 2025 21:38:05 +0200 Subject: [PATCH 84/88] Add snippets to Lib/test/test_ast/snippets.py --- Lib/test/test_ast/data/ast_repr.txt | 7 ++++++- Lib/test/test_ast/snippets.py | 11 +++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/Lib/test/test_ast/data/ast_repr.txt b/Lib/test/test_ast/data/ast_repr.txt index 3778b9e70a4605..1c1985519cd8b4 100644 --- a/Lib/test/test_ast/data/ast_repr.txt +++ b/Lib/test/test_ast/data/ast_repr.txt @@ -206,4 +206,9 @@ Module(body=[Expr(value=IfExp(test=Name(...), body=Call(...), orelse=Call(...))) Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[]) Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[]) Module(body=[Expr(value=JoinedStr(values=[FormattedValue(...)]))], type_ignores=[]) -Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[]) \ No newline at end of file +Module(body=[Expr(value=JoinedStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[]) +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) +Module(body=[Expr(value=TemplateStr(values=[Interpolation(...)]))], type_ignores=[]) +Module(body=[Expr(value=TemplateStr(values=[Constant(...), ..., Constant(...)]))], type_ignores=[]) \ No newline at end of file diff --git a/Lib/test/test_ast/snippets.py b/Lib/test/test_ast/snippets.py index 28d32b2941f30d..b76f98901d2ad8 100644 --- a/Lib/test/test_ast/snippets.py +++ b/Lib/test/test_ast/snippets.py @@ -364,6 +364,12 @@ "f'{a:.2f}'", "f'{a!r}'", "f'foo({a})'", + # TemplateStr and Interpolation + "t'{a}'", + "t'{a:.2f}'", + "t'{a!r}'", + "t'{a!r:.2f}'", + "t'foo({a})'", ] @@ -597,5 +603,10 @@ def main(): ('Expression', ('JoinedStr', (1, 0, 1, 10), [('FormattedValue', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])), ('Expression', ('JoinedStr', (1, 0, 1, 8), [('FormattedValue', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 114, None)])), ('Expression', ('JoinedStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('FormattedValue', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), -1, None), ('Constant', (1, 9, 1, 10), ')', None)])), +('Expression', ('TemplateStr', (1, 0, 1, 6), [('Interpolation', (1, 2, 1, 5), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, None)])), +('Expression', ('TemplateStr', (1, 0, 1, 10), [('Interpolation', (1, 2, 1, 9), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', -1, ('JoinedStr', (1, 4, 1, 8), [('Constant', (1, 5, 1, 8), '.2f', None)]))])), +('Expression', ('TemplateStr', (1, 0, 1, 8), [('Interpolation', (1, 2, 1, 7), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, None)])), +('Expression', ('TemplateStr', (1, 0, 1, 12), [('Interpolation', (1, 2, 1, 11), ('Name', (1, 3, 1, 4), 'a', ('Load',)), 'a', 114, ('JoinedStr', (1, 6, 1, 10), [('Constant', (1, 7, 1, 10), '.2f', None)]))])), +('Expression', ('TemplateStr', (1, 0, 1, 11), [('Constant', (1, 2, 1, 6), 'foo(', None), ('Interpolation', (1, 6, 1, 9), ('Name', (1, 7, 1, 8), 'a', ('Load',)), 'a', -1, None), ('Constant', (1, 9, 1, 10), ')', None)])), ] main() From ab9026fd6f43d248d062825367010ee6bb668580 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 29 Apr 2025 10:40:26 +0200 Subject: [PATCH 85/88] Remove _templatelib extension --- Lib/string/templatelib.py | 7 ++++-- Modules/Setup | 1 - Modules/Setup.bootstrap.in | 1 - Modules/_templatelibmodule.c | 38 ------------------------------ PC/config.c | 2 -- PCbuild/pythoncore.vcxproj | 1 - PCbuild/pythoncore.vcxproj.filters | 3 --- Python/stdlib_module_names.h | 1 - configure | 28 ---------------------- configure.ac | 1 - 10 files changed, 5 insertions(+), 78 deletions(-) delete mode 100644 Modules/_templatelibmodule.c diff --git a/Lib/string/templatelib.py b/Lib/string/templatelib.py index c843fd7ae58b74..14b40e1e36e30b 100644 --- a/Lib/string/templatelib.py +++ b/Lib/string/templatelib.py @@ -1,12 +1,15 @@ """Support for template string literals (t-strings).""" -from _templatelib import Interpolation, Template - __all__ = [ "Interpolation", "Template", ] +t = t"{0}" +Template = type(t) +Interpolation = type(t.interpolations[0]) +del t + def _template_unpickle(*args): import itertools diff --git a/Modules/Setup b/Modules/Setup index a4c780f5814bb0..65c22d48ba0bb7 100644 --- a/Modules/Setup +++ b/Modules/Setup @@ -149,7 +149,6 @@ PYTHONPATH=$(COREPYTHONPATH) #_socket socketmodule.c #_statistics _statisticsmodule.c #_struct _struct.c -#_templatelib _templatelibmodule.c #_types _typesmodule.c #_typing _typingmodule.c #_zoneinfo _zoneinfo.c diff --git a/Modules/Setup.bootstrap.in b/Modules/Setup.bootstrap.in index a3205f16862c4e..2b2e8cb3e3cacd 100644 --- a/Modules/Setup.bootstrap.in +++ b/Modules/Setup.bootstrap.in @@ -21,7 +21,6 @@ _io _io/_iomodule.c _io/iobase.c _io/fileio.c _io/bytesio.c _io/bufferedio.c _io itertools itertoolsmodule.c _sre _sre/sre.c _sysconfig _sysconfig.c -_templatelib _templatelibmodule.c _thread _threadmodule.c time timemodule.c _types _typesmodule.c diff --git a/Modules/_templatelibmodule.c b/Modules/_templatelibmodule.c deleted file mode 100644 index 3911bb4550cd11..00000000000000 --- a/Modules/_templatelibmodule.c +++ /dev/null @@ -1,38 +0,0 @@ -/* interpreter-internal types for string.templatelib */ - -#include "Python.h" -#include "pycore_interpolation.h" // _PyInterpolation_Type -#include "pycore_template.h" // _PyTemplate_Type - -static int -_templatelib_exec(PyObject *m) -{ - if (PyModule_AddObjectRef(m, "Template", (PyObject *)&_PyTemplate_Type) < 0) { - return -1; - } - if (PyModule_AddObjectRef(m, "Interpolation", (PyObject *)&_PyInterpolation_Type) < 0) { - return -1; - } - return 0; -} - -static struct PyModuleDef_Slot _templatelib_slots[] = { - {Py_mod_exec, _templatelib_exec}, - {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, - {Py_mod_gil, Py_MOD_GIL_NOT_USED}, - {0, NULL} -}; - -static struct PyModuleDef _templatemodule = { - .m_base = PyModuleDef_HEAD_INIT, - .m_name = "_templatelib", - .m_doc = "Interpreter types for template string literals (t-strings).", - .m_size = 0, - .m_slots = _templatelib_slots, -}; - -PyMODINIT_FUNC -PyInit__templatelib(void) -{ - return PyModuleDef_Init(&_templatemodule); -} diff --git a/PC/config.c b/PC/config.c index e09ad0db2ef5ee..6ce2131c7b84d0 100644 --- a/PC/config.c +++ b/PC/config.c @@ -19,7 +19,6 @@ extern PyObject* PyInit__operator(void); extern PyObject* PyInit__signal(void); extern PyObject* PyInit__statistics(void); extern PyObject* PyInit__sysconfig(void); -extern PyObject* PyInit__templatelib(void); extern PyObject* PyInit__types(void); extern PyObject* PyInit__typing(void); extern PyObject* PyInit_time(void); @@ -107,7 +106,6 @@ struct _inittab _PyImport_Inittab[] = { {"_signal", PyInit__signal}, {"_sysconfig", PyInit__sysconfig}, {"time", PyInit_time}, - {"_templatelib", PyInit__templatelib}, {"_thread", PyInit__thread}, {"_tokenize", PyInit__tokenize}, {"_types", PyInit__types}, diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj index d101a0b9ebba0b..d2aafce058d05e 100644 --- a/PCbuild/pythoncore.vcxproj +++ b/PCbuild/pythoncore.vcxproj @@ -484,7 +484,6 @@ - diff --git a/PCbuild/pythoncore.vcxproj.filters b/PCbuild/pythoncore.vcxproj.filters index 8fcb11f0bfd713..873f7d65a26a87 100644 --- a/PCbuild/pythoncore.vcxproj.filters +++ b/PCbuild/pythoncore.vcxproj.filters @@ -1004,9 +1004,6 @@ Modules - - Modules - Modules diff --git a/Python/stdlib_module_names.h b/Python/stdlib_module_names.h index 77d62a9bfb86d3..fcef7419bd397b 100644 --- a/Python/stdlib_module_names.h +++ b/Python/stdlib_module_names.h @@ -89,7 +89,6 @@ static const char* _Py_stdlib_module_names[] = { "_suggestions", "_symtable", "_sysconfig", -"_templatelib", "_thread", "_threading_local", "_tkinter", diff --git a/configure b/configure index f87377c82ec22c..205f196a25af2d 100755 --- a/configure +++ b/configure @@ -787,8 +787,6 @@ MODULE__TYPING_FALSE MODULE__TYPING_TRUE MODULE__TYPES_FALSE MODULE__TYPES_TRUE -MODULE__TEMPLATELIB_FALSE -MODULE__TEMPLATELIB_TRUE MODULE__STRUCT_FALSE MODULE__STRUCT_TRUE MODULE_SELECT_FALSE @@ -31027,28 +31025,6 @@ then : -fi - - - if test "$py_cv_module__templatelib" != "n/a" -then : - py_cv_module__templatelib=yes -fi - if test "$py_cv_module__templatelib" = yes; then - MODULE__TEMPLATELIB_TRUE= - MODULE__TEMPLATELIB_FALSE='#' -else - MODULE__TEMPLATELIB_TRUE='#' - MODULE__TEMPLATELIB_FALSE= -fi - - as_fn_append MODULE_BLOCK "MODULE__TEMPLATELIB_STATE=$py_cv_module__templatelib$as_nl" - if test "x$py_cv_module__templatelib" = xyes -then : - - - - fi @@ -33870,10 +33846,6 @@ if test -z "${MODULE__STRUCT_TRUE}" && test -z "${MODULE__STRUCT_FALSE}"; then as_fn_error $? "conditional \"MODULE__STRUCT\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi -if test -z "${MODULE__TEMPLATELIB_TRUE}" && test -z "${MODULE__TEMPLATELIB_FALSE}"; then - as_fn_error $? "conditional \"MODULE__TEMPLATELIB\" was never defined. -Usually this means the macro was only invoked conditionally." "$LINENO" 5 -fi if test -z "${MODULE__TYPES_TRUE}" && test -z "${MODULE__TYPES_FALSE}"; then as_fn_error $? "conditional \"MODULE__TYPES\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 diff --git a/configure.ac b/configure.ac index 359a0a55b75997..f0ae7fbec1cbfe 100644 --- a/configure.ac +++ b/configure.ac @@ -7795,7 +7795,6 @@ PY_STDLIB_MOD_SIMPLE([_queue]) PY_STDLIB_MOD_SIMPLE([_random]) PY_STDLIB_MOD_SIMPLE([select]) PY_STDLIB_MOD_SIMPLE([_struct]) -PY_STDLIB_MOD_SIMPLE([_templatelib]) PY_STDLIB_MOD_SIMPLE([_types]) PY_STDLIB_MOD_SIMPLE([_typing]) PY_STDLIB_MOD_SIMPLE([_interpreters]) From 48f771ba8a8e99a233f9cdedacb89494557ce530 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 29 Apr 2025 11:05:06 +0200 Subject: [PATCH 86/88] Change __reduce__ flags to METH_NOARGS --- Objects/interpolationobject.c | 7 +++---- Objects/templateobject.c | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c index 4b04f188a4a070..aaea3b8c0670c9 100644 --- a/Objects/interpolationobject.c +++ b/Objects/interpolationobject.c @@ -135,10 +135,9 @@ interpolation_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) } static PyMethodDef interpolation_methods[] = { - {"__reduce__", interpolation_reduce, METH_VARARGS, - PyDoc_STR("__reduce__() -> (cls, state)")}, - - {NULL, NULL}, + {"__reduce__", interpolation_reduce, METH_NOARGS, + PyDoc_STR("__reduce__() -> (cls, state)")}, + {NULL, NULL}, }; PyTypeObject _PyInterpolation_Type = { diff --git a/Objects/templateobject.c b/Objects/templateobject.c index 688dd2c1b3bc74..7d356980b56cbb 100644 --- a/Objects/templateobject.c +++ b/Objects/templateobject.c @@ -444,7 +444,7 @@ template_reduce(PyObject *op, PyObject *Py_UNUSED(dummy)) static PyMethodDef template_methods[] = { {"__reduce__", template_reduce, METH_NOARGS, NULL}, - {NULL, NULL}, + {NULL, NULL}, }; PyTypeObject _PyTemplate_Type = { From 8b0c13285196bea449095248578e2f34aeb41c37 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 30 Apr 2025 10:14:11 +0200 Subject: [PATCH 87/88] Fix docs for TSTRING_MIDDLE --- Doc/library/token.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Doc/library/token.rst b/Doc/library/token.rst index b49b22fd61cc54..1529d173e17af4 100644 --- a/Doc/library/token.rst +++ b/Doc/library/token.rst @@ -149,7 +149,7 @@ The token constants are: .. impl-detail:: - Replacement fields (that is, the non-literal parts of f-strings) use + Replacement fields (that is, the non-literal parts of t-strings) use the same tokens as other expressions, and are delimited by :data:`LBRACE`, :data:`RBRACE`, :data:`EXCLAMATION` and :data:`COLON` tokens. From 44749c7c19122b01ae9614ca4c654eebd0ad9d77 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 30 Apr 2025 10:28:23 +0200 Subject: [PATCH 88/88] Fix ERROR_IF --- Python/bytecodes.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 0b3e22b463ad79..b30fa0899106de 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1925,7 +1925,7 @@ dummy_func( } PyStackRef_CLOSE(str); PyStackRef_CLOSE(value); - ERROR_IF(interpolation_o == NULL, error); + ERROR_IF(interpolation_o == NULL); interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); } @@ -1935,7 +1935,7 @@ dummy_func( PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o); PyStackRef_CLOSE(interpolations); PyStackRef_CLOSE(strings); - ERROR_IF(template_o == NULL, error); + ERROR_IF(template_o == NULL); template = PyStackRef_FromPyObjectSteal(template_o); }