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); } pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy