From 17dffb39ddfed6e98c6dc1a3e6374c6534876adf Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 29 Apr 2024 04:46:07 +0800 Subject: [PATCH] unambiguous inline function defs and classes!! --- Grammar/python.gram | 51 +- Include/internal/pycore_ast.h | 11 +- Include/internal/pycore_ast_state.h | 1 + Parser/Python.asdl | 1 + Parser/parser.c | 8000 +++++++++++++++------------ Python/Python-ast.c | 76 + Python/ast.c | 3 + Python/ast_opt.c | 3 + Python/compile.c | 33 +- Python/pythonrun.c | 2 - Python/symtable.c | 3 + 11 files changed, 4759 insertions(+), 3425 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 5d3cfff..b4756ef 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -108,6 +108,10 @@ simple_stmts[asdl_stmt_seq*]: | a=simple_stmt !';' NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } # Not needed, there for speedup | a[asdl_stmt_seq*]=';'.simple_stmt+ [';'] NEWLINE { a } +simple_stmts_nonewline[asdl_stmt_seq*]: + | a=simple_stmt !';' { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } # Not needed, there for speedup + | a[asdl_stmt_seq*]=';'.simple_stmt+ [';'] { a } + # NOTE: assignment MUST precede expression, else parsing a simple assignment # will throw a SyntaxError. simple_stmt[stmt_ty] (memo): @@ -267,6 +271,10 @@ block[asdl_stmt_seq*] (memo): | simple_stmts | invalid_block +block_nonewline[asdl_stmt_seq*]: + | NEWLINE INDENT? a=statements DEDENT? { a } + | simple_stmts_nonewline + decorators[asdl_expr_seq*]: a[asdl_expr_seq*]=('@' f=named_expression NEWLINE { f })+ { a } # Class definitions @@ -284,6 +292,18 @@ class_def_raw[stmt_ty]: (b) ? ((expr_ty) b)->v.Call.keywords : NULL, c, NULL, t, EXTRA) } +class_def_nonewline[stmt_ty]: + | a=decorators b=class_def_raw_nonewline { _PyPegen_class_def_decorators(p, a, b) } + | class_def_raw_nonewline + +class_def_raw_nonewline[stmt_ty]: + | invalid_class_def_raw_nonewline + | 'class' a=NAME t=[type_params] b=['(' z=[arguments] ')' { z }] ':' c=block_nonewline { + _PyAST_ClassDef(a->v.Name.id, + (b) ? ((expr_ty) b)->v.Call.args : NULL, + (b) ? ((expr_ty) b)->v.Call.keywords : NULL, + c, NULL, t, EXTRA) } + # Function definitions # -------------------- @@ -307,6 +327,25 @@ function_def_raw[stmt_ty]: b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA) ) } +function_def_nonewline[stmt_ty]: + | d=decorators f=function_def_raw_nonewline { _PyPegen_function_def_decorators(p, d, f) } + | function_def_raw_nonewline + +function_def_raw_nonewline[stmt_ty]: + | "def" n=NAME t=[type_params] &&'(' params=[params] ')' a=['->' z=expression { z }] &&':' tc=[func_type_comment] b=block_nonewline { + _PyAST_FunctionDef(n->v.Name.id, + (params) ? params : CHECK(arguments_ty, _PyPegen_empty_arguments(p)), + b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA) } + | 'async' "def" n=NAME t=[type_params] &&'(' params=[params] ')' a=['->' z=expression { z }] &&':' tc=[func_type_comment] b=block_nonewline { + CHECK_VERSION( + stmt_ty, + 5, + "Async functions are", + _PyAST_AsyncFunctionDef(n->v.Name.id, + (params) ? params : CHECK(arguments_ty, _PyPegen_empty_arguments(p)), + b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA) + ) } + # Function parameters # ------------------- @@ -936,7 +975,7 @@ await_primary[expr_ty] (memo): primary[expr_ty]: | a=primary n='?'? '.' b=NAME { _PyAST_Attribute(a, b->v.Name.id, Load, n != NULL, EXTRA) } - | a=primary n='?'? b=(genexp | tuplecomp) { + | a=primary n='?'? b=(class_or_func_expr | tuplecomp | genexp) { _PyAST_Call(a, CHECK(asdl_expr_seq*, (asdl_expr_seq*)_PyPegen_singleton_seq(p, b)), NULL, @@ -971,7 +1010,7 @@ atom[expr_ty]: RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "template not in righthand side of pipe operation") } | &(STRING|FSTRING_START) strings | NUMBER - | &'(' (tuple | group | genexp | tuplecomp) + | &'(' (class_or_func_expr | tuple | group | tuplecomp | genexp) | &'[' (list | listcomp) | &'{' (dict | set | dictcomp | setcomp) | '...' { _PyAST_Constant(Py_Ellipsis, NULL, EXTRA) } @@ -980,6 +1019,10 @@ group[expr_ty]: | '(' a=(yield_expr | slice) ')' { a } | invalid_group +class_or_func_expr[expr_ty]: + | '(' a=( &("def" | '@' | 'async') function_def_nonewline + | &('class' | '@') class_def_nonewline ) ')' { _PyAST_CompoundExpr(a, EXTRA) } + # Lambda functions # ---------------- @@ -1510,8 +1553,10 @@ invalid_for_stmt: invalid_def_raw: | ['async'] a="def" NAME '(' [params] ')' ['->' expression] ':' NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block after function definition on line %d", a->lineno) } -invalid_class_def_raw: +invalid_class_def_raw_nonewline: | 'class' NAME ['(' [arguments] ')'] NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") } +invalid_class_def_raw: + | invalid_class_def_raw_nonewline | a='class' NAME ['(' [arguments] ')'] ':' NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block after class definition on line %d", a->lineno) } diff --git a/Include/internal/pycore_ast.h b/Include/internal/pycore_ast.h index c71612d..10db273 100644 --- a/Include/internal/pycore_ast.h +++ b/Include/internal/pycore_ast.h @@ -388,8 +388,9 @@ enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, Await_kind=15, Yield_kind=16, YieldFrom_kind=17, Compare_kind=18, Call_kind=19, FormattedValue_kind=20, JoinedStr_kind=21, Constant_kind=22, Template_kind=23, - Attribute_kind=24, Subscript_kind=25, Starred_kind=26, - Name_kind=27, List_kind=28, Tuple_kind=29, Slice_kind=30}; + CompoundExpr_kind=24, Attribute_kind=25, Subscript_kind=26, + Starred_kind=27, Name_kind=28, List_kind=29, Tuple_kind=30, + Slice_kind=31}; struct _expr { enum _expr_kind kind; union { @@ -509,6 +510,10 @@ struct _expr { int last; } Template; + struct { + stmt_ty value; + } CompoundExpr; + struct { expr_ty value; identifier attr; @@ -885,6 +890,8 @@ expr_ty _PyAST_Constant(constant value, string kind, int lineno, int *arena); expr_ty _PyAST_Template(int last, int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_CompoundExpr(stmt_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); expr_ty _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int aware, 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 8df08f2..43f0323 100644 --- a/Include/internal/pycore_ast_state.h +++ b/Include/internal/pycore_ast_state.h @@ -47,6 +47,7 @@ struct ast_state { PyObject *Comp_type; PyObject *Compare_type; PyObject *Composition_type; + PyObject *CompoundExpr_type; PyObject *Constant_type; PyObject *Continue_type; PyObject *Del_singleton; diff --git a/Parser/Python.asdl b/Parser/Python.asdl index 51a9ac6..41442e6 100644 --- a/Parser/Python.asdl +++ b/Parser/Python.asdl @@ -86,6 +86,7 @@ module Python | JoinedStr(expr* values) | Constant(constant value, string? kind) | Template(int last) + | CompoundExpr(stmt value) -- the following expression can appear in assignment context | Attribute(expr value, identifier attr, expr_context ctx, int aware) diff --git a/Parser/parser.c b/Parser/parser.c index d5a4d01..c9f95a7 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -17,55 +17,55 @@ static KeywordToken *reserved_keywords[] = { (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) { - {"if", 702}, - {"as", 700}, - {"in", 713}, - {"is", 634}, - {"or", 621}, + {"if", 706}, + {"as", 704}, + {"in", 717}, + {"is", 636}, + {"or", 623}, {NULL, -1}, }, (KeywordToken[]) { - {"del", 659}, - {"for", 712}, - {"try", 684}, - {"and", 622}, - {"not", 633}, + {"del", 663}, + {"for", 716}, + {"try", 688}, + {"and", 624}, + {"not", 635}, {NULL, -1}, }, (KeywordToken[]) { - {"from", 664}, + {"from", 668}, {"pass", 558}, {"goto", 567}, - {"with", 675}, - {"None", 657}, - {"True", 656}, - {"elif", 704}, - {"else", 705}, + {"with", 679}, + {"None", 661}, + {"True", 660}, + {"elif", 708}, + {"else", 709}, {NULL, -1}, }, (KeywordToken[]) { {"raise", 559}, - {"yield", 620}, + {"yield", 622}, {"break", 538}, - {"async", 714}, - {"class", 716}, - {"while", 707}, - {"False", 658}, - {"await", 635}, + {"async", 718}, + {"class", 720}, + {"while", 711}, + {"False", 662}, + {"await", 637}, {NULL, -1}, }, (KeywordToken[]) { {"return", 560}, - {"import", 663}, + {"import", 667}, {"assert", 566}, {"global", 548}, - {"except", 697}, - {"lambda", 655}, - {"unless", 615}, + {"except", 701}, + {"lambda", 659}, + {"unless", 617}, {NULL, -1}, }, (KeywordToken[]) { - {"finally", 693}, + {"finally", 697}, {NULL, -1}, }, (KeywordToken[]) { @@ -94,571 +94,587 @@ static char *soft_keywords[] = { #define statement_type 1006 #define statement_newline_type 1007 #define simple_stmts_type 1008 -#define simple_stmt_type 1009 -#define compound_stmt_type 1010 -#define assignment_type 1011 -#define annotated_rhs_type 1012 -#define augassign_type 1013 -#define unarassign_type 1014 -#define return_stmt_type 1015 -#define raise_stmt_type 1016 -#define global_stmt_type 1017 -#define nonlocal_stmt_type 1018 -#define del_kw_stmt_type 1019 -#define del_stmt_type 1020 -#define yield_stmt_type 1021 -#define assert_stmt_type 1022 -#define goto_stmt_type 1023 -#define label_stmt_type 1024 -#define import_stmt_type 1025 -#define import_name_type 1026 -#define import_from_type 1027 -#define import_from_targets_type 1028 -#define import_from_as_names_type 1029 -#define import_from_as_name_type 1030 -#define dotted_as_names_type 1031 -#define dotted_as_name_type 1032 -#define dotted_name_type 1033 // Left-recursive -#define block_type 1034 -#define decorators_type 1035 -#define class_def_type 1036 -#define class_def_raw_type 1037 -#define function_def_type 1038 -#define function_def_raw_type 1039 -#define params_type 1040 -#define parameters_type 1041 -#define slash_no_default_type 1042 -#define slash_with_default_type 1043 -#define star_etc_type 1044 -#define kwds_type 1045 -#define param_no_default_type 1046 -#define param_no_default_star_annotation_type 1047 -#define param_with_default_type 1048 -#define param_maybe_default_type 1049 -#define param_type 1050 -#define param_star_annotation_type 1051 -#define annotation_type 1052 -#define star_annotation_type 1053 -#define default_type 1054 -#define if_stmt_type 1055 -#define elif_stmt_type 1056 -#define else_block_type 1057 -#define while_stmt_type 1058 -#define for_stmt_type 1059 -#define with_stmt_type 1060 -#define with_item_type 1061 -#define try_stmt_type 1062 -#define except_block_type 1063 -#define except_star_block_type 1064 -#define finally_block_type 1065 -#define switch_stmt_type 1066 -#define switchcase_block_type 1067 -#define bitwiseor_pattern_type 1068 // Left-recursive -#define bitwisexor_pattern_type 1069 // Left-recursive -#define bitwiseand_pattern_type 1070 // Left-recursive -#define shift_pattern_type 1071 // Left-recursive -#define sum_pattern_type 1072 // Left-recursive -#define term_pattern_type 1073 // Left-recursive -#define factor_pattern_type 1074 -#define power_pattern_type 1075 -#define number_pattern_type 1076 -#define match_stmt_type 1077 -#define subject_expr_type 1078 -#define case_block_type 1079 -#define guard_type 1080 -#define patterns_type 1081 -#define pattern_type 1082 -#define as_pattern_type 1083 -#define or_pattern_type 1084 -#define closed_pattern_type 1085 -#define literal_pattern_type 1086 -#define literal_expr_type 1087 -#define complex_number_type 1088 -#define signed_number_type 1089 -#define signed_real_number_type 1090 -#define real_number_type 1091 -#define imaginary_number_type 1092 -#define capture_pattern_type 1093 -#define pattern_capture_target_type 1094 -#define wildcard_pattern_type 1095 -#define value_pattern_type 1096 -#define attr_type 1097 // Left-recursive -#define name_or_attr_type 1098 // Left-recursive -#define group_pattern_type 1099 -#define sequence_pattern_type 1100 -#define open_sequence_pattern_type 1101 -#define maybe_sequence_pattern_type 1102 -#define maybe_star_pattern_type 1103 -#define star_pattern_type 1104 -#define mapping_pattern_type 1105 -#define items_pattern_type 1106 -#define key_value_pattern_type 1107 -#define double_star_pattern_type 1108 -#define class_pattern_type 1109 -#define positional_patterns_type 1110 -#define keyword_patterns_type 1111 -#define keyword_pattern_type 1112 -#define unless_stmt_type 1113 -#define type_alias_type 1114 -#define type_params_type 1115 -#define type_param_seq_type 1116 -#define type_param_type 1117 -#define type_param_bound_type 1118 -#define expressions_type 1119 -#define expression_type 1120 -#define yield_expr_type 1121 -#define star_expressions_type 1122 -#define star_expression_type 1123 -#define star_named_expressions_type 1124 -#define star_named_expression_type 1125 -#define star_assignment_expression_type 1126 -#define assignment_expression_type 1127 -#define named_expression_type 1128 -#define disjunction_type 1129 -#define conjunction_type 1130 -#define inversion_type 1131 -#define comparison_type 1132 -#define compare_op_composition_pair_type 1133 -#define eq_composition_type 1134 -#define noteq_composition_type 1135 -#define lte_composition_type 1136 -#define lt_composition_type 1137 -#define gte_composition_type 1138 -#define gt_composition_type 1139 -#define notin_composition_type 1140 -#define in_composition_type 1141 -#define isnotin_composition_type 1142 -#define isin_composition_type 1143 -#define isnot_composition_type 1144 -#define is_composition_type 1145 -#define composition_type 1146 // Left-recursive -#define bitwise_or_type 1147 // Left-recursive -#define bitwise_xor_type 1148 // Left-recursive -#define bitwise_and_type 1149 // Left-recursive -#define shift_expr_type 1150 // Left-recursive -#define sum_type 1151 // Left-recursive -#define term_type 1152 // Left-recursive -#define factor_type 1153 -#define coalesce_type 1154 -#define power_type 1155 -#define await_primary_type 1156 -#define primary_type 1157 // Left-recursive -#define slices_type 1158 -#define slice_type 1159 -#define simple_slice_type 1160 -#define atom_type 1161 -#define group_type 1162 -#define lambdef_type 1163 -#define lambda_params_type 1164 -#define lambda_parameters_type 1165 -#define lambda_slash_no_default_type 1166 -#define lambda_slash_with_default_type 1167 -#define lambda_star_etc_type 1168 -#define lambda_kwds_type 1169 -#define lambda_param_no_default_type 1170 -#define lambda_param_with_default_type 1171 -#define lambda_param_maybe_default_type 1172 -#define lambda_param_type 1173 -#define fstring_middle_type 1174 -#define fstring_replacement_field_type 1175 -#define fstring_conversion_type 1176 -#define fstring_full_format_spec_type 1177 -#define fstring_format_spec_type 1178 -#define string_type 1179 -#define strings_type 1180 -#define list_type 1181 -#define tuple_type 1182 -#define set_type 1183 -#define dict_type 1184 -#define double_starred_kvpairs_type 1185 -#define double_starred_kvpair_type 1186 -#define kvpair_type 1187 -#define for_if_clauses_type 1188 -#define for_if_clause_type 1189 -#define listcomp_type 1190 -#define tuplecomp_type 1191 -#define setcomp_type 1192 -#define genexp_type 1193 -#define dictcomp_type 1194 -#define arguments_type 1195 -#define args_type 1196 -#define kwargs_type 1197 -#define starred_expression_type 1198 -#define kwarg_or_starred_type 1199 -#define kwarg_or_double_starred_type 1200 -#define star_targets_type 1201 -#define star_targets_list_seq_type 1202 -#define star_targets_tuple_seq_type 1203 -#define star_target_type 1204 -#define target_with_star_atom_type 1205 -#define star_atom_type 1206 -#define single_target_type 1207 -#define single_subscript_attribute_target_type 1208 -#define t_primary_type 1209 // Left-recursive -#define t_lookahead_type 1210 -#define t_lookmain_type 1211 -#define del_targets_type 1212 -#define del_target_type 1213 -#define del_t_atom_type 1214 -#define type_expressions_type 1215 -#define func_type_comment_type 1216 -#define invalid_arguments_type 1217 -#define invalid_kwarg_type 1218 -#define expression_without_invalid_type 1219 -#define invalid_legacy_expression_type 1220 -#define invalid_expression_type 1221 -#define invalid_named_expression_type 1222 -#define invalid_assignment_type 1223 -#define invalid_ann_assign_target_type 1224 -#define invalid_del_stmt_type 1225 -#define invalid_block_type 1226 -#define invalid_comprehension_type 1227 -#define invalid_dict_comprehension_type 1228 -#define invalid_parameters_type 1229 -#define invalid_default_type 1230 -#define invalid_star_etc_type 1231 -#define invalid_kwds_type 1232 -#define invalid_parameters_helper_type 1233 -#define invalid_lambda_parameters_type 1234 -#define invalid_lambda_parameters_helper_type 1235 -#define invalid_lambda_star_etc_type 1236 -#define invalid_lambda_kwds_type 1237 -#define invalid_double_type_comments_type 1238 -#define invalid_with_item_type 1239 -#define invalid_for_target_type 1240 -#define invalid_group_type 1241 -#define invalid_import_type 1242 -#define invalid_import_from_targets_type 1243 -#define invalid_with_stmt_type 1244 -#define invalid_with_stmt_indent_type 1245 -#define invalid_try_stmt_type 1246 -#define invalid_except_stmt_type 1247 -#define invalid_finally_stmt_type 1248 -#define invalid_except_stmt_indent_type 1249 -#define invalid_except_star_stmt_indent_type 1250 -#define invalid_match_stmt_type 1251 -#define invalid_case_block_type 1252 -#define invalid_as_pattern_type 1253 -#define invalid_class_pattern_type 1254 -#define invalid_class_argument_pattern_type 1255 -#define invalid_if_stmt_type 1256 -#define invalid_elif_stmt_type 1257 -#define invalid_else_stmt_type 1258 -#define invalid_while_stmt_type 1259 -#define invalid_for_stmt_type 1260 -#define invalid_def_raw_type 1261 -#define invalid_class_def_raw_type 1262 -#define invalid_double_starred_kvpairs_type 1263 -#define invalid_kvpair_type 1264 -#define invalid_starred_expression_type 1265 -#define invalid_replacement_field_type 1266 -#define invalid_conversion_character_type 1267 -#define _loop0_1_type 1268 -#define _loop0_2_type 1269 -#define _loop0_3_type 1270 -#define _loop1_4_type 1271 -#define _loop0_6_type 1272 -#define _gather_5_type 1273 -#define _tmp_7_type 1274 -#define _tmp_8_type 1275 -#define _tmp_9_type 1276 -#define _tmp_10_type 1277 -#define _tmp_11_type 1278 -#define _tmp_12_type 1279 -#define _tmp_13_type 1280 -#define _tmp_14_type 1281 -#define _tmp_15_type 1282 -#define _tmp_16_type 1283 -#define _loop1_17_type 1284 -#define _tmp_18_type 1285 -#define _tmp_19_type 1286 -#define _tmp_20_type 1287 -#define _tmp_21_type 1288 -#define _tmp_22_type 1289 -#define _tmp_23_type 1290 -#define _tmp_24_type 1291 -#define _tmp_25_type 1292 -#define _tmp_26_type 1293 -#define _loop0_28_type 1294 -#define _gather_27_type 1295 -#define _loop0_30_type 1296 -#define _gather_29_type 1297 -#define _tmp_31_type 1298 -#define _tmp_32_type 1299 -#define _tmp_33_type 1300 -#define _loop0_35_type 1301 -#define _gather_34_type 1302 -#define _loop0_36_type 1303 -#define _loop1_37_type 1304 -#define _loop0_39_type 1305 -#define _gather_38_type 1306 -#define _tmp_40_type 1307 -#define _loop0_42_type 1308 -#define _gather_41_type 1309 -#define _tmp_43_type 1310 -#define _loop1_44_type 1311 -#define _tmp_45_type 1312 -#define _tmp_46_type 1313 -#define _tmp_47_type 1314 -#define _loop0_48_type 1315 -#define _loop0_49_type 1316 -#define _loop0_50_type 1317 -#define _loop1_51_type 1318 -#define _loop0_52_type 1319 -#define _loop1_53_type 1320 -#define _loop1_54_type 1321 -#define _loop1_55_type 1322 -#define _loop0_56_type 1323 -#define _loop1_57_type 1324 -#define _loop0_58_type 1325 -#define _loop1_59_type 1326 -#define _loop0_60_type 1327 -#define _loop0_61_type 1328 -#define _loop1_62_type 1329 -#define _loop0_64_type 1330 -#define _gather_63_type 1331 -#define _loop0_66_type 1332 -#define _gather_65_type 1333 -#define _loop0_68_type 1334 -#define _gather_67_type 1335 -#define _loop0_70_type 1336 -#define _gather_69_type 1337 -#define _tmp_71_type 1338 -#define _loop1_72_type 1339 -#define _loop1_73_type 1340 -#define _tmp_74_type 1341 -#define _tmp_75_type 1342 -#define _loop1_76_type 1343 -#define _loop1_77_type 1344 -#define _loop0_79_type 1345 -#define _gather_78_type 1346 -#define _loop1_80_type 1347 -#define _loop1_81_type 1348 -#define _loop0_83_type 1349 -#define _gather_82_type 1350 -#define _tmp_84_type 1351 -#define _tmp_85_type 1352 -#define _tmp_86_type 1353 -#define _tmp_87_type 1354 -#define _loop0_89_type 1355 -#define _gather_88_type 1356 -#define _loop0_91_type 1357 -#define _gather_90_type 1358 -#define _tmp_92_type 1359 -#define _loop0_94_type 1360 -#define _gather_93_type 1361 -#define _loop0_96_type 1362 -#define _gather_95_type 1363 -#define _tmp_97_type 1364 -#define _loop0_99_type 1365 -#define _gather_98_type 1366 -#define _loop1_100_type 1367 -#define _loop1_101_type 1368 -#define _loop0_103_type 1369 -#define _gather_102_type 1370 -#define _loop1_104_type 1371 -#define _loop1_105_type 1372 -#define _loop1_106_type 1373 -#define _tmp_107_type 1374 -#define _tmp_108_type 1375 -#define _tmp_109_type 1376 -#define _tmp_110_type 1377 -#define _loop0_112_type 1378 -#define _gather_111_type 1379 -#define _tmp_113_type 1380 -#define _tmp_114_type 1381 -#define _tmp_115_type 1382 -#define _tmp_116_type 1383 -#define _tmp_117_type 1384 -#define _tmp_118_type 1385 -#define _loop0_119_type 1386 -#define _loop0_120_type 1387 -#define _loop0_121_type 1388 -#define _loop1_122_type 1389 -#define _loop0_123_type 1390 -#define _loop1_124_type 1391 -#define _loop1_125_type 1392 -#define _loop1_126_type 1393 -#define _loop0_127_type 1394 -#define _loop1_128_type 1395 -#define _loop0_129_type 1396 -#define _loop1_130_type 1397 -#define _loop0_131_type 1398 -#define _loop1_132_type 1399 -#define _tmp_133_type 1400 -#define _loop0_134_type 1401 -#define _loop1_135_type 1402 -#define _tmp_136_type 1403 -#define _loop0_138_type 1404 -#define _gather_137_type 1405 -#define _loop1_139_type 1406 -#define _loop0_140_type 1407 -#define _loop0_141_type 1408 -#define _loop0_142_type 1409 -#define _tmp_143_type 1410 -#define _tmp_144_type 1411 -#define _loop0_146_type 1412 -#define _gather_145_type 1413 -#define _tmp_147_type 1414 -#define _loop0_149_type 1415 -#define _gather_148_type 1416 -#define _loop0_151_type 1417 -#define _gather_150_type 1418 -#define _loop0_153_type 1419 -#define _gather_152_type 1420 -#define _loop0_155_type 1421 -#define _gather_154_type 1422 -#define _tmp_156_type 1423 -#define _tmp_157_type 1424 -#define _loop0_158_type 1425 -#define _loop0_160_type 1426 -#define _gather_159_type 1427 -#define _loop1_161_type 1428 -#define _tmp_162_type 1429 -#define _tmp_163_type 1430 -#define _loop0_165_type 1431 -#define _gather_164_type 1432 -#define _loop0_167_type 1433 -#define _gather_166_type 1434 -#define _loop0_169_type 1435 -#define _gather_168_type 1436 -#define _loop0_171_type 1437 -#define _gather_170_type 1438 -#define _loop0_173_type 1439 -#define _gather_172_type 1440 -#define _tmp_174_type 1441 -#define _tmp_175_type 1442 -#define _tmp_176_type 1443 -#define _tmp_177_type 1444 -#define _tmp_178_type 1445 -#define _tmp_179_type 1446 -#define _tmp_180_type 1447 -#define _tmp_181_type 1448 -#define _tmp_182_type 1449 -#define _tmp_183_type 1450 -#define _tmp_184_type 1451 -#define _tmp_185_type 1452 -#define _loop0_186_type 1453 -#define _loop0_187_type 1454 -#define _loop0_188_type 1455 -#define _tmp_189_type 1456 -#define _tmp_190_type 1457 -#define _tmp_191_type 1458 -#define _tmp_192_type 1459 -#define _tmp_193_type 1460 -#define _loop0_194_type 1461 -#define _loop0_195_type 1462 -#define _loop0_196_type 1463 -#define _loop1_197_type 1464 -#define _tmp_198_type 1465 -#define _loop0_199_type 1466 -#define _tmp_200_type 1467 -#define _loop0_201_type 1468 -#define _loop1_202_type 1469 -#define _tmp_203_type 1470 -#define _tmp_204_type 1471 -#define _tmp_205_type 1472 -#define _loop0_206_type 1473 -#define _tmp_207_type 1474 -#define _tmp_208_type 1475 -#define _loop1_209_type 1476 -#define _tmp_210_type 1477 -#define _loop0_211_type 1478 -#define _loop0_212_type 1479 -#define _loop0_213_type 1480 -#define _loop0_215_type 1481 -#define _gather_214_type 1482 -#define _tmp_216_type 1483 -#define _loop0_217_type 1484 -#define _tmp_218_type 1485 -#define _loop0_219_type 1486 -#define _loop1_220_type 1487 -#define _loop1_221_type 1488 -#define _tmp_222_type 1489 -#define _tmp_223_type 1490 -#define _loop0_224_type 1491 -#define _tmp_225_type 1492 -#define _tmp_226_type 1493 -#define _tmp_227_type 1494 -#define _loop0_229_type 1495 -#define _gather_228_type 1496 -#define _loop0_231_type 1497 -#define _gather_230_type 1498 -#define _loop0_233_type 1499 -#define _gather_232_type 1500 -#define _loop0_235_type 1501 -#define _gather_234_type 1502 -#define _loop0_237_type 1503 -#define _gather_236_type 1504 -#define _tmp_238_type 1505 -#define _loop0_239_type 1506 -#define _loop1_240_type 1507 -#define _tmp_241_type 1508 -#define _loop0_242_type 1509 -#define _loop1_243_type 1510 -#define _tmp_244_type 1511 -#define _tmp_245_type 1512 -#define _tmp_246_type 1513 -#define _tmp_247_type 1514 -#define _tmp_248_type 1515 -#define _tmp_249_type 1516 -#define _tmp_250_type 1517 -#define _tmp_251_type 1518 -#define _tmp_252_type 1519 -#define _tmp_253_type 1520 -#define _loop0_255_type 1521 -#define _gather_254_type 1522 -#define _tmp_256_type 1523 -#define _tmp_257_type 1524 -#define _tmp_258_type 1525 -#define _tmp_259_type 1526 -#define _tmp_260_type 1527 -#define _tmp_261_type 1528 -#define _tmp_262_type 1529 -#define _tmp_263_type 1530 -#define _tmp_264_type 1531 -#define _tmp_265_type 1532 -#define _tmp_266_type 1533 -#define _tmp_267_type 1534 -#define _tmp_268_type 1535 -#define _loop0_269_type 1536 -#define _tmp_270_type 1537 -#define _tmp_271_type 1538 -#define _tmp_272_type 1539 -#define _tmp_273_type 1540 -#define _tmp_274_type 1541 -#define _tmp_275_type 1542 -#define _tmp_276_type 1543 -#define _tmp_277_type 1544 -#define _tmp_278_type 1545 -#define _loop0_280_type 1546 -#define _gather_279_type 1547 -#define _tmp_281_type 1548 -#define _tmp_282_type 1549 -#define _tmp_283_type 1550 -#define _tmp_284_type 1551 -#define _tmp_285_type 1552 -#define _tmp_286_type 1553 -#define _tmp_287_type 1554 -#define _tmp_288_type 1555 -#define _tmp_289_type 1556 -#define _tmp_290_type 1557 -#define _tmp_291_type 1558 -#define _tmp_292_type 1559 -#define _tmp_293_type 1560 -#define _tmp_294_type 1561 -#define _tmp_295_type 1562 -#define _tmp_296_type 1563 -#define _tmp_297_type 1564 -#define _tmp_298_type 1565 -#define _tmp_299_type 1566 -#define _tmp_300_type 1567 -#define _tmp_301_type 1568 -#define _tmp_302_type 1569 -#define _tmp_303_type 1570 -#define _tmp_304_type 1571 -#define _tmp_305_type 1572 -#define _tmp_306_type 1573 +#define simple_stmts_nonewline_type 1009 +#define simple_stmt_type 1010 +#define compound_stmt_type 1011 +#define assignment_type 1012 +#define annotated_rhs_type 1013 +#define augassign_type 1014 +#define unarassign_type 1015 +#define return_stmt_type 1016 +#define raise_stmt_type 1017 +#define global_stmt_type 1018 +#define nonlocal_stmt_type 1019 +#define del_kw_stmt_type 1020 +#define del_stmt_type 1021 +#define yield_stmt_type 1022 +#define assert_stmt_type 1023 +#define goto_stmt_type 1024 +#define label_stmt_type 1025 +#define import_stmt_type 1026 +#define import_name_type 1027 +#define import_from_type 1028 +#define import_from_targets_type 1029 +#define import_from_as_names_type 1030 +#define import_from_as_name_type 1031 +#define dotted_as_names_type 1032 +#define dotted_as_name_type 1033 +#define dotted_name_type 1034 // Left-recursive +#define block_type 1035 +#define block_nonewline_type 1036 +#define decorators_type 1037 +#define class_def_type 1038 +#define class_def_raw_type 1039 +#define class_def_nonewline_type 1040 +#define class_def_raw_nonewline_type 1041 +#define function_def_type 1042 +#define function_def_raw_type 1043 +#define function_def_nonewline_type 1044 +#define function_def_raw_nonewline_type 1045 +#define params_type 1046 +#define parameters_type 1047 +#define slash_no_default_type 1048 +#define slash_with_default_type 1049 +#define star_etc_type 1050 +#define kwds_type 1051 +#define param_no_default_type 1052 +#define param_no_default_star_annotation_type 1053 +#define param_with_default_type 1054 +#define param_maybe_default_type 1055 +#define param_type 1056 +#define param_star_annotation_type 1057 +#define annotation_type 1058 +#define star_annotation_type 1059 +#define default_type 1060 +#define if_stmt_type 1061 +#define elif_stmt_type 1062 +#define else_block_type 1063 +#define while_stmt_type 1064 +#define for_stmt_type 1065 +#define with_stmt_type 1066 +#define with_item_type 1067 +#define try_stmt_type 1068 +#define except_block_type 1069 +#define except_star_block_type 1070 +#define finally_block_type 1071 +#define switch_stmt_type 1072 +#define switchcase_block_type 1073 +#define bitwiseor_pattern_type 1074 // Left-recursive +#define bitwisexor_pattern_type 1075 // Left-recursive +#define bitwiseand_pattern_type 1076 // Left-recursive +#define shift_pattern_type 1077 // Left-recursive +#define sum_pattern_type 1078 // Left-recursive +#define term_pattern_type 1079 // Left-recursive +#define factor_pattern_type 1080 +#define power_pattern_type 1081 +#define number_pattern_type 1082 +#define match_stmt_type 1083 +#define subject_expr_type 1084 +#define case_block_type 1085 +#define guard_type 1086 +#define patterns_type 1087 +#define pattern_type 1088 +#define as_pattern_type 1089 +#define or_pattern_type 1090 +#define closed_pattern_type 1091 +#define literal_pattern_type 1092 +#define literal_expr_type 1093 +#define complex_number_type 1094 +#define signed_number_type 1095 +#define signed_real_number_type 1096 +#define real_number_type 1097 +#define imaginary_number_type 1098 +#define capture_pattern_type 1099 +#define pattern_capture_target_type 1100 +#define wildcard_pattern_type 1101 +#define value_pattern_type 1102 +#define attr_type 1103 // Left-recursive +#define name_or_attr_type 1104 // Left-recursive +#define group_pattern_type 1105 +#define sequence_pattern_type 1106 +#define open_sequence_pattern_type 1107 +#define maybe_sequence_pattern_type 1108 +#define maybe_star_pattern_type 1109 +#define star_pattern_type 1110 +#define mapping_pattern_type 1111 +#define items_pattern_type 1112 +#define key_value_pattern_type 1113 +#define double_star_pattern_type 1114 +#define class_pattern_type 1115 +#define positional_patterns_type 1116 +#define keyword_patterns_type 1117 +#define keyword_pattern_type 1118 +#define unless_stmt_type 1119 +#define type_alias_type 1120 +#define type_params_type 1121 +#define type_param_seq_type 1122 +#define type_param_type 1123 +#define type_param_bound_type 1124 +#define expressions_type 1125 +#define expression_type 1126 +#define yield_expr_type 1127 +#define star_expressions_type 1128 +#define star_expression_type 1129 +#define star_named_expressions_type 1130 +#define star_named_expression_type 1131 +#define star_assignment_expression_type 1132 +#define assignment_expression_type 1133 +#define named_expression_type 1134 +#define disjunction_type 1135 +#define conjunction_type 1136 +#define inversion_type 1137 +#define comparison_type 1138 +#define compare_op_composition_pair_type 1139 +#define eq_composition_type 1140 +#define noteq_composition_type 1141 +#define lte_composition_type 1142 +#define lt_composition_type 1143 +#define gte_composition_type 1144 +#define gt_composition_type 1145 +#define notin_composition_type 1146 +#define in_composition_type 1147 +#define isnotin_composition_type 1148 +#define isin_composition_type 1149 +#define isnot_composition_type 1150 +#define is_composition_type 1151 +#define composition_type 1152 // Left-recursive +#define bitwise_or_type 1153 // Left-recursive +#define bitwise_xor_type 1154 // Left-recursive +#define bitwise_and_type 1155 // Left-recursive +#define shift_expr_type 1156 // Left-recursive +#define sum_type 1157 // Left-recursive +#define term_type 1158 // Left-recursive +#define factor_type 1159 +#define coalesce_type 1160 +#define power_type 1161 +#define await_primary_type 1162 +#define primary_type 1163 // Left-recursive +#define slices_type 1164 +#define slice_type 1165 +#define simple_slice_type 1166 +#define atom_type 1167 +#define group_type 1168 +#define class_or_func_expr_type 1169 +#define lambdef_type 1170 +#define lambda_params_type 1171 +#define lambda_parameters_type 1172 +#define lambda_slash_no_default_type 1173 +#define lambda_slash_with_default_type 1174 +#define lambda_star_etc_type 1175 +#define lambda_kwds_type 1176 +#define lambda_param_no_default_type 1177 +#define lambda_param_with_default_type 1178 +#define lambda_param_maybe_default_type 1179 +#define lambda_param_type 1180 +#define fstring_middle_type 1181 +#define fstring_replacement_field_type 1182 +#define fstring_conversion_type 1183 +#define fstring_full_format_spec_type 1184 +#define fstring_format_spec_type 1185 +#define string_type 1186 +#define strings_type 1187 +#define list_type 1188 +#define tuple_type 1189 +#define set_type 1190 +#define dict_type 1191 +#define double_starred_kvpairs_type 1192 +#define double_starred_kvpair_type 1193 +#define kvpair_type 1194 +#define for_if_clauses_type 1195 +#define for_if_clause_type 1196 +#define listcomp_type 1197 +#define tuplecomp_type 1198 +#define setcomp_type 1199 +#define genexp_type 1200 +#define dictcomp_type 1201 +#define arguments_type 1202 +#define args_type 1203 +#define kwargs_type 1204 +#define starred_expression_type 1205 +#define kwarg_or_starred_type 1206 +#define kwarg_or_double_starred_type 1207 +#define star_targets_type 1208 +#define star_targets_list_seq_type 1209 +#define star_targets_tuple_seq_type 1210 +#define star_target_type 1211 +#define target_with_star_atom_type 1212 +#define star_atom_type 1213 +#define single_target_type 1214 +#define single_subscript_attribute_target_type 1215 +#define t_primary_type 1216 // Left-recursive +#define t_lookahead_type 1217 +#define t_lookmain_type 1218 +#define del_targets_type 1219 +#define del_target_type 1220 +#define del_t_atom_type 1221 +#define type_expressions_type 1222 +#define func_type_comment_type 1223 +#define invalid_arguments_type 1224 +#define invalid_kwarg_type 1225 +#define expression_without_invalid_type 1226 +#define invalid_legacy_expression_type 1227 +#define invalid_expression_type 1228 +#define invalid_named_expression_type 1229 +#define invalid_assignment_type 1230 +#define invalid_ann_assign_target_type 1231 +#define invalid_del_stmt_type 1232 +#define invalid_block_type 1233 +#define invalid_comprehension_type 1234 +#define invalid_dict_comprehension_type 1235 +#define invalid_parameters_type 1236 +#define invalid_default_type 1237 +#define invalid_star_etc_type 1238 +#define invalid_kwds_type 1239 +#define invalid_parameters_helper_type 1240 +#define invalid_lambda_parameters_type 1241 +#define invalid_lambda_parameters_helper_type 1242 +#define invalid_lambda_star_etc_type 1243 +#define invalid_lambda_kwds_type 1244 +#define invalid_double_type_comments_type 1245 +#define invalid_with_item_type 1246 +#define invalid_for_target_type 1247 +#define invalid_group_type 1248 +#define invalid_import_type 1249 +#define invalid_import_from_targets_type 1250 +#define invalid_with_stmt_type 1251 +#define invalid_with_stmt_indent_type 1252 +#define invalid_try_stmt_type 1253 +#define invalid_except_stmt_type 1254 +#define invalid_finally_stmt_type 1255 +#define invalid_except_stmt_indent_type 1256 +#define invalid_except_star_stmt_indent_type 1257 +#define invalid_match_stmt_type 1258 +#define invalid_case_block_type 1259 +#define invalid_as_pattern_type 1260 +#define invalid_class_pattern_type 1261 +#define invalid_class_argument_pattern_type 1262 +#define invalid_if_stmt_type 1263 +#define invalid_elif_stmt_type 1264 +#define invalid_else_stmt_type 1265 +#define invalid_while_stmt_type 1266 +#define invalid_for_stmt_type 1267 +#define invalid_def_raw_type 1268 +#define invalid_class_def_raw_nonewline_type 1269 +#define invalid_class_def_raw_type 1270 +#define invalid_double_starred_kvpairs_type 1271 +#define invalid_kvpair_type 1272 +#define invalid_starred_expression_type 1273 +#define invalid_replacement_field_type 1274 +#define invalid_conversion_character_type 1275 +#define _loop0_1_type 1276 +#define _loop0_2_type 1277 +#define _loop0_3_type 1278 +#define _loop1_4_type 1279 +#define _loop0_6_type 1280 +#define _gather_5_type 1281 +#define _loop0_8_type 1282 +#define _gather_7_type 1283 +#define _tmp_9_type 1284 +#define _tmp_10_type 1285 +#define _tmp_11_type 1286 +#define _tmp_12_type 1287 +#define _tmp_13_type 1288 +#define _tmp_14_type 1289 +#define _tmp_15_type 1290 +#define _tmp_16_type 1291 +#define _tmp_17_type 1292 +#define _tmp_18_type 1293 +#define _loop1_19_type 1294 +#define _tmp_20_type 1295 +#define _tmp_21_type 1296 +#define _tmp_22_type 1297 +#define _tmp_23_type 1298 +#define _tmp_24_type 1299 +#define _tmp_25_type 1300 +#define _tmp_26_type 1301 +#define _tmp_27_type 1302 +#define _tmp_28_type 1303 +#define _loop0_30_type 1304 +#define _gather_29_type 1305 +#define _loop0_32_type 1306 +#define _gather_31_type 1307 +#define _tmp_33_type 1308 +#define _tmp_34_type 1309 +#define _tmp_35_type 1310 +#define _loop0_37_type 1311 +#define _gather_36_type 1312 +#define _loop0_38_type 1313 +#define _loop1_39_type 1314 +#define _loop0_41_type 1315 +#define _gather_40_type 1316 +#define _tmp_42_type 1317 +#define _loop0_44_type 1318 +#define _gather_43_type 1319 +#define _tmp_45_type 1320 +#define _loop1_46_type 1321 +#define _tmp_47_type 1322 +#define _tmp_48_type 1323 +#define _tmp_49_type 1324 +#define _tmp_50_type 1325 +#define _tmp_51_type 1326 +#define _tmp_52_type 1327 +#define _loop0_53_type 1328 +#define _loop0_54_type 1329 +#define _loop0_55_type 1330 +#define _loop1_56_type 1331 +#define _loop0_57_type 1332 +#define _loop1_58_type 1333 +#define _loop1_59_type 1334 +#define _loop1_60_type 1335 +#define _loop0_61_type 1336 +#define _loop1_62_type 1337 +#define _loop0_63_type 1338 +#define _loop1_64_type 1339 +#define _loop0_65_type 1340 +#define _loop0_66_type 1341 +#define _loop1_67_type 1342 +#define _loop0_69_type 1343 +#define _gather_68_type 1344 +#define _loop0_71_type 1345 +#define _gather_70_type 1346 +#define _loop0_73_type 1347 +#define _gather_72_type 1348 +#define _loop0_75_type 1349 +#define _gather_74_type 1350 +#define _tmp_76_type 1351 +#define _loop1_77_type 1352 +#define _loop1_78_type 1353 +#define _tmp_79_type 1354 +#define _tmp_80_type 1355 +#define _loop1_81_type 1356 +#define _loop1_82_type 1357 +#define _loop0_84_type 1358 +#define _gather_83_type 1359 +#define _loop1_85_type 1360 +#define _loop1_86_type 1361 +#define _loop0_88_type 1362 +#define _gather_87_type 1363 +#define _tmp_89_type 1364 +#define _tmp_90_type 1365 +#define _tmp_91_type 1366 +#define _tmp_92_type 1367 +#define _loop0_94_type 1368 +#define _gather_93_type 1369 +#define _loop0_96_type 1370 +#define _gather_95_type 1371 +#define _tmp_97_type 1372 +#define _loop0_99_type 1373 +#define _gather_98_type 1374 +#define _loop0_101_type 1375 +#define _gather_100_type 1376 +#define _tmp_102_type 1377 +#define _loop0_104_type 1378 +#define _gather_103_type 1379 +#define _loop1_105_type 1380 +#define _loop1_106_type 1381 +#define _loop0_108_type 1382 +#define _gather_107_type 1383 +#define _loop1_109_type 1384 +#define _loop1_110_type 1385 +#define _loop1_111_type 1386 +#define _tmp_112_type 1387 +#define _tmp_113_type 1388 +#define _tmp_114_type 1389 +#define _tmp_115_type 1390 +#define _loop0_117_type 1391 +#define _gather_116_type 1392 +#define _tmp_118_type 1393 +#define _tmp_119_type 1394 +#define _tmp_120_type 1395 +#define _tmp_121_type 1396 +#define _tmp_122_type 1397 +#define _tmp_123_type 1398 +#define _tmp_124_type 1399 +#define _loop0_125_type 1400 +#define _loop0_126_type 1401 +#define _loop0_127_type 1402 +#define _loop1_128_type 1403 +#define _loop0_129_type 1404 +#define _loop1_130_type 1405 +#define _loop1_131_type 1406 +#define _loop1_132_type 1407 +#define _loop0_133_type 1408 +#define _loop1_134_type 1409 +#define _loop0_135_type 1410 +#define _loop1_136_type 1411 +#define _loop0_137_type 1412 +#define _loop1_138_type 1413 +#define _tmp_139_type 1414 +#define _loop0_140_type 1415 +#define _loop1_141_type 1416 +#define _tmp_142_type 1417 +#define _loop0_144_type 1418 +#define _gather_143_type 1419 +#define _loop1_145_type 1420 +#define _loop0_146_type 1421 +#define _loop0_147_type 1422 +#define _loop0_148_type 1423 +#define _tmp_149_type 1424 +#define _tmp_150_type 1425 +#define _loop0_152_type 1426 +#define _gather_151_type 1427 +#define _tmp_153_type 1428 +#define _loop0_155_type 1429 +#define _gather_154_type 1430 +#define _loop0_157_type 1431 +#define _gather_156_type 1432 +#define _loop0_159_type 1433 +#define _gather_158_type 1434 +#define _loop0_161_type 1435 +#define _gather_160_type 1436 +#define _tmp_162_type 1437 +#define _tmp_163_type 1438 +#define _loop0_164_type 1439 +#define _loop0_166_type 1440 +#define _gather_165_type 1441 +#define _loop1_167_type 1442 +#define _tmp_168_type 1443 +#define _tmp_169_type 1444 +#define _loop0_171_type 1445 +#define _gather_170_type 1446 +#define _loop0_173_type 1447 +#define _gather_172_type 1448 +#define _loop0_175_type 1449 +#define _gather_174_type 1450 +#define _loop0_177_type 1451 +#define _gather_176_type 1452 +#define _loop0_179_type 1453 +#define _gather_178_type 1454 +#define _tmp_180_type 1455 +#define _tmp_181_type 1456 +#define _tmp_182_type 1457 +#define _tmp_183_type 1458 +#define _tmp_184_type 1459 +#define _tmp_185_type 1460 +#define _tmp_186_type 1461 +#define _tmp_187_type 1462 +#define _tmp_188_type 1463 +#define _tmp_189_type 1464 +#define _tmp_190_type 1465 +#define _tmp_191_type 1466 +#define _loop0_192_type 1467 +#define _loop0_193_type 1468 +#define _loop0_194_type 1469 +#define _tmp_195_type 1470 +#define _tmp_196_type 1471 +#define _tmp_197_type 1472 +#define _tmp_198_type 1473 +#define _tmp_199_type 1474 +#define _loop0_200_type 1475 +#define _loop0_201_type 1476 +#define _loop0_202_type 1477 +#define _loop1_203_type 1478 +#define _tmp_204_type 1479 +#define _loop0_205_type 1480 +#define _tmp_206_type 1481 +#define _loop0_207_type 1482 +#define _loop1_208_type 1483 +#define _tmp_209_type 1484 +#define _tmp_210_type 1485 +#define _tmp_211_type 1486 +#define _loop0_212_type 1487 +#define _tmp_213_type 1488 +#define _tmp_214_type 1489 +#define _loop1_215_type 1490 +#define _tmp_216_type 1491 +#define _loop0_217_type 1492 +#define _loop0_218_type 1493 +#define _loop0_219_type 1494 +#define _loop0_221_type 1495 +#define _gather_220_type 1496 +#define _tmp_222_type 1497 +#define _loop0_223_type 1498 +#define _tmp_224_type 1499 +#define _loop0_225_type 1500 +#define _loop1_226_type 1501 +#define _loop1_227_type 1502 +#define _tmp_228_type 1503 +#define _tmp_229_type 1504 +#define _loop0_230_type 1505 +#define _tmp_231_type 1506 +#define _tmp_232_type 1507 +#define _tmp_233_type 1508 +#define _loop0_235_type 1509 +#define _gather_234_type 1510 +#define _loop0_237_type 1511 +#define _gather_236_type 1512 +#define _loop0_239_type 1513 +#define _gather_238_type 1514 +#define _loop0_241_type 1515 +#define _gather_240_type 1516 +#define _loop0_243_type 1517 +#define _gather_242_type 1518 +#define _tmp_244_type 1519 +#define _loop0_245_type 1520 +#define _loop1_246_type 1521 +#define _tmp_247_type 1522 +#define _loop0_248_type 1523 +#define _loop1_249_type 1524 +#define _tmp_250_type 1525 +#define _tmp_251_type 1526 +#define _tmp_252_type 1527 +#define _tmp_253_type 1528 +#define _tmp_254_type 1529 +#define _tmp_255_type 1530 +#define _tmp_256_type 1531 +#define _tmp_257_type 1532 +#define _tmp_258_type 1533 +#define _tmp_259_type 1534 +#define _loop0_261_type 1535 +#define _gather_260_type 1536 +#define _tmp_262_type 1537 +#define _tmp_263_type 1538 +#define _tmp_264_type 1539 +#define _tmp_265_type 1540 +#define _tmp_266_type 1541 +#define _tmp_267_type 1542 +#define _tmp_268_type 1543 +#define _tmp_269_type 1544 +#define _tmp_270_type 1545 +#define _tmp_271_type 1546 +#define _tmp_272_type 1547 +#define _tmp_273_type 1548 +#define _tmp_274_type 1549 +#define _loop0_275_type 1550 +#define _tmp_276_type 1551 +#define _tmp_277_type 1552 +#define _tmp_278_type 1553 +#define _tmp_279_type 1554 +#define _tmp_280_type 1555 +#define _tmp_281_type 1556 +#define _tmp_282_type 1557 +#define _tmp_283_type 1558 +#define _tmp_284_type 1559 +#define _loop0_286_type 1560 +#define _gather_285_type 1561 +#define _tmp_287_type 1562 +#define _tmp_288_type 1563 +#define _tmp_289_type 1564 +#define _tmp_290_type 1565 +#define _tmp_291_type 1566 +#define _tmp_292_type 1567 +#define _tmp_293_type 1568 +#define _tmp_294_type 1569 +#define _tmp_295_type 1570 +#define _tmp_296_type 1571 +#define _tmp_297_type 1572 +#define _tmp_298_type 1573 +#define _tmp_299_type 1574 +#define _tmp_300_type 1575 +#define _tmp_301_type 1576 +#define _tmp_302_type 1577 +#define _tmp_303_type 1578 +#define _tmp_304_type 1579 +#define _tmp_305_type 1580 +#define _tmp_306_type 1581 +#define _tmp_307_type 1582 +#define _tmp_308_type 1583 +#define _tmp_309_type 1584 +#define _tmp_310_type 1585 +#define _tmp_311_type 1586 +#define _tmp_312_type 1587 +#define _tmp_313_type 1588 +#define _tmp_314_type 1589 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -669,6 +685,7 @@ static asdl_stmt_seq* statements_rule(Parser *p); static asdl_stmt_seq* statement_rule(Parser *p); static asdl_stmt_seq* statement_newline_rule(Parser *p); static asdl_stmt_seq* simple_stmts_rule(Parser *p); +static asdl_stmt_seq* simple_stmts_nonewline_rule(Parser *p); static stmt_ty simple_stmt_rule(Parser *p); static stmt_ty compound_stmt_rule(Parser *p); static stmt_ty assignment_rule(Parser *p); @@ -695,11 +712,16 @@ static asdl_alias_seq* dotted_as_names_rule(Parser *p); static alias_ty dotted_as_name_rule(Parser *p); static expr_ty dotted_name_rule(Parser *p); static asdl_stmt_seq* block_rule(Parser *p); +static asdl_stmt_seq* block_nonewline_rule(Parser *p); static asdl_expr_seq* decorators_rule(Parser *p); static stmt_ty class_def_rule(Parser *p); static stmt_ty class_def_raw_rule(Parser *p); +static stmt_ty class_def_nonewline_rule(Parser *p); +static stmt_ty class_def_raw_nonewline_rule(Parser *p); static stmt_ty function_def_rule(Parser *p); static stmt_ty function_def_raw_rule(Parser *p); +static stmt_ty function_def_nonewline_rule(Parser *p); +static stmt_ty function_def_raw_nonewline_rule(Parser *p); static arguments_ty params_rule(Parser *p); static arguments_ty parameters_rule(Parser *p); static asdl_arg_seq* slash_no_default_rule(Parser *p); @@ -823,6 +845,7 @@ static expr_ty slice_rule(Parser *p); static expr_ty simple_slice_rule(Parser *p); static expr_ty atom_rule(Parser *p); static expr_ty group_rule(Parser *p); +static expr_ty class_or_func_expr_rule(Parser *p); static expr_ty lambdef_rule(Parser *p); static arguments_ty lambda_params_rule(Parser *p); static arguments_ty lambda_parameters_rule(Parser *p); @@ -922,6 +945,7 @@ static void *invalid_else_stmt_rule(Parser *p); static void *invalid_while_stmt_rule(Parser *p); static void *invalid_for_stmt_rule(Parser *p); static void *invalid_def_raw_rule(Parser *p); +static void *invalid_class_def_raw_nonewline_rule(Parser *p); static void *invalid_class_def_raw_rule(Parser *p); static void *invalid_double_starred_kvpairs_rule(Parser *p); static void *invalid_kvpair_rule(Parser *p); @@ -934,8 +958,8 @@ static asdl_seq *_loop0_3_rule(Parser *p); static asdl_seq *_loop1_4_rule(Parser *p); static asdl_seq *_loop0_6_rule(Parser *p); static asdl_seq *_gather_5_rule(Parser *p); -static void *_tmp_7_rule(Parser *p); -static void *_tmp_8_rule(Parser *p); +static asdl_seq *_loop0_8_rule(Parser *p); +static asdl_seq *_gather_7_rule(Parser *p); static void *_tmp_9_rule(Parser *p); static void *_tmp_10_rule(Parser *p); static void *_tmp_11_rule(Parser *p); @@ -944,9 +968,9 @@ static void *_tmp_13_rule(Parser *p); static void *_tmp_14_rule(Parser *p); static void *_tmp_15_rule(Parser *p); static void *_tmp_16_rule(Parser *p); -static asdl_seq *_loop1_17_rule(Parser *p); +static void *_tmp_17_rule(Parser *p); static void *_tmp_18_rule(Parser *p); -static void *_tmp_19_rule(Parser *p); +static asdl_seq *_loop1_19_rule(Parser *p); static void *_tmp_20_rule(Parser *p); static void *_tmp_21_rule(Parser *p); static void *_tmp_22_rule(Parser *p); @@ -954,71 +978,71 @@ static void *_tmp_23_rule(Parser *p); static void *_tmp_24_rule(Parser *p); static void *_tmp_25_rule(Parser *p); static void *_tmp_26_rule(Parser *p); -static asdl_seq *_loop0_28_rule(Parser *p); -static asdl_seq *_gather_27_rule(Parser *p); +static void *_tmp_27_rule(Parser *p); +static void *_tmp_28_rule(Parser *p); static asdl_seq *_loop0_30_rule(Parser *p); static asdl_seq *_gather_29_rule(Parser *p); -static void *_tmp_31_rule(Parser *p); -static void *_tmp_32_rule(Parser *p); +static asdl_seq *_loop0_32_rule(Parser *p); +static asdl_seq *_gather_31_rule(Parser *p); static void *_tmp_33_rule(Parser *p); -static asdl_seq *_loop0_35_rule(Parser *p); -static asdl_seq *_gather_34_rule(Parser *p); -static asdl_seq *_loop0_36_rule(Parser *p); -static asdl_seq *_loop1_37_rule(Parser *p); -static asdl_seq *_loop0_39_rule(Parser *p); -static asdl_seq *_gather_38_rule(Parser *p); -static void *_tmp_40_rule(Parser *p); -static asdl_seq *_loop0_42_rule(Parser *p); -static asdl_seq *_gather_41_rule(Parser *p); -static void *_tmp_43_rule(Parser *p); -static asdl_seq *_loop1_44_rule(Parser *p); +static void *_tmp_34_rule(Parser *p); +static void *_tmp_35_rule(Parser *p); +static asdl_seq *_loop0_37_rule(Parser *p); +static asdl_seq *_gather_36_rule(Parser *p); +static asdl_seq *_loop0_38_rule(Parser *p); +static asdl_seq *_loop1_39_rule(Parser *p); +static asdl_seq *_loop0_41_rule(Parser *p); +static asdl_seq *_gather_40_rule(Parser *p); +static void *_tmp_42_rule(Parser *p); +static asdl_seq *_loop0_44_rule(Parser *p); +static asdl_seq *_gather_43_rule(Parser *p); static void *_tmp_45_rule(Parser *p); -static void *_tmp_46_rule(Parser *p); +static asdl_seq *_loop1_46_rule(Parser *p); static void *_tmp_47_rule(Parser *p); -static asdl_seq *_loop0_48_rule(Parser *p); -static asdl_seq *_loop0_49_rule(Parser *p); -static asdl_seq *_loop0_50_rule(Parser *p); -static asdl_seq *_loop1_51_rule(Parser *p); -static asdl_seq *_loop0_52_rule(Parser *p); -static asdl_seq *_loop1_53_rule(Parser *p); -static asdl_seq *_loop1_54_rule(Parser *p); -static asdl_seq *_loop1_55_rule(Parser *p); -static asdl_seq *_loop0_56_rule(Parser *p); -static asdl_seq *_loop1_57_rule(Parser *p); -static asdl_seq *_loop0_58_rule(Parser *p); +static void *_tmp_48_rule(Parser *p); +static void *_tmp_49_rule(Parser *p); +static void *_tmp_50_rule(Parser *p); +static void *_tmp_51_rule(Parser *p); +static void *_tmp_52_rule(Parser *p); +static asdl_seq *_loop0_53_rule(Parser *p); +static asdl_seq *_loop0_54_rule(Parser *p); +static asdl_seq *_loop0_55_rule(Parser *p); +static asdl_seq *_loop1_56_rule(Parser *p); +static asdl_seq *_loop0_57_rule(Parser *p); +static asdl_seq *_loop1_58_rule(Parser *p); static asdl_seq *_loop1_59_rule(Parser *p); -static asdl_seq *_loop0_60_rule(Parser *p); +static asdl_seq *_loop1_60_rule(Parser *p); static asdl_seq *_loop0_61_rule(Parser *p); static asdl_seq *_loop1_62_rule(Parser *p); -static asdl_seq *_loop0_64_rule(Parser *p); -static asdl_seq *_gather_63_rule(Parser *p); +static asdl_seq *_loop0_63_rule(Parser *p); +static asdl_seq *_loop1_64_rule(Parser *p); +static asdl_seq *_loop0_65_rule(Parser *p); static asdl_seq *_loop0_66_rule(Parser *p); -static asdl_seq *_gather_65_rule(Parser *p); -static asdl_seq *_loop0_68_rule(Parser *p); -static asdl_seq *_gather_67_rule(Parser *p); -static asdl_seq *_loop0_70_rule(Parser *p); -static asdl_seq *_gather_69_rule(Parser *p); -static void *_tmp_71_rule(Parser *p); -static asdl_seq *_loop1_72_rule(Parser *p); -static asdl_seq *_loop1_73_rule(Parser *p); -static void *_tmp_74_rule(Parser *p); -static void *_tmp_75_rule(Parser *p); -static asdl_seq *_loop1_76_rule(Parser *p); +static asdl_seq *_loop1_67_rule(Parser *p); +static asdl_seq *_loop0_69_rule(Parser *p); +static asdl_seq *_gather_68_rule(Parser *p); +static asdl_seq *_loop0_71_rule(Parser *p); +static asdl_seq *_gather_70_rule(Parser *p); +static asdl_seq *_loop0_73_rule(Parser *p); +static asdl_seq *_gather_72_rule(Parser *p); +static asdl_seq *_loop0_75_rule(Parser *p); +static asdl_seq *_gather_74_rule(Parser *p); +static void *_tmp_76_rule(Parser *p); static asdl_seq *_loop1_77_rule(Parser *p); -static asdl_seq *_loop0_79_rule(Parser *p); -static asdl_seq *_gather_78_rule(Parser *p); -static asdl_seq *_loop1_80_rule(Parser *p); +static asdl_seq *_loop1_78_rule(Parser *p); +static void *_tmp_79_rule(Parser *p); +static void *_tmp_80_rule(Parser *p); static asdl_seq *_loop1_81_rule(Parser *p); -static asdl_seq *_loop0_83_rule(Parser *p); -static asdl_seq *_gather_82_rule(Parser *p); -static void *_tmp_84_rule(Parser *p); -static void *_tmp_85_rule(Parser *p); -static void *_tmp_86_rule(Parser *p); -static void *_tmp_87_rule(Parser *p); -static asdl_seq *_loop0_89_rule(Parser *p); -static asdl_seq *_gather_88_rule(Parser *p); -static asdl_seq *_loop0_91_rule(Parser *p); -static asdl_seq *_gather_90_rule(Parser *p); +static asdl_seq *_loop1_82_rule(Parser *p); +static asdl_seq *_loop0_84_rule(Parser *p); +static asdl_seq *_gather_83_rule(Parser *p); +static asdl_seq *_loop1_85_rule(Parser *p); +static asdl_seq *_loop1_86_rule(Parser *p); +static asdl_seq *_loop0_88_rule(Parser *p); +static asdl_seq *_gather_87_rule(Parser *p); +static void *_tmp_89_rule(Parser *p); +static void *_tmp_90_rule(Parser *p); +static void *_tmp_91_rule(Parser *p); static void *_tmp_92_rule(Parser *p); static asdl_seq *_loop0_94_rule(Parser *p); static asdl_seq *_gather_93_rule(Parser *p); @@ -1027,168 +1051,168 @@ static asdl_seq *_gather_95_rule(Parser *p); static void *_tmp_97_rule(Parser *p); static asdl_seq *_loop0_99_rule(Parser *p); static asdl_seq *_gather_98_rule(Parser *p); -static asdl_seq *_loop1_100_rule(Parser *p); -static asdl_seq *_loop1_101_rule(Parser *p); -static asdl_seq *_loop0_103_rule(Parser *p); -static asdl_seq *_gather_102_rule(Parser *p); -static asdl_seq *_loop1_104_rule(Parser *p); +static asdl_seq *_loop0_101_rule(Parser *p); +static asdl_seq *_gather_100_rule(Parser *p); +static void *_tmp_102_rule(Parser *p); +static asdl_seq *_loop0_104_rule(Parser *p); +static asdl_seq *_gather_103_rule(Parser *p); static asdl_seq *_loop1_105_rule(Parser *p); static asdl_seq *_loop1_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); -static void *_tmp_110_rule(Parser *p); -static asdl_seq *_loop0_112_rule(Parser *p); -static asdl_seq *_gather_111_rule(Parser *p); +static asdl_seq *_loop0_108_rule(Parser *p); +static asdl_seq *_gather_107_rule(Parser *p); +static asdl_seq *_loop1_109_rule(Parser *p); +static asdl_seq *_loop1_110_rule(Parser *p); +static asdl_seq *_loop1_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 void *_tmp_116_rule(Parser *p); -static void *_tmp_117_rule(Parser *p); +static asdl_seq *_loop0_117_rule(Parser *p); +static asdl_seq *_gather_116_rule(Parser *p); static void *_tmp_118_rule(Parser *p); -static asdl_seq *_loop0_119_rule(Parser *p); -static asdl_seq *_loop0_120_rule(Parser *p); -static asdl_seq *_loop0_121_rule(Parser *p); -static asdl_seq *_loop1_122_rule(Parser *p); -static asdl_seq *_loop0_123_rule(Parser *p); -static asdl_seq *_loop1_124_rule(Parser *p); -static asdl_seq *_loop1_125_rule(Parser *p); -static asdl_seq *_loop1_126_rule(Parser *p); +static void *_tmp_119_rule(Parser *p); +static void *_tmp_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); +static void *_tmp_124_rule(Parser *p); +static asdl_seq *_loop0_125_rule(Parser *p); +static asdl_seq *_loop0_126_rule(Parser *p); static asdl_seq *_loop0_127_rule(Parser *p); static asdl_seq *_loop1_128_rule(Parser *p); static asdl_seq *_loop0_129_rule(Parser *p); static asdl_seq *_loop1_130_rule(Parser *p); -static asdl_seq *_loop0_131_rule(Parser *p); +static asdl_seq *_loop1_131_rule(Parser *p); static asdl_seq *_loop1_132_rule(Parser *p); -static void *_tmp_133_rule(Parser *p); -static asdl_seq *_loop0_134_rule(Parser *p); -static asdl_seq *_loop1_135_rule(Parser *p); -static void *_tmp_136_rule(Parser *p); -static asdl_seq *_loop0_138_rule(Parser *p); -static asdl_seq *_gather_137_rule(Parser *p); -static asdl_seq *_loop1_139_rule(Parser *p); +static asdl_seq *_loop0_133_rule(Parser *p); +static asdl_seq *_loop1_134_rule(Parser *p); +static asdl_seq *_loop0_135_rule(Parser *p); +static asdl_seq *_loop1_136_rule(Parser *p); +static asdl_seq *_loop0_137_rule(Parser *p); +static asdl_seq *_loop1_138_rule(Parser *p); +static void *_tmp_139_rule(Parser *p); static asdl_seq *_loop0_140_rule(Parser *p); -static asdl_seq *_loop0_141_rule(Parser *p); -static asdl_seq *_loop0_142_rule(Parser *p); -static void *_tmp_143_rule(Parser *p); -static void *_tmp_144_rule(Parser *p); +static asdl_seq *_loop1_141_rule(Parser *p); +static void *_tmp_142_rule(Parser *p); +static asdl_seq *_loop0_144_rule(Parser *p); +static asdl_seq *_gather_143_rule(Parser *p); +static asdl_seq *_loop1_145_rule(Parser *p); static asdl_seq *_loop0_146_rule(Parser *p); -static asdl_seq *_gather_145_rule(Parser *p); -static void *_tmp_147_rule(Parser *p); -static asdl_seq *_loop0_149_rule(Parser *p); -static asdl_seq *_gather_148_rule(Parser *p); -static asdl_seq *_loop0_151_rule(Parser *p); -static asdl_seq *_gather_150_rule(Parser *p); -static asdl_seq *_loop0_153_rule(Parser *p); -static asdl_seq *_gather_152_rule(Parser *p); +static asdl_seq *_loop0_147_rule(Parser *p); +static asdl_seq *_loop0_148_rule(Parser *p); +static void *_tmp_149_rule(Parser *p); +static void *_tmp_150_rule(Parser *p); +static asdl_seq *_loop0_152_rule(Parser *p); +static asdl_seq *_gather_151_rule(Parser *p); +static void *_tmp_153_rule(Parser *p); static asdl_seq *_loop0_155_rule(Parser *p); static asdl_seq *_gather_154_rule(Parser *p); -static void *_tmp_156_rule(Parser *p); -static void *_tmp_157_rule(Parser *p); -static asdl_seq *_loop0_158_rule(Parser *p); -static asdl_seq *_loop0_160_rule(Parser *p); -static asdl_seq *_gather_159_rule(Parser *p); -static asdl_seq *_loop1_161_rule(Parser *p); +static asdl_seq *_loop0_157_rule(Parser *p); +static asdl_seq *_gather_156_rule(Parser *p); +static asdl_seq *_loop0_159_rule(Parser *p); +static asdl_seq *_gather_158_rule(Parser *p); +static asdl_seq *_loop0_161_rule(Parser *p); +static asdl_seq *_gather_160_rule(Parser *p); static void *_tmp_162_rule(Parser *p); static void *_tmp_163_rule(Parser *p); -static asdl_seq *_loop0_165_rule(Parser *p); -static asdl_seq *_gather_164_rule(Parser *p); -static asdl_seq *_loop0_167_rule(Parser *p); -static asdl_seq *_gather_166_rule(Parser *p); -static asdl_seq *_loop0_169_rule(Parser *p); -static asdl_seq *_gather_168_rule(Parser *p); +static asdl_seq *_loop0_164_rule(Parser *p); +static asdl_seq *_loop0_166_rule(Parser *p); +static asdl_seq *_gather_165_rule(Parser *p); +static asdl_seq *_loop1_167_rule(Parser *p); +static void *_tmp_168_rule(Parser *p); +static void *_tmp_169_rule(Parser *p); static asdl_seq *_loop0_171_rule(Parser *p); static asdl_seq *_gather_170_rule(Parser *p); static asdl_seq *_loop0_173_rule(Parser *p); static asdl_seq *_gather_172_rule(Parser *p); -static void *_tmp_174_rule(Parser *p); -static void *_tmp_175_rule(Parser *p); -static void *_tmp_176_rule(Parser *p); -static void *_tmp_177_rule(Parser *p); -static void *_tmp_178_rule(Parser *p); -static void *_tmp_179_rule(Parser *p); +static asdl_seq *_loop0_175_rule(Parser *p); +static asdl_seq *_gather_174_rule(Parser *p); +static asdl_seq *_loop0_177_rule(Parser *p); +static asdl_seq *_gather_176_rule(Parser *p); +static asdl_seq *_loop0_179_rule(Parser *p); +static asdl_seq *_gather_178_rule(Parser *p); static void *_tmp_180_rule(Parser *p); static void *_tmp_181_rule(Parser *p); static void *_tmp_182_rule(Parser *p); static void *_tmp_183_rule(Parser *p); static void *_tmp_184_rule(Parser *p); static void *_tmp_185_rule(Parser *p); -static asdl_seq *_loop0_186_rule(Parser *p); -static asdl_seq *_loop0_187_rule(Parser *p); -static asdl_seq *_loop0_188_rule(Parser *p); +static void *_tmp_186_rule(Parser *p); +static void *_tmp_187_rule(Parser *p); +static void *_tmp_188_rule(Parser *p); static void *_tmp_189_rule(Parser *p); static void *_tmp_190_rule(Parser *p); static void *_tmp_191_rule(Parser *p); -static void *_tmp_192_rule(Parser *p); -static void *_tmp_193_rule(Parser *p); +static asdl_seq *_loop0_192_rule(Parser *p); +static asdl_seq *_loop0_193_rule(Parser *p); static asdl_seq *_loop0_194_rule(Parser *p); -static asdl_seq *_loop0_195_rule(Parser *p); -static asdl_seq *_loop0_196_rule(Parser *p); -static asdl_seq *_loop1_197_rule(Parser *p); +static void *_tmp_195_rule(Parser *p); +static void *_tmp_196_rule(Parser *p); +static void *_tmp_197_rule(Parser *p); static void *_tmp_198_rule(Parser *p); -static asdl_seq *_loop0_199_rule(Parser *p); -static void *_tmp_200_rule(Parser *p); +static void *_tmp_199_rule(Parser *p); +static asdl_seq *_loop0_200_rule(Parser *p); static asdl_seq *_loop0_201_rule(Parser *p); -static asdl_seq *_loop1_202_rule(Parser *p); -static void *_tmp_203_rule(Parser *p); +static asdl_seq *_loop0_202_rule(Parser *p); +static asdl_seq *_loop1_203_rule(Parser *p); static void *_tmp_204_rule(Parser *p); -static void *_tmp_205_rule(Parser *p); -static asdl_seq *_loop0_206_rule(Parser *p); -static void *_tmp_207_rule(Parser *p); -static void *_tmp_208_rule(Parser *p); -static asdl_seq *_loop1_209_rule(Parser *p); +static asdl_seq *_loop0_205_rule(Parser *p); +static void *_tmp_206_rule(Parser *p); +static asdl_seq *_loop0_207_rule(Parser *p); +static asdl_seq *_loop1_208_rule(Parser *p); +static void *_tmp_209_rule(Parser *p); static void *_tmp_210_rule(Parser *p); -static asdl_seq *_loop0_211_rule(Parser *p); +static void *_tmp_211_rule(Parser *p); static asdl_seq *_loop0_212_rule(Parser *p); -static asdl_seq *_loop0_213_rule(Parser *p); -static asdl_seq *_loop0_215_rule(Parser *p); -static asdl_seq *_gather_214_rule(Parser *p); +static void *_tmp_213_rule(Parser *p); +static void *_tmp_214_rule(Parser *p); +static asdl_seq *_loop1_215_rule(Parser *p); static void *_tmp_216_rule(Parser *p); static asdl_seq *_loop0_217_rule(Parser *p); -static void *_tmp_218_rule(Parser *p); +static asdl_seq *_loop0_218_rule(Parser *p); static asdl_seq *_loop0_219_rule(Parser *p); -static asdl_seq *_loop1_220_rule(Parser *p); -static asdl_seq *_loop1_221_rule(Parser *p); +static asdl_seq *_loop0_221_rule(Parser *p); +static asdl_seq *_gather_220_rule(Parser *p); static void *_tmp_222_rule(Parser *p); -static void *_tmp_223_rule(Parser *p); -static asdl_seq *_loop0_224_rule(Parser *p); -static void *_tmp_225_rule(Parser *p); -static void *_tmp_226_rule(Parser *p); -static void *_tmp_227_rule(Parser *p); -static asdl_seq *_loop0_229_rule(Parser *p); -static asdl_seq *_gather_228_rule(Parser *p); -static asdl_seq *_loop0_231_rule(Parser *p); -static asdl_seq *_gather_230_rule(Parser *p); -static asdl_seq *_loop0_233_rule(Parser *p); -static asdl_seq *_gather_232_rule(Parser *p); +static asdl_seq *_loop0_223_rule(Parser *p); +static void *_tmp_224_rule(Parser *p); +static asdl_seq *_loop0_225_rule(Parser *p); +static asdl_seq *_loop1_226_rule(Parser *p); +static asdl_seq *_loop1_227_rule(Parser *p); +static void *_tmp_228_rule(Parser *p); +static void *_tmp_229_rule(Parser *p); +static asdl_seq *_loop0_230_rule(Parser *p); +static void *_tmp_231_rule(Parser *p); +static void *_tmp_232_rule(Parser *p); +static void *_tmp_233_rule(Parser *p); static asdl_seq *_loop0_235_rule(Parser *p); static asdl_seq *_gather_234_rule(Parser *p); static asdl_seq *_loop0_237_rule(Parser *p); static asdl_seq *_gather_236_rule(Parser *p); -static void *_tmp_238_rule(Parser *p); static asdl_seq *_loop0_239_rule(Parser *p); -static asdl_seq *_loop1_240_rule(Parser *p); -static void *_tmp_241_rule(Parser *p); -static asdl_seq *_loop0_242_rule(Parser *p); -static asdl_seq *_loop1_243_rule(Parser *p); +static asdl_seq *_gather_238_rule(Parser *p); +static asdl_seq *_loop0_241_rule(Parser *p); +static asdl_seq *_gather_240_rule(Parser *p); +static asdl_seq *_loop0_243_rule(Parser *p); +static asdl_seq *_gather_242_rule(Parser *p); static void *_tmp_244_rule(Parser *p); -static void *_tmp_245_rule(Parser *p); -static void *_tmp_246_rule(Parser *p); +static asdl_seq *_loop0_245_rule(Parser *p); +static asdl_seq *_loop1_246_rule(Parser *p); static void *_tmp_247_rule(Parser *p); -static void *_tmp_248_rule(Parser *p); -static void *_tmp_249_rule(Parser *p); +static asdl_seq *_loop0_248_rule(Parser *p); +static asdl_seq *_loop1_249_rule(Parser *p); static void *_tmp_250_rule(Parser *p); static void *_tmp_251_rule(Parser *p); static void *_tmp_252_rule(Parser *p); static void *_tmp_253_rule(Parser *p); -static asdl_seq *_loop0_255_rule(Parser *p); -static asdl_seq *_gather_254_rule(Parser *p); +static void *_tmp_254_rule(Parser *p); +static void *_tmp_255_rule(Parser *p); static void *_tmp_256_rule(Parser *p); static void *_tmp_257_rule(Parser *p); static void *_tmp_258_rule(Parser *p); static void *_tmp_259_rule(Parser *p); -static void *_tmp_260_rule(Parser *p); -static void *_tmp_261_rule(Parser *p); +static asdl_seq *_loop0_261_rule(Parser *p); +static asdl_seq *_gather_260_rule(Parser *p); static void *_tmp_262_rule(Parser *p); static void *_tmp_263_rule(Parser *p); static void *_tmp_264_rule(Parser *p); @@ -1196,24 +1220,24 @@ static void *_tmp_265_rule(Parser *p); static void *_tmp_266_rule(Parser *p); static void *_tmp_267_rule(Parser *p); static void *_tmp_268_rule(Parser *p); -static asdl_seq *_loop0_269_rule(Parser *p); +static void *_tmp_269_rule(Parser *p); static void *_tmp_270_rule(Parser *p); static void *_tmp_271_rule(Parser *p); static void *_tmp_272_rule(Parser *p); static void *_tmp_273_rule(Parser *p); static void *_tmp_274_rule(Parser *p); -static void *_tmp_275_rule(Parser *p); +static asdl_seq *_loop0_275_rule(Parser *p); static void *_tmp_276_rule(Parser *p); static void *_tmp_277_rule(Parser *p); static void *_tmp_278_rule(Parser *p); -static asdl_seq *_loop0_280_rule(Parser *p); -static asdl_seq *_gather_279_rule(Parser *p); +static void *_tmp_279_rule(Parser *p); +static void *_tmp_280_rule(Parser *p); static void *_tmp_281_rule(Parser *p); static void *_tmp_282_rule(Parser *p); static void *_tmp_283_rule(Parser *p); static void *_tmp_284_rule(Parser *p); -static void *_tmp_285_rule(Parser *p); -static void *_tmp_286_rule(Parser *p); +static asdl_seq *_loop0_286_rule(Parser *p); +static asdl_seq *_gather_285_rule(Parser *p); static void *_tmp_287_rule(Parser *p); static void *_tmp_288_rule(Parser *p); static void *_tmp_289_rule(Parser *p); @@ -1234,6 +1258,14 @@ static void *_tmp_303_rule(Parser *p); static void *_tmp_304_rule(Parser *p); static void *_tmp_305_rule(Parser *p); static void *_tmp_306_rule(Parser *p); +static void *_tmp_307_rule(Parser *p); +static void *_tmp_308_rule(Parser *p); +static void *_tmp_309_rule(Parser *p); +static void *_tmp_310_rule(Parser *p); +static void *_tmp_311_rule(Parser *p); +static void *_tmp_312_rule(Parser *p); +static void *_tmp_313_rule(Parser *p); +static void *_tmp_314_rule(Parser *p); // file: statements? $ @@ -1813,6 +1845,80 @@ simple_stmts_rule(Parser *p) return _res; } +// simple_stmts_nonewline: simple_stmt !';' | ';'.simple_stmt+ ';'? +static asdl_stmt_seq* +simple_stmts_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + int _mark = p->mark; + { // simple_stmt !';' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> simple_stmts_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt !';'")); + stmt_ty a; + if ( + (a = simple_stmt_rule(p)) // simple_stmt + && + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';' + ) + { + D(fprintf(stderr, "%*c+ simple_stmts_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt !';'")); + _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s simple_stmts_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt !';'")); + } + { // ';'.simple_stmt+ ';'? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> simple_stmts_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_stmt_seq* a; + if ( + (a = (asdl_stmt_seq*)_gather_7_rule(p)) // ';'.simple_stmt+ + && + (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? + ) + { + D(fprintf(stderr, "%*c+ simple_stmts_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + _res = a; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s simple_stmts_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // simple_stmt: // | assignment // | &"type" type_alias @@ -1956,15 +2062,15 @@ simple_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'return' ('return' del_kw_stmt | return_stmt)")); - void *_tmp_7_var; + void *_tmp_9_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 560) // token='return' && - (_tmp_7_var = _tmp_7_rule(p)) // 'return' del_kw_stmt | return_stmt + (_tmp_9_var = _tmp_9_rule(p)) // 'return' del_kw_stmt | return_stmt ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'return' ('return' del_kw_stmt | return_stmt)")); - _res = _tmp_7_var; + _res = _tmp_9_var; goto done; } p->mark = _mark; @@ -1979,7 +2085,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('import' | 'from') import_stmt")); stmt_ty import_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_8_rule, p) + _PyPegen_lookahead(1, _tmp_10_rule, p) && (import_stmt_var = import_stmt_rule(p)) // import_stmt ) @@ -2052,15 +2158,15 @@ simple_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'del' (del_kw_stmt | del_stmt)")); - void *_tmp_9_var; + void *_tmp_11_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 659) // token='del' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 663) // token='del' && - (_tmp_9_var = _tmp_9_rule(p)) // del_kw_stmt | del_stmt + (_tmp_11_var = _tmp_11_rule(p)) // del_kw_stmt | del_stmt ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'del' (del_kw_stmt | del_stmt)")); - _res = _tmp_9_var; + _res = _tmp_11_var; goto done; } p->mark = _mark; @@ -2075,7 +2181,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'yield' yield_stmt")); stmt_ty yield_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 620) // token='yield' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 622) // token='yield' && (yield_stmt_var = yield_stmt_rule(p)) // yield_stmt ) @@ -2277,7 +2383,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def")); stmt_ty function_def_var; if ( - _PyPegen_lookahead(1, _tmp_10_rule, p) + _PyPegen_lookahead(1, _tmp_12_rule, p) && (function_def_var = function_def_rule(p)) // function_def ) @@ -2298,7 +2404,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'if' if_stmt")); stmt_ty if_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 702) // token='if' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 706) // token='if' && (if_stmt_var = if_stmt_rule(p)) // if_stmt ) @@ -2340,7 +2446,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def")); stmt_ty class_def_var; if ( - _PyPegen_lookahead(1, _tmp_11_rule, p) + _PyPegen_lookahead(1, _tmp_13_rule, p) && (class_def_var = class_def_rule(p)) // class_def ) @@ -2361,7 +2467,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('with' | 'async') with_stmt")); stmt_ty with_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_12_rule, p) + _PyPegen_lookahead(1, _tmp_14_rule, p) && (with_stmt_var = with_stmt_rule(p)) // with_stmt ) @@ -2382,7 +2488,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('for' | 'async') for_stmt")); stmt_ty for_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_13_rule, p) + _PyPegen_lookahead(1, _tmp_15_rule, p) && (for_stmt_var = for_stmt_rule(p)) // for_stmt ) @@ -2403,7 +2509,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'try' try_stmt")); stmt_ty try_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 684) // token='try' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 688) // token='try' && (try_stmt_var = try_stmt_rule(p)) // try_stmt ) @@ -2424,7 +2530,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'while' while_stmt")); stmt_ty while_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 707) // token='while' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 711) // token='while' && (while_stmt_var = while_stmt_rule(p)) // while_stmt ) @@ -2530,7 +2636,7 @@ assignment_rule(Parser *p) && (b = expression_rule(p)) // expression && - (c = _tmp_14_rule(p), !p->error_indicator) // ['=' annotated_rhs] + (c = _tmp_16_rule(p), !p->error_indicator) // ['=' annotated_rhs] ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME ':' expression ['=' annotated_rhs]")); @@ -2566,13 +2672,13 @@ assignment_rule(Parser *p) expr_ty b; void *c; if ( - (a = _tmp_15_rule(p)) // '(' single_target ')' | single_subscript_attribute_target + (a = _tmp_17_rule(p)) // '(' single_target ')' | single_subscript_attribute_target && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (b = expression_rule(p)) // expression && - (c = _tmp_16_rule(p), !p->error_indicator) // ['=' annotated_rhs] + (c = _tmp_18_rule(p), !p->error_indicator) // ['=' annotated_rhs] ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); @@ -2607,9 +2713,9 @@ assignment_rule(Parser *p) void *b; void *tc; if ( - (a = (asdl_expr_seq*)_loop1_17_rule(p)) // ((star_targets '='))+ + (a = (asdl_expr_seq*)_loop1_19_rule(p)) // ((star_targets '='))+ && - (b = _tmp_18_rule(p)) // yield_expr | star_expressions + (b = _tmp_20_rule(p)) // yield_expr | star_expressions && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' && @@ -2651,11 +2757,11 @@ assignment_rule(Parser *p) if ( (a = single_target_rule(p)) // single_target && - (t = _tmp_19_rule(p)) // '|>=' + (t = _tmp_21_rule(p)) // '|>=' && (_cut_var = 1) && - (c = _tmp_20_rule(p)) // [yield_expr | star_expressions] + (c = _tmp_22_rule(p)) // [yield_expr | star_expressions] ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_target ('|>=') ~ ([yield_expr | star_expressions])")); @@ -2697,7 +2803,7 @@ assignment_rule(Parser *p) && (b = unarassign_rule(p)) // unarassign && - _PyPegen_lookahead(1, _tmp_21_rule, p) + _PyPegen_lookahead(1, _tmp_23_rule, p) ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_target unarassign &(';' | NEWLINE)")); @@ -2739,7 +2845,7 @@ assignment_rule(Parser *p) && (_cut_var = 1) && - (c = _tmp_22_rule(p)) // yield_expr | star_expressions + (c = _tmp_24_rule(p)) // yield_expr | star_expressions ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_target augassign ~ (yield_expr | star_expressions)")); @@ -3266,9 +3372,9 @@ unarassign_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> unarassign[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('+=' | '+' '=')")); - void *_tmp_23_var; + void *_tmp_25_var; if ( - (_tmp_23_var = _tmp_23_rule(p)) // '+=' | '+' '=' + (_tmp_25_var = _tmp_25_rule(p)) // '+=' | '+' '=' ) { D(fprintf(stderr, "%*c+ unarassign[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('+=' | '+' '=')")); @@ -3290,9 +3396,9 @@ unarassign_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> unarassign[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('-=' | '-' '=')")); - void *_tmp_24_var; + void *_tmp_26_var; if ( - (_tmp_24_var = _tmp_24_rule(p)) // '-=' | '-' '=' + (_tmp_26_var = _tmp_26_rule(p)) // '-=' | '-' '=' ) { D(fprintf(stderr, "%*c+ unarassign[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('-=' | '-' '=')")); @@ -3341,9 +3447,9 @@ unarassign_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> unarassign[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('!=' | '!' '=')")); - void *_tmp_25_var; + void *_tmp_27_var; if ( - (_tmp_25_var = _tmp_25_rule(p)) // '!=' | '!' '=' + (_tmp_27_var = _tmp_27_rule(p)) // '!=' | '!' '=' ) { D(fprintf(stderr, "%*c+ unarassign[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('!=' | '!' '=')")); @@ -3467,7 +3573,7 @@ raise_stmt_rule(Parser *p) && (a = expression_rule(p)) // expression && - (b = _tmp_26_rule(p), !p->error_indicator) // ['from' expression] + (b = _tmp_28_rule(p), !p->error_indicator) // ['from' expression] ) { D(fprintf(stderr, "%*c+ raise_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise' expression ['from' expression]")); @@ -3565,7 +3671,7 @@ global_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 548)) // token='global' && - (a = (asdl_expr_seq*)_gather_27_rule(p)) // ','.NAME+ + (a = (asdl_expr_seq*)_gather_29_rule(p)) // ','.NAME+ ) { D(fprintf(stderr, "%*c+ global_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global' ','.NAME+")); @@ -3630,7 +3736,7 @@ nonlocal_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 555)) // token='nonlocal' && - (a = (asdl_expr_seq*)_gather_29_rule(p)) // ','.NAME+ + (a = (asdl_expr_seq*)_gather_31_rule(p)) // ','.NAME+ ) { D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal' ','.NAME+")); @@ -3694,9 +3800,9 @@ del_kw_stmt_rule(Parser *p) Token * _keyword; Token* a; if ( - (_keyword = _PyPegen_expect_token(p, 659)) // token='del' + (_keyword = _PyPegen_expect_token(p, 663)) // token='del' && - (a = (Token*)_tmp_31_rule(p)) // 'False' | 'None' | 'True' | 'and' | 'as' | 'assert' | 'async' | 'await' | 'break' | 'class' | 'continue' | 'del' | 'elif' | 'else' | 'except' | 'finally' | 'for' | 'from' | 'global' | 'goto' | 'if' | 'import' | 'in' | 'is' | 'lambda' | 'nonlocal' | 'not' | 'or' | 'pass' | 'raise' | 'return' | 'try' | 'while' | 'with' | 'yield' + (a = (Token*)_tmp_33_rule(p)) // 'False' | 'None' | 'True' | 'and' | 'as' | 'assert' | 'async' | 'await' | 'break' | 'class' | 'continue' | 'del' | 'elif' | 'else' | 'except' | 'finally' | 'for' | 'from' | 'global' | 'goto' | 'if' | 'import' | 'in' | 'is' | 'lambda' | 'nonlocal' | 'not' | 'or' | 'pass' | 'raise' | 'return' | 'try' | 'while' | 'with' | 'yield' ) { D(fprintf(stderr, "%*c+ del_kw_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del' ('False' | 'None' | 'True' | 'and' | 'as' | 'assert' | 'async' | 'await' | 'break' | 'class' | 'continue' | 'del' | 'elif' | 'else' | 'except' | 'finally' | 'for' | 'from' | 'global' | 'goto' | 'if' | 'import' | 'in' | 'is' | 'lambda' | 'nonlocal' | 'not' | 'or' | 'pass' | 'raise' | 'return' | 'try' | 'while' | 'with' | 'yield')")); @@ -3759,11 +3865,11 @@ del_stmt_rule(Parser *p) Token * _keyword; asdl_expr_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 659)) // token='del' + (_keyword = _PyPegen_expect_token(p, 663)) // token='del' && (a = del_targets_rule(p)) // del_targets && - _PyPegen_lookahead(1, _tmp_32_rule, p) + _PyPegen_lookahead(1, _tmp_34_rule, p) ) { D(fprintf(stderr, "%*c+ del_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del' del_targets &(';' | NEWLINE)")); @@ -3912,7 +4018,7 @@ assert_stmt_rule(Parser *p) && (a = expression_rule(p)) // expression && - (b = _tmp_33_rule(p), !p->error_indicator) // [',' expression] + (b = _tmp_35_rule(p), !p->error_indicator) // [',' expression] ) { D(fprintf(stderr, "%*c+ assert_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert' expression [',' expression]")); @@ -4042,7 +4148,7 @@ label_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_soft_keyword(p, "label")) // soft_keyword='"label"' && - (a = (asdl_expr_seq*)_gather_34_rule(p)) // ','.NAME+ + (a = (asdl_expr_seq*)_gather_36_rule(p)) // ','.NAME+ ) { D(fprintf(stderr, "%*c+ label_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"label\" ','.NAME+")); @@ -4182,7 +4288,7 @@ import_name_rule(Parser *p) Token * _keyword; asdl_alias_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='import' + (_keyword = _PyPegen_expect_token(p, 667)) // token='import' && (a = dotted_as_names_rule(p)) // dotted_as_names ) @@ -4252,13 +4358,13 @@ import_from_rule(Parser *p) expr_ty b; asdl_alias_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword = _PyPegen_expect_token(p, 668)) // token='from' && - (a = _loop0_36_rule(p)) // (('.' | '...'))* + (a = _loop0_38_rule(p)) // (('.' | '...'))* && (b = dotted_name_rule(p)) // dotted_name && - (_keyword_1 = _PyPegen_expect_token(p, 663)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 667)) // token='import' && (c = import_from_targets_rule(p)) // import_from_targets ) @@ -4296,11 +4402,11 @@ import_from_rule(Parser *p) asdl_seq * a; asdl_alias_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword = _PyPegen_expect_token(p, 668)) // token='from' && - (a = _loop1_37_rule(p)) // (('.' | '...'))+ + (a = _loop1_39_rule(p)) // (('.' | '...'))+ && - (_keyword_1 = _PyPegen_expect_token(p, 663)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 667)) // token='import' && (b = import_from_targets_rule(p)) // import_from_targets ) @@ -4495,7 +4601,7 @@ import_from_as_names_rule(Parser *p) D(fprintf(stderr, "%*c> import_from_as_names[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.import_from_as_name+")); asdl_alias_seq* a; if ( - (a = (asdl_alias_seq*)_gather_38_rule(p)) // ','.import_from_as_name+ + (a = (asdl_alias_seq*)_gather_40_rule(p)) // ','.import_from_as_name+ ) { D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.import_from_as_name+")); @@ -4551,7 +4657,7 @@ import_from_as_name_rule(Parser *p) if ( (a = _PyPegen_name_token(p)) // NAME && - (b = _tmp_40_rule(p), !p->error_indicator) // ['as' NAME] + (b = _tmp_42_rule(p), !p->error_indicator) // ['as' NAME] ) { D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME ['as' NAME]")); @@ -4604,7 +4710,7 @@ dotted_as_names_rule(Parser *p) D(fprintf(stderr, "%*c> dotted_as_names[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.dotted_as_name+")); asdl_alias_seq* a; if ( - (a = (asdl_alias_seq*)_gather_41_rule(p)) // ','.dotted_as_name+ + (a = (asdl_alias_seq*)_gather_43_rule(p)) // ','.dotted_as_name+ ) { D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.dotted_as_name+")); @@ -4660,7 +4766,7 @@ dotted_as_name_rule(Parser *p) if ( (a = dotted_name_rule(p)) // dotted_name && - (b = _tmp_43_rule(p), !p->error_indicator) // ['as' NAME] + (b = _tmp_45_rule(p), !p->error_indicator) // ['as' NAME] ) { D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name ['as' NAME]")); @@ -4893,6 +4999,80 @@ block_rule(Parser *p) return _res; } +// block_nonewline: NEWLINE INDENT? statements DEDENT? | simple_stmts_nonewline +static asdl_stmt_seq* +block_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + int _mark = p->mark; + { // NEWLINE INDENT? statements DEDENT? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT? statements DEDENT?")); + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *_opt_var_1; + UNUSED(_opt_var_1); // Silence compiler warnings + asdl_stmt_seq* a; + Token * newline_var; + if ( + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (_opt_var = _PyPegen_expect_token(p, INDENT), !p->error_indicator) // INDENT? + && + (a = statements_rule(p)) // statements + && + (_opt_var_1 = _PyPegen_expect_token(p, DEDENT), !p->error_indicator) // DEDENT? + ) + { + D(fprintf(stderr, "%*c+ block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT? statements DEDENT?")); + _res = a; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE INDENT? statements DEDENT?")); + } + { // simple_stmts_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + asdl_stmt_seq* simple_stmts_nonewline_var; + if ( + (simple_stmts_nonewline_var = simple_stmts_nonewline_rule(p)) // simple_stmts_nonewline + ) + { + D(fprintf(stderr, "%*c+ block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + _res = simple_stmts_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // decorators: (('@' named_expression NEWLINE))+ static asdl_expr_seq* decorators_rule(Parser *p) @@ -4915,7 +5095,7 @@ decorators_rule(Parser *p) D(fprintf(stderr, "%*c> decorators[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(('@' named_expression NEWLINE))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_44_rule(p)) // (('@' named_expression NEWLINE))+ + (a = (asdl_expr_seq*)_loop1_46_rule(p)) // (('@' named_expression NEWLINE))+ ) { D(fprintf(stderr, "%*c+ decorators[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(('@' named_expression NEWLINE))+")); @@ -5060,13 +5240,13 @@ class_def_raw_rule(Parser *p) asdl_stmt_seq* c; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='class' + (_keyword = _PyPegen_expect_token(p, 720)) // token='class' && (a = _PyPegen_name_token(p)) // NAME && (t = type_params_rule(p), !p->error_indicator) // type_params? && - (b = _tmp_45_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (b = _tmp_47_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -5101,6 +5281,170 @@ class_def_raw_rule(Parser *p) return _res; } +// class_def_nonewline: decorators class_def_raw_nonewline | class_def_raw_nonewline +static stmt_ty +class_def_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + { // decorators class_def_raw_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> class_def_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "decorators class_def_raw_nonewline")); + asdl_expr_seq* a; + stmt_ty b; + if ( + (a = decorators_rule(p)) // decorators + && + (b = class_def_raw_nonewline_rule(p)) // class_def_raw_nonewline + ) + { + D(fprintf(stderr, "%*c+ class_def_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "decorators class_def_raw_nonewline")); + _res = _PyPegen_class_def_decorators ( p , a , b ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s class_def_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "decorators class_def_raw_nonewline")); + } + { // class_def_raw_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> class_def_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_def_raw_nonewline")); + stmt_ty class_def_raw_nonewline_var; + if ( + (class_def_raw_nonewline_var = class_def_raw_nonewline_rule(p)) // class_def_raw_nonewline + ) + { + D(fprintf(stderr, "%*c+ class_def_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_def_raw_nonewline")); + _res = class_def_raw_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s class_def_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "class_def_raw_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// class_def_raw_nonewline: +// | invalid_class_def_raw_nonewline +// | 'class' NAME type_params? ['(' arguments? ')'] ':' block_nonewline +static stmt_ty +class_def_raw_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_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 + if (p->call_invalid_rules) { // invalid_class_def_raw_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> class_def_raw_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_class_def_raw_nonewline")); + void *invalid_class_def_raw_nonewline_var; + if ( + (invalid_class_def_raw_nonewline_var = invalid_class_def_raw_nonewline_rule(p)) // invalid_class_def_raw_nonewline + ) + { + D(fprintf(stderr, "%*c+ class_def_raw_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_class_def_raw_nonewline")); + _res = invalid_class_def_raw_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s class_def_raw_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_class_def_raw_nonewline")); + } + { // 'class' NAME type_params? ['(' arguments? ')'] ':' block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> class_def_raw_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class' NAME type_params? ['(' arguments? ')'] ':' block_nonewline")); + Token * _keyword; + Token * _literal; + expr_ty a; + void *b; + asdl_stmt_seq* c; + void *t; + if ( + (_keyword = _PyPegen_expect_token(p, 720)) // token='class' + && + (a = _PyPegen_name_token(p)) // NAME + && + (t = type_params_rule(p), !p->error_indicator) // type_params? + && + (b = _tmp_48_rule(p), !p->error_indicator) // ['(' arguments? ')'] + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (c = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ class_def_raw_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class' NAME type_params? ['(' arguments? ')'] ':' block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , t , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s class_def_raw_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class' NAME type_params? ['(' arguments? ')'] ':' block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // function_def: decorators function_def_raw | function_def_raw static stmt_ty function_def_rule(Parser *p) @@ -5241,7 +5585,7 @@ function_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_46_rule(p), !p->error_indicator) // ['->' expression] + (a = _tmp_49_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -5290,7 +5634,7 @@ function_def_raw_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' && (_keyword_1 = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' && @@ -5304,7 +5648,7 @@ function_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_47_rule(p), !p->error_indicator) // ['->' expression] + (a = _tmp_50_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -5341,6 +5685,228 @@ function_def_raw_rule(Parser *p) return _res; } +// function_def_nonewline: +// | decorators function_def_raw_nonewline +// | function_def_raw_nonewline +static stmt_ty +function_def_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + { // decorators function_def_raw_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> function_def_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "decorators function_def_raw_nonewline")); + asdl_expr_seq* d; + stmt_ty f; + if ( + (d = decorators_rule(p)) // decorators + && + (f = function_def_raw_nonewline_rule(p)) // function_def_raw_nonewline + ) + { + D(fprintf(stderr, "%*c+ function_def_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "decorators function_def_raw_nonewline")); + _res = _PyPegen_function_def_decorators ( p , d , f ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s function_def_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "decorators function_def_raw_nonewline")); + } + { // function_def_raw_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> function_def_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "function_def_raw_nonewline")); + stmt_ty function_def_raw_nonewline_var; + if ( + (function_def_raw_nonewline_var = function_def_raw_nonewline_rule(p)) // function_def_raw_nonewline + ) + { + D(fprintf(stderr, "%*c+ function_def_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "function_def_raw_nonewline")); + _res = function_def_raw_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s function_def_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "function_def_raw_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// function_def_raw_nonewline: +// | "def" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline +// | 'async' "def" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline +static stmt_ty +function_def_raw_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_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 + { // "def" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> function_def_raw_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline")); + expr_ty _keyword; + Token * _literal; + Token * _literal_1; + Token * _literal_2; + void *a; + asdl_stmt_seq* b; + expr_ty n; + void *params; + void *t; + void *tc; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' + && + (n = _PyPegen_name_token(p)) // NAME + && + (t = type_params_rule(p), !p->error_indicator) // type_params? + && + (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='(' + && + (params = params_rule(p), !p->error_indicator) // params? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + && + (a = _tmp_51_rule(p), !p->error_indicator) // ['->' expression] + && + (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' + && + (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment? + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ function_def_raw_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , t , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s function_def_raw_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"def\" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline")); + } + { // 'async' "def" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> function_def_raw_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' \"def\" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline")); + Token * _keyword; + expr_ty _keyword_1; + Token * _literal; + Token * _literal_1; + Token * _literal_2; + void *a; + asdl_stmt_seq* b; + expr_ty n; + void *params; + void *t; + void *tc; + if ( + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + && + (_keyword_1 = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' + && + (n = _PyPegen_name_token(p)) // NAME + && + (t = type_params_rule(p), !p->error_indicator) // type_params? + && + (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='(' + && + (params = params_rule(p), !p->error_indicator) // params? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + && + (a = _tmp_52_rule(p), !p->error_indicator) // ['->' expression] + && + (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' + && + (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment? + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ function_def_raw_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' \"def\" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline")); + 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 = CHECK_VERSION ( stmt_ty , 5 , "Async functions are" , _PyAST_AsyncFunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , t , EXTRA ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s function_def_raw_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async' \"def\" NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // params: invalid_parameters | parameters static arguments_ty params_rule(Parser *p) @@ -5431,9 +5997,9 @@ parameters_rule(Parser *p) if ( (a = slash_no_default_rule(p)) // slash_no_default && - (b = (asdl_arg_seq*)_loop0_48_rule(p)) // param_no_default* + (b = (asdl_arg_seq*)_loop0_53_rule(p)) // param_no_default* && - (c = _loop0_49_rule(p)) // param_with_default* + (c = _loop0_54_rule(p)) // param_with_default* && (d = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -5463,7 +6029,7 @@ parameters_rule(Parser *p) if ( (a = slash_with_default_rule(p)) // slash_with_default && - (b = _loop0_50_rule(p)) // param_with_default* + (b = _loop0_55_rule(p)) // param_with_default* && (c = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -5491,9 +6057,9 @@ parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_51_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_56_rule(p)) // param_no_default+ && - (b = _loop0_52_rule(p)) // param_with_default* + (b = _loop0_57_rule(p)) // param_with_default* && (c = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -5520,7 +6086,7 @@ parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_53_rule(p)) // param_with_default+ + (a = _loop1_58_rule(p)) // param_with_default+ && (b = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -5592,7 +6158,7 @@ slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_54_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_59_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5621,7 +6187,7 @@ slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_55_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_60_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5674,9 +6240,9 @@ slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_56_rule(p)) // param_no_default* + (a = _loop0_61_rule(p)) // param_no_default* && - (b = _loop1_57_rule(p)) // param_with_default+ + (b = _loop1_62_rule(p)) // param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5706,9 +6272,9 @@ slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_58_rule(p)) // param_no_default* + (a = _loop0_63_rule(p)) // param_no_default* && - (b = _loop1_59_rule(p)) // param_with_default+ + (b = _loop1_64_rule(p)) // param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5787,7 +6353,7 @@ star_etc_rule(Parser *p) && (a = param_no_default_rule(p)) // param_no_default && - (b = _loop0_60_rule(p)) // param_maybe_default* + (b = _loop0_65_rule(p)) // param_maybe_default* && (c = kwds_rule(p), !p->error_indicator) // kwds? ) @@ -5820,7 +6386,7 @@ star_etc_rule(Parser *p) && (a = param_no_default_star_annotation_rule(p)) // param_no_default_star_annotation && - (b = _loop0_61_rule(p)) // param_maybe_default* + (b = _loop0_66_rule(p)) // param_maybe_default* && (c = kwds_rule(p), !p->error_indicator) // kwds? ) @@ -5853,7 +6419,7 @@ star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_62_rule(p)) // param_maybe_default+ + (b = _loop1_67_rule(p)) // param_maybe_default+ && (c = kwds_rule(p), !p->error_indicator) // kwds? ) @@ -6646,7 +7212,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -6691,7 +7257,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -6787,7 +7353,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -6832,7 +7398,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -6914,7 +7480,7 @@ else_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 705)) // token='else' + (_keyword = _PyPegen_expect_token(p, 709)) // token='else' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -6994,7 +7560,7 @@ while_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='while' + (_keyword = _PyPegen_expect_token(p, 711)) // token='while' && (a = named_expression_rule(p)) // named_expression && @@ -7095,11 +7661,11 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword = _PyPegen_expect_token(p, 716)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' && (_cut_var = 1) && @@ -7157,13 +7723,13 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 716)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 717)) // token='in' && (_cut_var = 1) && @@ -7292,11 +7858,11 @@ with_stmt_rule(Parser *p) asdl_withitem_seq* a; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword = _PyPegen_expect_token(p, 679)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = (asdl_withitem_seq*)_gather_63_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_68_rule(p)) // ','.with_item+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -7341,9 +7907,9 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword = _PyPegen_expect_token(p, 679)) // token='with' && - (a = (asdl_withitem_seq*)_gather_65_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_70_rule(p)) // ','.with_item+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -7390,13 +7956,13 @@ with_stmt_rule(Parser *p) asdl_withitem_seq* a; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 679)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = (asdl_withitem_seq*)_gather_67_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_72_rule(p)) // ','.with_item+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -7442,11 +8008,11 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 679)) // token='with' && - (a = (asdl_withitem_seq*)_gather_69_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_74_rule(p)) // ','.with_item+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -7531,11 +8097,11 @@ with_item_rule(Parser *p) if ( (e = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (t = star_target_rule(p)) // star_target && - _PyPegen_lookahead(1, _tmp_71_rule, p) + _PyPegen_lookahead(1, _tmp_76_rule, p) ) { D(fprintf(stderr, "%*c+ with_item[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression 'as' star_target &(',' | ')' | ':')")); @@ -7657,7 +8223,7 @@ try_stmt_rule(Parser *p) asdl_stmt_seq* b; asdl_stmt_seq* f; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7701,13 +8267,13 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && (b = block_rule(p)) // block && - (ex = (asdl_excepthandler_seq*)_loop1_72_rule(p)) // except_block+ + (ex = (asdl_excepthandler_seq*)_loop1_77_rule(p)) // except_block+ && (el = else_block_rule(p), !p->error_indicator) // else_block? && @@ -7749,13 +8315,13 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && (b = block_rule(p)) // block && - (ex = (asdl_excepthandler_seq*)_loop1_73_rule(p)) // except_star_block+ + (ex = (asdl_excepthandler_seq*)_loop1_78_rule(p)) // except_star_block+ && (el = else_block_rule(p), !p->error_indicator) // else_block? && @@ -7848,11 +8414,11 @@ except_block_rule(Parser *p) expr_ty e; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='except' + (_keyword = _PyPegen_expect_token(p, 701)) // token='except' && (e = expression_rule(p)) // expression && - (t = _tmp_74_rule(p), !p->error_indicator) // ['as' NAME] + (t = _tmp_79_rule(p), !p->error_indicator) // ['as' NAME] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -7891,7 +8457,7 @@ except_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='except' + (_keyword = _PyPegen_expect_token(p, 701)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -8003,13 +8569,13 @@ except_star_block_rule(Parser *p) expr_ty e; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='except' + (_keyword = _PyPegen_expect_token(p, 701)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (e = expression_rule(p)) // expression && - (t = _tmp_75_rule(p), !p->error_indicator) // ['as' NAME] + (t = _tmp_80_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -8106,7 +8672,7 @@ finally_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 693)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 697)) // token='finally' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -8181,7 +8747,7 @@ switch_stmt_rule(Parser *p) && (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' && - (cases = (asdl_switch_case_seq*)_loop1_76_rule(p)) // switchcase_block+ + (cases = (asdl_switch_case_seq*)_loop1_81_rule(p)) // switchcase_block+ && (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' ) @@ -8228,7 +8794,7 @@ switch_stmt_rule(Parser *p) && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' && - (cases = (asdl_switch_case_seq*)_loop1_77_rule(p)) // switchcase_block+ + (cases = (asdl_switch_case_seq*)_loop1_82_rule(p)) // switchcase_block+ ) { D(fprintf(stderr, "%*c+ switch_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); @@ -8286,7 +8852,7 @@ switchcase_block_rule(Parser *p) if ( (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' && - (exprs = (asdl_expr_seq*)_gather_78_rule(p)) // ','.(bitwiseor_pattern | 'None')+ + (exprs = (asdl_expr_seq*)_gather_83_rule(p)) // ','.(bitwiseor_pattern | 'None')+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -9619,7 +10185,7 @@ number_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> number_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { D(fprintf(stderr, "%*c+ number_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -9652,7 +10218,7 @@ number_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> number_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { D(fprintf(stderr, "%*c+ number_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -9757,7 +10323,7 @@ match_stmt_rule(Parser *p) && (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' && - (cases = (asdl_match_case_seq*)_loop1_80_rule(p)) // case_block+ + (cases = (asdl_match_case_seq*)_loop1_85_rule(p)) // case_block+ && (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' ) @@ -9804,7 +10370,7 @@ match_stmt_rule(Parser *p) && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' && - (cases = (asdl_match_case_seq*)_loop1_81_rule(p)) // case_block+ + (cases = (asdl_match_case_seq*)_loop1_86_rule(p)) // case_block+ ) { D(fprintf(stderr, "%*c+ match_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE case_block+")); @@ -10039,7 +10605,7 @@ guard_rule(Parser *p) Token * _keyword; expr_ty guard; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (guard = named_expression_rule(p)) // named_expression ) @@ -10237,7 +10803,7 @@ as_pattern_rule(Parser *p) if ( (pattern = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (target = pattern_capture_target_rule(p)) // pattern_capture_target ) @@ -10320,7 +10886,7 @@ or_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> or_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'.closed_pattern+")); asdl_pattern_seq* patterns; if ( - (patterns = (asdl_pattern_seq*)_gather_82_rule(p)) // '|'.closed_pattern+ + (patterns = (asdl_pattern_seq*)_gather_87_rule(p)) // '|'.closed_pattern+ ) { D(fprintf(stderr, "%*c+ or_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'.closed_pattern+")); @@ -10575,7 +11141,7 @@ literal_pattern_rule(Parser *p) if ( (value = signed_number_rule(p)) // signed_number && - _PyPegen_lookahead(0, _tmp_84_rule, p) + _PyPegen_lookahead(0, _tmp_89_rule, p) ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "signed_number !('+' | '-')")); @@ -10674,7 +11240,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); @@ -10707,7 +11273,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -10740,7 +11306,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -10810,7 +11376,7 @@ literal_expr_rule(Parser *p) if ( (signed_number_var = signed_number_rule(p)) // signed_number && - _PyPegen_lookahead(0, _tmp_85_rule, p) + _PyPegen_lookahead(0, _tmp_90_rule, p) ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "signed_number !('+' | '-')")); @@ -10867,7 +11433,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); @@ -10900,7 +11466,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -10933,7 +11499,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -11417,7 +11983,7 @@ pattern_capture_target_rule(Parser *p) && (name = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(0, _tmp_86_rule, p) + _PyPegen_lookahead(0, _tmp_91_rule, p) ) { D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!\"_\" NAME !('.' | '(' | '=')")); @@ -11534,7 +12100,7 @@ value_pattern_rule(Parser *p) if ( (attr = attr_rule(p)) // attr && - _PyPegen_lookahead(0, _tmp_87_rule, p) + _PyPegen_lookahead(0, _tmp_92_rule, p) ) { D(fprintf(stderr, "%*c+ value_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr !('.' | '(' | '=')")); @@ -11960,7 +12526,7 @@ maybe_sequence_pattern_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * patterns; if ( - (patterns = _gather_88_rule(p)) // ','.maybe_star_pattern+ + (patterns = _gather_93_rule(p)) // ','.maybe_star_pattern+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -12372,13 +12938,13 @@ items_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> items_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.key_value_pattern+")); - asdl_seq * _gather_90_var; + asdl_seq * _gather_95_var; if ( - (_gather_90_var = _gather_90_rule(p)) // ','.key_value_pattern+ + (_gather_95_var = _gather_95_rule(p)) // ','.key_value_pattern+ ) { D(fprintf(stderr, "%*c+ items_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.key_value_pattern+")); - _res = _gather_90_var; + _res = _gather_95_var; goto done; } p->mark = _mark; @@ -12415,7 +12981,7 @@ key_value_pattern_rule(Parser *p) void *key; pattern_ty pattern; if ( - (key = _tmp_92_rule(p)) // literal_expr | attr + (key = _tmp_97_rule(p)) // literal_expr | attr && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -12746,7 +13312,7 @@ positional_patterns_rule(Parser *p) D(fprintf(stderr, "%*c> positional_patterns[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.pattern+")); asdl_pattern_seq* args; if ( - (args = (asdl_pattern_seq*)_gather_93_rule(p)) // ','.pattern+ + (args = (asdl_pattern_seq*)_gather_98_rule(p)) // ','.pattern+ ) { D(fprintf(stderr, "%*c+ positional_patterns[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.pattern+")); @@ -12788,13 +13354,13 @@ keyword_patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> keyword_patterns[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.keyword_pattern+")); - asdl_seq * _gather_95_var; + asdl_seq * _gather_100_var; if ( - (_gather_95_var = _gather_95_rule(p)) // ','.keyword_pattern+ + (_gather_100_var = _gather_100_rule(p)) // ','.keyword_pattern+ ) { D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.keyword_pattern+")); - _res = _gather_95_var; + _res = _gather_100_var; goto done; } p->mark = _mark; @@ -12893,9 +13459,9 @@ unless_stmt_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (b = _tmp_97_rule(p)) // ';'.simple_stmt+ ';'? | block + (b = _tmp_102_rule(p)) // ';'.simple_stmt+ ';'? | block && - (_keyword = _PyPegen_expect_token(p, 615)) // token='unless' + (_keyword = _PyPegen_expect_token(p, 617)) // token='unless' && (a = named_expression_rule(p)) // named_expression ) @@ -13076,7 +13642,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_98_rule(p)) // ','.type_param+ + (a = (asdl_type_param_seq*)_gather_103_rule(p)) // ','.type_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -13396,7 +13962,7 @@ expressions_rule(Parser *p) if ( (a = expression_rule(p)) // expression && - (b = _loop1_100_rule(p)) // ((',' expression))+ + (b = _loop1_105_rule(p)) // ((',' expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -13568,11 +14134,11 @@ expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 705)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 709)) // token='else' && (c = expression_rule(p)) // expression ) @@ -13677,9 +14243,9 @@ yield_expr_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='yield' + (_keyword = _PyPegen_expect_token(p, 622)) // token='yield' && - (_keyword_1 = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword_1 = _PyPegen_expect_token(p, 668)) // token='from' && (a = expression_rule(p)) // expression ) @@ -13715,7 +14281,7 @@ yield_expr_rule(Parser *p) Token * _keyword; void *a; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='yield' + (_keyword = _PyPegen_expect_token(p, 622)) // token='yield' && (a = star_expressions_rule(p), !p->error_indicator) // star_expressions? ) @@ -13787,7 +14353,7 @@ star_expressions_rule(Parser *p) if ( (a = star_expression_rule(p)) // star_expression && - (b = _loop1_101_rule(p)) // ((',' star_expression))+ + (b = _loop1_106_rule(p)) // ((',' star_expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -13988,7 +14554,7 @@ star_named_expressions_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_102_rule(p)) // ','.star_named_expression+ + (a = (asdl_expr_seq*)_gather_107_rule(p)) // ','.star_named_expression+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -14410,7 +14976,7 @@ disjunction_rule(Parser *p) if ( (a = conjunction_rule(p)) // conjunction && - (b = _loop1_104_rule(p)) // (('or' conjunction))+ + (b = _loop1_109_rule(p)) // (('or' conjunction))+ ) { D(fprintf(stderr, "%*c+ disjunction[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "conjunction (('or' conjunction))+")); @@ -14499,7 +15065,7 @@ conjunction_rule(Parser *p) if ( (a = inversion_rule(p)) // inversion && - (b = _loop1_105_rule(p)) // (('and' inversion))+ + (b = _loop1_110_rule(p)) // (('and' inversion))+ ) { D(fprintf(stderr, "%*c+ conjunction[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "inversion (('and' inversion))+")); @@ -14586,7 +15152,7 @@ inversion_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 633)) // token='not' + (_keyword = _PyPegen_expect_token(p, 635)) // token='not' && (a = inversion_rule(p)) // inversion ) @@ -14673,7 +15239,7 @@ comparison_rule(Parser *p) if ( (a = composition_rule(p)) // composition && - (b = _loop1_106_rule(p)) // compare_op_composition_pair+ + (b = _loop1_111_rule(p)) // compare_op_composition_pair+ ) { D(fprintf(stderr, "%*c+ comparison[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "composition compare_op_composition_pair+")); @@ -15050,10 +15616,10 @@ noteq_composition_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> noteq_composition[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('!=') composition")); - void *_tmp_107_var; + void *_tmp_112_var; expr_ty a; if ( - (_tmp_107_var = _tmp_107_rule(p)) // '!=' + (_tmp_112_var = _tmp_112_rule(p)) // '!=' && (a = composition_rule(p)) // composition ) @@ -15289,9 +15855,9 @@ notin_composition_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 633)) // token='not' + (_keyword = _PyPegen_expect_token(p, 635)) // token='not' && - (_keyword_1 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' && (a = composition_rule(p)) // composition ) @@ -15338,7 +15904,7 @@ in_composition_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword = _PyPegen_expect_token(p, 717)) // token='in' && (a = composition_rule(p)) // composition ) @@ -15387,11 +15953,11 @@ isnotin_composition_rule(Parser *p) Token * _keyword_2; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='is' + (_keyword = _PyPegen_expect_token(p, 636)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 633)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 635)) // token='not' && - (_keyword_2 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 717)) // token='in' && (a = composition_rule(p)) // composition ) @@ -15439,9 +16005,9 @@ isin_composition_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='is' + (_keyword = _PyPegen_expect_token(p, 636)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' && (a = composition_rule(p)) // composition ) @@ -15489,9 +16055,9 @@ isnot_composition_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='is' + (_keyword = _PyPegen_expect_token(p, 636)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 633)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 635)) // token='not' && (a = composition_rule(p)) // composition ) @@ -15538,7 +16104,7 @@ is_composition_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='is' + (_keyword = _PyPegen_expect_token(p, 636)) // token='is' && (a = composition_rule(p)) // composition ) @@ -15634,9 +16200,9 @@ composition_raw(Parser *p) if ( (a = composition_rule(p)) // composition && - (t = _tmp_108_rule(p)) // '|>' + (t = _tmp_113_rule(p)) // '|>' && - (b = _tmp_109_rule(p)) // bitwise_or? + (b = _tmp_114_rule(p)) // bitwise_or? ) { D(fprintf(stderr, "%*c+ composition[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "composition ('|>') (bitwise_or?)")); @@ -17077,7 +17643,7 @@ await_primary_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 635)) // token='await' + (_keyword = _PyPegen_expect_token(p, 637)) // token='await' && (a = primary_rule(p)) // primary ) @@ -17133,7 +17699,7 @@ await_primary_rule(Parser *p) // Left-recursive // primary: // | primary '?'? '.' NAME -// | primary '?'? (genexp | tuplecomp) +// | primary '?'? (class_or_func_expr | tuplecomp | genexp) // | primary '?'? '(' arguments? ')' // | primary '?'? '[' slices ']' // | atom @@ -17237,12 +17803,12 @@ primary_raw(Parser *p) D(fprintf(stderr, "%*c%s primary[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "primary '?'? '.' NAME")); } - { // primary '?'? (genexp | tuplecomp) + { // primary '?'? (class_or_func_expr | tuplecomp | genexp) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> primary[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "primary '?'? (genexp | tuplecomp)")); + D(fprintf(stderr, "%*c> primary[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "primary '?'? (class_or_func_expr | tuplecomp | genexp)")); expr_ty a; void *b; void *n; @@ -17251,10 +17817,10 @@ primary_raw(Parser *p) && (n = _PyPegen_expect_token(p, 58), !p->error_indicator) // '?'? && - (b = _tmp_110_rule(p)) // genexp | tuplecomp + (b = _tmp_115_rule(p)) // class_or_func_expr | tuplecomp | genexp ) { - D(fprintf(stderr, "%*c+ primary[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "primary '?'? (genexp | tuplecomp)")); + D(fprintf(stderr, "%*c+ primary[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "primary '?'? (class_or_func_expr | tuplecomp | genexp)")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -17274,7 +17840,7 @@ primary_raw(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s primary[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "primary '?'? (genexp | tuplecomp)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "primary '?'? (class_or_func_expr | tuplecomp | genexp)")); } { // primary '?'? '(' arguments? ')' if (p->error_indicator) { @@ -17450,7 +18016,7 @@ slices_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_111_rule(p)) // ','.(slice | starred_expression)+ + (a = (asdl_expr_seq*)_gather_116_rule(p)) // ','.(slice | starred_expression)+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -17581,7 +18147,7 @@ simple_slice_rule(Parser *p) && (b = expression_rule(p), !p->error_indicator) // expression? && - (c = _tmp_113_rule(p), !p->error_indicator) // [':' expression?] + (c = _tmp_118_rule(p), !p->error_indicator) // [':' expression?] ) { D(fprintf(stderr, "%*c+ simple_slice[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression? ':' expression? [':' expression?]")); @@ -17620,7 +18186,7 @@ simple_slice_rule(Parser *p) // | '$' // | &(STRING | FSTRING_START) strings // | NUMBER -// | &'(' (tuple | group | genexp | tuplecomp) +// | &'(' (class_or_func_expr | tuple | group | tuplecomp | genexp) // | &'[' (list | listcomp) // | &'{' (dict | set | dictcomp | setcomp) // | '...' @@ -17673,7 +18239,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -17706,7 +18272,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -17739,7 +18305,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); @@ -17805,7 +18371,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(STRING | FSTRING_START) strings")); expr_ty strings_var; if ( - _PyPegen_lookahead(1, _tmp_114_rule, p) + _PyPegen_lookahead(1, _tmp_119_rule, p) && (strings_var = strings_rule(p)) // strings ) @@ -17837,26 +18403,26 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NUMBER")); } - { // &'(' (tuple | group | genexp | tuplecomp) + { // &'(' (class_or_func_expr | tuple | group | tuplecomp | genexp) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'(' (tuple | group | genexp | tuplecomp)")); - void *_tmp_115_var; + D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'(' (class_or_func_expr | tuple | group | tuplecomp | genexp)")); + void *_tmp_120_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='(' && - (_tmp_115_var = _tmp_115_rule(p)) // tuple | group | genexp | tuplecomp + (_tmp_120_var = _tmp_120_rule(p)) // class_or_func_expr | tuple | group | tuplecomp | genexp ) { - D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'(' (tuple | group | genexp | tuplecomp)")); - _res = _tmp_115_var; + D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'(' (class_or_func_expr | tuple | group | tuplecomp | genexp)")); + _res = _tmp_120_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s atom[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&'(' (tuple | group | genexp | tuplecomp)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&'(' (class_or_func_expr | tuple | group | tuplecomp | genexp)")); } { // &'[' (list | listcomp) if (p->error_indicator) { @@ -17864,15 +18430,15 @@ atom_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'[' (list | listcomp)")); - void *_tmp_116_var; + void *_tmp_121_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='[' && - (_tmp_116_var = _tmp_116_rule(p)) // list | listcomp + (_tmp_121_var = _tmp_121_rule(p)) // list | listcomp ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'[' (list | listcomp)")); - _res = _tmp_116_var; + _res = _tmp_121_var; goto done; } p->mark = _mark; @@ -17885,15 +18451,15 @@ atom_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'{' (dict | set | dictcomp | setcomp)")); - void *_tmp_117_var; + void *_tmp_122_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{' && - (_tmp_117_var = _tmp_117_rule(p)) // dict | set | dictcomp | setcomp + (_tmp_122_var = _tmp_122_rule(p)) // dict | set | dictcomp | setcomp ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'{' (dict | set | dictcomp | setcomp)")); - _res = _tmp_117_var; + _res = _tmp_122_var; goto done; } p->mark = _mark; @@ -17965,7 +18531,7 @@ group_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_118_rule(p)) // yield_expr | slice + (a = _tmp_123_rule(p)) // yield_expr | slice && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -18008,6 +18574,75 @@ group_rule(Parser *p) return _res; } +// class_or_func_expr: +// | '(' (&("def" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline) ')' +static expr_ty +class_or_func_expr_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + 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 + { // '(' (&("def" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline) ')' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> class_or_func_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' (&(\"def\" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline) ')'")); + Token * _literal; + Token * _literal_1; + void *a; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = _tmp_124_rule(p)) // &("def" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + D(fprintf(stderr, "%*c+ class_or_func_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' (&(\"def\" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline) ')'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_CompoundExpr ( a , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s class_or_func_expr[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' (&(\"def\" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline) ')'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // lambdef: 'lambda' lambda_params? ':' expression static expr_ty lambdef_rule(Parser *p) @@ -18042,7 +18677,7 @@ lambdef_rule(Parser *p) void *a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 655)) // token='lambda' + (_keyword = _PyPegen_expect_token(p, 659)) // token='lambda' && (a = lambda_params_rule(p), !p->error_indicator) // lambda_params? && @@ -18169,9 +18804,9 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default && - (b = (asdl_arg_seq*)_loop0_119_rule(p)) // lambda_param_no_default* + (b = (asdl_arg_seq*)_loop0_125_rule(p)) // lambda_param_no_default* && - (c = _loop0_120_rule(p)) // lambda_param_with_default* + (c = _loop0_126_rule(p)) // lambda_param_with_default* && (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -18201,7 +18836,7 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default && - (b = _loop0_121_rule(p)) // lambda_param_with_default* + (b = _loop0_127_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -18229,9 +18864,9 @@ lambda_parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_122_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_128_rule(p)) // lambda_param_no_default+ && - (b = _loop0_123_rule(p)) // lambda_param_with_default* + (b = _loop0_129_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -18258,7 +18893,7 @@ lambda_parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_124_rule(p)) // lambda_param_with_default+ + (a = _loop1_130_rule(p)) // lambda_param_with_default+ && (b = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -18332,7 +18967,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_125_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_131_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -18361,7 +18996,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_126_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_132_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -18414,9 +19049,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_127_rule(p)) // lambda_param_no_default* + (a = _loop0_133_rule(p)) // lambda_param_no_default* && - (b = _loop1_128_rule(p)) // lambda_param_with_default+ + (b = _loop1_134_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -18446,9 +19081,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_129_rule(p)) // lambda_param_no_default* + (a = _loop0_135_rule(p)) // lambda_param_no_default* && - (b = _loop1_130_rule(p)) // lambda_param_with_default+ + (b = _loop1_136_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -18526,7 +19161,7 @@ lambda_star_etc_rule(Parser *p) && (a = lambda_param_no_default_rule(p)) // lambda_param_no_default && - (b = _loop0_131_rule(p)) // lambda_param_maybe_default* + (b = _loop0_137_rule(p)) // lambda_param_maybe_default* && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -18559,7 +19194,7 @@ lambda_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_132_rule(p)) // lambda_param_maybe_default+ + (b = _loop1_138_rule(p)) // lambda_param_maybe_default+ && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -19069,7 +19704,7 @@ fstring_replacement_field_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (a = _tmp_133_rule(p)) // yield_expr | star_expressions + (a = _tmp_139_rule(p)) // yield_expr | star_expressions && (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // "="? && @@ -19208,7 +19843,7 @@ fstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_134_rule(p)) // fstring_format_spec* + (spec = _loop0_140_rule(p)) // fstring_format_spec* ) { D(fprintf(stderr, "%*c+ fstring_full_format_spec[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' fstring_format_spec*")); @@ -19381,7 +20016,7 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c> strings[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "((fstring | string))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_135_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_141_rule(p)) // ((fstring | string))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "((fstring | string))+")); @@ -19516,7 +20151,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_136_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_142_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -19734,7 +20369,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_137_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_143_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19896,7 +20531,7 @@ for_if_clauses_rule(Parser *p) D(fprintf(stderr, "%*c> for_if_clauses[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "for_if_clause+")); asdl_comprehension_seq* a; if ( - (a = (asdl_comprehension_seq*)_loop1_139_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_145_rule(p)) // for_if_clause+ ) { D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "for_if_clause+")); @@ -19959,19 +20594,19 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 716)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 717)) // token='in' && (_cut_var = 1) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_140_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_146_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); @@ -20004,17 +20639,17 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword = _PyPegen_expect_token(p, 716)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' && (_cut_var = 1) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_141_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_147_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); @@ -20054,7 +20689,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_142_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_148_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"where\" star_targets '=' disjunction (('if' disjunction))*")); @@ -20233,7 +20868,7 @@ tuplecomp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_143_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_149_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -20417,7 +21052,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_144_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_150_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -20669,9 +21304,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_145_rule(p)) // ','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_151_rule(p)) // ','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_147_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_153_rule(p), !p->error_indicator) // [',' kwargs] ) { D(fprintf(stderr, "%*c+ args[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); @@ -20762,11 +21397,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_148_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_154_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_150_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_156_rule(p)) // ','.kwarg_or_double_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); @@ -20788,13 +21423,13 @@ kwargs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> kwargs[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.kwarg_or_starred+")); - asdl_seq * _gather_152_var; + asdl_seq * _gather_158_var; if ( - (_gather_152_var = _gather_152_rule(p)) // ','.kwarg_or_starred+ + (_gather_158_var = _gather_158_rule(p)) // ','.kwarg_or_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.kwarg_or_starred+")); - _res = _gather_152_var; + _res = _gather_158_var; goto done; } p->mark = _mark; @@ -20807,13 +21442,13 @@ kwargs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> kwargs[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.kwarg_or_double_starred+")); - asdl_seq * _gather_154_var; + asdl_seq * _gather_160_var; if ( - (_gather_154_var = _gather_154_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_160_var = _gather_160_rule(p)) // ','.kwarg_or_double_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.kwarg_or_double_starred+")); - _res = _gather_154_var; + _res = _gather_160_var; goto done; } p->mark = _mark; @@ -20969,7 +21604,7 @@ kwarg_or_starred_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (b = _tmp_156_rule(p), !p->error_indicator) // [(simple_slice | expression)] + (b = _tmp_162_rule(p), !p->error_indicator) // [(simple_slice | expression)] ) { D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '=' [(simple_slice | expression)]")); @@ -21083,7 +21718,7 @@ kwarg_or_double_starred_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (b = _tmp_157_rule(p), !p->error_indicator) // [(simple_slice | expression)] + (b = _tmp_163_rule(p), !p->error_indicator) // [(simple_slice | expression)] ) { D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '=' [(simple_slice | expression)]")); @@ -21214,7 +21849,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_158_rule(p)) // ((',' star_target))* + (b = _loop0_164_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -21271,7 +21906,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_159_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_165_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -21322,7 +21957,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_161_rule(p)) // ((',' star_target))+ + (b = _loop1_167_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -21411,7 +22046,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_162_rule(p)) // !'*' star_target + (a = _tmp_168_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (!'*' star_target)")); @@ -22159,7 +22794,7 @@ t_primary_raw(Parser *p) && (n = _PyPegen_expect_token(p, 58), !p->error_indicator) // '?'? && - (b = _tmp_163_rule(p)) // genexp | tuplecomp + (b = _tmp_169_rule(p)) // genexp | tuplecomp && _PyPegen_lookahead(1, t_lookahead_rule, p) ) @@ -22409,7 +23044,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_164_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_170_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -22776,7 +23411,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_166_rule(p)) // ','.expression+ + (a = _gather_172_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -22815,7 +23450,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_168_rule(p)) // ','.expression+ + (a = _gather_174_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -22848,7 +23483,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_170_rule(p)) // ','.expression+ + (a = _gather_176_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -22968,7 +23603,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c> type_expressions[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.expression+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_172_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_178_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.expression+")); @@ -23020,7 +23655,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, _tmp_174_rule, p) + _PyPegen_lookahead(1, _tmp_180_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -23149,7 +23784,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_175_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_181_rule(p), !p->error_indicator) // [args | expression for_if_clauses] ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression for_if_clauses ',' [args | expression for_if_clauses]")); @@ -23209,13 +23844,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_176_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_182_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_177_rule, p) + _PyPegen_lookahead(1, _tmp_183_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[(args ',')] NAME '=' &(',' | ')')")); @@ -23354,7 +23989,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_178_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_184_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -23414,7 +24049,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, _tmp_179_rule, p) + _PyPegen_lookahead(0, _tmp_185_rule, p) && (a = expression_rule(p)) // expression && @@ -23518,11 +24153,11 @@ expression_without_invalid_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 705)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 709)) // token='else' && (c = expression_rule(p)) // expression ) @@ -23673,7 +24308,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, _tmp_180_rule, p) + _PyPegen_lookahead(0, _tmp_186_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -23705,11 +24340,11 @@ invalid_expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, _tmp_181_rule, p) + _PyPegen_lookahead(0, _tmp_187_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "disjunction 'if' disjunction !('else' | ':')")); @@ -23736,13 +24371,13 @@ invalid_expression_rule(Parser *p) Token * a; Token * b; if ( - (a = _PyPegen_expect_token(p, 655)) // token='lambda' + (a = _PyPegen_expect_token(p, 659)) // token='lambda' && (_opt_var = lambda_params_rule(p), !p->error_indicator) // lambda_params? && (b = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_182_rule, p) + _PyPegen_lookahead(1, _tmp_188_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda' lambda_params? ':' &(FSTRING_MIDDLE | fstring_replacement_field)")); @@ -23831,7 +24466,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_183_rule, p) + _PyPegen_lookahead(0, _tmp_189_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '=' bitwise_or !('=' | ':=')")); @@ -23857,7 +24492,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, _tmp_184_rule, p) + _PyPegen_lookahead(0, _tmp_190_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -23865,7 +24500,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_185_rule, p) + _PyPegen_lookahead(0, _tmp_191_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')")); @@ -23946,7 +24581,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_assignment[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions* ':' expression")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_186_var; + asdl_seq * _loop0_192_var; expr_ty a; expr_ty expression_var; if ( @@ -23954,7 +24589,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_186_var = _loop0_186_rule(p)) // star_named_expressions* + (_loop0_192_var = _loop0_192_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -24011,10 +24646,10 @@ invalid_assignment_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "((star_targets '='))* star_expressions '='")); Token * _literal; - asdl_seq * _loop0_187_var; + asdl_seq * _loop0_193_var; expr_ty a; if ( - (_loop0_187_var = _loop0_187_rule(p)) // ((star_targets '='))* + (_loop0_193_var = _loop0_193_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -24041,10 +24676,10 @@ invalid_assignment_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "((star_targets '='))* yield_expr '='")); Token * _literal; - asdl_seq * _loop0_188_var; + asdl_seq * _loop0_194_var; expr_ty a; if ( - (_loop0_188_var = _loop0_188_rule(p)) // ((star_targets '='))* + (_loop0_194_var = _loop0_194_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -24070,7 +24705,7 @@ invalid_assignment_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions augassign (yield_expr | star_expressions)")); - void *_tmp_189_var; + void *_tmp_195_var; expr_ty a; AugOperator* augassign_var; if ( @@ -24078,7 +24713,7 @@ invalid_assignment_rule(Parser *p) && (augassign_var = augassign_rule(p)) // augassign && - (_tmp_189_var = _tmp_189_rule(p)) // yield_expr | star_expressions + (_tmp_195_var = _tmp_195_rule(p)) // yield_expr | star_expressions ) { D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions augassign (yield_expr | star_expressions)")); @@ -24211,7 +24846,7 @@ invalid_del_stmt_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 659)) // token='del' + (_keyword = _PyPegen_expect_token(p, 663)) // token='del' && (a = star_expressions_rule(p)) // star_expressions ) @@ -24304,11 +24939,11 @@ invalid_comprehension_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('[' | '(' | '{') starred_expression for_if_clauses")); - void *_tmp_190_var; + void *_tmp_196_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_190_var = _tmp_190_rule(p)) // '[' | '(' | '{' + (_tmp_196_var = _tmp_196_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -24335,12 +24970,12 @@ invalid_comprehension_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); Token * _literal; - void *_tmp_191_var; + void *_tmp_197_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_191_var = _tmp_191_rule(p)) // '[' | '{' + (_tmp_197_var = _tmp_197_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -24370,12 +25005,12 @@ invalid_comprehension_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('[' | '{') star_named_expression ',' for_if_clauses")); - void *_tmp_192_var; + void *_tmp_198_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_192_var = _tmp_192_rule(p)) // '[' | '{' + (_tmp_198_var = _tmp_198_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -24512,13 +25147,13 @@ invalid_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); - asdl_seq * _loop0_194_var; - void *_tmp_193_var; + asdl_seq * _loop0_200_var; + void *_tmp_199_var; Token * a; if ( - (_tmp_193_var = _tmp_193_rule(p)) // slash_no_default | slash_with_default + (_tmp_199_var = _tmp_199_rule(p)) // slash_no_default | slash_with_default && - (_loop0_194_var = _loop0_194_rule(p)) // param_maybe_default* + (_loop0_200_var = _loop0_200_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -24542,7 +25177,7 @@ invalid_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default? param_no_default* invalid_parameters_helper param_no_default")); - asdl_seq * _loop0_195_var; + asdl_seq * _loop0_201_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -24550,7 +25185,7 @@ invalid_parameters_rule(Parser *p) if ( (_opt_var = slash_no_default_rule(p), !p->error_indicator) // slash_no_default? && - (_loop0_195_var = _loop0_195_rule(p)) // param_no_default* + (_loop0_201_var = _loop0_201_rule(p)) // param_no_default* && (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper && @@ -24576,18 +25211,18 @@ invalid_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default* '(' param_no_default+ ','? ')'")); - asdl_seq * _loop0_196_var; - asdl_seq * _loop1_197_var; + asdl_seq * _loop0_202_var; + asdl_seq * _loop1_203_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_196_var = _loop0_196_rule(p)) // param_no_default* + (_loop0_202_var = _loop0_202_rule(p)) // param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_loop1_197_var = _loop1_197_rule(p)) // param_no_default+ + (_loop1_203_var = _loop1_203_rule(p)) // param_no_default+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -24614,22 +25249,22 @@ invalid_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'")); Token * _literal; - asdl_seq * _loop0_199_var; - asdl_seq * _loop0_201_var; + asdl_seq * _loop0_205_var; + asdl_seq * _loop0_207_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_200_var; + void *_tmp_206_var; Token * a; if ( - (_opt_var = _tmp_198_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_204_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && - (_loop0_199_var = _loop0_199_rule(p)) // param_maybe_default* + (_loop0_205_var = _loop0_205_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_200_var = _tmp_200_rule(p)) // ',' | param_no_default + (_tmp_206_var = _tmp_206_rule(p)) // ',' | param_no_default && - (_loop0_201_var = _loop0_201_rule(p)) // param_maybe_default* + (_loop0_207_var = _loop0_207_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -24654,10 +25289,10 @@ invalid_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default+ '/' '*'")); Token * _literal; - asdl_seq * _loop1_202_var; + asdl_seq * _loop1_208_var; Token * a; if ( - (_loop1_202_var = _loop1_202_rule(p)) // param_maybe_default+ + (_loop1_208_var = _loop1_208_rule(p)) // param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -24707,7 +25342,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_203_rule, p) + _PyPegen_lookahead(1, _tmp_209_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' &(')' | ',')")); @@ -24753,12 +25388,12 @@ invalid_star_etc_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (')' | ',' (')' | '**'))")); - void *_tmp_204_var; + void *_tmp_210_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_204_var = _tmp_204_rule(p)) // ')' | ',' (')' | '**') + (_tmp_210_var = _tmp_210_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (')' | ',' (')' | '**'))")); @@ -24841,20 +25476,20 @@ invalid_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); Token * _literal; - asdl_seq * _loop0_206_var; - void *_tmp_205_var; - void *_tmp_207_var; + asdl_seq * _loop0_212_var; + void *_tmp_211_var; + void *_tmp_213_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_205_var = _tmp_205_rule(p)) // param_no_default | ',' + (_tmp_211_var = _tmp_211_rule(p)) // param_no_default | ',' && - (_loop0_206_var = _loop0_206_rule(p)) // param_maybe_default* + (_loop0_212_var = _loop0_212_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_207_var = _tmp_207_rule(p)) // param_no_default | ',' + (_tmp_213_var = _tmp_213_rule(p)) // param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); @@ -24970,7 +25605,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_208_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_214_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**' param ',' ('*' | '**' | '/')")); @@ -25036,13 +25671,13 @@ invalid_parameters_helper_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default+")); - asdl_seq * _loop1_209_var; + asdl_seq * _loop1_215_var; if ( - (_loop1_209_var = _loop1_209_rule(p)) // param_with_default+ + (_loop1_215_var = _loop1_215_rule(p)) // param_with_default+ ) { D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default+")); - _res = _loop1_209_var; + _res = _loop1_215_var; goto done; } p->mark = _mark; @@ -25108,13 +25743,13 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); - asdl_seq * _loop0_211_var; - void *_tmp_210_var; + asdl_seq * _loop0_217_var; + void *_tmp_216_var; Token * a; if ( - (_tmp_210_var = _tmp_210_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_216_var = _tmp_216_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && - (_loop0_211_var = _loop0_211_rule(p)) // lambda_param_maybe_default* + (_loop0_217_var = _loop0_217_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -25138,7 +25773,7 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); - asdl_seq * _loop0_212_var; + asdl_seq * _loop0_218_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -25146,7 +25781,7 @@ invalid_lambda_parameters_rule(Parser *p) if ( (_opt_var = lambda_slash_no_default_rule(p), !p->error_indicator) // lambda_slash_no_default? && - (_loop0_212_var = _loop0_212_rule(p)) // lambda_param_no_default* + (_loop0_218_var = _loop0_218_rule(p)) // lambda_param_no_default* && (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper && @@ -25172,18 +25807,18 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_214_var; - asdl_seq * _loop0_213_var; + asdl_seq * _gather_220_var; + asdl_seq * _loop0_219_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_213_var = _loop0_213_rule(p)) // lambda_param_no_default* + (_loop0_219_var = _loop0_219_rule(p)) // lambda_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_214_var = _gather_214_rule(p)) // ','.lambda_param+ + (_gather_220_var = _gather_220_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -25210,22 +25845,22 @@ invalid_lambda_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'")); Token * _literal; - asdl_seq * _loop0_217_var; - asdl_seq * _loop0_219_var; + asdl_seq * _loop0_223_var; + asdl_seq * _loop0_225_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_218_var; + void *_tmp_224_var; Token * a; if ( - (_opt_var = _tmp_216_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_222_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && - (_loop0_217_var = _loop0_217_rule(p)) // lambda_param_maybe_default* + (_loop0_223_var = _loop0_223_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_218_var = _tmp_218_rule(p)) // ',' | lambda_param_no_default + (_tmp_224_var = _tmp_224_rule(p)) // ',' | lambda_param_no_default && - (_loop0_219_var = _loop0_219_rule(p)) // lambda_param_maybe_default* + (_loop0_225_var = _loop0_225_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -25250,10 +25885,10 @@ invalid_lambda_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default+ '/' '*'")); Token * _literal; - asdl_seq * _loop1_220_var; + asdl_seq * _loop1_226_var; Token * a; if ( - (_loop1_220_var = _loop1_220_rule(p)) // lambda_param_maybe_default+ + (_loop1_226_var = _loop1_226_rule(p)) // lambda_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -25325,13 +25960,13 @@ invalid_lambda_parameters_helper_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default+")); - asdl_seq * _loop1_221_var; + asdl_seq * _loop1_227_var; if ( - (_loop1_221_var = _loop1_221_rule(p)) // lambda_param_with_default+ + (_loop1_227_var = _loop1_227_rule(p)) // lambda_param_with_default+ ) { D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default+")); - _res = _loop1_221_var; + _res = _loop1_227_var; goto done; } p->mark = _mark; @@ -25368,11 +26003,11 @@ invalid_lambda_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (':' | ',' (':' | '**'))")); Token * _literal; - void *_tmp_222_var; + void *_tmp_228_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_222_var = _tmp_222_rule(p)) // ':' | ',' (':' | '**') + (_tmp_228_var = _tmp_228_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (':' | ',' (':' | '**'))")); @@ -25425,20 +26060,20 @@ invalid_lambda_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); Token * _literal; - asdl_seq * _loop0_224_var; - void *_tmp_223_var; - void *_tmp_225_var; + asdl_seq * _loop0_230_var; + void *_tmp_229_var; + void *_tmp_231_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_223_var = _tmp_223_rule(p)) // lambda_param_no_default | ',' + (_tmp_229_var = _tmp_229_rule(p)) // lambda_param_no_default | ',' && - (_loop0_224_var = _loop0_224_rule(p)) // lambda_param_maybe_default* + (_loop0_230_var = _loop0_230_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_225_var = _tmp_225_rule(p)) // lambda_param_no_default | ',' + (_tmp_231_var = _tmp_231_rule(p)) // lambda_param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); @@ -25557,7 +26192,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_226_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_232_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -25661,11 +26296,11 @@ invalid_with_item_rule(Parser *p) if ( (expression_var = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (a = expression_rule(p)) // expression && - _PyPegen_lookahead(1, _tmp_227_rule, p) + _PyPegen_lookahead(1, _tmp_233_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression 'as' expression &(',' | ')' | ':')")); @@ -25712,9 +26347,9 @@ invalid_for_target_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings expr_ty a; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword = _PyPegen_expect_token(p, 716)) // token='for' && (a = star_expressions_rule(p)) // star_expressions ) @@ -25841,16 +26476,16 @@ invalid_import_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_import[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import' ','.dotted_name+ 'from' dotted_name")); - asdl_seq * _gather_228_var; + asdl_seq * _gather_234_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( - (a = _PyPegen_expect_token(p, 663)) // token='import' + (a = _PyPegen_expect_token(p, 667)) // token='import' && - (_gather_228_var = _gather_228_rule(p)) // ','.dotted_name+ + (_gather_234_var = _gather_234_rule(p)) // ','.dotted_name+ && - (_keyword = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword = _PyPegen_expect_token(p, 668)) // token='from' && (dotted_name_var = dotted_name_rule(p)) // dotted_name ) @@ -25946,17 +26581,17 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE")); - asdl_seq * _gather_230_var; + asdl_seq * _gather_236_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword = _PyPegen_expect_token(p, 679)) // token='with' && - (_gather_230_var = _gather_230_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_236_var = _gather_236_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -25980,7 +26615,7 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE")); - asdl_seq * _gather_232_var; + asdl_seq * _gather_238_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -25990,13 +26625,13 @@ invalid_with_stmt_rule(Parser *p) UNUSED(_opt_var_1); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword = _PyPegen_expect_token(p, 679)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_232_var = _gather_232_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_238_var = _gather_238_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -26046,18 +26681,18 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); - asdl_seq * _gather_234_var; + asdl_seq * _gather_240_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 675)) // token='with' + (a = _PyPegen_expect_token(p, 679)) // token='with' && - (_gather_234_var = _gather_234_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_240_var = _gather_240_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26085,7 +26720,7 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT")); - asdl_seq * _gather_236_var; + asdl_seq * _gather_242_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -26096,13 +26731,13 @@ invalid_with_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 675)) // token='with' + (a = _PyPegen_expect_token(p, 679)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_236_var = _gather_236_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_242_var = _gather_242_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -26162,7 +26797,7 @@ invalid_try_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 684)) // token='try' + (a = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26194,13 +26829,13 @@ invalid_try_stmt_rule(Parser *p) Token * _literal; asdl_stmt_seq* block_var; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, _tmp_238_rule, p) + _PyPegen_lookahead(0, _tmp_244_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block !('except' | 'finally')")); @@ -26225,29 +26860,29 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_239_var; - asdl_seq * _loop1_240_var; + asdl_seq * _loop0_245_var; + asdl_seq * _loop1_246_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_239_var = _loop0_239_rule(p)) // block* + (_loop0_245_var = _loop0_245_rule(p)) // block* && - (_loop1_240_var = _loop1_240_rule(p)) // except_block+ + (_loop1_246_var = _loop1_246_rule(p)) // except_block+ && - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (b = _PyPegen_expect_token(p, 16)) // token='*' && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_241_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_247_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -26274,23 +26909,23 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_242_var; - asdl_seq * _loop1_243_var; + asdl_seq * _loop0_248_var; + asdl_seq * _loop1_249_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_242_var = _loop0_242_rule(p)) // block* + (_loop0_248_var = _loop0_248_rule(p)) // block* && - (_loop1_243_var = _loop1_243_rule(p)) // except_star_block+ + (_loop1_249_var = _loop1_249_rule(p)) // except_star_block+ && - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && - (_opt_var = _tmp_244_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_250_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -26348,7 +26983,7 @@ invalid_except_stmt_rule(Parser *p) expr_ty a; expr_ty expressions_var; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='except' + (_keyword = _PyPegen_expect_token(p, 701)) // token='except' && (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? && @@ -26358,7 +26993,7 @@ invalid_except_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_opt_var_1 = _tmp_245_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var_1 = _tmp_251_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -26390,13 +27025,13 @@ invalid_except_stmt_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? && (expression_var = expression_rule(p)) // expression && - (_opt_var_1 = _tmp_246_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var_1 = _tmp_252_rule(p), !p->error_indicator) // ['as' NAME] && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -26423,7 +27058,7 @@ invalid_except_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -26448,14 +27083,14 @@ invalid_except_stmt_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*' (NEWLINE | ':')")); Token * _literal; - void *_tmp_247_var; + void *_tmp_253_var; Token * a; if ( - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_247_var = _tmp_247_rule(p)) // NEWLINE | ':' + (_tmp_253_var = _tmp_253_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*' (NEWLINE | ':')")); @@ -26501,7 +27136,7 @@ invalid_finally_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 693)) // token='finally' + (a = _PyPegen_expect_token(p, 697)) // token='finally' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26558,11 +27193,11 @@ invalid_except_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_248_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_254_rule(p), !p->error_indicator) // ['as' NAME] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26594,7 +27229,7 @@ invalid_except_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26651,13 +27286,13 @@ invalid_except_star_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 697)) // token='except' + (a = _PyPegen_expect_token(p, 701)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_249_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_255_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26893,7 +27528,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (a = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' ) @@ -26923,7 +27558,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p) && @@ -27026,7 +27661,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_250_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_256_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -27080,7 +27715,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -27111,7 +27746,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty a_1; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 702)) // token='if' + (a = _PyPegen_expect_token(p, 706)) // token='if' && (a_1 = named_expression_rule(p)) // named_expression && @@ -27167,7 +27802,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -27198,7 +27833,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 704)) // token='elif' + (a = _PyPegen_expect_token(p, 708)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -27252,7 +27887,7 @@ invalid_else_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 705)) // token='else' + (a = _PyPegen_expect_token(p, 709)) // token='else' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -27306,7 +27941,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='while' + (_keyword = _PyPegen_expect_token(p, 711)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -27337,7 +27972,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 707)) // token='while' + (a = _PyPegen_expect_token(p, 711)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -27397,13 +28032,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword = _PyPegen_expect_token(p, 716)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -27438,13 +28073,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 712)) // token='for' + (a = _PyPegen_expect_token(p, 716)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword = _PyPegen_expect_token(p, 717)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -27508,7 +28143,7 @@ invalid_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 714), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? && (a = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' && @@ -27520,7 +28155,7 @@ invalid_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (_opt_var_2 = _tmp_251_rule(p), !p->error_indicator) // ['->' expression] + (_opt_var_2 = _tmp_257_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -27548,11 +28183,9 @@ invalid_def_raw_rule(Parser *p) return _res; } -// invalid_class_def_raw: -// | 'class' NAME ['(' arguments? ')'] NEWLINE -// | 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT +// invalid_class_def_raw_nonewline: 'class' NAME ['(' arguments? ')'] NEWLINE static void * -invalid_class_def_raw_rule(Parser *p) +invalid_class_def_raw_nonewline_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -27569,23 +28202,23 @@ invalid_class_def_raw_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class' NAME ['(' arguments? ')'] NEWLINE")); + D(fprintf(stderr, "%*c> invalid_class_def_raw_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class' NAME ['(' arguments? ')'] NEWLINE")); Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty name_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='class' + (_keyword = _PyPegen_expect_token(p, 720)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && - (_opt_var = _tmp_252_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (_opt_var = _tmp_258_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class' NAME ['(' arguments? ')'] NEWLINE")); + D(fprintf(stderr, "%*c+ invalid_class_def_raw_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class' NAME ['(' arguments? ')'] NEWLINE")); _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -27595,9 +28228,50 @@ invalid_class_def_raw_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s invalid_class_def_raw_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class' NAME ['(' arguments? ')'] NEWLINE")); } + _res = NULL; + done: + p->level--; + return _res; +} + +// invalid_class_def_raw: +// | invalid_class_def_raw_nonewline +// | 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT +static void * +invalid_class_def_raw_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + if (p->call_invalid_rules) { // invalid_class_def_raw_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_class_def_raw_nonewline")); + void *invalid_class_def_raw_nonewline_var; + if ( + (invalid_class_def_raw_nonewline_var = invalid_class_def_raw_nonewline_rule(p)) // invalid_class_def_raw_nonewline + ) + { + D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_class_def_raw_nonewline")); + _res = invalid_class_def_raw_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_class_def_raw_nonewline")); + } { // 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT if (p->error_indicator) { p->level--; @@ -27611,11 +28285,11 @@ invalid_class_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 716)) // token='class' + (a = _PyPegen_expect_token(p, 720)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && - (_opt_var = _tmp_253_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (_opt_var = _tmp_259_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -27666,11 +28340,11 @@ invalid_double_starred_kvpairs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.double_starred_kvpair+ ',' invalid_kvpair")); - asdl_seq * _gather_254_var; + asdl_seq * _gather_260_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_254_var = _gather_254_rule(p)) // ','.double_starred_kvpair+ + (_gather_260_var = _gather_260_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -27678,7 +28352,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.double_starred_kvpair+ ',' invalid_kvpair")); - _res = _PyPegen_dummy_name(p, _gather_254_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_260_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -27731,7 +28405,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_256_rule, p) + _PyPegen_lookahead(1, _tmp_262_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ':' &('}' | ',')")); @@ -27842,7 +28516,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_257_rule, p) + _PyPegen_lookahead(1, _tmp_263_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ':' &('}' | ',')")); @@ -28060,7 +28734,7 @@ invalid_replacement_field_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - _PyPegen_lookahead(0, _tmp_258_rule, p) + _PyPegen_lookahead(0, _tmp_264_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' !(yield_expr | star_expressions)")); @@ -28083,13 +28757,13 @@ invalid_replacement_field_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) !('=' | '!' | ':' | '}')")); Token * _literal; - void *_tmp_259_var; + void *_tmp_265_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_259_var = _tmp_259_rule(p)) // yield_expr | star_expressions + (_tmp_265_var = _tmp_265_rule(p)) // yield_expr | star_expressions && - _PyPegen_lookahead(0, _tmp_260_rule, p) + _PyPegen_lookahead(0, _tmp_266_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) !('=' | '!' | ':' | '}')")); @@ -28113,15 +28787,15 @@ invalid_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) '=' !('!' | ':' | '}')")); Token * _literal; Token * _literal_1; - void *_tmp_261_var; + void *_tmp_267_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_261_var = _tmp_261_rule(p)) // yield_expr | star_expressions + (_tmp_267_var = _tmp_267_rule(p)) // yield_expr | star_expressions && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_262_rule, p) + _PyPegen_lookahead(0, _tmp_268_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) '=' !('!' | ':' | '}')")); @@ -28146,12 +28820,12 @@ invalid_replacement_field_rule(Parser *p) Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_263_var; + void *_tmp_269_var; void *invalid_conversion_character_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_263_var = _tmp_263_rule(p)) // yield_expr | star_expressions + (_tmp_269_var = _tmp_269_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && @@ -28159,7 +28833,7 @@ invalid_replacement_field_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) '='? invalid_conversion_character")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_263_var, _opt_var, invalid_conversion_character_var); + _res = _PyPegen_dummy_name(p, _literal, _tmp_269_var, _opt_var, invalid_conversion_character_var); goto done; } p->mark = _mark; @@ -28177,17 +28851,17 @@ invalid_replacement_field_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; UNUSED(_opt_var_1); // Silence compiler warnings - void *_tmp_264_var; + void *_tmp_270_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_264_var = _tmp_264_rule(p)) // yield_expr | star_expressions + (_tmp_270_var = _tmp_270_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_265_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_271_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_266_rule, p) + _PyPegen_lookahead(0, _tmp_272_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) '='? ['!' NAME] !(':' | '}')")); @@ -28211,24 +28885,24 @@ invalid_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{' (yield_expr | star_expressions) '='? ['!' NAME] ':' fstring_format_spec* !'}'")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_269_var; + asdl_seq * _loop0_275_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; UNUSED(_opt_var_1); // Silence compiler warnings - void *_tmp_267_var; + void *_tmp_273_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_267_var = _tmp_267_rule(p)) // yield_expr | star_expressions + (_tmp_273_var = _tmp_273_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_268_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_274_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_269_var = _loop0_269_rule(p)) // fstring_format_spec* + (_loop0_275_var = _loop0_275_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -28257,15 +28931,15 @@ invalid_replacement_field_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; UNUSED(_opt_var_1); // Silence compiler warnings - void *_tmp_270_var; + void *_tmp_276_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_270_var = _tmp_270_rule(p)) // yield_expr | star_expressions + (_tmp_276_var = _tmp_276_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_271_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_277_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -28313,7 +28987,7 @@ invalid_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_272_rule, p) + _PyPegen_lookahead(1, _tmp_278_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' &(':' | '}')")); @@ -28757,9 +29431,128 @@ _gather_5_rule(Parser *p) return _res; } -// _tmp_7: 'return' del_kw_stmt | return_stmt +// _loop0_8: ';' simple_stmt +static asdl_seq * +_loop0_8_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + 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; + { // ';' simple_stmt + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_8[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + Token * _literal; + stmt_ty elem; + while ( + (_literal = _PyPegen_expect_token(p, 13)) // token=';' + && + (elem = simple_stmt_rule(p)) // simple_stmt + ) + { + _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_8[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + } + 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 (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_7: simple_stmt _loop0_8 +static asdl_seq * +_gather_7_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // simple_stmt _loop0_8 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_7[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_8")); + stmt_ty elem; + asdl_seq * seq; + if ( + (elem = simple_stmt_rule(p)) // simple_stmt + && + (seq = _loop0_8_rule(p)) // _loop0_8 + ) + { + D(fprintf(stderr, "%*c+ _gather_7[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_8")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_7[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_8")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_9: 'return' del_kw_stmt | return_stmt static void * -_tmp_7_rule(Parser *p) +_tmp_9_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -28785,7 +29578,7 @@ _tmp_7_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_7[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); + D(fprintf(stderr, "%*c> _tmp_9[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); Token * _keyword; stmt_ty del_kw_stmt_var; if ( @@ -28794,7 +29587,7 @@ _tmp_7_rule(Parser *p) (del_kw_stmt_var = del_kw_stmt_rule(p)) // del_kw_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_7[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); + D(fprintf(stderr, "%*c+ _tmp_9[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -28813,7 +29606,7 @@ _tmp_7_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_7[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); } { // return_stmt @@ -28821,18 +29614,18 @@ _tmp_7_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_7[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); + D(fprintf(stderr, "%*c> _tmp_9[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); stmt_ty return_stmt_var; if ( (return_stmt_var = return_stmt_rule(p)) // return_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_7[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); + D(fprintf(stderr, "%*c+ _tmp_9[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); _res = return_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_7[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "return_stmt")); } _res = NULL; @@ -28841,9 +29634,9 @@ _tmp_7_rule(Parser *p) return _res; } -// _tmp_8: 'import' | 'from' +// _tmp_10: 'import' | 'from' static void * -_tmp_8_rule(Parser *p) +_tmp_10_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -28860,18 +29653,18 @@ _tmp_8_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_8[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='import' + (_keyword = _PyPegen_expect_token(p, 667)) // token='import' ) { - D(fprintf(stderr, "%*c+ _tmp_8[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_8[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'import'")); } { // 'from' @@ -28879,18 +29672,18 @@ _tmp_8_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_8[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword = _PyPegen_expect_token(p, 668)) // token='from' ) { - D(fprintf(stderr, "%*c+ _tmp_8[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_8[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'from'")); } _res = NULL; @@ -28899,9 +29692,9 @@ _tmp_8_rule(Parser *p) return _res; } -// _tmp_9: del_kw_stmt | del_stmt +// _tmp_11: del_kw_stmt | del_stmt static void * -_tmp_9_rule(Parser *p) +_tmp_11_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -28918,18 +29711,18 @@ _tmp_9_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_9[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); + D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); stmt_ty del_kw_stmt_var; if ( (del_kw_stmt_var = del_kw_stmt_rule(p)) // del_kw_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_9[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); + D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); _res = del_kw_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_kw_stmt")); } { // del_stmt @@ -28937,18 +29730,18 @@ _tmp_9_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_9[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); + D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); stmt_ty del_stmt_var; if ( (del_stmt_var = del_stmt_rule(p)) // del_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_9[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); + D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); _res = del_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_stmt")); } _res = NULL; @@ -28957,9 +29750,9 @@ _tmp_9_rule(Parser *p) return _res; } -// _tmp_10: "def" | '@' | 'async' +// _tmp_12: "def" | '@' | 'async' static void * -_tmp_10_rule(Parser *p) +_tmp_12_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -28976,18 +29769,18 @@ _tmp_10_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); expr_ty _keyword; if ( (_keyword = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' ) { - D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c+ _tmp_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_12[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"def\"")); } { // '@' @@ -28995,18 +29788,18 @@ _tmp_10_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_12[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } { // 'async' @@ -29014,18 +29807,18 @@ _tmp_10_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_12[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -29034,9 +29827,9 @@ _tmp_10_rule(Parser *p) return _res; } -// _tmp_11: 'class' | '@' +// _tmp_13: 'class' | '@' static void * -_tmp_11_rule(Parser *p) +_tmp_13_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29053,18 +29846,18 @@ _tmp_11_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c> _tmp_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='class' + (_keyword = _PyPegen_expect_token(p, 720)) // token='class' ) { - D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c+ _tmp_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_13[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); } { // '@' @@ -29072,18 +29865,18 @@ _tmp_11_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c> _tmp_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_13[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } _res = NULL; @@ -29092,9 +29885,9 @@ _tmp_11_rule(Parser *p) return _res; } -// _tmp_12: 'with' | 'async' +// _tmp_14: 'with' | 'async' static void * -_tmp_12_rule(Parser *p) +_tmp_14_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29111,18 +29904,18 @@ _tmp_12_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c> _tmp_14[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword = _PyPegen_expect_token(p, 679)) // token='with' ) { - D(fprintf(stderr, "%*c+ _tmp_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c+ _tmp_14[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_12[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_14[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with'")); } { // 'async' @@ -29130,18 +29923,18 @@ _tmp_12_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_14[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_14[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_12[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_14[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -29150,9 +29943,9 @@ _tmp_12_rule(Parser *p) return _res; } -// _tmp_13: 'for' | 'async' +// _tmp_15: 'for' | 'async' static void * -_tmp_13_rule(Parser *p) +_tmp_15_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29169,18 +29962,18 @@ _tmp_13_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword = _PyPegen_expect_token(p, 716)) // token='for' ) { - D(fprintf(stderr, "%*c+ _tmp_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_13[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_15[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'for'")); } { // 'async' @@ -29188,18 +29981,18 @@ _tmp_13_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_13[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_15[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -29208,9 +30001,9 @@ _tmp_13_rule(Parser *p) return _res; } -// _tmp_14: '=' annotated_rhs +// _tmp_16: '=' annotated_rhs static void * -_tmp_14_rule(Parser *p) +_tmp_16_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29227,7 +30020,7 @@ _tmp_14_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_14[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c> _tmp_16[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); Token * _literal; expr_ty d; if ( @@ -29236,7 +30029,7 @@ _tmp_14_rule(Parser *p) (d = annotated_rhs_rule(p)) // annotated_rhs ) { - D(fprintf(stderr, "%*c+ _tmp_14[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c+ _tmp_16[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29246,7 +30039,7 @@ _tmp_14_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_14[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_16[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); } _res = NULL; @@ -29255,9 +30048,9 @@ _tmp_14_rule(Parser *p) return _res; } -// _tmp_15: '(' single_target ')' | single_subscript_attribute_target +// _tmp_17: '(' single_target ')' | single_subscript_attribute_target static void * -_tmp_15_rule(Parser *p) +_tmp_17_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29274,7 +30067,7 @@ _tmp_15_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); + D(fprintf(stderr, "%*c> _tmp_17[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); Token * _literal; Token * _literal_1; expr_ty b; @@ -29286,7 +30079,7 @@ _tmp_15_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); + D(fprintf(stderr, "%*c+ _tmp_17[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); _res = b; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29296,7 +30089,7 @@ _tmp_15_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_15[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_17[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); } { // single_subscript_attribute_target @@ -29304,18 +30097,18 @@ _tmp_15_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); + D(fprintf(stderr, "%*c> _tmp_17[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); expr_ty single_subscript_attribute_target_var; if ( (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target ) { - D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); + D(fprintf(stderr, "%*c+ _tmp_17[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); _res = single_subscript_attribute_target_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_15[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_17[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); } _res = NULL; @@ -29324,9 +30117,9 @@ _tmp_15_rule(Parser *p) return _res; } -// _tmp_16: '=' annotated_rhs +// _tmp_18: '=' annotated_rhs static void * -_tmp_16_rule(Parser *p) +_tmp_18_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29343,7 +30136,7 @@ _tmp_16_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_16[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c> _tmp_18[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); Token * _literal; expr_ty d; if ( @@ -29352,7 +30145,7 @@ _tmp_16_rule(Parser *p) (d = annotated_rhs_rule(p)) // annotated_rhs ) { - D(fprintf(stderr, "%*c+ _tmp_16[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c+ _tmp_18[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29362,7 +30155,7 @@ _tmp_16_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_16[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_18[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); } _res = NULL; @@ -29371,9 +30164,9 @@ _tmp_16_rule(Parser *p) return _res; } -// _loop1_17: (star_targets '=') +// _loop1_19: (star_targets '=') static asdl_seq * -_loop1_17_rule(Parser *p) +_loop1_19_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29399,13 +30192,13 @@ _loop1_17_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_17[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); - void *_tmp_273_var; + D(fprintf(stderr, "%*c> _loop1_19[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_279_var; while ( - (_tmp_273_var = _tmp_273_rule(p)) // star_targets '=' + (_tmp_279_var = _tmp_279_rule(p)) // star_targets '=' ) { - _res = _tmp_273_var; + _res = _tmp_279_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -29422,7 +30215,7 @@ _loop1_17_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_17[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_19[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(star_targets '=')")); } if (_n == 0 || p->error_indicator) { @@ -29444,9 +30237,9 @@ _loop1_17_rule(Parser *p) return _seq; } -// _tmp_18: yield_expr | star_expressions +// _tmp_20: yield_expr | star_expressions static void * -_tmp_18_rule(Parser *p) +_tmp_20_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29463,18 +30256,18 @@ _tmp_18_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_18[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_20[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_18[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_20[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_18[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_20[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -29482,18 +30275,18 @@ _tmp_18_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_18[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_20[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_18[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_20[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_18[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_20[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -29502,9 +30295,9 @@ _tmp_18_rule(Parser *p) return _res; } -// _tmp_19: '|>=' +// _tmp_21: '|>=' static void * -_tmp_19_rule(Parser *p) +_tmp_21_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29521,13 +30314,13 @@ _tmp_19_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_19[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); + D(fprintf(stderr, "%*c> _tmp_21[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); Token * t; if ( (t = _PyPegen_expect_token(p, 57)) // token='|>=' ) { - D(fprintf(stderr, "%*c+ _tmp_19[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); + D(fprintf(stderr, "%*c+ _tmp_21[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); _res = ( ++ p -> subn , t ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29537,7 +30330,7 @@ _tmp_19_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_19[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_21[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|>='")); } _res = NULL; @@ -29546,9 +30339,9 @@ _tmp_19_rule(Parser *p) return _res; } -// _tmp_20: [yield_expr | star_expressions] +// _tmp_22: [yield_expr | star_expressions] static void * -_tmp_20_rule(Parser *p) +_tmp_22_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29565,13 +30358,13 @@ _tmp_20_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_20[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); + D(fprintf(stderr, "%*c> _tmp_22[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); void *d; if ( - (d = _tmp_274_rule(p), !p->error_indicator) // [yield_expr | star_expressions] + (d = _tmp_280_rule(p), !p->error_indicator) // [yield_expr | star_expressions] ) { - D(fprintf(stderr, "%*c+ _tmp_20[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); + D(fprintf(stderr, "%*c+ _tmp_22[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); _res = ( - - p -> subn , d ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29581,7 +30374,7 @@ _tmp_20_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_20[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_22[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); } _res = NULL; @@ -29590,9 +30383,9 @@ _tmp_20_rule(Parser *p) return _res; } -// _tmp_21: ';' | NEWLINE +// _tmp_23: ';' | NEWLINE static void * -_tmp_21_rule(Parser *p) +_tmp_23_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29609,18 +30402,18 @@ _tmp_21_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_21[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 13)) // token=';' ) { - D(fprintf(stderr, "%*c+ _tmp_21[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c+ _tmp_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_21[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_23[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'")); } { // NEWLINE @@ -29628,18 +30421,18 @@ _tmp_21_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_21[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_21[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_21[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_23[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE")); } _res = NULL; @@ -29648,9 +30441,9 @@ _tmp_21_rule(Parser *p) return _res; } -// _tmp_22: yield_expr | star_expressions +// _tmp_24: yield_expr | star_expressions static void * -_tmp_22_rule(Parser *p) +_tmp_24_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29667,18 +30460,18 @@ _tmp_22_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_22[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_22[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_22[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_24[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -29686,18 +30479,18 @@ _tmp_22_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_22[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_22[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_22[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_24[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -29706,9 +30499,9 @@ _tmp_22_rule(Parser *p) return _res; } -// _tmp_23: '+=' | '+' '=' +// _tmp_25: '+=' | '+' '=' static void * -_tmp_23_rule(Parser *p) +_tmp_25_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29725,18 +30518,18 @@ _tmp_23_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); + D(fprintf(stderr, "%*c> _tmp_25[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 36)) // token='+=' ) { - D(fprintf(stderr, "%*c+ _tmp_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); + D(fprintf(stderr, "%*c+ _tmp_25[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_23[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+='")); } { // '+' '=' @@ -29744,7 +30537,7 @@ _tmp_23_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); + D(fprintf(stderr, "%*c> _tmp_25[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); Token * _literal; Token * _literal_1; if ( @@ -29753,12 +30546,12 @@ _tmp_23_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); + D(fprintf(stderr, "%*c+ _tmp_25[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); _res = _PyPegen_dummy_name(p, _literal, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_23[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+' '='")); } _res = NULL; @@ -29767,9 +30560,9 @@ _tmp_23_rule(Parser *p) return _res; } -// _tmp_24: '-=' | '-' '=' +// _tmp_26: '-=' | '-' '=' static void * -_tmp_24_rule(Parser *p) +_tmp_26_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29786,18 +30579,18 @@ _tmp_24_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); + D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 37)) // token='-=' ) { - D(fprintf(stderr, "%*c+ _tmp_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); + D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_24[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-='")); } { // '-' '=' @@ -29805,7 +30598,7 @@ _tmp_24_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); + D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); Token * _literal; Token * _literal_1; if ( @@ -29814,12 +30607,12 @@ _tmp_24_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); + D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); _res = _PyPegen_dummy_name(p, _literal, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_24[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-' '='")); } _res = NULL; @@ -29828,9 +30621,9 @@ _tmp_24_rule(Parser *p) return _res; } -// _tmp_25: '!=' | '!' '=' +// _tmp_27: '!=' | '!' '=' static void * -_tmp_25_rule(Parser *p) +_tmp_27_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29847,18 +30640,18 @@ _tmp_25_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_25[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c> _tmp_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 28)) // token='!=' ) { - D(fprintf(stderr, "%*c+ _tmp_25[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c+ _tmp_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_27[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!='")); } { // '!' '=' @@ -29866,7 +30659,7 @@ _tmp_25_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_25[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); + D(fprintf(stderr, "%*c> _tmp_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); Token * _literal; Token * _literal_1; if ( @@ -29875,12 +30668,12 @@ _tmp_25_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_25[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); + D(fprintf(stderr, "%*c+ _tmp_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); _res = _PyPegen_dummy_name(p, _literal, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_27[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!' '='")); } _res = NULL; @@ -29889,9 +30682,9 @@ _tmp_25_rule(Parser *p) return _res; } -// _tmp_26: 'from' expression +// _tmp_28: 'from' expression static void * -_tmp_26_rule(Parser *p) +_tmp_28_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29908,16 +30701,16 @@ _tmp_26_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); + D(fprintf(stderr, "%*c> _tmp_28[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword = _PyPegen_expect_token(p, 668)) // token='from' && (z = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); + D(fprintf(stderr, "%*c+ _tmp_28[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -29927,7 +30720,7 @@ _tmp_26_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_28[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'from' expression")); } _res = NULL; @@ -29936,9 +30729,9 @@ _tmp_26_rule(Parser *p) return _res; } -// _loop0_28: ',' NAME +// _loop0_30: ',' NAME static asdl_seq * -_loop0_28_rule(Parser *p) +_loop0_30_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -29964,7 +30757,7 @@ _loop0_28_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_28[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c> _loop0_30[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); Token * _literal; expr_ty elem; while ( @@ -29996,7 +30789,7 @@ _loop0_28_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_28[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_30[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -30013,9 +30806,9 @@ _loop0_28_rule(Parser *p) return _seq; } -// _gather_27: NAME _loop0_28 +// _gather_29: NAME _loop0_30 static asdl_seq * -_gather_27_rule(Parser *p) +_gather_29_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -30027,27 +30820,27 @@ _gather_27_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_28 + { // NAME _loop0_30 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_28")); + D(fprintf(stderr, "%*c> _gather_29[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_28_rule(p)) // _loop0_28 + (seq = _loop0_30_rule(p)) // _loop0_30 ) { - D(fprintf(stderr, "%*c+ _gather_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_28")); + D(fprintf(stderr, "%*c+ _gather_29[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_27[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_28")); + D(fprintf(stderr, "%*c%s _gather_29[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); } _res = NULL; done: @@ -30055,9 +30848,9 @@ _gather_27_rule(Parser *p) return _res; } -// _loop0_30: ',' NAME +// _loop0_32: ',' NAME static asdl_seq * -_loop0_30_rule(Parser *p) +_loop0_32_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -30083,7 +30876,7 @@ _loop0_30_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_30[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c> _loop0_32[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); Token * _literal; expr_ty elem; while ( @@ -30115,7 +30908,7 @@ _loop0_30_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_30[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_32[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -30132,9 +30925,9 @@ _loop0_30_rule(Parser *p) return _seq; } -// _gather_29: NAME _loop0_30 +// _gather_31: NAME _loop0_32 static asdl_seq * -_gather_29_rule(Parser *p) +_gather_31_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -30146,27 +30939,27 @@ _gather_29_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_30 + { // NAME _loop0_32 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_29[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); + D(fprintf(stderr, "%*c> _gather_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_32")); expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_30_rule(p)) // _loop0_30 + (seq = _loop0_32_rule(p)) // _loop0_32 ) { - D(fprintf(stderr, "%*c+ _gather_29[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); + D(fprintf(stderr, "%*c+ _gather_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_32")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_29[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); + D(fprintf(stderr, "%*c%s _gather_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_32")); } _res = NULL; done: @@ -30174,7 +30967,7 @@ _gather_29_rule(Parser *p) return _res; } -// _tmp_31: +// _tmp_33: // | 'False' // | 'None' // | 'True' @@ -30211,7 +31004,7 @@ _gather_29_rule(Parser *p) // | 'with' // | 'yield' static void * -_tmp_31_rule(Parser *p) +_tmp_33_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -30228,18 +31021,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'False'")); } { // 'None' @@ -30247,18 +31040,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } { // 'True' @@ -30266,18 +31059,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'True'")); } { // 'and' @@ -30285,18 +31078,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='and' + (_keyword = _PyPegen_expect_token(p, 624)) // token='and' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'and'")); } { // 'as' @@ -30304,18 +31097,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as'")); } { // 'assert' @@ -30323,18 +31116,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 566)) // token='assert' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'assert'")); } { // 'async' @@ -30342,18 +31135,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 714)) // token='async' + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } { // 'await' @@ -30361,18 +31154,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 635)) // token='await' + (_keyword = _PyPegen_expect_token(p, 637)) // token='await' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'await'")); } { // 'break' @@ -30380,18 +31173,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 538)) // token='break' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'break'")); } { // 'class' @@ -30399,18 +31192,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='class' + (_keyword = _PyPegen_expect_token(p, 720)) // token='class' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); } { // 'continue' @@ -30418,18 +31211,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 540)) // token='continue' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'continue'")); } { // 'del' @@ -30437,18 +31230,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 659)) // token='del' + (_keyword = _PyPegen_expect_token(p, 663)) // token='del' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'del'")); } { // 'elif' @@ -30456,18 +31249,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'elif'")); } { // 'else' @@ -30475,18 +31268,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 705)) // token='else' + (_keyword = _PyPegen_expect_token(p, 709)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'else'")); } { // 'except' @@ -30494,18 +31287,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='except' + (_keyword = _PyPegen_expect_token(p, 701)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except'")); } { // 'finally' @@ -30513,18 +31306,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 693)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 697)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'finally'")); } { // 'for' @@ -30532,18 +31325,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 712)) // token='for' + (_keyword = _PyPegen_expect_token(p, 716)) // token='for' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'for'")); } { // 'from' @@ -30551,18 +31344,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 664)) // token='from' + (_keyword = _PyPegen_expect_token(p, 668)) // token='from' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'from'")); } { // 'global' @@ -30570,18 +31363,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 548)) // token='global' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'global'")); } { // 'goto' @@ -30589,18 +31382,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 567)) // token='goto' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'goto'")); } { // 'if' @@ -30608,18 +31401,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if'")); } { // 'import' @@ -30627,18 +31420,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='import' + (_keyword = _PyPegen_expect_token(p, 667)) // token='import' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'import'")); } { // 'in' @@ -30646,18 +31439,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 713)) // token='in' + (_keyword = _PyPegen_expect_token(p, 717)) // token='in' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'in'")); } { // 'is' @@ -30665,18 +31458,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='is' + (_keyword = _PyPegen_expect_token(p, 636)) // token='is' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'is'")); } { // 'lambda' @@ -30684,18 +31477,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 655)) // token='lambda' + (_keyword = _PyPegen_expect_token(p, 659)) // token='lambda' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'lambda'")); } { // 'nonlocal' @@ -30703,18 +31496,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 555)) // token='nonlocal' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'nonlocal'")); } { // 'not' @@ -30722,18 +31515,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 633)) // token='not' + (_keyword = _PyPegen_expect_token(p, 635)) // token='not' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'not'")); } { // 'or' @@ -30741,18 +31534,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='or' + (_keyword = _PyPegen_expect_token(p, 623)) // token='or' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'or'")); } { // 'pass' @@ -30760,18 +31553,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 558)) // token='pass' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'pass'")); } { // 'raise' @@ -30779,18 +31572,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 559)) // token='raise' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'raise'")); } { // 'return' @@ -30798,18 +31591,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 560)) // token='return' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'return'")); } { // 'try' @@ -30817,18 +31610,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 684)) // token='try' + (_keyword = _PyPegen_expect_token(p, 688)) // token='try' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try'")); } { // 'while' @@ -30836,18 +31629,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='while' + (_keyword = _PyPegen_expect_token(p, 711)) // token='while' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'while'")); } { // 'with' @@ -30855,18 +31648,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 675)) // token='with' + (_keyword = _PyPegen_expect_token(p, 679)) // token='with' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with'")); } { // 'yield' @@ -30874,18 +31667,18 @@ _tmp_31_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); + D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 620)) // token='yield' + (_keyword = _PyPegen_expect_token(p, 622)) // token='yield' ) { - D(fprintf(stderr, "%*c+ _tmp_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); + D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_31[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'yield'")); } _res = NULL; @@ -30894,9 +31687,9 @@ _tmp_31_rule(Parser *p) return _res; } -// _tmp_32: ';' | NEWLINE +// _tmp_34: ';' | NEWLINE static void * -_tmp_32_rule(Parser *p) +_tmp_34_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -30913,18 +31706,18 @@ _tmp_32_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_32[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 13)) // token=';' ) { - D(fprintf(stderr, "%*c+ _tmp_32[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_32[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'")); } { // NEWLINE @@ -30932,18 +31725,18 @@ _tmp_32_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_32[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_32[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_32[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE")); } _res = NULL; @@ -30952,9 +31745,9 @@ _tmp_32_rule(Parser *p) return _res; } -// _tmp_33: ',' expression +// _tmp_35: ',' expression static void * -_tmp_33_rule(Parser *p) +_tmp_35_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -30971,7 +31764,7 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _tmp_35[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty z; if ( @@ -30980,7 +31773,7 @@ _tmp_33_rule(Parser *p) (z = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c+ _tmp_35[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -30990,7 +31783,7 @@ _tmp_33_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_35[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } _res = NULL; @@ -30999,9 +31792,9 @@ _tmp_33_rule(Parser *p) return _res; } -// _loop0_35: ',' NAME +// _loop0_37: ',' NAME static asdl_seq * -_loop0_35_rule(Parser *p) +_loop0_37_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31027,7 +31820,7 @@ _loop0_35_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_35[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c> _loop0_37[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); Token * _literal; expr_ty elem; while ( @@ -31059,7 +31852,7 @@ _loop0_35_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_35[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_37[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31076,9 +31869,9 @@ _loop0_35_rule(Parser *p) return _seq; } -// _gather_34: NAME _loop0_35 +// _gather_36: NAME _loop0_37 static asdl_seq * -_gather_34_rule(Parser *p) +_gather_36_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31090,27 +31883,27 @@ _gather_34_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_35 + { // NAME _loop0_37 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_35")); + D(fprintf(stderr, "%*c> _gather_36[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_37")); expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_35_rule(p)) // _loop0_35 + (seq = _loop0_37_rule(p)) // _loop0_37 ) { - D(fprintf(stderr, "%*c+ _gather_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_35")); + D(fprintf(stderr, "%*c+ _gather_36[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_37")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_34[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_35")); + D(fprintf(stderr, "%*c%s _gather_36[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_37")); } _res = NULL; done: @@ -31118,9 +31911,9 @@ _gather_34_rule(Parser *p) return _res; } -// _loop0_36: ('.' | '...') +// _loop0_38: ('.' | '...') static asdl_seq * -_loop0_36_rule(Parser *p) +_loop0_38_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31146,13 +31939,13 @@ _loop0_36_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_36[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); - void *_tmp_275_var; + D(fprintf(stderr, "%*c> _loop0_38[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); + void *_tmp_281_var; while ( - (_tmp_275_var = _tmp_275_rule(p)) // '.' | '...' + (_tmp_281_var = _tmp_281_rule(p)) // '.' | '...' ) { - _res = _tmp_275_var; + _res = _tmp_281_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31169,7 +31962,7 @@ _loop0_36_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_36[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_38[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('.' | '...')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31186,9 +31979,9 @@ _loop0_36_rule(Parser *p) return _seq; } -// _loop1_37: ('.' | '...') +// _loop1_39: ('.' | '...') static asdl_seq * -_loop1_37_rule(Parser *p) +_loop1_39_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31214,13 +32007,13 @@ _loop1_37_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_37[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); - void *_tmp_276_var; + D(fprintf(stderr, "%*c> _loop1_39[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); + void *_tmp_282_var; while ( - (_tmp_276_var = _tmp_276_rule(p)) // '.' | '...' + (_tmp_282_var = _tmp_282_rule(p)) // '.' | '...' ) { - _res = _tmp_276_var; + _res = _tmp_282_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31237,7 +32030,7 @@ _loop1_37_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_37[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_39[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('.' | '...')")); } if (_n == 0 || p->error_indicator) { @@ -31259,9 +32052,9 @@ _loop1_37_rule(Parser *p) return _seq; } -// _loop0_39: ',' import_from_as_name +// _loop0_41: ',' import_from_as_name static asdl_seq * -_loop0_39_rule(Parser *p) +_loop0_41_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31287,7 +32080,7 @@ _loop0_39_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_39[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); + D(fprintf(stderr, "%*c> _loop0_41[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); Token * _literal; alias_ty elem; while ( @@ -31319,7 +32112,7 @@ _loop0_39_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_39[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_41[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31336,9 +32129,9 @@ _loop0_39_rule(Parser *p) return _seq; } -// _gather_38: import_from_as_name _loop0_39 +// _gather_40: import_from_as_name _loop0_41 static asdl_seq * -_gather_38_rule(Parser *p) +_gather_40_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31350,27 +32143,27 @@ _gather_38_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // import_from_as_name _loop0_39 + { // import_from_as_name _loop0_41 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_38[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_39")); + D(fprintf(stderr, "%*c> _gather_40[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_41")); alias_ty elem; asdl_seq * seq; if ( (elem = import_from_as_name_rule(p)) // import_from_as_name && - (seq = _loop0_39_rule(p)) // _loop0_39 + (seq = _loop0_41_rule(p)) // _loop0_41 ) { - D(fprintf(stderr, "%*c+ _gather_38[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_39")); + D(fprintf(stderr, "%*c+ _gather_40[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_41")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_38[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_39")); + D(fprintf(stderr, "%*c%s _gather_40[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_41")); } _res = NULL; done: @@ -31378,9 +32171,9 @@ _gather_38_rule(Parser *p) return _res; } -// _tmp_40: 'as' NAME +// _tmp_42: 'as' NAME static void * -_tmp_40_rule(Parser *p) +_tmp_42_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31397,16 +32190,16 @@ _tmp_40_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_40[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_42[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_40[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_42[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31416,7 +32209,7 @@ _tmp_40_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_40[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_42[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -31425,9 +32218,9 @@ _tmp_40_rule(Parser *p) return _res; } -// _loop0_42: ',' dotted_as_name +// _loop0_44: ',' dotted_as_name static asdl_seq * -_loop0_42_rule(Parser *p) +_loop0_44_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31453,7 +32246,7 @@ _loop0_42_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_42[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); + D(fprintf(stderr, "%*c> _loop0_44[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); Token * _literal; alias_ty elem; while ( @@ -31485,7 +32278,7 @@ _loop0_42_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_42[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_44[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31502,9 +32295,9 @@ _loop0_42_rule(Parser *p) return _seq; } -// _gather_41: dotted_as_name _loop0_42 +// _gather_43: dotted_as_name _loop0_44 static asdl_seq * -_gather_41_rule(Parser *p) +_gather_43_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31516,27 +32309,27 @@ _gather_41_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_as_name _loop0_42 + { // dotted_as_name _loop0_44 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_41[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_42")); + D(fprintf(stderr, "%*c> _gather_43[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_44")); alias_ty elem; asdl_seq * seq; if ( (elem = dotted_as_name_rule(p)) // dotted_as_name && - (seq = _loop0_42_rule(p)) // _loop0_42 + (seq = _loop0_44_rule(p)) // _loop0_44 ) { - D(fprintf(stderr, "%*c+ _gather_41[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_42")); + D(fprintf(stderr, "%*c+ _gather_43[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_44")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_41[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_42")); + D(fprintf(stderr, "%*c%s _gather_43[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_44")); } _res = NULL; done: @@ -31544,9 +32337,9 @@ _gather_41_rule(Parser *p) return _res; } -// _tmp_43: 'as' NAME +// _tmp_45: 'as' NAME static void * -_tmp_43_rule(Parser *p) +_tmp_45_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31563,16 +32356,16 @@ _tmp_43_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_43[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_45[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_43[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_45[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31582,7 +32375,7 @@ _tmp_43_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_43[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_45[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -31591,9 +32384,9 @@ _tmp_43_rule(Parser *p) return _res; } -// _loop1_44: ('@' named_expression NEWLINE) +// _loop1_46: ('@' named_expression NEWLINE) static asdl_seq * -_loop1_44_rule(Parser *p) +_loop1_46_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31619,13 +32412,13 @@ _loop1_44_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_44[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('@' named_expression NEWLINE)")); - void *_tmp_277_var; + D(fprintf(stderr, "%*c> _loop1_46[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('@' named_expression NEWLINE)")); + void *_tmp_283_var; while ( - (_tmp_277_var = _tmp_277_rule(p)) // '@' named_expression NEWLINE + (_tmp_283_var = _tmp_283_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_277_var; + _res = _tmp_283_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31642,7 +32435,7 @@ _loop1_44_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_44[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_46[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('@' named_expression NEWLINE)")); } if (_n == 0 || p->error_indicator) { @@ -31664,9 +32457,9 @@ _loop1_44_rule(Parser *p) return _seq; } -// _tmp_45: '(' arguments? ')' +// _tmp_47: '(' arguments? ')' static void * -_tmp_45_rule(Parser *p) +_tmp_47_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31683,7 +32476,7 @@ _tmp_45_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_45[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_47[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *z; @@ -31695,7 +32488,7 @@ _tmp_45_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_45[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_47[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31705,7 +32498,7 @@ _tmp_45_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_45[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_47[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); } _res = NULL; @@ -31714,9 +32507,59 @@ _tmp_45_rule(Parser *p) return _res; } -// _tmp_46: '->' expression +// _tmp_48: '(' arguments? ')' static void * -_tmp_46_rule(Parser *p) +_tmp_48_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '(' arguments? ')' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_48[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + Token * _literal; + Token * _literal_1; + void *z; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (z = arguments_rule(p), !p->error_indicator) // arguments? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + D(fprintf(stderr, "%*c+ _tmp_48[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + _res = 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_48[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_49: '->' expression +static void * +_tmp_49_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31733,7 +32576,7 @@ _tmp_46_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_46[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c> _tmp_49[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); Token * _literal; expr_ty z; if ( @@ -31742,7 +32585,7 @@ _tmp_46_rule(Parser *p) (z = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_46[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c+ _tmp_49[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31752,7 +32595,7 @@ _tmp_46_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_46[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_49[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); } _res = NULL; @@ -31761,9 +32604,9 @@ _tmp_46_rule(Parser *p) return _res; } -// _tmp_47: '->' expression +// _tmp_50: '->' expression static void * -_tmp_47_rule(Parser *p) +_tmp_50_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31780,7 +32623,7 @@ _tmp_47_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_47[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c> _tmp_50[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); Token * _literal; expr_ty z; if ( @@ -31789,7 +32632,7 @@ _tmp_47_rule(Parser *p) (z = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_47[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c+ _tmp_50[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31799,7 +32642,7 @@ _tmp_47_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_47[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_50[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); } _res = NULL; @@ -31808,9 +32651,103 @@ _tmp_47_rule(Parser *p) return _res; } -// _loop0_48: param_no_default +// _tmp_51: '->' expression +static void * +_tmp_51_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '->' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_51[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + Token * _literal; + expr_ty z; + if ( + (_literal = _PyPegen_expect_token(p, 51)) // token='->' + && + (z = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_51[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + _res = 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_51[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_52: '->' expression +static void * +_tmp_52_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '->' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_52[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + Token * _literal; + expr_ty z; + if ( + (_literal = _PyPegen_expect_token(p, 51)) // token='->' + && + (z = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_52[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + _res = 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_52[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_53: param_no_default static asdl_seq * -_loop0_48_rule(Parser *p) +_loop0_53_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31836,7 +32773,7 @@ _loop0_48_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_48[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_53[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -31859,7 +32796,7 @@ _loop0_48_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_48[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_53[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31876,9 +32813,9 @@ _loop0_48_rule(Parser *p) return _seq; } -// _loop0_49: param_with_default +// _loop0_54: param_with_default static asdl_seq * -_loop0_49_rule(Parser *p) +_loop0_54_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31904,7 +32841,7 @@ _loop0_49_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_49[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop0_54[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -31927,7 +32864,7 @@ _loop0_49_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_49[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_54[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31944,9 +32881,9 @@ _loop0_49_rule(Parser *p) return _seq; } -// _loop0_50: param_with_default +// _loop0_55: param_with_default static asdl_seq * -_loop0_50_rule(Parser *p) +_loop0_55_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31972,7 +32909,7 @@ _loop0_50_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_50[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop0_55[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -31995,7 +32932,7 @@ _loop0_50_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_50[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_55[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32012,9 +32949,9 @@ _loop0_50_rule(Parser *p) return _seq; } -// _loop1_51: param_no_default +// _loop1_56: param_no_default static asdl_seq * -_loop1_51_rule(Parser *p) +_loop1_56_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32040,7 +32977,7 @@ _loop1_51_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_51[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_56[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -32063,7 +33000,7 @@ _loop1_51_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_51[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_56[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -32085,9 +33022,9 @@ _loop1_51_rule(Parser *p) return _seq; } -// _loop0_52: param_with_default +// _loop0_57: param_with_default static asdl_seq * -_loop0_52_rule(Parser *p) +_loop0_57_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32113,7 +33050,7 @@ _loop0_52_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_52[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop0_57[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -32136,7 +33073,7 @@ _loop0_52_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_52[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_57[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32153,9 +33090,9 @@ _loop0_52_rule(Parser *p) return _seq; } -// _loop1_53: param_with_default +// _loop1_58: param_with_default static asdl_seq * -_loop1_53_rule(Parser *p) +_loop1_58_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32181,7 +33118,7 @@ _loop1_53_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_53[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop1_58[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -32204,7 +33141,7 @@ _loop1_53_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_53[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_58[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -32226,9 +33163,9 @@ _loop1_53_rule(Parser *p) return _seq; } -// _loop1_54: param_no_default +// _loop1_59: param_no_default static asdl_seq * -_loop1_54_rule(Parser *p) +_loop1_59_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32254,7 +33191,7 @@ _loop1_54_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_54[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_59[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -32277,7 +33214,7 @@ _loop1_54_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_54[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_59[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -32299,9 +33236,9 @@ _loop1_54_rule(Parser *p) return _seq; } -// _loop1_55: param_no_default +// _loop1_60: param_no_default static asdl_seq * -_loop1_55_rule(Parser *p) +_loop1_60_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32327,7 +33264,7 @@ _loop1_55_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_55[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_60[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -32350,7 +33287,7 @@ _loop1_55_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_55[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_60[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -32372,9 +33309,9 @@ _loop1_55_rule(Parser *p) return _seq; } -// _loop0_56: param_no_default +// _loop0_61: param_no_default static asdl_seq * -_loop0_56_rule(Parser *p) +_loop0_61_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32400,7 +33337,7 @@ _loop0_56_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_56[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_61[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -32423,7 +33360,7 @@ _loop0_56_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_56[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_61[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32440,9 +33377,9 @@ _loop0_56_rule(Parser *p) return _seq; } -// _loop1_57: param_with_default +// _loop1_62: param_with_default static asdl_seq * -_loop1_57_rule(Parser *p) +_loop1_62_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32468,7 +33405,7 @@ _loop1_57_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_57[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop1_62[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -32491,7 +33428,7 @@ _loop1_57_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_57[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_62[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -32513,9 +33450,9 @@ _loop1_57_rule(Parser *p) return _seq; } -// _loop0_58: param_no_default +// _loop0_63: param_no_default static asdl_seq * -_loop0_58_rule(Parser *p) +_loop0_63_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32541,7 +33478,7 @@ _loop0_58_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_58[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_63[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -32564,7 +33501,7 @@ _loop0_58_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_58[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_63[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32581,9 +33518,9 @@ _loop0_58_rule(Parser *p) return _seq; } -// _loop1_59: param_with_default +// _loop1_64: param_with_default static asdl_seq * -_loop1_59_rule(Parser *p) +_loop1_64_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32609,7 +33546,7 @@ _loop1_59_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_59[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop1_64[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -32632,7 +33569,7 @@ _loop1_59_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_59[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_64[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -32654,9 +33591,9 @@ _loop1_59_rule(Parser *p) return _seq; } -// _loop0_60: param_maybe_default +// _loop0_65: param_maybe_default static asdl_seq * -_loop0_60_rule(Parser *p) +_loop0_65_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32682,7 +33619,7 @@ _loop0_60_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_60[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_65[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -32705,7 +33642,7 @@ _loop0_60_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_60[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_65[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32722,9 +33659,9 @@ _loop0_60_rule(Parser *p) return _seq; } -// _loop0_61: param_maybe_default +// _loop0_66: param_maybe_default static asdl_seq * -_loop0_61_rule(Parser *p) +_loop0_66_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32750,7 +33687,7 @@ _loop0_61_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_61[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_66[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -32773,7 +33710,7 @@ _loop0_61_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_61[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_66[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32790,9 +33727,9 @@ _loop0_61_rule(Parser *p) return _seq; } -// _loop1_62: param_maybe_default +// _loop1_67: param_maybe_default static asdl_seq * -_loop1_62_rule(Parser *p) +_loop1_67_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32818,7 +33755,7 @@ _loop1_62_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_62[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_67[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -32841,7 +33778,7 @@ _loop1_62_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_62[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_67[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -32863,9 +33800,9 @@ _loop1_62_rule(Parser *p) return _seq; } -// _loop0_64: ',' with_item +// _loop0_69: ',' with_item static asdl_seq * -_loop0_64_rule(Parser *p) +_loop0_69_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32891,7 +33828,7 @@ _loop0_64_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_64[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c> _loop0_69[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); Token * _literal; withitem_ty elem; while ( @@ -32923,7 +33860,7 @@ _loop0_64_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_64[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_69[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32940,9 +33877,9 @@ _loop0_64_rule(Parser *p) return _seq; } -// _gather_63: with_item _loop0_64 +// _gather_68: with_item _loop0_69 static asdl_seq * -_gather_63_rule(Parser *p) +_gather_68_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32954,27 +33891,27 @@ _gather_63_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_64 + { // with_item _loop0_69 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_63[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_64")); + D(fprintf(stderr, "%*c> _gather_68[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_69")); withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_64_rule(p)) // _loop0_64 + (seq = _loop0_69_rule(p)) // _loop0_69 ) { - D(fprintf(stderr, "%*c+ _gather_63[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_64")); + D(fprintf(stderr, "%*c+ _gather_68[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_69")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_63[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_64")); + D(fprintf(stderr, "%*c%s _gather_68[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_69")); } _res = NULL; done: @@ -32982,9 +33919,9 @@ _gather_63_rule(Parser *p) return _res; } -// _loop0_66: ',' with_item +// _loop0_71: ',' with_item static asdl_seq * -_loop0_66_rule(Parser *p) +_loop0_71_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33010,7 +33947,7 @@ _loop0_66_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_66[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c> _loop0_71[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); Token * _literal; withitem_ty elem; while ( @@ -33042,7 +33979,7 @@ _loop0_66_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_66[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_71[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33059,9 +33996,9 @@ _loop0_66_rule(Parser *p) return _seq; } -// _gather_65: with_item _loop0_66 +// _gather_70: with_item _loop0_71 static asdl_seq * -_gather_65_rule(Parser *p) +_gather_70_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33073,27 +34010,27 @@ _gather_65_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_66 + { // with_item _loop0_71 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_65[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_66")); + D(fprintf(stderr, "%*c> _gather_70[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_71")); withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_66_rule(p)) // _loop0_66 + (seq = _loop0_71_rule(p)) // _loop0_71 ) { - D(fprintf(stderr, "%*c+ _gather_65[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_66")); + D(fprintf(stderr, "%*c+ _gather_70[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_71")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_65[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_66")); + D(fprintf(stderr, "%*c%s _gather_70[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_71")); } _res = NULL; done: @@ -33101,9 +34038,9 @@ _gather_65_rule(Parser *p) return _res; } -// _loop0_68: ',' with_item +// _loop0_73: ',' with_item static asdl_seq * -_loop0_68_rule(Parser *p) +_loop0_73_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33129,7 +34066,7 @@ _loop0_68_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_68[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c> _loop0_73[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); Token * _literal; withitem_ty elem; while ( @@ -33161,7 +34098,7 @@ _loop0_68_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_68[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_73[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33178,9 +34115,9 @@ _loop0_68_rule(Parser *p) return _seq; } -// _gather_67: with_item _loop0_68 +// _gather_72: with_item _loop0_73 static asdl_seq * -_gather_67_rule(Parser *p) +_gather_72_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33192,27 +34129,27 @@ _gather_67_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_68 + { // with_item _loop0_73 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_67[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_68")); + D(fprintf(stderr, "%*c> _gather_72[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_73")); withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_68_rule(p)) // _loop0_68 + (seq = _loop0_73_rule(p)) // _loop0_73 ) { - D(fprintf(stderr, "%*c+ _gather_67[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_68")); + D(fprintf(stderr, "%*c+ _gather_72[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_73")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_67[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_68")); + D(fprintf(stderr, "%*c%s _gather_72[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_73")); } _res = NULL; done: @@ -33220,9 +34157,9 @@ _gather_67_rule(Parser *p) return _res; } -// _loop0_70: ',' with_item +// _loop0_75: ',' with_item static asdl_seq * -_loop0_70_rule(Parser *p) +_loop0_75_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33248,7 +34185,7 @@ _loop0_70_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_70[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c> _loop0_75[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); Token * _literal; withitem_ty elem; while ( @@ -33280,7 +34217,7 @@ _loop0_70_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_70[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_75[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33297,9 +34234,9 @@ _loop0_70_rule(Parser *p) return _seq; } -// _gather_69: with_item _loop0_70 +// _gather_74: with_item _loop0_75 static asdl_seq * -_gather_69_rule(Parser *p) +_gather_74_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33311,27 +34248,27 @@ _gather_69_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_70 + { // with_item _loop0_75 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_69[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_70")); + D(fprintf(stderr, "%*c> _gather_74[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_75")); withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_70_rule(p)) // _loop0_70 + (seq = _loop0_75_rule(p)) // _loop0_75 ) { - D(fprintf(stderr, "%*c+ _gather_69[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_70")); + D(fprintf(stderr, "%*c+ _gather_74[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_75")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_69[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_70")); + D(fprintf(stderr, "%*c%s _gather_74[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_75")); } _res = NULL; done: @@ -33339,9 +34276,9 @@ _gather_69_rule(Parser *p) return _res; } -// _tmp_71: ',' | ')' | ':' +// _tmp_76: ',' | ')' | ':' static void * -_tmp_71_rule(Parser *p) +_tmp_76_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33358,18 +34295,18 @@ _tmp_71_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_71[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_71[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_76[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_71[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_76[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // ')' @@ -33377,18 +34314,18 @@ _tmp_71_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_71[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_71[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_76[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_71[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_76[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // ':' @@ -33396,18 +34333,18 @@ _tmp_71_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_71[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_71[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_76[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_71[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_76[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -33416,9 +34353,9 @@ _tmp_71_rule(Parser *p) return _res; } -// _loop1_72: except_block +// _loop1_77: except_block static asdl_seq * -_loop1_72_rule(Parser *p) +_loop1_77_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33444,7 +34381,7 @@ _loop1_72_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_72[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); + D(fprintf(stderr, "%*c> _loop1_77[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); excepthandler_ty except_block_var; while ( (except_block_var = except_block_rule(p)) // except_block @@ -33467,7 +34404,7 @@ _loop1_72_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_72[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_77[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_block")); } if (_n == 0 || p->error_indicator) { @@ -33489,9 +34426,9 @@ _loop1_72_rule(Parser *p) return _seq; } -// _loop1_73: except_star_block +// _loop1_78: except_star_block static asdl_seq * -_loop1_73_rule(Parser *p) +_loop1_78_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33517,7 +34454,7 @@ _loop1_73_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_73[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); + D(fprintf(stderr, "%*c> _loop1_78[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); excepthandler_ty except_star_block_var; while ( (except_star_block_var = except_star_block_rule(p)) // except_star_block @@ -33540,7 +34477,7 @@ _loop1_73_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_73[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_78[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_star_block")); } if (_n == 0 || p->error_indicator) { @@ -33562,9 +34499,9 @@ _loop1_73_rule(Parser *p) return _seq; } -// _tmp_74: 'as' NAME +// _tmp_79: 'as' NAME static void * -_tmp_74_rule(Parser *p) +_tmp_79_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33581,16 +34518,16 @@ _tmp_74_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_74[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_79[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_74[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_79[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -33600,7 +34537,7 @@ _tmp_74_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_74[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_79[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -33609,9 +34546,9 @@ _tmp_74_rule(Parser *p) return _res; } -// _tmp_75: 'as' NAME +// _tmp_80: 'as' NAME static void * -_tmp_75_rule(Parser *p) +_tmp_80_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33628,16 +34565,16 @@ _tmp_75_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_75[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_80[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_75[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_80[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -33647,7 +34584,7 @@ _tmp_75_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_75[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_80[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -33656,9 +34593,9 @@ _tmp_75_rule(Parser *p) return _res; } -// _loop1_76: switchcase_block +// _loop1_81: switchcase_block static asdl_seq * -_loop1_76_rule(Parser *p) +_loop1_81_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33684,7 +34621,7 @@ _loop1_76_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); + D(fprintf(stderr, "%*c> _loop1_81[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); switch_case_ty switchcase_block_var; while ( (switchcase_block_var = switchcase_block_rule(p)) // switchcase_block @@ -33707,7 +34644,7 @@ _loop1_76_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_76[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_81[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block")); } if (_n == 0 || p->error_indicator) { @@ -33729,9 +34666,9 @@ _loop1_76_rule(Parser *p) return _seq; } -// _loop1_77: switchcase_block +// _loop1_82: switchcase_block static asdl_seq * -_loop1_77_rule(Parser *p) +_loop1_82_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33757,7 +34694,7 @@ _loop1_77_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_77[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); + D(fprintf(stderr, "%*c> _loop1_82[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); switch_case_ty switchcase_block_var; while ( (switchcase_block_var = switchcase_block_rule(p)) // switchcase_block @@ -33780,7 +34717,7 @@ _loop1_77_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_77[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_82[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block")); } if (_n == 0 || p->error_indicator) { @@ -33802,9 +34739,9 @@ _loop1_77_rule(Parser *p) return _seq; } -// _loop0_79: ',' (bitwiseor_pattern | 'None') +// _loop0_84: ',' (bitwiseor_pattern | 'None') static asdl_seq * -_loop0_79_rule(Parser *p) +_loop0_84_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33830,13 +34767,13 @@ _loop0_79_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_79[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); + D(fprintf(stderr, "%*c> _loop0_84[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_278_rule(p)) // bitwiseor_pattern | 'None' + (elem = _tmp_284_rule(p)) // bitwiseor_pattern | 'None' ) { _res = elem; @@ -33862,7 +34799,7 @@ _loop0_79_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_79[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_84[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33879,9 +34816,9 @@ _loop0_79_rule(Parser *p) return _seq; } -// _gather_78: (bitwiseor_pattern | 'None') _loop0_79 +// _gather_83: (bitwiseor_pattern | 'None') _loop0_84 static asdl_seq * -_gather_78_rule(Parser *p) +_gather_83_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33893,27 +34830,27 @@ _gather_78_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (bitwiseor_pattern | 'None') _loop0_79 + { // (bitwiseor_pattern | 'None') _loop0_84 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_78[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_79")); + D(fprintf(stderr, "%*c> _gather_83[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_84")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_278_rule(p)) // bitwiseor_pattern | 'None' + (elem = _tmp_284_rule(p)) // bitwiseor_pattern | 'None' && - (seq = _loop0_79_rule(p)) // _loop0_79 + (seq = _loop0_84_rule(p)) // _loop0_84 ) { - D(fprintf(stderr, "%*c+ _gather_78[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_79")); + D(fprintf(stderr, "%*c+ _gather_83[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_84")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_78[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_79")); + D(fprintf(stderr, "%*c%s _gather_83[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_84")); } _res = NULL; done: @@ -33921,9 +34858,9 @@ _gather_78_rule(Parser *p) return _res; } -// _loop1_80: case_block +// _loop1_85: case_block static asdl_seq * -_loop1_80_rule(Parser *p) +_loop1_85_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33949,7 +34886,7 @@ _loop1_80_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_80[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); + D(fprintf(stderr, "%*c> _loop1_85[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); match_case_ty case_block_var; while ( (case_block_var = case_block_rule(p)) // case_block @@ -33972,7 +34909,7 @@ _loop1_80_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_80[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_85[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block")); } if (_n == 0 || p->error_indicator) { @@ -33994,9 +34931,9 @@ _loop1_80_rule(Parser *p) return _seq; } -// _loop1_81: case_block +// _loop1_86: case_block static asdl_seq * -_loop1_81_rule(Parser *p) +_loop1_86_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34022,7 +34959,7 @@ _loop1_81_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_81[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); + D(fprintf(stderr, "%*c> _loop1_86[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); match_case_ty case_block_var; while ( (case_block_var = case_block_rule(p)) // case_block @@ -34045,7 +34982,7 @@ _loop1_81_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_81[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_86[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block")); } if (_n == 0 || p->error_indicator) { @@ -34067,9 +35004,9 @@ _loop1_81_rule(Parser *p) return _seq; } -// _loop0_83: '|' closed_pattern +// _loop0_88: '|' closed_pattern static asdl_seq * -_loop0_83_rule(Parser *p) +_loop0_88_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34095,7 +35032,7 @@ _loop0_83_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_83[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|' closed_pattern")); + D(fprintf(stderr, "%*c> _loop0_88[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|' closed_pattern")); Token * _literal; pattern_ty elem; while ( @@ -34127,7 +35064,7 @@ _loop0_83_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_83[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_88[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|' closed_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34144,9 +35081,9 @@ _loop0_83_rule(Parser *p) return _seq; } -// _gather_82: closed_pattern _loop0_83 +// _gather_87: closed_pattern _loop0_88 static asdl_seq * -_gather_82_rule(Parser *p) +_gather_87_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34158,27 +35095,27 @@ _gather_82_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // closed_pattern _loop0_83 + { // closed_pattern _loop0_88 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_82[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_83")); + D(fprintf(stderr, "%*c> _gather_87[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_88")); pattern_ty elem; asdl_seq * seq; if ( (elem = closed_pattern_rule(p)) // closed_pattern && - (seq = _loop0_83_rule(p)) // _loop0_83 + (seq = _loop0_88_rule(p)) // _loop0_88 ) { - D(fprintf(stderr, "%*c+ _gather_82[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_83")); + D(fprintf(stderr, "%*c+ _gather_87[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_88")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_82[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_83")); + D(fprintf(stderr, "%*c%s _gather_87[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_88")); } _res = NULL; done: @@ -34186,9 +35123,9 @@ _gather_82_rule(Parser *p) return _res; } -// _tmp_84: '+' | '-' +// _tmp_89: '+' | '-' static void * -_tmp_84_rule(Parser *p) +_tmp_89_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34205,18 +35142,18 @@ _tmp_84_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_84[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c> _tmp_89[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_84[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_84[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+'")); } { // '-' @@ -34224,18 +35161,18 @@ _tmp_84_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_84[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c> _tmp_89[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_84[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_84[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-'")); } _res = NULL; @@ -34244,9 +35181,9 @@ _tmp_84_rule(Parser *p) return _res; } -// _tmp_85: '+' | '-' +// _tmp_90: '+' | '-' static void * -_tmp_85_rule(Parser *p) +_tmp_90_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34263,18 +35200,18 @@ _tmp_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_85[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c> _tmp_90[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_85[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_85[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_90[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+'")); } { // '-' @@ -34282,18 +35219,18 @@ _tmp_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_85[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c> _tmp_90[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_85[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_85[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_90[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-'")); } _res = NULL; @@ -34302,9 +35239,9 @@ _tmp_85_rule(Parser *p) return _res; } -// _tmp_86: '.' | '(' | '=' +// _tmp_91: '.' | '(' | '=' static void * -_tmp_86_rule(Parser *p) +_tmp_91_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34321,18 +35258,18 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_86[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_86[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_91[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'.'")); } { // '(' @@ -34340,18 +35277,18 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_86[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c+ _tmp_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_86[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_91[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'('")); } { // '=' @@ -34359,18 +35296,18 @@ _tmp_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_86[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_86[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_86[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_91[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } _res = NULL; @@ -34379,9 +35316,9 @@ _tmp_86_rule(Parser *p) return _res; } -// _tmp_87: '.' | '(' | '=' +// _tmp_92: '.' | '(' | '=' static void * -_tmp_87_rule(Parser *p) +_tmp_92_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34398,18 +35335,18 @@ _tmp_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_87[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_87[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_87[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_92[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'.'")); } { // '(' @@ -34417,18 +35354,18 @@ _tmp_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_87[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_87[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c+ _tmp_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_87[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_92[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'('")); } { // '=' @@ -34436,18 +35373,18 @@ _tmp_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_87[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_87[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_87[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_92[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } _res = NULL; @@ -34456,9 +35393,9 @@ _tmp_87_rule(Parser *p) return _res; } -// _loop0_89: ',' maybe_star_pattern +// _loop0_94: ',' maybe_star_pattern static asdl_seq * -_loop0_89_rule(Parser *p) +_loop0_94_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34484,7 +35421,7 @@ _loop0_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_89[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' maybe_star_pattern")); + D(fprintf(stderr, "%*c> _loop0_94[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' maybe_star_pattern")); Token * _literal; pattern_ty elem; while ( @@ -34516,7 +35453,7 @@ _loop0_89_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_89[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_94[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' maybe_star_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34533,9 +35470,9 @@ _loop0_89_rule(Parser *p) return _seq; } -// _gather_88: maybe_star_pattern _loop0_89 +// _gather_93: maybe_star_pattern _loop0_94 static asdl_seq * -_gather_88_rule(Parser *p) +_gather_93_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34547,27 +35484,27 @@ _gather_88_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // maybe_star_pattern _loop0_89 + { // maybe_star_pattern _loop0_94 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_88[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_89")); + D(fprintf(stderr, "%*c> _gather_93[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_94")); pattern_ty elem; asdl_seq * seq; if ( (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern && - (seq = _loop0_89_rule(p)) // _loop0_89 + (seq = _loop0_94_rule(p)) // _loop0_94 ) { - D(fprintf(stderr, "%*c+ _gather_88[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_89")); + D(fprintf(stderr, "%*c+ _gather_93[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_94")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_88[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_89")); + D(fprintf(stderr, "%*c%s _gather_93[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_94")); } _res = NULL; done: @@ -34575,9 +35512,9 @@ _gather_88_rule(Parser *p) return _res; } -// _loop0_91: ',' key_value_pattern +// _loop0_96: ',' key_value_pattern static asdl_seq * -_loop0_91_rule(Parser *p) +_loop0_96_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34603,7 +35540,7 @@ _loop0_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' key_value_pattern")); + D(fprintf(stderr, "%*c> _loop0_96[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' key_value_pattern")); Token * _literal; KeyPatternPair* elem; while ( @@ -34635,7 +35572,7 @@ _loop0_91_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_91[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_96[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' key_value_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34652,9 +35589,9 @@ _loop0_91_rule(Parser *p) return _seq; } -// _gather_90: key_value_pattern _loop0_91 +// _gather_95: key_value_pattern _loop0_96 static asdl_seq * -_gather_90_rule(Parser *p) +_gather_95_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34666,27 +35603,27 @@ _gather_90_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // key_value_pattern _loop0_91 + { // key_value_pattern _loop0_96 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_90[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_91")); + D(fprintf(stderr, "%*c> _gather_95[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_96")); KeyPatternPair* elem; asdl_seq * seq; if ( (elem = key_value_pattern_rule(p)) // key_value_pattern && - (seq = _loop0_91_rule(p)) // _loop0_91 + (seq = _loop0_96_rule(p)) // _loop0_96 ) { - D(fprintf(stderr, "%*c+ _gather_90[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_91")); + D(fprintf(stderr, "%*c+ _gather_95[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_96")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_90[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_91")); + D(fprintf(stderr, "%*c%s _gather_95[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_96")); } _res = NULL; done: @@ -34694,9 +35631,9 @@ _gather_90_rule(Parser *p) return _res; } -// _tmp_92: literal_expr | attr +// _tmp_97: literal_expr | attr static void * -_tmp_92_rule(Parser *p) +_tmp_97_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34713,18 +35650,18 @@ _tmp_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); + D(fprintf(stderr, "%*c> _tmp_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); expr_ty literal_expr_var; if ( (literal_expr_var = literal_expr_rule(p)) // literal_expr ) { - D(fprintf(stderr, "%*c+ _tmp_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); + D(fprintf(stderr, "%*c+ _tmp_97[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); _res = literal_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_92[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_97[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "literal_expr")); } { // attr @@ -34732,18 +35669,18 @@ _tmp_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); + D(fprintf(stderr, "%*c> _tmp_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); expr_ty attr_var; if ( (attr_var = attr_rule(p)) // attr ) { - D(fprintf(stderr, "%*c+ _tmp_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); + D(fprintf(stderr, "%*c+ _tmp_97[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); _res = attr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_92[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_97[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "attr")); } _res = NULL; @@ -34752,9 +35689,9 @@ _tmp_92_rule(Parser *p) return _res; } -// _loop0_94: ',' pattern +// _loop0_99: ',' pattern static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_99_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34780,7 +35717,7 @@ _loop0_94_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_94[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' pattern")); + D(fprintf(stderr, "%*c> _loop0_99[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' pattern")); Token * _literal; pattern_ty elem; while ( @@ -34812,7 +35749,7 @@ _loop0_94_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_94[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_99[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34829,9 +35766,9 @@ _loop0_94_rule(Parser *p) return _seq; } -// _gather_93: pattern _loop0_94 +// _gather_98: pattern _loop0_99 static asdl_seq * -_gather_93_rule(Parser *p) +_gather_98_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34843,27 +35780,27 @@ _gather_93_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // pattern _loop0_94 + { // pattern _loop0_99 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_93[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_94")); + D(fprintf(stderr, "%*c> _gather_98[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_99")); pattern_ty elem; asdl_seq * seq; if ( (elem = pattern_rule(p)) // pattern && - (seq = _loop0_94_rule(p)) // _loop0_94 + (seq = _loop0_99_rule(p)) // _loop0_99 ) { - D(fprintf(stderr, "%*c+ _gather_93[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_94")); + D(fprintf(stderr, "%*c+ _gather_98[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_99")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_93[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "pattern _loop0_94")); + D(fprintf(stderr, "%*c%s _gather_98[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "pattern _loop0_99")); } _res = NULL; done: @@ -34871,9 +35808,9 @@ _gather_93_rule(Parser *p) return _res; } -// _loop0_96: ',' keyword_pattern +// _loop0_101: ',' keyword_pattern static asdl_seq * -_loop0_96_rule(Parser *p) +_loop0_101_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34899,7 +35836,7 @@ _loop0_96_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_96[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' keyword_pattern")); + D(fprintf(stderr, "%*c> _loop0_101[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' keyword_pattern")); Token * _literal; KeyPatternPair* elem; while ( @@ -34931,7 +35868,7 @@ _loop0_96_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_96[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_101[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' keyword_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34948,9 +35885,9 @@ _loop0_96_rule(Parser *p) return _seq; } -// _gather_95: keyword_pattern _loop0_96 +// _gather_100: keyword_pattern _loop0_101 static asdl_seq * -_gather_95_rule(Parser *p) +_gather_100_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34962,27 +35899,27 @@ _gather_95_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // keyword_pattern _loop0_96 + { // keyword_pattern _loop0_101 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_95[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_96")); + D(fprintf(stderr, "%*c> _gather_100[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_101")); KeyPatternPair* elem; asdl_seq * seq; if ( (elem = keyword_pattern_rule(p)) // keyword_pattern && - (seq = _loop0_96_rule(p)) // _loop0_96 + (seq = _loop0_101_rule(p)) // _loop0_101 ) { - D(fprintf(stderr, "%*c+ _gather_95[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_96")); + D(fprintf(stderr, "%*c+ _gather_100[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_101")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_95[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_96")); + D(fprintf(stderr, "%*c%s _gather_100[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_101")); } _res = NULL; done: @@ -34990,9 +35927,9 @@ _gather_95_rule(Parser *p) return _res; } -// _tmp_97: ';'.simple_stmt+ ';'? | block +// _tmp_102: ';'.simple_stmt+ ';'? | block static void * -_tmp_97_rule(Parser *p) +_tmp_102_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35009,17 +35946,17 @@ _tmp_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + D(fprintf(stderr, "%*c> _tmp_102[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings asdl_stmt_seq* s; if ( - (s = (asdl_stmt_seq*)_gather_279_rule(p)) // ';'.simple_stmt+ + (s = (asdl_stmt_seq*)_gather_285_rule(p)) // ';'.simple_stmt+ && (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? ) { - D(fprintf(stderr, "%*c+ _tmp_97[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + D(fprintf(stderr, "%*c+ _tmp_102[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); _res = s; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35029,7 +35966,7 @@ _tmp_97_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_97[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_102[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); } { // block @@ -35037,18 +35974,18 @@ _tmp_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c> _tmp_102[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); asdl_stmt_seq* block_var; if ( (block_var = block_rule(p)) // block ) { - D(fprintf(stderr, "%*c+ _tmp_97[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c+ _tmp_102[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); _res = block_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_97[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_102[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block")); } _res = NULL; @@ -35057,9 +35994,9 @@ _tmp_97_rule(Parser *p) return _res; } -// _loop0_99: ',' type_param +// _loop0_104: ',' type_param static asdl_seq * -_loop0_99_rule(Parser *p) +_loop0_104_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35085,7 +36022,7 @@ _loop0_99_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_99[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' type_param")); + D(fprintf(stderr, "%*c> _loop0_104[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' type_param")); Token * _literal; type_param_ty elem; while ( @@ -35117,7 +36054,7 @@ _loop0_99_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_99[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_104[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' type_param")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35134,9 +36071,9 @@ _loop0_99_rule(Parser *p) return _seq; } -// _gather_98: type_param _loop0_99 +// _gather_103: type_param _loop0_104 static asdl_seq * -_gather_98_rule(Parser *p) +_gather_103_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35148,27 +36085,27 @@ _gather_98_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // type_param _loop0_99 + { // type_param _loop0_104 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_98[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_99")); + D(fprintf(stderr, "%*c> _gather_103[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_104")); type_param_ty elem; asdl_seq * seq; if ( (elem = type_param_rule(p)) // type_param && - (seq = _loop0_99_rule(p)) // _loop0_99 + (seq = _loop0_104_rule(p)) // _loop0_104 ) { - D(fprintf(stderr, "%*c+ _gather_98[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_99")); + D(fprintf(stderr, "%*c+ _gather_103[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_104")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_98[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "type_param _loop0_99")); + D(fprintf(stderr, "%*c%s _gather_103[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "type_param _loop0_104")); } _res = NULL; done: @@ -35176,9 +36113,9 @@ _gather_98_rule(Parser *p) return _res; } -// _loop1_100: (',' expression) +// _loop1_105: (',' expression) static asdl_seq * -_loop1_100_rule(Parser *p) +_loop1_105_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35204,13 +36141,13 @@ _loop1_100_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_100[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' expression)")); - void *_tmp_281_var; + D(fprintf(stderr, "%*c> _loop1_105[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' expression)")); + void *_tmp_287_var; while ( - (_tmp_281_var = _tmp_281_rule(p)) // ',' expression + (_tmp_287_var = _tmp_287_rule(p)) // ',' expression ) { - _res = _tmp_281_var; + _res = _tmp_287_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35227,7 +36164,7 @@ _loop1_100_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_100[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_105[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(',' expression)")); } if (_n == 0 || p->error_indicator) { @@ -35249,9 +36186,9 @@ _loop1_100_rule(Parser *p) return _seq; } -// _loop1_101: (',' star_expression) +// _loop1_106: (',' star_expression) static asdl_seq * -_loop1_101_rule(Parser *p) +_loop1_106_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35277,13 +36214,13 @@ _loop1_101_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_101[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_expression)")); - void *_tmp_282_var; + D(fprintf(stderr, "%*c> _loop1_106[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_expression)")); + void *_tmp_288_var; while ( - (_tmp_282_var = _tmp_282_rule(p)) // ',' star_expression + (_tmp_288_var = _tmp_288_rule(p)) // ',' star_expression ) { - _res = _tmp_282_var; + _res = _tmp_288_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35300,7 +36237,7 @@ _loop1_101_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_101[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_106[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(',' star_expression)")); } if (_n == 0 || p->error_indicator) { @@ -35322,9 +36259,9 @@ _loop1_101_rule(Parser *p) return _seq; } -// _loop0_103: ',' star_named_expression +// _loop0_108: ',' star_named_expression static asdl_seq * -_loop0_103_rule(Parser *p) +_loop0_108_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35350,7 +36287,7 @@ _loop0_103_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_103[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_named_expression")); + D(fprintf(stderr, "%*c> _loop0_108[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_named_expression")); Token * _literal; expr_ty elem; while ( @@ -35382,7 +36319,7 @@ _loop0_103_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_103[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_108[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_named_expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35399,9 +36336,9 @@ _loop0_103_rule(Parser *p) return _seq; } -// _gather_102: star_named_expression _loop0_103 +// _gather_107: star_named_expression _loop0_108 static asdl_seq * -_gather_102_rule(Parser *p) +_gather_107_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35413,27 +36350,27 @@ _gather_102_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_named_expression _loop0_103 + { // star_named_expression _loop0_108 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_102[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_103")); + D(fprintf(stderr, "%*c> _gather_107[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_108")); expr_ty elem; asdl_seq * seq; if ( (elem = star_named_expression_rule(p)) // star_named_expression && - (seq = _loop0_103_rule(p)) // _loop0_103 + (seq = _loop0_108_rule(p)) // _loop0_108 ) { - D(fprintf(stderr, "%*c+ _gather_102[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_103")); + D(fprintf(stderr, "%*c+ _gather_107[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_108")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_102[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_103")); + D(fprintf(stderr, "%*c%s _gather_107[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_108")); } _res = NULL; done: @@ -35441,9 +36378,9 @@ _gather_102_rule(Parser *p) return _res; } -// _loop1_104: ('or' conjunction) +// _loop1_109: ('or' conjunction) static asdl_seq * -_loop1_104_rule(Parser *p) +_loop1_109_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35469,13 +36406,13 @@ _loop1_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_104[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('or' conjunction)")); - void *_tmp_283_var; + D(fprintf(stderr, "%*c> _loop1_109[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('or' conjunction)")); + void *_tmp_289_var; while ( - (_tmp_283_var = _tmp_283_rule(p)) // 'or' conjunction + (_tmp_289_var = _tmp_289_rule(p)) // 'or' conjunction ) { - _res = _tmp_283_var; + _res = _tmp_289_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35492,7 +36429,7 @@ _loop1_104_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_104[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_109[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('or' conjunction)")); } if (_n == 0 || p->error_indicator) { @@ -35514,9 +36451,9 @@ _loop1_104_rule(Parser *p) return _seq; } -// _loop1_105: ('and' inversion) +// _loop1_110: ('and' inversion) static asdl_seq * -_loop1_105_rule(Parser *p) +_loop1_110_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35542,13 +36479,13 @@ _loop1_105_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_105[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('and' inversion)")); - void *_tmp_284_var; + D(fprintf(stderr, "%*c> _loop1_110[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('and' inversion)")); + void *_tmp_290_var; while ( - (_tmp_284_var = _tmp_284_rule(p)) // 'and' inversion + (_tmp_290_var = _tmp_290_rule(p)) // 'and' inversion ) { - _res = _tmp_284_var; + _res = _tmp_290_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35565,7 +36502,7 @@ _loop1_105_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_105[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_110[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('and' inversion)")); } if (_n == 0 || p->error_indicator) { @@ -35587,9 +36524,9 @@ _loop1_105_rule(Parser *p) return _seq; } -// _loop1_106: compare_op_composition_pair +// _loop1_111: compare_op_composition_pair static asdl_seq * -_loop1_106_rule(Parser *p) +_loop1_111_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35615,7 +36552,7 @@ _loop1_106_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_106[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "compare_op_composition_pair")); + D(fprintf(stderr, "%*c> _loop1_111[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "compare_op_composition_pair")); CmpopExprPair* compare_op_composition_pair_var; while ( (compare_op_composition_pair_var = compare_op_composition_pair_rule(p)) // compare_op_composition_pair @@ -35638,7 +36575,7 @@ _loop1_106_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_106[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_111[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "compare_op_composition_pair")); } if (_n == 0 || p->error_indicator) { @@ -35660,9 +36597,9 @@ _loop1_106_rule(Parser *p) return _seq; } -// _tmp_107: '!=' +// _tmp_112: '!=' static void * -_tmp_107_rule(Parser *p) +_tmp_112_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35679,13 +36616,13 @@ _tmp_107_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_107[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); Token * tok; if ( (tok = _PyPegen_expect_token(p, 28)) // token='!=' ) { - D(fprintf(stderr, "%*c+ _tmp_107[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c+ _tmp_112[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35695,7 +36632,7 @@ _tmp_107_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_107[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_112[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!='")); } _res = NULL; @@ -35704,9 +36641,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _tmp_108: '|>' +// _tmp_113: '|>' static void * -_tmp_108_rule(Parser *p) +_tmp_113_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35723,13 +36660,13 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); Token * t; if ( (t = _PyPegen_expect_token(p, 55)) // token='|>' ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); _res = ( ++ p -> subn , t ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35739,7 +36676,7 @@ _tmp_108_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_113[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|>'")); } _res = NULL; @@ -35748,9 +36685,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _tmp_109: bitwise_or? +// _tmp_114: bitwise_or? static void * -_tmp_109_rule(Parser *p) +_tmp_114_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35767,13 +36704,13 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); void *c; if ( (c = bitwise_or_rule(p), !p->error_indicator) // bitwise_or? ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); _res = ( - - p -> subn , c ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -35783,7 +36720,7 @@ _tmp_109_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_114[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwise_or?")); } _res = NULL; @@ -35792,9 +36729,9 @@ _tmp_109_rule(Parser *p) return _res; } -// _tmp_110: genexp | tuplecomp +// _tmp_115: class_or_func_expr | tuplecomp | genexp static void * -_tmp_110_rule(Parser *p) +_tmp_115_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35806,53 +36743,72 @@ _tmp_110_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // genexp + { // class_or_func_expr if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_110[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); - expr_ty genexp_var; + D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + expr_ty class_or_func_expr_var; if ( - (genexp_var = genexp_rule(p)) // genexp + (class_or_func_expr_var = class_or_func_expr_rule(p)) // class_or_func_expr ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); - _res = genexp_var; + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + _res = class_or_func_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_110[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "class_or_func_expr")); } { // tuplecomp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_110[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); expr_ty tuplecomp_var; if ( (tuplecomp_var = tuplecomp_rule(p)) // tuplecomp ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); _res = tuplecomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_110[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuplecomp")); } + { // genexp + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + expr_ty genexp_var; + if ( + (genexp_var = genexp_rule(p)) // genexp + ) + { + D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + _res = genexp_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); + } _res = NULL; done: p->level--; return _res; } -// _loop0_112: ',' (slice | starred_expression) +// _loop0_117: ',' (slice | starred_expression) static asdl_seq * -_loop0_112_rule(Parser *p) +_loop0_117_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35878,13 +36834,13 @@ _loop0_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_112[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (slice | starred_expression)")); + D(fprintf(stderr, "%*c> _loop0_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (slice | starred_expression)")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_285_rule(p)) // slice | starred_expression + (elem = _tmp_291_rule(p)) // slice | starred_expression ) { _res = elem; @@ -35910,7 +36866,7 @@ _loop0_112_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_112[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_117[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (slice | starred_expression)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35927,9 +36883,9 @@ _loop0_112_rule(Parser *p) return _seq; } -// _gather_111: (slice | starred_expression) _loop0_112 +// _gather_116: (slice | starred_expression) _loop0_117 static asdl_seq * -_gather_111_rule(Parser *p) +_gather_116_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35941,27 +36897,27 @@ _gather_111_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (slice | starred_expression) _loop0_112 + { // (slice | starred_expression) _loop0_117 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_111[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_112")); + D(fprintf(stderr, "%*c> _gather_116[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_117")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_285_rule(p)) // slice | starred_expression + (elem = _tmp_291_rule(p)) // slice | starred_expression && - (seq = _loop0_112_rule(p)) // _loop0_112 + (seq = _loop0_117_rule(p)) // _loop0_117 ) { - D(fprintf(stderr, "%*c+ _gather_111[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_112")); + D(fprintf(stderr, "%*c+ _gather_116[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_117")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_111[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_112")); + D(fprintf(stderr, "%*c%s _gather_116[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_117")); } _res = NULL; done: @@ -35969,9 +36925,9 @@ _gather_111_rule(Parser *p) return _res; } -// _tmp_113: ':' expression? +// _tmp_118: ':' expression? static void * -_tmp_113_rule(Parser *p) +_tmp_118_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35988,7 +36944,7 @@ _tmp_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_113[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); Token * _literal; void *d; if ( @@ -35997,7 +36953,7 @@ _tmp_113_rule(Parser *p) (d = expression_rule(p), !p->error_indicator) // expression? ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -36007,7 +36963,7 @@ _tmp_113_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_113[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_118[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':' expression?")); } _res = NULL; @@ -36016,9 +36972,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: STRING | FSTRING_START +// _tmp_119: STRING | FSTRING_START static void * -_tmp_114_rule(Parser *p) +_tmp_119_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36035,18 +36991,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); expr_ty string_var; if ( (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); _res = string_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_114[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "STRING")); } { // FSTRING_START @@ -36054,18 +37010,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); Token * fstring_start_var; if ( (fstring_start_var = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START' ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); _res = fstring_start_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_114[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "FSTRING_START")); } _res = NULL; @@ -36074,9 +37030,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _tmp_115: tuple | group | genexp | tuplecomp +// _tmp_120: class_or_func_expr | tuple | group | tuplecomp | genexp static void * -_tmp_115_rule(Parser *p) +_tmp_120_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36088,23 +37044,42 @@ _tmp_115_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + { // class_or_func_expr + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + expr_ty class_or_func_expr_var; + if ( + (class_or_func_expr_var = class_or_func_expr_rule(p)) // class_or_func_expr + ) + { + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + _res = class_or_func_expr_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + } { // tuple if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); expr_ty tuple_var; if ( (tuple_var = tuple_rule(p)) // tuple ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); _res = tuple_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuple")); } { // group @@ -36112,57 +37087,57 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); expr_ty group_var; if ( (group_var = group_rule(p)) // group ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); _res = group_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "group")); } - { // genexp + { // tuplecomp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); - expr_ty genexp_var; + D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + expr_ty tuplecomp_var; if ( - (genexp_var = genexp_rule(p)) // genexp + (tuplecomp_var = tuplecomp_rule(p)) // tuplecomp ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); - _res = genexp_var; + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + _res = tuplecomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuplecomp")); } - { // tuplecomp + { // genexp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); - expr_ty tuplecomp_var; + D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + expr_ty genexp_var; if ( - (tuplecomp_var = tuplecomp_rule(p)) // tuplecomp + (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); - _res = tuplecomp_var; + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } _res = NULL; done: @@ -36170,9 +37145,9 @@ _tmp_115_rule(Parser *p) return _res; } -// _tmp_116: list | listcomp +// _tmp_121: list | listcomp static void * -_tmp_116_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36189,18 +37164,18 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); expr_ty list_var; if ( (list_var = list_rule(p)) // list ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); _res = list_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "list")); } { // listcomp @@ -36208,18 +37183,18 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); expr_ty listcomp_var; if ( (listcomp_var = listcomp_rule(p)) // listcomp ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); _res = listcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "listcomp")); } _res = NULL; @@ -36228,9 +37203,9 @@ _tmp_116_rule(Parser *p) return _res; } -// _tmp_117: dict | set | dictcomp | setcomp +// _tmp_122: dict | set | dictcomp | setcomp static void * -_tmp_117_rule(Parser *p) +_tmp_122_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36247,18 +37222,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); expr_ty dict_var; if ( (dict_var = dict_rule(p)) // dict ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); _res = dict_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dict")); } { // set @@ -36266,18 +37241,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); expr_ty set_var; if ( (set_var = set_rule(p)) // set ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); _res = set_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "set")); } { // dictcomp @@ -36285,18 +37260,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); expr_ty dictcomp_var; if ( (dictcomp_var = dictcomp_rule(p)) // dictcomp ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); _res = dictcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dictcomp")); } { // setcomp @@ -36304,18 +37279,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); + D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); expr_ty setcomp_var; if ( (setcomp_var = setcomp_rule(p)) // setcomp ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); _res = setcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "setcomp")); } _res = NULL; @@ -36324,9 +37299,9 @@ _tmp_117_rule(Parser *p) return _res; } -// _tmp_118: yield_expr | slice +// _tmp_123: yield_expr | slice static void * -_tmp_118_rule(Parser *p) +_tmp_123_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36343,18 +37318,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // slice @@ -36362,18 +37337,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); expr_ty slice_var; if ( (slice_var = slice_rule(p)) // slice ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); _res = slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slice")); } _res = NULL; @@ -36382,9 +37357,11 @@ _tmp_118_rule(Parser *p) return _res; } -// _loop0_119: lambda_param_no_default -static asdl_seq * -_loop0_119_rule(Parser *p) +// _tmp_124: +// | &("def" | '@' | 'async') function_def_nonewline +// | &('class' | '@') class_def_nonewline +static void * +_tmp_124_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36394,133 +37371,59 @@ _loop0_119_rule(Parser *p) p->level--; return NULL; } - void *_res = 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; - { // lambda_param_no_default + { // &("def" | '@' | 'async') function_def_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_119[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); - arg_ty lambda_param_no_default_var; - while ( - (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default + D(fprintf(stderr, "%*c> _tmp_124[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def_nonewline")); + stmt_ty function_def_nonewline_var; + if ( + _PyPegen_lookahead(1, _tmp_292_rule, p) + && + (function_def_nonewline_var = function_def_nonewline_rule(p)) // function_def_nonewline ) { - _res = lambda_param_no_default_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; + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def_nonewline")); + _res = function_def_nonewline_var; + goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_119[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def_nonewline")); } - 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 (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _loop0_120: lambda_param_with_default -static asdl_seq * -_loop0_120_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - 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; - { // lambda_param_with_default + { // &('class' | '@') class_def_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); - NameDefaultPair* lambda_param_with_default_var; - while ( - (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default + D(fprintf(stderr, "%*c> _tmp_124[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); + stmt_ty class_def_nonewline_var; + if ( + _PyPegen_lookahead(1, _tmp_293_rule, p) + && + (class_def_nonewline_var = class_def_nonewline_rule(p)) // class_def_nonewline ) { - _res = lambda_param_with_default_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; + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); + _res = class_def_nonewline_var; + goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_120[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); - } - 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; + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); + _res = NULL; + done: p->level--; - return _seq; + return _res; } -// _loop0_121: lambda_param_with_default +// _loop0_125: lambda_param_no_default static asdl_seq * -_loop0_121_rule(Parser *p) +_loop0_125_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36541,18 +37444,18 @@ _loop0_121_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // lambda_param_with_default + { // lambda_param_no_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); - NameDefaultPair* lambda_param_with_default_var; + D(fprintf(stderr, "%*c> _loop0_125[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + arg_ty lambda_param_no_default_var; while ( - (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default + (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { - _res = lambda_param_with_default_var; + _res = lambda_param_no_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36569,8 +37472,8 @@ _loop0_121_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_121[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c%s _loop0_125[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -36586,9 +37489,9 @@ _loop0_121_rule(Parser *p) return _seq; } -// _loop1_122: lambda_param_no_default +// _loop0_126: lambda_param_with_default static asdl_seq * -_loop1_122_rule(Parser *p) +_loop0_126_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36609,18 +37512,18 @@ _loop1_122_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // lambda_param_no_default + { // lambda_param_with_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); - arg_ty lambda_param_no_default_var; + D(fprintf(stderr, "%*c> _loop0_126[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + NameDefaultPair* lambda_param_with_default_var; while ( - (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default + (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default ) { - _res = lambda_param_no_default_var; + _res = lambda_param_with_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36637,13 +37540,8 @@ _loop1_122_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_122[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_126[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -36659,9 +37557,9 @@ _loop1_122_rule(Parser *p) return _seq; } -// _loop0_123: lambda_param_with_default +// _loop0_127: lambda_param_with_default static asdl_seq * -_loop0_123_rule(Parser *p) +_loop0_127_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36687,7 +37585,7 @@ _loop0_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_123[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_127[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -36710,7 +37608,148 @@ _loop0_123_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_123[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_127[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + } + 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 (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop1_128: lambda_param_no_default +static asdl_seq * +_loop1_128_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + 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; + { // lambda_param_no_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_128[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + arg_ty lambda_param_no_default_var; + while ( + (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default + ) + { + _res = lambda_param_no_default_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_128[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + } + 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 (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop0_129: lambda_param_with_default +static asdl_seq * +_loop0_129_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + 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; + { // lambda_param_with_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_129[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + NameDefaultPair* lambda_param_with_default_var; + while ( + (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default + ) + { + _res = lambda_param_with_default_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_129[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36727,9 +37766,9 @@ _loop0_123_rule(Parser *p) return _seq; } -// _loop1_124: lambda_param_with_default +// _loop1_130: lambda_param_with_default static asdl_seq * -_loop1_124_rule(Parser *p) +_loop1_130_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36755,7 +37794,7 @@ _loop1_124_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_124[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_130[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -36778,7 +37817,7 @@ _loop1_124_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_124[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_130[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -36800,9 +37839,9 @@ _loop1_124_rule(Parser *p) return _seq; } -// _loop1_125: lambda_param_no_default +// _loop1_131: lambda_param_no_default static asdl_seq * -_loop1_125_rule(Parser *p) +_loop1_131_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36828,7 +37867,7 @@ _loop1_125_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_125[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_131[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -36851,7 +37890,7 @@ _loop1_125_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_125[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_131[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -36873,9 +37912,9 @@ _loop1_125_rule(Parser *p) return _seq; } -// _loop1_126: lambda_param_no_default +// _loop1_132: lambda_param_no_default static asdl_seq * -_loop1_126_rule(Parser *p) +_loop1_132_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36901,7 +37940,7 @@ _loop1_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_126[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_132[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -36924,7 +37963,7 @@ _loop1_126_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_126[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_132[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -36946,9 +37985,9 @@ _loop1_126_rule(Parser *p) return _seq; } -// _loop0_127: lambda_param_no_default +// _loop0_133: lambda_param_no_default static asdl_seq * -_loop0_127_rule(Parser *p) +_loop0_133_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36974,7 +38013,7 @@ _loop0_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_127[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_133[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -36997,7 +38036,7 @@ _loop0_127_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_127[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_133[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37014,9 +38053,9 @@ _loop0_127_rule(Parser *p) return _seq; } -// _loop1_128: lambda_param_with_default +// _loop1_134: lambda_param_with_default static asdl_seq * -_loop1_128_rule(Parser *p) +_loop1_134_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37042,7 +38081,7 @@ _loop1_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_128[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_134[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -37065,7 +38104,7 @@ _loop1_128_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_128[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_134[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -37087,9 +38126,9 @@ _loop1_128_rule(Parser *p) return _seq; } -// _loop0_129: lambda_param_no_default +// _loop0_135: lambda_param_no_default static asdl_seq * -_loop0_129_rule(Parser *p) +_loop0_135_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37115,7 +38154,7 @@ _loop0_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_129[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_135[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -37138,7 +38177,7 @@ _loop0_129_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_129[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_135[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37155,9 +38194,9 @@ _loop0_129_rule(Parser *p) return _seq; } -// _loop1_130: lambda_param_with_default +// _loop1_136: lambda_param_with_default static asdl_seq * -_loop1_130_rule(Parser *p) +_loop1_136_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37183,7 +38222,7 @@ _loop1_130_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_130[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_136[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -37206,7 +38245,7 @@ _loop1_130_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_130[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_136[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -37228,9 +38267,9 @@ _loop1_130_rule(Parser *p) return _seq; } -// _loop0_131: lambda_param_maybe_default +// _loop0_137: lambda_param_maybe_default static asdl_seq * -_loop0_131_rule(Parser *p) +_loop0_137_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37256,7 +38295,7 @@ _loop0_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_131[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_137[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -37279,7 +38318,7 @@ _loop0_131_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_131[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_137[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37296,9 +38335,9 @@ _loop0_131_rule(Parser *p) return _seq; } -// _loop1_132: lambda_param_maybe_default +// _loop1_138: lambda_param_maybe_default static asdl_seq * -_loop1_132_rule(Parser *p) +_loop1_138_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37324,7 +38363,7 @@ _loop1_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_132[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_138[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -37347,7 +38386,7 @@ _loop1_132_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_132[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_138[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -37369,9 +38408,9 @@ _loop1_132_rule(Parser *p) return _seq; } -// _tmp_133: yield_expr | star_expressions +// _tmp_139: yield_expr | star_expressions static void * -_tmp_133_rule(Parser *p) +_tmp_139_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37388,18 +38427,18 @@ _tmp_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_133[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_133[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_133[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -37407,18 +38446,18 @@ _tmp_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_133[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_133[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_133[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -37427,9 +38466,9 @@ _tmp_133_rule(Parser *p) return _res; } -// _loop0_134: fstring_format_spec +// _loop0_140: fstring_format_spec static asdl_seq * -_loop0_134_rule(Parser *p) +_loop0_140_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37455,7 +38494,7 @@ _loop0_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_134[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_140[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); expr_ty fstring_format_spec_var; while ( (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec @@ -37478,7 +38517,7 @@ _loop0_134_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_134[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_140[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37495,9 +38534,9 @@ _loop0_134_rule(Parser *p) return _seq; } -// _loop1_135: (fstring | string) +// _loop1_141: (fstring | string) static asdl_seq * -_loop1_135_rule(Parser *p) +_loop1_141_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37523,13 +38562,13 @@ _loop1_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_135[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(fstring | string)")); - void *_tmp_286_var; + D(fprintf(stderr, "%*c> _loop1_141[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(fstring | string)")); + void *_tmp_294_var; while ( - (_tmp_286_var = _tmp_286_rule(p)) // fstring | string + (_tmp_294_var = _tmp_294_rule(p)) // fstring | string ) { - _res = _tmp_286_var; + _res = _tmp_294_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37546,7 +38585,7 @@ _loop1_135_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_135[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_141[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(fstring | string)")); } if (_n == 0 || p->error_indicator) { @@ -37568,9 +38607,9 @@ _loop1_135_rule(Parser *p) return _seq; } -// _tmp_136: star_named_expression ',' star_named_expressions? +// _tmp_142: star_named_expression ',' star_named_expressions? static void * -_tmp_136_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37587,7 +38626,7 @@ _tmp_136_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_136[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions?")); Token * _literal; expr_ty y; void *z; @@ -37599,7 +38638,7 @@ _tmp_136_rule(Parser *p) (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? ) { - D(fprintf(stderr, "%*c+ _tmp_136[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions?")); _res = _PyPegen_seq_insert_in_front ( p , y , z ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37609,7 +38648,7 @@ _tmp_136_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_136[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions?")); } _res = NULL; @@ -37618,9 +38657,9 @@ _tmp_136_rule(Parser *p) return _res; } -// _loop0_138: ',' double_starred_kvpair +// _loop0_144: ',' double_starred_kvpair static asdl_seq * -_loop0_138_rule(Parser *p) +_loop0_144_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37646,7 +38685,7 @@ _loop0_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_138[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_144[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -37678,7 +38717,7 @@ _loop0_138_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_138[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_144[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37695,9 +38734,9 @@ _loop0_138_rule(Parser *p) return _seq; } -// _gather_137: double_starred_kvpair _loop0_138 +// _gather_143: double_starred_kvpair _loop0_144 static asdl_seq * -_gather_137_rule(Parser *p) +_gather_143_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37709,27 +38748,27 @@ _gather_137_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_138 + { // double_starred_kvpair _loop0_144 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_137[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_138")); + D(fprintf(stderr, "%*c> _gather_143[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_144")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_138_rule(p)) // _loop0_138 + (seq = _loop0_144_rule(p)) // _loop0_144 ) { - D(fprintf(stderr, "%*c+ _gather_137[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_138")); + D(fprintf(stderr, "%*c+ _gather_143[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_144")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_137[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_138")); + D(fprintf(stderr, "%*c%s _gather_143[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_144")); } _res = NULL; done: @@ -37737,9 +38776,9 @@ _gather_137_rule(Parser *p) return _res; } -// _loop1_139: for_if_clause +// _loop1_145: for_if_clause static asdl_seq * -_loop1_139_rule(Parser *p) +_loop1_145_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37765,7 +38804,7 @@ _loop1_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_139[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_145[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "for_if_clause")); comprehension_ty for_if_clause_var; while ( (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause @@ -37788,7 +38827,7 @@ _loop1_139_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_139[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_145[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "for_if_clause")); } if (_n == 0 || p->error_indicator) { @@ -37810,9 +38849,9 @@ _loop1_139_rule(Parser *p) return _seq; } -// _loop0_140: ('if' disjunction) +// _loop0_146: ('if' disjunction) static asdl_seq * -_loop0_140_rule(Parser *p) +_loop0_146_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37838,13 +38877,13 @@ _loop0_140_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_140[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); - void *_tmp_287_var; + D(fprintf(stderr, "%*c> _loop0_146[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_295_var; while ( - (_tmp_287_var = _tmp_287_rule(p)) // 'if' disjunction + (_tmp_295_var = _tmp_295_rule(p)) // 'if' disjunction ) { - _res = _tmp_287_var; + _res = _tmp_295_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37861,7 +38900,7 @@ _loop0_140_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_140[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_146[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('if' disjunction)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37878,9 +38917,9 @@ _loop0_140_rule(Parser *p) return _seq; } -// _loop0_141: ('if' disjunction) +// _loop0_147: ('if' disjunction) static asdl_seq * -_loop0_141_rule(Parser *p) +_loop0_147_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37906,13 +38945,13 @@ _loop0_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_141[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); - void *_tmp_288_var; + D(fprintf(stderr, "%*c> _loop0_147[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_296_var; while ( - (_tmp_288_var = _tmp_288_rule(p)) // 'if' disjunction + (_tmp_296_var = _tmp_296_rule(p)) // 'if' disjunction ) { - _res = _tmp_288_var; + _res = _tmp_296_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37929,7 +38968,7 @@ _loop0_141_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_141[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_147[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('if' disjunction)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37946,9 +38985,9 @@ _loop0_141_rule(Parser *p) return _seq; } -// _loop0_142: ('if' disjunction) +// _loop0_148: ('if' disjunction) static asdl_seq * -_loop0_142_rule(Parser *p) +_loop0_148_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37974,13 +39013,13 @@ _loop0_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); - void *_tmp_289_var; + D(fprintf(stderr, "%*c> _loop0_148[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_297_var; while ( - (_tmp_289_var = _tmp_289_rule(p)) // 'if' disjunction + (_tmp_297_var = _tmp_297_rule(p)) // 'if' disjunction ) { - _res = _tmp_289_var; + _res = _tmp_297_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37997,7 +39036,7 @@ _loop0_142_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_142[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_148[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('if' disjunction)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38014,9 +39053,9 @@ _loop0_142_rule(Parser *p) return _seq; } -// _tmp_143: assignment_expression | expression !':=' +// _tmp_149: assignment_expression | expression !':=' static void * -_tmp_143_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38033,18 +39072,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); expr_ty assignment_expression_var; if ( (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); _res = assignment_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_149[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -38052,7 +39091,7 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -38060,12 +39099,12 @@ _tmp_143_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_149[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -38074,9 +39113,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: assignment_expression | expression !':=' +// _tmp_150: assignment_expression | expression !':=' static void * -_tmp_144_rule(Parser *p) +_tmp_150_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38093,18 +39132,18 @@ _tmp_144_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_144[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); expr_ty assignment_expression_var; if ( (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); _res = assignment_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_144[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_150[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -38112,7 +39151,7 @@ _tmp_144_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_144[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_150[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -38120,12 +39159,12 @@ _tmp_144_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_144[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_144[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_150[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -38134,10 +39173,10 @@ _tmp_144_rule(Parser *p) return _res; } -// _loop0_146: +// _loop0_152: // | ',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_146_rule(Parser *p) +_loop0_152_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38163,13 +39202,13 @@ _loop0_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_146[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_152[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_290_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' + (elem = _tmp_298_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -38195,7 +39234,7 @@ _loop0_146_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_146[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_152[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38212,10 +39251,10 @@ _loop0_146_rule(Parser *p) return _seq; } -// _gather_145: -// | (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_146 +// _gather_151: +// | (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_152 static asdl_seq * -_gather_145_rule(Parser *p) +_gather_151_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38227,27 +39266,27 @@ _gather_145_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_146 + { // (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_152 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_145[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_146")); + D(fprintf(stderr, "%*c> _gather_151[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_152")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_290_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' + (elem = _tmp_298_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_146_rule(p)) // _loop0_146 + (seq = _loop0_152_rule(p)) // _loop0_152 ) { - D(fprintf(stderr, "%*c+ _gather_145[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_146")); + D(fprintf(stderr, "%*c+ _gather_151[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_152")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_145[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_146")); + D(fprintf(stderr, "%*c%s _gather_151[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_152")); } _res = NULL; done: @@ -38255,9 +39294,9 @@ _gather_145_rule(Parser *p) return _res; } -// _tmp_147: ',' kwargs +// _tmp_153: ',' kwargs static void * -_tmp_147_rule(Parser *p) +_tmp_153_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38274,7 +39313,7 @@ _tmp_147_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_147[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -38283,7 +39322,7 @@ _tmp_147_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_147[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); _res = k; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -38293,7 +39332,7 @@ _tmp_147_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_147[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_153[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' kwargs")); } _res = NULL; @@ -38302,9 +39341,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _loop0_149: ',' kwarg_or_starred +// _loop0_155: ',' kwarg_or_starred static asdl_seq * -_loop0_149_rule(Parser *p) +_loop0_155_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38330,7 +39369,7 @@ _loop0_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_149[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_155[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -38362,7 +39401,7 @@ _loop0_149_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_149[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_155[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38379,9 +39418,9 @@ _loop0_149_rule(Parser *p) return _seq; } -// _gather_148: kwarg_or_starred _loop0_149 +// _gather_154: kwarg_or_starred _loop0_155 static asdl_seq * -_gather_148_rule(Parser *p) +_gather_154_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38393,27 +39432,27 @@ _gather_148_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_149 + { // kwarg_or_starred _loop0_155 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_148[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_149")); + D(fprintf(stderr, "%*c> _gather_154[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_155")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_149_rule(p)) // _loop0_149 + (seq = _loop0_155_rule(p)) // _loop0_155 ) { - D(fprintf(stderr, "%*c+ _gather_148[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_149")); + D(fprintf(stderr, "%*c+ _gather_154[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_155")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_148[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_149")); + D(fprintf(stderr, "%*c%s _gather_154[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_155")); } _res = NULL; done: @@ -38421,9 +39460,9 @@ _gather_148_rule(Parser *p) return _res; } -// _loop0_151: ',' kwarg_or_double_starred +// _loop0_157: ',' kwarg_or_double_starred static asdl_seq * -_loop0_151_rule(Parser *p) +_loop0_157_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38449,7 +39488,7 @@ _loop0_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_151[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_157[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -38481,7 +39520,7 @@ _loop0_151_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_151[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_157[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38498,9 +39537,9 @@ _loop0_151_rule(Parser *p) return _seq; } -// _gather_150: kwarg_or_double_starred _loop0_151 +// _gather_156: kwarg_or_double_starred _loop0_157 static asdl_seq * -_gather_150_rule(Parser *p) +_gather_156_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38512,27 +39551,27 @@ _gather_150_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_151 + { // kwarg_or_double_starred _loop0_157 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_150[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_151")); + D(fprintf(stderr, "%*c> _gather_156[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_157")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_151_rule(p)) // _loop0_151 + (seq = _loop0_157_rule(p)) // _loop0_157 ) { - D(fprintf(stderr, "%*c+ _gather_150[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_151")); + D(fprintf(stderr, "%*c+ _gather_156[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_157")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_150[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_151")); + D(fprintf(stderr, "%*c%s _gather_156[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_157")); } _res = NULL; done: @@ -38540,9 +39579,9 @@ _gather_150_rule(Parser *p) return _res; } -// _loop0_153: ',' kwarg_or_starred +// _loop0_159: ',' kwarg_or_starred static asdl_seq * -_loop0_153_rule(Parser *p) +_loop0_159_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38568,7 +39607,7 @@ _loop0_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_153[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_159[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -38600,7 +39639,7 @@ _loop0_153_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_153[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_159[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38617,9 +39656,9 @@ _loop0_153_rule(Parser *p) return _seq; } -// _gather_152: kwarg_or_starred _loop0_153 +// _gather_158: kwarg_or_starred _loop0_159 static asdl_seq * -_gather_152_rule(Parser *p) +_gather_158_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38631,27 +39670,27 @@ _gather_152_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_153 + { // kwarg_or_starred _loop0_159 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_152[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_153")); + D(fprintf(stderr, "%*c> _gather_158[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_159")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_153_rule(p)) // _loop0_153 + (seq = _loop0_159_rule(p)) // _loop0_159 ) { - D(fprintf(stderr, "%*c+ _gather_152[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_153")); + D(fprintf(stderr, "%*c+ _gather_158[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_159")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_152[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_153")); + D(fprintf(stderr, "%*c%s _gather_158[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_159")); } _res = NULL; done: @@ -38659,9 +39698,9 @@ _gather_152_rule(Parser *p) return _res; } -// _loop0_155: ',' kwarg_or_double_starred +// _loop0_161: ',' kwarg_or_double_starred static asdl_seq * -_loop0_155_rule(Parser *p) +_loop0_161_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38687,7 +39726,7 @@ _loop0_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_155[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_161[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -38719,7 +39758,7 @@ _loop0_155_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_155[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_161[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38736,9 +39775,9 @@ _loop0_155_rule(Parser *p) return _seq; } -// _gather_154: kwarg_or_double_starred _loop0_155 +// _gather_160: kwarg_or_double_starred _loop0_161 static asdl_seq * -_gather_154_rule(Parser *p) +_gather_160_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38750,27 +39789,27 @@ _gather_154_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_155 + { // kwarg_or_double_starred _loop0_161 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_154[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_155")); + D(fprintf(stderr, "%*c> _gather_160[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_161")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_155_rule(p)) // _loop0_155 + (seq = _loop0_161_rule(p)) // _loop0_161 ) { - D(fprintf(stderr, "%*c+ _gather_154[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_155")); + D(fprintf(stderr, "%*c+ _gather_160[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_161")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_154[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_155")); + D(fprintf(stderr, "%*c%s _gather_160[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_161")); } _res = NULL; done: @@ -38778,9 +39817,9 @@ _gather_154_rule(Parser *p) return _res; } -// _tmp_156: simple_slice | expression +// _tmp_162: simple_slice | expression static void * -_tmp_156_rule(Parser *p) +_tmp_162_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38797,18 +39836,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_162[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); expr_ty simple_slice_var; if ( (simple_slice_var = simple_slice_rule(p)) // simple_slice ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); _res = simple_slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_162[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // expression @@ -38816,18 +39855,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c> _tmp_162[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_162[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression")); } _res = NULL; @@ -38836,9 +39875,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: simple_slice | expression +// _tmp_163: simple_slice | expression static void * -_tmp_157_rule(Parser *p) +_tmp_163_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38855,18 +39894,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_163[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); expr_ty simple_slice_var; if ( (simple_slice_var = simple_slice_rule(p)) // simple_slice ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); _res = simple_slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_163[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // expression @@ -38874,18 +39913,18 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c> _tmp_163[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_163[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression")); } _res = NULL; @@ -38894,9 +39933,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _loop0_158: (',' star_target) +// _loop0_164: (',' star_target) static asdl_seq * -_loop0_158_rule(Parser *p) +_loop0_164_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38922,13 +39961,13 @@ _loop0_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_158[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); - void *_tmp_291_var; + D(fprintf(stderr, "%*c> _loop0_164[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); + void *_tmp_299_var; while ( - (_tmp_291_var = _tmp_291_rule(p)) // ',' star_target + (_tmp_299_var = _tmp_299_rule(p)) // ',' star_target ) { - _res = _tmp_291_var; + _res = _tmp_299_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38945,7 +39984,7 @@ _loop0_158_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_158[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_164[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(',' star_target)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38962,9 +40001,9 @@ _loop0_158_rule(Parser *p) return _seq; } -// _loop0_160: ',' star_target +// _loop0_166: ',' star_target static asdl_seq * -_loop0_160_rule(Parser *p) +_loop0_166_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38990,7 +40029,7 @@ _loop0_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_160[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_166[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -39022,7 +40061,7 @@ _loop0_160_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_160[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_166[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39039,9 +40078,9 @@ _loop0_160_rule(Parser *p) return _seq; } -// _gather_159: star_target _loop0_160 +// _gather_165: star_target _loop0_166 static asdl_seq * -_gather_159_rule(Parser *p) +_gather_165_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39053,27 +40092,27 @@ _gather_159_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_160 + { // star_target _loop0_166 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_159[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_160")); + D(fprintf(stderr, "%*c> _gather_165[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_166")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_160_rule(p)) // _loop0_160 + (seq = _loop0_166_rule(p)) // _loop0_166 ) { - D(fprintf(stderr, "%*c+ _gather_159[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_160")); + D(fprintf(stderr, "%*c+ _gather_165[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_166")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_159[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_target _loop0_160")); + D(fprintf(stderr, "%*c%s _gather_165[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_target _loop0_166")); } _res = NULL; done: @@ -39081,9 +40120,9 @@ _gather_159_rule(Parser *p) return _res; } -// _loop1_161: (',' star_target) +// _loop1_167: (',' star_target) static asdl_seq * -_loop1_161_rule(Parser *p) +_loop1_167_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39109,13 +40148,13 @@ _loop1_161_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_161[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); - void *_tmp_292_var; + D(fprintf(stderr, "%*c> _loop1_167[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); + void *_tmp_300_var; while ( - (_tmp_292_var = _tmp_292_rule(p)) // ',' star_target + (_tmp_300_var = _tmp_300_rule(p)) // ',' star_target ) { - _res = _tmp_292_var; + _res = _tmp_300_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -39132,7 +40171,7 @@ _loop1_161_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_161[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_167[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -39154,9 +40193,9 @@ _loop1_161_rule(Parser *p) return _seq; } -// _tmp_162: !'*' star_target +// _tmp_168: !'*' star_target static void * -_tmp_162_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39173,7 +40212,7 @@ _tmp_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_162[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!'*' star_target")); expr_ty star_target_var; if ( _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*' @@ -39181,12 +40220,12 @@ _tmp_162_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_162[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_168[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!'*' star_target")); _res = star_target_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_162[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_168[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "!'*' star_target")); } _res = NULL; @@ -39195,9 +40234,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: genexp | tuplecomp +// _tmp_169: genexp | tuplecomp static void * -_tmp_163_rule(Parser *p) +_tmp_169_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39214,18 +40253,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); expr_ty genexp_var; if ( (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_169[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_163[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_169[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } { // tuplecomp @@ -39233,18 +40272,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c> _tmp_169[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); expr_ty tuplecomp_var; if ( (tuplecomp_var = tuplecomp_rule(p)) // tuplecomp ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c+ _tmp_169[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); _res = tuplecomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_163[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_169[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuplecomp")); } _res = NULL; @@ -39253,9 +40292,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _loop0_165: ',' del_target +// _loop0_171: ',' del_target static asdl_seq * -_loop0_165_rule(Parser *p) +_loop0_171_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39281,7 +40320,7 @@ _loop0_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_165[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_171[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -39313,7 +40352,7 @@ _loop0_165_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_165[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_171[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' del_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39330,9 +40369,9 @@ _loop0_165_rule(Parser *p) return _seq; } -// _gather_164: del_target _loop0_165 +// _gather_170: del_target _loop0_171 static asdl_seq * -_gather_164_rule(Parser *p) +_gather_170_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39344,27 +40383,27 @@ _gather_164_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_165 + { // del_target _loop0_171 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_164[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_165")); + D(fprintf(stderr, "%*c> _gather_170[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_171")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_165_rule(p)) // _loop0_165 + (seq = _loop0_171_rule(p)) // _loop0_171 ) { - D(fprintf(stderr, "%*c+ _gather_164[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_165")); + D(fprintf(stderr, "%*c+ _gather_170[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_171")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_164[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_target _loop0_165")); + D(fprintf(stderr, "%*c%s _gather_170[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_target _loop0_171")); } _res = NULL; done: @@ -39372,9 +40411,9 @@ _gather_164_rule(Parser *p) return _res; } -// _loop0_167: ',' expression +// _loop0_173: ',' expression static asdl_seq * -_loop0_167_rule(Parser *p) +_loop0_173_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39400,7 +40439,7 @@ _loop0_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_167[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_173[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -39432,7 +40471,7 @@ _loop0_167_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_167[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_173[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39449,9 +40488,9 @@ _loop0_167_rule(Parser *p) return _seq; } -// _gather_166: expression _loop0_167 +// _gather_172: expression _loop0_173 static asdl_seq * -_gather_166_rule(Parser *p) +_gather_172_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39463,27 +40502,27 @@ _gather_166_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_167 + { // expression _loop0_173 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_166[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_167")); + D(fprintf(stderr, "%*c> _gather_172[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_173")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_167_rule(p)) // _loop0_167 + (seq = _loop0_173_rule(p)) // _loop0_173 ) { - D(fprintf(stderr, "%*c+ _gather_166[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_167")); + D(fprintf(stderr, "%*c+ _gather_172[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_173")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_166[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_167")); + D(fprintf(stderr, "%*c%s _gather_172[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_173")); } _res = NULL; done: @@ -39491,9 +40530,9 @@ _gather_166_rule(Parser *p) return _res; } -// _loop0_169: ',' expression +// _loop0_175: ',' expression static asdl_seq * -_loop0_169_rule(Parser *p) +_loop0_175_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39519,7 +40558,7 @@ _loop0_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_169[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_175[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -39551,7 +40590,7 @@ _loop0_169_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_169[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_175[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39568,9 +40607,9 @@ _loop0_169_rule(Parser *p) return _seq; } -// _gather_168: expression _loop0_169 +// _gather_174: expression _loop0_175 static asdl_seq * -_gather_168_rule(Parser *p) +_gather_174_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39582,27 +40621,27 @@ _gather_168_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_169 + { // expression _loop0_175 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_168[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_169")); + D(fprintf(stderr, "%*c> _gather_174[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_175")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_169_rule(p)) // _loop0_169 + (seq = _loop0_175_rule(p)) // _loop0_175 ) { - D(fprintf(stderr, "%*c+ _gather_168[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_169")); + D(fprintf(stderr, "%*c+ _gather_174[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_175")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_168[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_169")); + D(fprintf(stderr, "%*c%s _gather_174[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_175")); } _res = NULL; done: @@ -39610,9 +40649,9 @@ _gather_168_rule(Parser *p) return _res; } -// _loop0_171: ',' expression +// _loop0_177: ',' expression static asdl_seq * -_loop0_171_rule(Parser *p) +_loop0_177_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39638,7 +40677,7 @@ _loop0_171_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_171[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_177[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -39670,7 +40709,7 @@ _loop0_171_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_171[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_177[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39687,9 +40726,9 @@ _loop0_171_rule(Parser *p) return _seq; } -// _gather_170: expression _loop0_171 +// _gather_176: expression _loop0_177 static asdl_seq * -_gather_170_rule(Parser *p) +_gather_176_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39701,27 +40740,27 @@ _gather_170_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_171 + { // expression _loop0_177 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_170[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_171")); + D(fprintf(stderr, "%*c> _gather_176[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_177")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_171_rule(p)) // _loop0_171 + (seq = _loop0_177_rule(p)) // _loop0_177 ) { - D(fprintf(stderr, "%*c+ _gather_170[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_171")); + D(fprintf(stderr, "%*c+ _gather_176[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_177")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_170[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_171")); + D(fprintf(stderr, "%*c%s _gather_176[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_177")); } _res = NULL; done: @@ -39729,9 +40768,9 @@ _gather_170_rule(Parser *p) return _res; } -// _loop0_173: ',' expression +// _loop0_179: ',' expression static asdl_seq * -_loop0_173_rule(Parser *p) +_loop0_179_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39757,7 +40796,7 @@ _loop0_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_173[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_179[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -39789,7 +40828,7 @@ _loop0_173_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_173[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_179[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39806,9 +40845,9 @@ _loop0_173_rule(Parser *p) return _seq; } -// _gather_172: expression _loop0_173 +// _gather_178: expression _loop0_179 static asdl_seq * -_gather_172_rule(Parser *p) +_gather_178_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39820,27 +40859,27 @@ _gather_172_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_173 + { // expression _loop0_179 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_172[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_173")); + D(fprintf(stderr, "%*c> _gather_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_179")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_173_rule(p)) // _loop0_173 + (seq = _loop0_179_rule(p)) // _loop0_179 ) { - D(fprintf(stderr, "%*c+ _gather_172[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_173")); + D(fprintf(stderr, "%*c+ _gather_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_179")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_172[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_173")); + D(fprintf(stderr, "%*c%s _gather_178[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_179")); } _res = NULL; done: @@ -39848,9 +40887,9 @@ _gather_172_rule(Parser *p) return _res; } -// _tmp_174: NEWLINE INDENT +// _tmp_180: NEWLINE INDENT static void * -_tmp_174_rule(Parser *p) +_tmp_180_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39867,7 +40906,7 @@ _tmp_174_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_174[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_180[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -39876,12 +40915,12 @@ _tmp_174_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_174[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_180[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); _res = _PyPegen_dummy_name(p, newline_var, indent_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_174[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_180[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); } _res = NULL; @@ -39890,9 +40929,9 @@ _tmp_174_rule(Parser *p) return _res; } -// _tmp_175: args | expression for_if_clauses +// _tmp_181: args | expression for_if_clauses static void * -_tmp_175_rule(Parser *p) +_tmp_181_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39909,18 +40948,18 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); + D(fprintf(stderr, "%*c> _tmp_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); expr_ty args_var; if ( (args_var = args_rule(p)) // args ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); + D(fprintf(stderr, "%*c+ _tmp_181[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); _res = args_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_175[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_181[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "args")); } { // expression for_if_clauses @@ -39928,7 +40967,7 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); expr_ty expression_var; asdl_comprehension_seq* for_if_clauses_var; if ( @@ -39937,12 +40976,12 @@ _tmp_175_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_181[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_175[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_181[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); } _res = NULL; @@ -39951,9 +40990,9 @@ _tmp_175_rule(Parser *p) return _res; } -// _tmp_176: args ',' +// _tmp_182: args ',' static void * -_tmp_176_rule(Parser *p) +_tmp_182_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39970,7 +41009,7 @@ _tmp_176_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_176[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); + D(fprintf(stderr, "%*c> _tmp_182[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -39979,12 +41018,12 @@ _tmp_176_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_176[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_182[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); _res = _PyPegen_dummy_name(p, args_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_176[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_182[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "args ','")); } _res = NULL; @@ -39993,9 +41032,9 @@ _tmp_176_rule(Parser *p) return _res; } -// _tmp_177: ',' | ')' +// _tmp_183: ',' | ')' static void * -_tmp_177_rule(Parser *p) +_tmp_183_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40012,18 +41051,18 @@ _tmp_177_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_177[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_183[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_177[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_183[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_177[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_183[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // ')' @@ -40031,18 +41070,18 @@ _tmp_177_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_177[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_183[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_177[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_183[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_177[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_183[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } _res = NULL; @@ -40051,9 +41090,9 @@ _tmp_177_rule(Parser *p) return _res; } -// _tmp_178: 'True' | 'False' | 'None' +// _tmp_184: 'True' | 'False' | 'None' static void * -_tmp_178_rule(Parser *p) +_tmp_184_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40070,18 +41109,18 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_178[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'True'")); } { // 'False' @@ -40089,18 +41128,18 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_178[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'False'")); } { // 'None' @@ -40108,18 +41147,18 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_178[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } _res = NULL; @@ -40128,9 +41167,9 @@ _tmp_178_rule(Parser *p) return _res; } -// _tmp_179: NAME '=' +// _tmp_185: NAME '=' static void * -_tmp_179_rule(Parser *p) +_tmp_185_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40147,7 +41186,7 @@ _tmp_179_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_179[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_185[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -40156,12 +41195,12 @@ _tmp_179_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_179[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_185[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); _res = _PyPegen_dummy_name(p, name_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_179[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_185[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME '='")); } _res = NULL; @@ -40170,9 +41209,9 @@ _tmp_179_rule(Parser *p) return _res; } -// _tmp_180: NAME STRING | SOFT_KEYWORD +// _tmp_186: NAME STRING | SOFT_KEYWORD static void * -_tmp_180_rule(Parser *p) +_tmp_186_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40189,7 +41228,7 @@ _tmp_180_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_180[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -40198,12 +41237,12 @@ _tmp_180_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_180[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_186[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME STRING")); _res = _PyPegen_dummy_name(p, name_var, string_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_180[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_186[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME STRING")); } { // SOFT_KEYWORD @@ -40211,18 +41250,18 @@ _tmp_180_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_180[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); expr_ty soft_keyword_var; if ( (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD ) { - D(fprintf(stderr, "%*c+ _tmp_180[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_186[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); _res = soft_keyword_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_180[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_186[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); } _res = NULL; @@ -40231,9 +41270,9 @@ _tmp_180_rule(Parser *p) return _res; } -// _tmp_181: 'else' | ':' +// _tmp_187: 'else' | ':' static void * -_tmp_181_rule(Parser *p) +_tmp_187_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40250,18 +41289,18 @@ _tmp_181_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c> _tmp_187[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 705)) // token='else' + (_keyword = _PyPegen_expect_token(p, 709)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_181[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_187[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_181[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_187[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'else'")); } { // ':' @@ -40269,18 +41308,18 @@ _tmp_181_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_187[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_181[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_187[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_181[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_187[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -40289,9 +41328,9 @@ _tmp_181_rule(Parser *p) return _res; } -// _tmp_182: FSTRING_MIDDLE | fstring_replacement_field +// _tmp_188: FSTRING_MIDDLE | fstring_replacement_field static void * -_tmp_182_rule(Parser *p) +_tmp_188_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40308,18 +41347,18 @@ _tmp_182_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_182[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c> _tmp_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); Token * fstring_middle_var; if ( (fstring_middle_var = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE' ) { - D(fprintf(stderr, "%*c+ _tmp_182[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c+ _tmp_188[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); _res = fstring_middle_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_182[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_188[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); } { // fstring_replacement_field @@ -40327,18 +41366,18 @@ _tmp_182_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_182[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); + D(fprintf(stderr, "%*c> _tmp_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); expr_ty fstring_replacement_field_var; if ( (fstring_replacement_field_var = fstring_replacement_field_rule(p)) // fstring_replacement_field ) { - D(fprintf(stderr, "%*c+ _tmp_182[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); + D(fprintf(stderr, "%*c+ _tmp_188[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); _res = fstring_replacement_field_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_182[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_188[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); } _res = NULL; @@ -40347,9 +41386,9 @@ _tmp_182_rule(Parser *p) return _res; } -// _tmp_183: '=' | ':=' +// _tmp_189: '=' | ':=' static void * -_tmp_183_rule(Parser *p) +_tmp_189_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40366,18 +41405,18 @@ _tmp_183_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_183[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_183[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_183[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_189[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } { // ':=' @@ -40385,18 +41424,18 @@ _tmp_183_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_183[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); + D(fprintf(stderr, "%*c> _tmp_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_183[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); + D(fprintf(stderr, "%*c+ _tmp_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_183[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_189[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':='")); } _res = NULL; @@ -40405,9 +41444,9 @@ _tmp_183_rule(Parser *p) return _res; } -// _tmp_184: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_190: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_184_rule(Parser *p) +_tmp_190_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40424,18 +41463,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); expr_ty list_var; if ( (list_var = list_rule(p)) // list ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); _res = list_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "list")); } { // tuple @@ -40443,18 +41482,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); expr_ty tuple_var; if ( (tuple_var = tuple_rule(p)) // tuple ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); _res = tuple_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuple")); } { // genexp @@ -40462,18 +41501,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); expr_ty genexp_var; if ( (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } { // 'True' @@ -40481,18 +41520,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='True' + (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'True'")); } { // 'None' @@ -40500,18 +41539,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } { // 'False' @@ -40519,18 +41558,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 658)) // token='False' + (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'False'")); } _res = NULL; @@ -40539,9 +41578,9 @@ _tmp_184_rule(Parser *p) return _res; } -// _tmp_185: '=' | ':=' +// _tmp_191: '=' | ':=' static void * -_tmp_185_rule(Parser *p) +_tmp_191_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40558,18 +41597,18 @@ _tmp_185_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_185[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_185[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_185[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_191[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } { // ':=' @@ -40577,18 +41616,18 @@ _tmp_185_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_185[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); + D(fprintf(stderr, "%*c> _tmp_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_185[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); + D(fprintf(stderr, "%*c+ _tmp_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_185[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_191[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':='")); } _res = NULL; @@ -40597,9 +41636,9 @@ _tmp_185_rule(Parser *p) return _res; } -// _loop0_186: star_named_expressions +// _loop0_192: star_named_expressions static asdl_seq * -_loop0_186_rule(Parser *p) +_loop0_192_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40625,7 +41664,7 @@ _loop0_186_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expressions")); asdl_expr_seq* star_named_expressions_var; while ( (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions @@ -40648,7 +41687,7 @@ _loop0_186_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_186[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_192[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_named_expressions")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40665,9 +41704,9 @@ _loop0_186_rule(Parser *p) return _seq; } -// _loop0_187: (star_targets '=') +// _loop0_193: (star_targets '=') static asdl_seq * -_loop0_187_rule(Parser *p) +_loop0_193_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40693,13 +41732,13 @@ _loop0_187_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_187[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); - void *_tmp_293_var; + D(fprintf(stderr, "%*c> _loop0_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_301_var; while ( - (_tmp_293_var = _tmp_293_rule(p)) // star_targets '=' + (_tmp_301_var = _tmp_301_rule(p)) // star_targets '=' ) { - _res = _tmp_293_var; + _res = _tmp_301_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -40716,7 +41755,7 @@ _loop0_187_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_187[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_193[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(star_targets '=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40733,9 +41772,9 @@ _loop0_187_rule(Parser *p) return _seq; } -// _loop0_188: (star_targets '=') +// _loop0_194: (star_targets '=') static asdl_seq * -_loop0_188_rule(Parser *p) +_loop0_194_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40761,13 +41800,13 @@ _loop0_188_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); - void *_tmp_294_var; + D(fprintf(stderr, "%*c> _loop0_194[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_302_var; while ( - (_tmp_294_var = _tmp_294_rule(p)) // star_targets '=' + (_tmp_302_var = _tmp_302_rule(p)) // star_targets '=' ) { - _res = _tmp_294_var; + _res = _tmp_302_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -40784,7 +41823,7 @@ _loop0_188_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_188[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_194[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(star_targets '=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40801,9 +41840,9 @@ _loop0_188_rule(Parser *p) return _seq; } -// _tmp_189: yield_expr | star_expressions +// _tmp_195: yield_expr | star_expressions static void * -_tmp_189_rule(Parser *p) +_tmp_195_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40820,18 +41859,18 @@ _tmp_189_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_195[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_189[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_195[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -40839,18 +41878,18 @@ _tmp_189_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_195[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_189[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_195[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -40859,9 +41898,9 @@ _tmp_189_rule(Parser *p) return _res; } -// _tmp_190: '[' | '(' | '{' +// _tmp_196: '[' | '(' | '{' static void * -_tmp_190_rule(Parser *p) +_tmp_196_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40878,18 +41917,18 @@ _tmp_190_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c> _tmp_196[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c+ _tmp_196[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_196[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'['")); } { // '(' @@ -40897,18 +41936,18 @@ _tmp_190_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c> _tmp_196[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c+ _tmp_196[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_196[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'('")); } { // '{' @@ -40916,18 +41955,18 @@ _tmp_190_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c> _tmp_196[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_196[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_190[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_196[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -40936,9 +41975,9 @@ _tmp_190_rule(Parser *p) return _res; } -// _tmp_191: '[' | '{' +// _tmp_197: '[' | '{' static void * -_tmp_191_rule(Parser *p) +_tmp_197_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40955,18 +41994,18 @@ _tmp_191_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c> _tmp_197[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c+ _tmp_197[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_191[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_197[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'['")); } { // '{' @@ -40974,18 +42013,18 @@ _tmp_191_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c> _tmp_197[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_197[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_191[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_197[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -40994,9 +42033,9 @@ _tmp_191_rule(Parser *p) return _res; } -// _tmp_192: '[' | '{' +// _tmp_198: '[' | '{' static void * -_tmp_192_rule(Parser *p) +_tmp_198_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41013,18 +42052,18 @@ _tmp_192_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c> _tmp_198[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_192[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c+ _tmp_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_192[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_198[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'['")); } { // '{' @@ -41032,18 +42071,18 @@ _tmp_192_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c> _tmp_198[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_192[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_192[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_198[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -41052,9 +42091,9 @@ _tmp_192_rule(Parser *p) return _res; } -// _tmp_193: slash_no_default | slash_with_default +// _tmp_199: slash_no_default | slash_with_default static void * -_tmp_193_rule(Parser *p) +_tmp_199_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41071,18 +42110,18 @@ _tmp_193_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_193[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_199[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); _res = slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_193[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_199[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_no_default")); } { // slash_with_default @@ -41090,18 +42129,18 @@ _tmp_193_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_193[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_199[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); _res = slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_193[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_199[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_with_default")); } _res = NULL; @@ -41110,9 +42149,9 @@ _tmp_193_rule(Parser *p) return _res; } -// _loop0_194: param_maybe_default +// _loop0_200: param_maybe_default static asdl_seq * -_loop0_194_rule(Parser *p) +_loop0_200_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41138,7 +42177,7 @@ _loop0_194_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_194[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_200[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -41161,7 +42200,7 @@ _loop0_194_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_194[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_200[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41178,9 +42217,9 @@ _loop0_194_rule(Parser *p) return _seq; } -// _loop0_195: param_no_default +// _loop0_201: param_no_default static asdl_seq * -_loop0_195_rule(Parser *p) +_loop0_201_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41206,7 +42245,7 @@ _loop0_195_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_201[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -41229,7 +42268,7 @@ _loop0_195_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_195[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_201[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41246,9 +42285,9 @@ _loop0_195_rule(Parser *p) return _seq; } -// _loop0_196: param_no_default +// _loop0_202: param_no_default static asdl_seq * -_loop0_196_rule(Parser *p) +_loop0_202_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41274,7 +42313,7 @@ _loop0_196_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_196[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_202[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -41297,7 +42336,7 @@ _loop0_196_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_196[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_202[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41314,9 +42353,9 @@ _loop0_196_rule(Parser *p) return _seq; } -// _loop1_197: param_no_default +// _loop1_203: param_no_default static asdl_seq * -_loop1_197_rule(Parser *p) +_loop1_203_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41342,7 +42381,7 @@ _loop1_197_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_197[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_203[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); arg_ty param_no_default_var; while ( (param_no_default_var = param_no_default_rule(p)) // param_no_default @@ -41365,7 +42404,7 @@ _loop1_197_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_197[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_203[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -41387,9 +42426,9 @@ _loop1_197_rule(Parser *p) return _seq; } -// _tmp_198: slash_no_default | slash_with_default +// _tmp_204: slash_no_default | slash_with_default static void * -_tmp_198_rule(Parser *p) +_tmp_204_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41406,18 +42445,18 @@ _tmp_198_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_198[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); _res = slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_198[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_204[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_no_default")); } { // slash_with_default @@ -41425,18 +42464,18 @@ _tmp_198_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_198[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); _res = slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_198[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_204[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_with_default")); } _res = NULL; @@ -41445,9 +42484,9 @@ _tmp_198_rule(Parser *p) return _res; } -// _loop0_199: param_maybe_default +// _loop0_205: param_maybe_default static asdl_seq * -_loop0_199_rule(Parser *p) +_loop0_205_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41473,7 +42512,7 @@ _loop0_199_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -41496,7 +42535,7 @@ _loop0_199_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_199[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41513,9 +42552,9 @@ _loop0_199_rule(Parser *p) return _seq; } -// _tmp_200: ',' | param_no_default +// _tmp_206: ',' | param_no_default static void * -_tmp_200_rule(Parser *p) +_tmp_206_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41532,18 +42571,18 @@ _tmp_200_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_200[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_206[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_200[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_206[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_200[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_206[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // param_no_default @@ -41551,18 +42590,18 @@ _tmp_200_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_200[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_206[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_200[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_206[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_200[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_206[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } _res = NULL; @@ -41571,9 +42610,9 @@ _tmp_200_rule(Parser *p) return _res; } -// _loop0_201: param_maybe_default +// _loop0_207: param_maybe_default static asdl_seq * -_loop0_201_rule(Parser *p) +_loop0_207_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41599,7 +42638,7 @@ _loop0_201_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_201[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_207[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -41622,7 +42661,7 @@ _loop0_201_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_201[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_207[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41639,9 +42678,9 @@ _loop0_201_rule(Parser *p) return _seq; } -// _loop1_202: param_maybe_default +// _loop1_208: param_maybe_default static asdl_seq * -_loop1_202_rule(Parser *p) +_loop1_208_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41667,7 +42706,7 @@ _loop1_202_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_202[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -41690,7 +42729,7 @@ _loop1_202_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_202[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_208[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -41712,9 +42751,9 @@ _loop1_202_rule(Parser *p) return _seq; } -// _tmp_203: ')' | ',' +// _tmp_209: ')' | ',' static void * -_tmp_203_rule(Parser *p) +_tmp_209_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41731,18 +42770,18 @@ _tmp_203_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_203[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_203[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_209[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_203[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_209[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // ',' @@ -41750,18 +42789,18 @@ _tmp_203_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_203[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_203[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_209[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_203[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_209[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -41770,9 +42809,9 @@ _tmp_203_rule(Parser *p) return _res; } -// _tmp_204: ')' | ',' (')' | '**') +// _tmp_210: ')' | ',' (')' | '**') static void * -_tmp_204_rule(Parser *p) +_tmp_210_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41789,18 +42828,18 @@ _tmp_204_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_210[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_210[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_210[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // ',' (')' | '**') @@ -41808,21 +42847,21 @@ _tmp_204_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_210[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); Token * _literal; - void *_tmp_295_var; + void *_tmp_303_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_295_var = _tmp_295_rule(p)) // ')' | '**' + (_tmp_303_var = _tmp_303_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_295_var); + D(fprintf(stderr, "%*c+ _tmp_210[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_303_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_210[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); } _res = NULL; @@ -41831,9 +42870,9 @@ _tmp_204_rule(Parser *p) return _res; } -// _tmp_205: param_no_default | ',' +// _tmp_211: param_no_default | ',' static void * -_tmp_205_rule(Parser *p) +_tmp_211_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41850,18 +42889,18 @@ _tmp_205_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_211[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_211[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_211[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } { // ',' @@ -41869,18 +42908,18 @@ _tmp_205_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_211[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_211[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_211[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -41889,9 +42928,9 @@ _tmp_205_rule(Parser *p) return _res; } -// _loop0_206: param_maybe_default +// _loop0_212: param_maybe_default static asdl_seq * -_loop0_206_rule(Parser *p) +_loop0_212_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41917,7 +42956,7 @@ _loop0_206_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_206[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_212[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default @@ -41940,7 +42979,7 @@ _loop0_206_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_206[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_212[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41957,9 +42996,9 @@ _loop0_206_rule(Parser *p) return _seq; } -// _tmp_207: param_no_default | ',' +// _tmp_213: param_no_default | ',' static void * -_tmp_207_rule(Parser *p) +_tmp_213_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41976,18 +43015,18 @@ _tmp_207_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_207[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_213[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_207[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_207[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_213[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } { // ',' @@ -41995,18 +43034,18 @@ _tmp_207_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_207[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_213[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_207[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_207[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_213[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -42015,9 +43054,9 @@ _tmp_207_rule(Parser *p) return _res; } -// _tmp_208: '*' | '**' | '/' +// _tmp_214: '*' | '**' | '/' static void * -_tmp_208_rule(Parser *p) +_tmp_214_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42034,18 +43073,18 @@ _tmp_208_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c> _tmp_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_208[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_214[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_208[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_214[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*'")); } { // '**' @@ -42053,18 +43092,18 @@ _tmp_208_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_208[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_214[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_208[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_214[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } { // '/' @@ -42072,18 +43111,18 @@ _tmp_208_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c> _tmp_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_208[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_214[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_208[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_214[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'/'")); } _res = NULL; @@ -42092,9 +43131,9 @@ _tmp_208_rule(Parser *p) return _res; } -// _loop1_209: param_with_default +// _loop1_215: param_with_default static asdl_seq * -_loop1_209_rule(Parser *p) +_loop1_215_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42120,7 +43159,7 @@ _loop1_209_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop1_215[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); NameDefaultPair* param_with_default_var; while ( (param_with_default_var = param_with_default_rule(p)) // param_with_default @@ -42143,7 +43182,7 @@ _loop1_209_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_209[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_215[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -42165,9 +43204,9 @@ _loop1_209_rule(Parser *p) return _seq; } -// _tmp_210: lambda_slash_no_default | lambda_slash_with_default +// _tmp_216: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_210_rule(Parser *p) +_tmp_216_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42184,18 +43223,18 @@ _tmp_210_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_210[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_216[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_210[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_216[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); _res = lambda_slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_210[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_216[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -42203,18 +43242,18 @@ _tmp_210_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_210[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_216[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_210[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_216[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); _res = lambda_slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_210[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_216[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); } _res = NULL; @@ -42223,9 +43262,9 @@ _tmp_210_rule(Parser *p) return _res; } -// _loop0_211: lambda_param_maybe_default +// _loop0_217: lambda_param_maybe_default static asdl_seq * -_loop0_211_rule(Parser *p) +_loop0_217_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42251,7 +43290,7 @@ _loop0_211_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_211[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_217[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -42274,7 +43313,7 @@ _loop0_211_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_217[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42291,9 +43330,9 @@ _loop0_211_rule(Parser *p) return _seq; } -// _loop0_212: lambda_param_no_default +// _loop0_218: lambda_param_no_default static asdl_seq * -_loop0_212_rule(Parser *p) +_loop0_218_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42319,7 +43358,7 @@ _loop0_212_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_212[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_218[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -42342,7 +43381,7 @@ _loop0_212_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_212[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_218[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42359,9 +43398,9 @@ _loop0_212_rule(Parser *p) return _seq; } -// _loop0_213: lambda_param_no_default +// _loop0_219: lambda_param_no_default static asdl_seq * -_loop0_213_rule(Parser *p) +_loop0_219_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42387,7 +43426,7 @@ _loop0_213_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_213[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_219[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -42410,7 +43449,7 @@ _loop0_213_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_213[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_219[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42427,9 +43466,9 @@ _loop0_213_rule(Parser *p) return _seq; } -// _loop0_215: ',' lambda_param +// _loop0_221: ',' lambda_param static asdl_seq * -_loop0_215_rule(Parser *p) +_loop0_221_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42455,7 +43494,7 @@ _loop0_215_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_215[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_221[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -42487,7 +43526,7 @@ _loop0_215_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_215[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_221[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' lambda_param")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42504,9 +43543,9 @@ _loop0_215_rule(Parser *p) return _seq; } -// _gather_214: lambda_param _loop0_215 +// _gather_220: lambda_param _loop0_221 static asdl_seq * -_gather_214_rule(Parser *p) +_gather_220_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42518,27 +43557,27 @@ _gather_214_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_215 + { // lambda_param _loop0_221 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_215")); + D(fprintf(stderr, "%*c> _gather_220[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_221")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_215_rule(p)) // _loop0_215 + (seq = _loop0_221_rule(p)) // _loop0_221 ) { - D(fprintf(stderr, "%*c+ _gather_214[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_215")); + D(fprintf(stderr, "%*c+ _gather_220[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_221")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_214[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_215")); + D(fprintf(stderr, "%*c%s _gather_220[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_221")); } _res = NULL; done: @@ -42546,9 +43585,9 @@ _gather_214_rule(Parser *p) return _res; } -// _tmp_216: lambda_slash_no_default | lambda_slash_with_default +// _tmp_222: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_216_rule(Parser *p) +_tmp_222_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42565,18 +43604,18 @@ _tmp_216_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_216[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_222[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_216[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_222[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); _res = lambda_slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_216[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_222[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -42584,18 +43623,18 @@ _tmp_216_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_216[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_222[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_216[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_222[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); _res = lambda_slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_216[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_222[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); } _res = NULL; @@ -42604,9 +43643,9 @@ _tmp_216_rule(Parser *p) return _res; } -// _loop0_217: lambda_param_maybe_default +// _loop0_223: lambda_param_maybe_default static asdl_seq * -_loop0_217_rule(Parser *p) +_loop0_223_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42632,7 +43671,7 @@ _loop0_217_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_217[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_223[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -42655,7 +43694,7 @@ _loop0_217_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_217[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_223[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42672,9 +43711,9 @@ _loop0_217_rule(Parser *p) return _seq; } -// _tmp_218: ',' | lambda_param_no_default +// _tmp_224: ',' | lambda_param_no_default static void * -_tmp_218_rule(Parser *p) +_tmp_224_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42691,18 +43730,18 @@ _tmp_218_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_218[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_224[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_218[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_224[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_218[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_224[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // lambda_param_no_default @@ -42710,18 +43749,18 @@ _tmp_218_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_218[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_224[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_218[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_224[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_218[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_224[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } _res = NULL; @@ -42730,9 +43769,9 @@ _tmp_218_rule(Parser *p) return _res; } -// _loop0_219: lambda_param_maybe_default +// _loop0_225: lambda_param_maybe_default static asdl_seq * -_loop0_219_rule(Parser *p) +_loop0_225_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42758,7 +43797,7 @@ _loop0_219_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_219[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_225[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -42781,7 +43820,7 @@ _loop0_219_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_219[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_225[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42798,9 +43837,9 @@ _loop0_219_rule(Parser *p) return _seq; } -// _loop1_220: lambda_param_maybe_default +// _loop1_226: lambda_param_maybe_default static asdl_seq * -_loop1_220_rule(Parser *p) +_loop1_226_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42826,7 +43865,7 @@ _loop1_220_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_220[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -42849,7 +43888,7 @@ _loop1_220_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_220[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_226[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -42871,9 +43910,9 @@ _loop1_220_rule(Parser *p) return _seq; } -// _loop1_221: lambda_param_with_default +// _loop1_227: lambda_param_with_default static asdl_seq * -_loop1_221_rule(Parser *p) +_loop1_227_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42899,7 +43938,7 @@ _loop1_221_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_221[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_227[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -42922,7 +43961,7 @@ _loop1_221_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_221[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_227[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -42944,9 +43983,9 @@ _loop1_221_rule(Parser *p) return _seq; } -// _tmp_222: ':' | ',' (':' | '**') +// _tmp_228: ':' | ',' (':' | '**') static void * -_tmp_222_rule(Parser *p) +_tmp_228_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42963,18 +44002,18 @@ _tmp_222_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_222[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_222[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_228[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_222[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_228[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // ',' (':' | '**') @@ -42982,21 +44021,21 @@ _tmp_222_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_222[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); + D(fprintf(stderr, "%*c> _tmp_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); Token * _literal; - void *_tmp_296_var; + void *_tmp_304_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_296_var = _tmp_296_rule(p)) // ':' | '**' + (_tmp_304_var = _tmp_304_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_222[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_296_var); + D(fprintf(stderr, "%*c+ _tmp_228[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_304_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_222[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_228[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); } _res = NULL; @@ -43005,9 +44044,9 @@ _tmp_222_rule(Parser *p) return _res; } -// _tmp_223: lambda_param_no_default | ',' +// _tmp_229: lambda_param_no_default | ',' static void * -_tmp_223_rule(Parser *p) +_tmp_229_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43024,18 +44063,18 @@ _tmp_223_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_223[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_223[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_229[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_223[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_229[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } { // ',' @@ -43043,18 +44082,18 @@ _tmp_223_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_223[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_223[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_229[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_223[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_229[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -43063,9 +44102,9 @@ _tmp_223_rule(Parser *p) return _res; } -// _loop0_224: lambda_param_maybe_default +// _loop0_230: lambda_param_maybe_default static asdl_seq * -_loop0_224_rule(Parser *p) +_loop0_230_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43091,7 +44130,7 @@ _loop0_224_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_224[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_230[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -43114,7 +44153,7 @@ _loop0_224_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_224[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_230[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43131,9 +44170,9 @@ _loop0_224_rule(Parser *p) return _seq; } -// _tmp_225: lambda_param_no_default | ',' +// _tmp_231: lambda_param_no_default | ',' static void * -_tmp_225_rule(Parser *p) +_tmp_231_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43150,18 +44189,18 @@ _tmp_225_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_225[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_231[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_225[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_231[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_225[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_231[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } { // ',' @@ -43169,18 +44208,18 @@ _tmp_225_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_225[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_231[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_225[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_231[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_225[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_231[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -43189,9 +44228,9 @@ _tmp_225_rule(Parser *p) return _res; } -// _tmp_226: '*' | '**' | '/' +// _tmp_232: '*' | '**' | '/' static void * -_tmp_226_rule(Parser *p) +_tmp_232_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43208,18 +44247,18 @@ _tmp_226_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c> _tmp_232[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_226[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_232[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*'")); } { // '**' @@ -43227,18 +44266,18 @@ _tmp_226_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_232[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_226[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_232[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } { // '/' @@ -43246,18 +44285,18 @@ _tmp_226_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c> _tmp_232[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_226[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_232[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'/'")); } _res = NULL; @@ -43266,9 +44305,9 @@ _tmp_226_rule(Parser *p) return _res; } -// _tmp_227: ',' | ')' | ':' +// _tmp_233: ',' | ')' | ':' static void * -_tmp_227_rule(Parser *p) +_tmp_233_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43285,18 +44324,18 @@ _tmp_227_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_227[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_233[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_227[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_233[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_227[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_233[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // ')' @@ -43304,18 +44343,18 @@ _tmp_227_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_227[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_233[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_227[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_233[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_227[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_233[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // ':' @@ -43323,18 +44362,18 @@ _tmp_227_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_227[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_233[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_227[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_233[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_227[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_233[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -43343,9 +44382,9 @@ _tmp_227_rule(Parser *p) return _res; } -// _loop0_229: ',' dotted_name +// _loop0_235: ',' dotted_name static asdl_seq * -_loop0_229_rule(Parser *p) +_loop0_235_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43371,7 +44410,7 @@ _loop0_229_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_235[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -43403,7 +44442,7 @@ _loop0_229_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_229[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_235[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' dotted_name")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43420,9 +44459,9 @@ _loop0_229_rule(Parser *p) return _seq; } -// _gather_228: dotted_name _loop0_229 +// _gather_234: dotted_name _loop0_235 static asdl_seq * -_gather_228_rule(Parser *p) +_gather_234_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43434,27 +44473,27 @@ _gather_228_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_229 + { // dotted_name _loop0_235 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_229")); + D(fprintf(stderr, "%*c> _gather_234[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_235")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_229_rule(p)) // _loop0_229 + (seq = _loop0_235_rule(p)) // _loop0_235 ) { - D(fprintf(stderr, "%*c+ _gather_228[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_229")); + D(fprintf(stderr, "%*c+ _gather_234[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_235")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_228[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_name _loop0_229")); + D(fprintf(stderr, "%*c%s _gather_234[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_name _loop0_235")); } _res = NULL; done: @@ -43462,9 +44501,9 @@ _gather_228_rule(Parser *p) return _res; } -// _loop0_231: ',' (expression ['as' star_target]) +// _loop0_237: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_231_rule(Parser *p) +_loop0_237_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43490,13 +44529,13 @@ _loop0_231_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_231[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_237[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_297_rule(p)) // expression ['as' star_target] + (elem = _tmp_305_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -43522,7 +44561,7 @@ _loop0_231_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_231[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_237[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43539,9 +44578,9 @@ _loop0_231_rule(Parser *p) return _seq; } -// _gather_230: (expression ['as' star_target]) _loop0_231 +// _gather_236: (expression ['as' star_target]) _loop0_237 static asdl_seq * -_gather_230_rule(Parser *p) +_gather_236_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43553,27 +44592,27 @@ _gather_230_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_231 + { // (expression ['as' star_target]) _loop0_237 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_230[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_231")); + D(fprintf(stderr, "%*c> _gather_236[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_237")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_297_rule(p)) // expression ['as' star_target] + (elem = _tmp_305_rule(p)) // expression ['as' star_target] && - (seq = _loop0_231_rule(p)) // _loop0_231 + (seq = _loop0_237_rule(p)) // _loop0_237 ) { - D(fprintf(stderr, "%*c+ _gather_230[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_231")); + D(fprintf(stderr, "%*c+ _gather_236[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_237")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_230[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_231")); + D(fprintf(stderr, "%*c%s _gather_236[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_237")); } _res = NULL; done: @@ -43581,9 +44620,9 @@ _gather_230_rule(Parser *p) return _res; } -// _loop0_233: ',' (expressions ['as' star_target]) +// _loop0_239: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_233_rule(Parser *p) +_loop0_239_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43609,13 +44648,13 @@ _loop0_233_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_233[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_239[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_298_rule(p)) // expressions ['as' star_target] + (elem = _tmp_306_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -43641,7 +44680,7 @@ _loop0_233_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_233[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_239[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43658,9 +44697,9 @@ _loop0_233_rule(Parser *p) return _seq; } -// _gather_232: (expressions ['as' star_target]) _loop0_233 +// _gather_238: (expressions ['as' star_target]) _loop0_239 static asdl_seq * -_gather_232_rule(Parser *p) +_gather_238_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43672,27 +44711,27 @@ _gather_232_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_233 + { // (expressions ['as' star_target]) _loop0_239 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_232[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_233")); + D(fprintf(stderr, "%*c> _gather_238[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_239")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_298_rule(p)) // expressions ['as' star_target] + (elem = _tmp_306_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_233_rule(p)) // _loop0_233 + (seq = _loop0_239_rule(p)) // _loop0_239 ) { - D(fprintf(stderr, "%*c+ _gather_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_233")); + D(fprintf(stderr, "%*c+ _gather_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_239")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_232[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_233")); + D(fprintf(stderr, "%*c%s _gather_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_239")); } _res = NULL; done: @@ -43700,9 +44739,9 @@ _gather_232_rule(Parser *p) return _res; } -// _loop0_235: ',' (expression ['as' star_target]) +// _loop0_241: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_235_rule(Parser *p) +_loop0_241_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43728,13 +44767,13 @@ _loop0_235_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_235[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_241[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_299_rule(p)) // expression ['as' star_target] + (elem = _tmp_307_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -43760,7 +44799,7 @@ _loop0_235_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_235[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_241[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43777,9 +44816,9 @@ _loop0_235_rule(Parser *p) return _seq; } -// _gather_234: (expression ['as' star_target]) _loop0_235 +// _gather_240: (expression ['as' star_target]) _loop0_241 static asdl_seq * -_gather_234_rule(Parser *p) +_gather_240_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43791,27 +44830,27 @@ _gather_234_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_235 + { // (expression ['as' star_target]) _loop0_241 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_234[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_235")); + D(fprintf(stderr, "%*c> _gather_240[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_241")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_299_rule(p)) // expression ['as' star_target] + (elem = _tmp_307_rule(p)) // expression ['as' star_target] && - (seq = _loop0_235_rule(p)) // _loop0_235 + (seq = _loop0_241_rule(p)) // _loop0_241 ) { - D(fprintf(stderr, "%*c+ _gather_234[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_235")); + D(fprintf(stderr, "%*c+ _gather_240[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_241")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_234[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_235")); + D(fprintf(stderr, "%*c%s _gather_240[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_241")); } _res = NULL; done: @@ -43819,9 +44858,9 @@ _gather_234_rule(Parser *p) return _res; } -// _loop0_237: ',' (expressions ['as' star_target]) +// _loop0_243: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_237_rule(Parser *p) +_loop0_243_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43847,13 +44886,13 @@ _loop0_237_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_237[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_243[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_300_rule(p)) // expressions ['as' star_target] + (elem = _tmp_308_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -43879,7 +44918,7 @@ _loop0_237_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_237[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_243[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43896,9 +44935,9 @@ _loop0_237_rule(Parser *p) return _seq; } -// _gather_236: (expressions ['as' star_target]) _loop0_237 +// _gather_242: (expressions ['as' star_target]) _loop0_243 static asdl_seq * -_gather_236_rule(Parser *p) +_gather_242_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43910,27 +44949,27 @@ _gather_236_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_237 + { // (expressions ['as' star_target]) _loop0_243 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_236[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_237")); + D(fprintf(stderr, "%*c> _gather_242[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_243")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_300_rule(p)) // expressions ['as' star_target] + (elem = _tmp_308_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_237_rule(p)) // _loop0_237 + (seq = _loop0_243_rule(p)) // _loop0_243 ) { - D(fprintf(stderr, "%*c+ _gather_236[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_237")); + D(fprintf(stderr, "%*c+ _gather_242[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_243")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_236[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_237")); + D(fprintf(stderr, "%*c%s _gather_242[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_243")); } _res = NULL; done: @@ -43938,9 +44977,9 @@ _gather_236_rule(Parser *p) return _res; } -// _tmp_238: 'except' | 'finally' +// _tmp_244: 'except' | 'finally' static void * -_tmp_238_rule(Parser *p) +_tmp_244_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43957,18 +44996,18 @@ _tmp_238_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_238[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c> _tmp_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='except' + (_keyword = _PyPegen_expect_token(p, 701)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_244[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_244[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except'")); } { // 'finally' @@ -43976,18 +45015,18 @@ _tmp_238_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_238[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 693)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 697)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_244[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_244[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'finally'")); } _res = NULL; @@ -43996,9 +45035,9 @@ _tmp_238_rule(Parser *p) return _res; } -// _loop0_239: block +// _loop0_245: block static asdl_seq * -_loop0_239_rule(Parser *p) +_loop0_245_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44024,7 +45063,7 @@ _loop0_239_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_239[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c> _loop0_245[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -44047,7 +45086,7 @@ _loop0_239_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_239[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_245[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -44064,9 +45103,9 @@ _loop0_239_rule(Parser *p) return _seq; } -// _loop1_240: except_block +// _loop1_246: except_block static asdl_seq * -_loop1_240_rule(Parser *p) +_loop1_246_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44092,7 +45131,7 @@ _loop1_240_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_240[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); + D(fprintf(stderr, "%*c> _loop1_246[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); excepthandler_ty except_block_var; while ( (except_block_var = except_block_rule(p)) // except_block @@ -44115,7 +45154,7 @@ _loop1_240_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_240[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_246[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_block")); } if (_n == 0 || p->error_indicator) { @@ -44137,9 +45176,9 @@ _loop1_240_rule(Parser *p) return _seq; } -// _tmp_241: 'as' NAME +// _tmp_247: 'as' NAME static void * -_tmp_241_rule(Parser *p) +_tmp_247_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44156,21 +45195,21 @@ _tmp_241_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_241[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_247[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_241[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = _PyPegen_dummy_name(p, _keyword, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_241[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_247[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -44179,9 +45218,9 @@ _tmp_241_rule(Parser *p) return _res; } -// _loop0_242: block +// _loop0_248: block static asdl_seq * -_loop0_242_rule(Parser *p) +_loop0_248_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44207,7 +45246,7 @@ _loop0_242_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_242[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c> _loop0_248[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -44230,7 +45269,7 @@ _loop0_242_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_242[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_248[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -44247,9 +45286,9 @@ _loop0_242_rule(Parser *p) return _seq; } -// _loop1_243: except_star_block +// _loop1_249: except_star_block static asdl_seq * -_loop1_243_rule(Parser *p) +_loop1_249_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44275,7 +45314,7 @@ _loop1_243_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_243[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); + D(fprintf(stderr, "%*c> _loop1_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); excepthandler_ty except_star_block_var; while ( (except_star_block_var = except_star_block_rule(p)) // except_star_block @@ -44298,7 +45337,7 @@ _loop1_243_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_243[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_249[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_star_block")); } if (_n == 0 || p->error_indicator) { @@ -44320,9 +45359,9 @@ _loop1_243_rule(Parser *p) return _seq; } -// _tmp_244: expression ['as' NAME] +// _tmp_250: expression ['as' NAME] static void * -_tmp_244_rule(Parser *p) +_tmp_250_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44339,22 +45378,22 @@ _tmp_244_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_250[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_301_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_309_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_244[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_250[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_244[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_250[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); } _res = NULL; @@ -44363,9 +45402,9 @@ _tmp_244_rule(Parser *p) return _res; } -// _tmp_245: 'as' NAME +// _tmp_251: 'as' NAME static void * -_tmp_245_rule(Parser *p) +_tmp_251_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44382,21 +45421,21 @@ _tmp_245_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_245[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_251[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_245[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_251[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = _PyPegen_dummy_name(p, _keyword, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_245[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_251[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -44405,9 +45444,9 @@ _tmp_245_rule(Parser *p) return _res; } -// _tmp_246: 'as' NAME +// _tmp_252: 'as' NAME static void * -_tmp_246_rule(Parser *p) +_tmp_252_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44424,21 +45463,21 @@ _tmp_246_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_246[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_252[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_246[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_252[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = _PyPegen_dummy_name(p, _keyword, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_246[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_252[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -44447,9 +45486,9 @@ _tmp_246_rule(Parser *p) return _res; } -// _tmp_247: NEWLINE | ':' +// _tmp_253: NEWLINE | ':' static void * -_tmp_247_rule(Parser *p) +_tmp_253_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44466,18 +45505,18 @@ _tmp_247_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_247[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_253[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_253[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_247[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_253[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE")); } { // ':' @@ -44485,18 +45524,18 @@ _tmp_247_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_247[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_253[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_253[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_247[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_253[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -44505,9 +45544,9 @@ _tmp_247_rule(Parser *p) return _res; } -// _tmp_248: 'as' NAME +// _tmp_254: 'as' NAME static void * -_tmp_248_rule(Parser *p) +_tmp_254_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44524,21 +45563,21 @@ _tmp_248_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_248[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_254[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_248[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_254[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = _PyPegen_dummy_name(p, _keyword, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_254[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -44547,9 +45586,9 @@ _tmp_248_rule(Parser *p) return _res; } -// _tmp_249: 'as' NAME +// _tmp_255: 'as' NAME static void * -_tmp_249_rule(Parser *p) +_tmp_255_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44566,21 +45605,21 @@ _tmp_249_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_255[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_249[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_255[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = _PyPegen_dummy_name(p, _keyword, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_249[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_255[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -44589,9 +45628,9 @@ _tmp_249_rule(Parser *p) return _res; } -// _tmp_250: positional_patterns ',' +// _tmp_256: positional_patterns ',' static void * -_tmp_250_rule(Parser *p) +_tmp_256_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44608,7 +45647,7 @@ _tmp_250_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_250[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_256[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -44617,12 +45656,12 @@ _tmp_250_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_250[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_256[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "positional_patterns ','")); _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_250[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_256[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "positional_patterns ','")); } _res = NULL; @@ -44631,9 +45670,9 @@ _tmp_250_rule(Parser *p) return _res; } -// _tmp_251: '->' expression +// _tmp_257: '->' expression static void * -_tmp_251_rule(Parser *p) +_tmp_257_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44650,7 +45689,7 @@ _tmp_251_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_251[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c> _tmp_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); Token * _literal; expr_ty expression_var; if ( @@ -44659,12 +45698,12 @@ _tmp_251_rule(Parser *p) (expression_var = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_251[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c+ _tmp_257[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); _res = _PyPegen_dummy_name(p, _literal, expression_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_251[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_257[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); } _res = NULL; @@ -44673,9 +45712,9 @@ _tmp_251_rule(Parser *p) return _res; } -// _tmp_252: '(' arguments? ')' +// _tmp_258: '(' arguments? ')' static void * -_tmp_252_rule(Parser *p) +_tmp_258_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44692,7 +45731,7 @@ _tmp_252_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_252[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_258[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *_opt_var; @@ -44705,12 +45744,12 @@ _tmp_252_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_252[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_258[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_252[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_258[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); } _res = NULL; @@ -44719,9 +45758,9 @@ _tmp_252_rule(Parser *p) return _res; } -// _tmp_253: '(' arguments? ')' +// _tmp_259: '(' arguments? ')' static void * -_tmp_253_rule(Parser *p) +_tmp_259_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44738,7 +45777,7 @@ _tmp_253_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_253[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_259[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *_opt_var; @@ -44751,12 +45790,12 @@ _tmp_253_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_253[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_259[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_253[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_259[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); } _res = NULL; @@ -44765,9 +45804,9 @@ _tmp_253_rule(Parser *p) return _res; } -// _loop0_255: ',' double_starred_kvpair +// _loop0_261: ',' double_starred_kvpair static asdl_seq * -_loop0_255_rule(Parser *p) +_loop0_261_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44793,7 +45832,7 @@ _loop0_255_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_255[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -44825,7 +45864,7 @@ _loop0_255_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_255[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_261[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -44842,9 +45881,9 @@ _loop0_255_rule(Parser *p) return _seq; } -// _gather_254: double_starred_kvpair _loop0_255 +// _gather_260: double_starred_kvpair _loop0_261 static asdl_seq * -_gather_254_rule(Parser *p) +_gather_260_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44856,27 +45895,27 @@ _gather_254_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_255 + { // double_starred_kvpair _loop0_261 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_254[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_255")); + D(fprintf(stderr, "%*c> _gather_260[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_261")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_255_rule(p)) // _loop0_255 + (seq = _loop0_261_rule(p)) // _loop0_261 ) { - D(fprintf(stderr, "%*c+ _gather_254[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_255")); + D(fprintf(stderr, "%*c+ _gather_260[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_261")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_254[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_255")); + D(fprintf(stderr, "%*c%s _gather_260[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_261")); } _res = NULL; done: @@ -44884,9 +45923,9 @@ _gather_254_rule(Parser *p) return _res; } -// _tmp_256: '}' | ',' +// _tmp_262: '}' | ',' static void * -_tmp_256_rule(Parser *p) +_tmp_262_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44903,18 +45942,18 @@ _tmp_256_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_256[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_262[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_256[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_256[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_262[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } { // ',' @@ -44922,18 +45961,18 @@ _tmp_256_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_256[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_262[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_256[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_256[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_262[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -44942,9 +45981,9 @@ _tmp_256_rule(Parser *p) return _res; } -// _tmp_257: '}' | ',' +// _tmp_263: '}' | ',' static void * -_tmp_257_rule(Parser *p) +_tmp_263_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44961,18 +46000,18 @@ _tmp_257_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_263[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_257[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_257[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_263[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } { // ',' @@ -44980,18 +46019,18 @@ _tmp_257_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_263[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_257[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_257[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_263[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -45000,9 +46039,9 @@ _tmp_257_rule(Parser *p) return _res; } -// _tmp_258: yield_expr | star_expressions +// _tmp_264: yield_expr | star_expressions static void * -_tmp_258_rule(Parser *p) +_tmp_264_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45019,18 +46058,18 @@ _tmp_258_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_258[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_258[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_258[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_264[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45038,18 +46077,18 @@ _tmp_258_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_258[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_258[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_258[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_264[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45058,9 +46097,9 @@ _tmp_258_rule(Parser *p) return _res; } -// _tmp_259: yield_expr | star_expressions +// _tmp_265: yield_expr | star_expressions static void * -_tmp_259_rule(Parser *p) +_tmp_265_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45077,18 +46116,18 @@ _tmp_259_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_259[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_259[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_265[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_259[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_265[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45096,18 +46135,18 @@ _tmp_259_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_259[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_259[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_265[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_259[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_265[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45116,9 +46155,9 @@ _tmp_259_rule(Parser *p) return _res; } -// _tmp_260: '=' | '!' | ':' | '}' +// _tmp_266: '=' | '!' | ':' | '}' static void * -_tmp_260_rule(Parser *p) +_tmp_266_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45135,18 +46174,18 @@ _tmp_260_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_260[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_260[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_260[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_266[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } { // '!' @@ -45154,18 +46193,18 @@ _tmp_260_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_260[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c> _tmp_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_260[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_260[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_266[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!'")); } { // ':' @@ -45173,18 +46212,18 @@ _tmp_260_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_260[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_260[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_260[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_266[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '}' @@ -45192,18 +46231,18 @@ _tmp_260_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_260[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_260[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_260[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_266[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } _res = NULL; @@ -45212,9 +46251,9 @@ _tmp_260_rule(Parser *p) return _res; } -// _tmp_261: yield_expr | star_expressions +// _tmp_267: yield_expr | star_expressions static void * -_tmp_261_rule(Parser *p) +_tmp_267_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45231,18 +46270,18 @@ _tmp_261_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_267[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_261[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_267[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_261[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_267[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45250,18 +46289,18 @@ _tmp_261_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_267[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_261[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_267[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_261[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_267[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45270,9 +46309,9 @@ _tmp_261_rule(Parser *p) return _res; } -// _tmp_262: '!' | ':' | '}' +// _tmp_268: '!' | ':' | '}' static void * -_tmp_262_rule(Parser *p) +_tmp_268_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45289,18 +46328,18 @@ _tmp_262_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_262[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_262[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!'")); } { // ':' @@ -45308,18 +46347,18 @@ _tmp_262_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_262[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_262[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '}' @@ -45327,18 +46366,18 @@ _tmp_262_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_262[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_262[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } _res = NULL; @@ -45347,9 +46386,9 @@ _tmp_262_rule(Parser *p) return _res; } -// _tmp_263: yield_expr | star_expressions +// _tmp_269: yield_expr | star_expressions static void * -_tmp_263_rule(Parser *p) +_tmp_269_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45366,18 +46405,18 @@ _tmp_263_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_263[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_269[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_269[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_263[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_269[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45385,18 +46424,18 @@ _tmp_263_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_263[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_269[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_269[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_263[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_269[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45405,9 +46444,9 @@ _tmp_263_rule(Parser *p) return _res; } -// _tmp_264: yield_expr | star_expressions +// _tmp_270: yield_expr | star_expressions static void * -_tmp_264_rule(Parser *p) +_tmp_270_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45424,18 +46463,18 @@ _tmp_264_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_270[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_270[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_264[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_270[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45443,18 +46482,18 @@ _tmp_264_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_270[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_270[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_264[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_270[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45463,9 +46502,9 @@ _tmp_264_rule(Parser *p) return _res; } -// _tmp_265: '!' NAME +// _tmp_271: '!' NAME static void * -_tmp_265_rule(Parser *p) +_tmp_271_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45482,7 +46521,7 @@ _tmp_265_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_271[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -45491,12 +46530,12 @@ _tmp_265_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_265[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_271[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); _res = _PyPegen_dummy_name(p, _literal, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_265[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_271[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!' NAME")); } _res = NULL; @@ -45505,9 +46544,9 @@ _tmp_265_rule(Parser *p) return _res; } -// _tmp_266: ':' | '}' +// _tmp_272: ':' | '}' static void * -_tmp_266_rule(Parser *p) +_tmp_272_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45524,18 +46563,18 @@ _tmp_266_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_272[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_272[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_266[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_272[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '}' @@ -45543,18 +46582,18 @@ _tmp_266_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_272[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_272[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_266[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_272[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } _res = NULL; @@ -45563,9 +46602,9 @@ _tmp_266_rule(Parser *p) return _res; } -// _tmp_267: yield_expr | star_expressions +// _tmp_273: yield_expr | star_expressions static void * -_tmp_267_rule(Parser *p) +_tmp_273_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45582,18 +46621,18 @@ _tmp_267_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_267[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_273[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_267[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_273[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_267[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_273[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45601,18 +46640,18 @@ _tmp_267_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_267[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_273[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_267[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_273[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_267[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_273[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45621,9 +46660,9 @@ _tmp_267_rule(Parser *p) return _res; } -// _tmp_268: '!' NAME +// _tmp_274: '!' NAME static void * -_tmp_268_rule(Parser *p) +_tmp_274_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45640,7 +46679,7 @@ _tmp_268_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_274[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -45649,12 +46688,12 @@ _tmp_268_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_274[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); _res = _PyPegen_dummy_name(p, _literal, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_274[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!' NAME")); } _res = NULL; @@ -45663,9 +46702,9 @@ _tmp_268_rule(Parser *p) return _res; } -// _loop0_269: fstring_format_spec +// _loop0_275: fstring_format_spec static asdl_seq * -_loop0_269_rule(Parser *p) +_loop0_275_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45691,7 +46730,7 @@ _loop0_269_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_269[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_275[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); expr_ty fstring_format_spec_var; while ( (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec @@ -45714,7 +46753,7 @@ _loop0_269_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_269[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_275[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -45731,9 +46770,9 @@ _loop0_269_rule(Parser *p) return _seq; } -// _tmp_270: yield_expr | star_expressions +// _tmp_276: yield_expr | star_expressions static void * -_tmp_270_rule(Parser *p) +_tmp_276_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45750,18 +46789,18 @@ _tmp_270_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_270[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_270[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_276[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_270[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_276[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45769,18 +46808,18 @@ _tmp_270_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_270[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_270[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_276[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_270[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_276[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45789,9 +46828,9 @@ _tmp_270_rule(Parser *p) return _res; } -// _tmp_271: '!' NAME +// _tmp_277: '!' NAME static void * -_tmp_271_rule(Parser *p) +_tmp_277_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45808,7 +46847,7 @@ _tmp_271_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_271[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_277[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -45817,12 +46856,12 @@ _tmp_271_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_271[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_277[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); _res = _PyPegen_dummy_name(p, _literal, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_271[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_277[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!' NAME")); } _res = NULL; @@ -45831,9 +46870,9 @@ _tmp_271_rule(Parser *p) return _res; } -// _tmp_272: ':' | '}' +// _tmp_278: ':' | '}' static void * -_tmp_272_rule(Parser *p) +_tmp_278_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45850,18 +46889,18 @@ _tmp_272_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_272[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_278[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_272[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_278[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_272[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_278[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '}' @@ -45869,18 +46908,18 @@ _tmp_272_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_272[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_278[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_272[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_278[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_272[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_278[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } _res = NULL; @@ -45889,9 +46928,9 @@ _tmp_272_rule(Parser *p) return _res; } -// _tmp_273: star_targets '=' +// _tmp_279: star_targets '=' static void * -_tmp_273_rule(Parser *p) +_tmp_279_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45908,7 +46947,7 @@ _tmp_273_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_273[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_279[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -45917,7 +46956,7 @@ _tmp_273_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_273[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_279[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -45927,7 +46966,7 @@ _tmp_273_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_273[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_279[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -45936,9 +46975,9 @@ _tmp_273_rule(Parser *p) return _res; } -// _tmp_274: yield_expr | star_expressions +// _tmp_280: yield_expr | star_expressions static void * -_tmp_274_rule(Parser *p) +_tmp_280_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45955,18 +46994,18 @@ _tmp_274_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_274[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_280[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_274[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_280[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_274[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_280[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -45974,18 +47013,18 @@ _tmp_274_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_274[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_280[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); expr_ty star_expressions_var; if ( (star_expressions_var = star_expressions_rule(p)) // star_expressions ) { - D(fprintf(stderr, "%*c+ _tmp_274[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_280[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); _res = star_expressions_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_274[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_280[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -45994,9 +47033,9 @@ _tmp_274_rule(Parser *p) return _res; } -// _tmp_275: '.' | '...' +// _tmp_281: '.' | '...' static void * -_tmp_275_rule(Parser *p) +_tmp_281_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46013,18 +47052,18 @@ _tmp_275_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_275[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_281[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_275[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_281[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_275[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_281[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'.'")); } { // '...' @@ -46032,18 +47071,18 @@ _tmp_275_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_275[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c> _tmp_281[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 52)) // token='...' ) { - D(fprintf(stderr, "%*c+ _tmp_275[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_281[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_275[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_281[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'...'")); } _res = NULL; @@ -46052,9 +47091,9 @@ _tmp_275_rule(Parser *p) return _res; } -// _tmp_276: '.' | '...' +// _tmp_282: '.' | '...' static void * -_tmp_276_rule(Parser *p) +_tmp_282_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46071,18 +47110,18 @@ _tmp_276_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_282[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_276[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_282[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_276[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_282[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'.'")); } { // '...' @@ -46090,18 +47129,18 @@ _tmp_276_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c> _tmp_282[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 52)) // token='...' ) { - D(fprintf(stderr, "%*c+ _tmp_276[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_282[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_276[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_282[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'...'")); } _res = NULL; @@ -46110,9 +47149,9 @@ _tmp_276_rule(Parser *p) return _res; } -// _tmp_277: '@' named_expression NEWLINE +// _tmp_283: '@' named_expression NEWLINE static void * -_tmp_277_rule(Parser *p) +_tmp_283_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46129,7 +47168,7 @@ _tmp_277_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_277[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_283[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -46141,7 +47180,7 @@ _tmp_277_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_277[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_283[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); _res = f; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46151,7 +47190,7 @@ _tmp_277_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_277[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_283[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); } _res = NULL; @@ -46160,9 +47199,9 @@ _tmp_277_rule(Parser *p) return _res; } -// _tmp_278: bitwiseor_pattern | 'None' +// _tmp_284: bitwiseor_pattern | 'None' static void * -_tmp_278_rule(Parser *p) +_tmp_284_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46188,18 +47227,18 @@ _tmp_278_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_278[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + D(fprintf(stderr, "%*c> _tmp_284[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); expr_ty bitwiseor_pattern_var; if ( (bitwiseor_pattern_var = bitwiseor_pattern_rule(p)) // bitwiseor_pattern ) { - D(fprintf(stderr, "%*c+ _tmp_278[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + D(fprintf(stderr, "%*c+ _tmp_284[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); _res = bitwiseor_pattern_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_278[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_284[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); } { // 'None' @@ -46207,13 +47246,13 @@ _tmp_278_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_278[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_284[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 657)) // token='None' + (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_278[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_284[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -46232,7 +47271,7 @@ _tmp_278_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_278[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_284[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } _res = NULL; @@ -46241,9 +47280,9 @@ _tmp_278_rule(Parser *p) return _res; } -// _loop0_280: ';' simple_stmt +// _loop0_286: ';' simple_stmt static asdl_seq * -_loop0_280_rule(Parser *p) +_loop0_286_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46269,7 +47308,7 @@ _loop0_280_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_280[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + D(fprintf(stderr, "%*c> _loop0_286[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); Token * _literal; stmt_ty elem; while ( @@ -46301,7 +47340,7 @@ _loop0_280_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_280[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_286[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';' simple_stmt")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46318,9 +47357,9 @@ _loop0_280_rule(Parser *p) return _seq; } -// _gather_279: simple_stmt _loop0_280 +// _gather_285: simple_stmt _loop0_286 static asdl_seq * -_gather_279_rule(Parser *p) +_gather_285_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46332,27 +47371,27 @@ _gather_279_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // simple_stmt _loop0_280 + { // simple_stmt _loop0_286 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_279[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_280")); + D(fprintf(stderr, "%*c> _gather_285[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_286")); stmt_ty elem; asdl_seq * seq; if ( (elem = simple_stmt_rule(p)) // simple_stmt && - (seq = _loop0_280_rule(p)) // _loop0_280 + (seq = _loop0_286_rule(p)) // _loop0_286 ) { - D(fprintf(stderr, "%*c+ _gather_279[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_280")); + D(fprintf(stderr, "%*c+ _gather_285[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_286")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_279[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_280")); + D(fprintf(stderr, "%*c%s _gather_285[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_286")); } _res = NULL; done: @@ -46360,9 +47399,9 @@ _gather_279_rule(Parser *p) return _res; } -// _tmp_281: ',' expression +// _tmp_287: ',' expression static void * -_tmp_281_rule(Parser *p) +_tmp_287_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46379,7 +47418,7 @@ _tmp_281_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_281[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _tmp_287[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty c; if ( @@ -46388,7 +47427,7 @@ _tmp_281_rule(Parser *p) (c = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_281[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c+ _tmp_287[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46398,7 +47437,7 @@ _tmp_281_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_281[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_287[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } _res = NULL; @@ -46407,9 +47446,9 @@ _tmp_281_rule(Parser *p) return _res; } -// _tmp_282: ',' star_expression +// _tmp_288: ',' star_expression static void * -_tmp_282_rule(Parser *p) +_tmp_288_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46426,7 +47465,7 @@ _tmp_282_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_282[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_288[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -46435,7 +47474,7 @@ _tmp_282_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_282[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_288[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46445,7 +47484,7 @@ _tmp_282_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_282[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_288[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_expression")); } _res = NULL; @@ -46454,9 +47493,9 @@ _tmp_282_rule(Parser *p) return _res; } -// _tmp_283: 'or' conjunction +// _tmp_289: 'or' conjunction static void * -_tmp_283_rule(Parser *p) +_tmp_289_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46473,16 +47512,16 @@ _tmp_283_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_283[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_289[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); Token * _keyword; expr_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 621)) // token='or' + (_keyword = _PyPegen_expect_token(p, 623)) // token='or' && (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_283[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_289[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46492,7 +47531,7 @@ _tmp_283_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_283[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_289[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'or' conjunction")); } _res = NULL; @@ -46501,9 +47540,9 @@ _tmp_283_rule(Parser *p) return _res; } -// _tmp_284: 'and' inversion +// _tmp_290: 'and' inversion static void * -_tmp_284_rule(Parser *p) +_tmp_290_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46520,16 +47559,16 @@ _tmp_284_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_284[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); Token * _keyword; expr_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='and' + (_keyword = _PyPegen_expect_token(p, 624)) // token='and' && (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_284[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46539,7 +47578,7 @@ _tmp_284_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_284[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_290[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'and' inversion")); } _res = NULL; @@ -46548,9 +47587,9 @@ _tmp_284_rule(Parser *p) return _res; } -// _tmp_285: slice | starred_expression +// _tmp_291: slice | starred_expression static void * -_tmp_285_rule(Parser *p) +_tmp_291_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46567,18 +47606,18 @@ _tmp_285_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_285[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c> _tmp_291[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); expr_ty slice_var; if ( (slice_var = slice_rule(p)) // slice ) { - D(fprintf(stderr, "%*c+ _tmp_285[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c+ _tmp_291[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); _res = slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_285[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_291[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slice")); } { // starred_expression @@ -46586,18 +47625,18 @@ _tmp_285_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_285[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_291[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_285[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_291[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_285[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_291[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "starred_expression")); } _res = NULL; @@ -46606,9 +47645,144 @@ _tmp_285_rule(Parser *p) return _res; } -// _tmp_286: fstring | string +// _tmp_292: "def" | '@' | 'async' static void * -_tmp_286_rule(Parser *p) +_tmp_292_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // "def" + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_292[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + expr_ty _keyword; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' + ) + { + D(fprintf(stderr, "%*c+ _tmp_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + _res = _keyword; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_292[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"def\"")); + } + { // '@' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_292[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 49)) // token='@' + ) + { + D(fprintf(stderr, "%*c+ _tmp_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_292[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); + } + { // 'async' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_292[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + ) + { + D(fprintf(stderr, "%*c+ _tmp_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + _res = _keyword; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_292[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_293: 'class' | '@' +static void * +_tmp_293_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // 'class' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_293[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 720)) // token='class' + ) + { + D(fprintf(stderr, "%*c+ _tmp_293[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + _res = _keyword; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_293[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); + } + { // '@' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_293[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 49)) // token='@' + ) + { + D(fprintf(stderr, "%*c+ _tmp_293[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_293[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_294: fstring | string +static void * +_tmp_294_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46625,18 +47799,18 @@ _tmp_286_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_286[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); + D(fprintf(stderr, "%*c> _tmp_294[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); expr_ty fstring_var; if ( (fstring_var = fstring_rule(p)) // fstring ) { - D(fprintf(stderr, "%*c+ _tmp_286[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); _res = fstring_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_286[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_294[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring")); } { // string @@ -46644,18 +47818,18 @@ _tmp_286_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_286[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); + D(fprintf(stderr, "%*c> _tmp_294[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); expr_ty string_var; if ( (string_var = string_rule(p)) // string ) { - D(fprintf(stderr, "%*c+ _tmp_286[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); + D(fprintf(stderr, "%*c+ _tmp_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); _res = string_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_286[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_294[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "string")); } _res = NULL; @@ -46664,9 +47838,9 @@ _tmp_286_rule(Parser *p) return _res; } -// _tmp_287: 'if' disjunction +// _tmp_295: 'if' disjunction static void * -_tmp_287_rule(Parser *p) +_tmp_295_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46683,16 +47857,16 @@ _tmp_287_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_287[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_295[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_287[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46702,7 +47876,7 @@ _tmp_287_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_287[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_295[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -46711,9 +47885,9 @@ _tmp_287_rule(Parser *p) return _res; } -// _tmp_288: 'if' disjunction +// _tmp_296: 'if' disjunction static void * -_tmp_288_rule(Parser *p) +_tmp_296_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46730,16 +47904,16 @@ _tmp_288_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_288[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_296[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_288[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46749,7 +47923,7 @@ _tmp_288_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_288[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_296[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -46758,9 +47932,9 @@ _tmp_288_rule(Parser *p) return _res; } -// _tmp_289: 'if' disjunction +// _tmp_297: 'if' disjunction static void * -_tmp_289_rule(Parser *p) +_tmp_297_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46777,16 +47951,16 @@ _tmp_289_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_289[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_297[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 702)) // token='if' + (_keyword = _PyPegen_expect_token(p, 706)) // token='if' && (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_289[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_297[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46796,7 +47970,7 @@ _tmp_289_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_289[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_297[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -46805,12 +47979,12 @@ _tmp_289_rule(Parser *p) return _res; } -// _tmp_290: +// _tmp_298: // | starred_expression // | simple_slice // | (assignment_expression | expression !':=') !'=' static void * -_tmp_290_rule(Parser *p) +_tmp_298_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46827,18 +48001,18 @@ _tmp_290_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_298[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_290[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "starred_expression")); } { // simple_slice @@ -46846,18 +48020,18 @@ _tmp_290_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_298[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); expr_ty simple_slice_var; if ( (simple_slice_var = simple_slice_rule(p)) // simple_slice ) { - D(fprintf(stderr, "%*c+ _tmp_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); _res = simple_slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_290[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // (assignment_expression | expression !':=') !'=' @@ -46865,20 +48039,20 @@ _tmp_290_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); - void *_tmp_302_var; + D(fprintf(stderr, "%*c> _tmp_298[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); + void *_tmp_310_var; if ( - (_tmp_302_var = _tmp_302_rule(p)) // assignment_expression | expression !':=' + (_tmp_310_var = _tmp_310_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_302_var; + D(fprintf(stderr, "%*c+ _tmp_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_310_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_290[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -46887,9 +48061,9 @@ _tmp_290_rule(Parser *p) return _res; } -// _tmp_291: ',' star_target +// _tmp_299: ',' star_target static void * -_tmp_291_rule(Parser *p) +_tmp_299_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46906,7 +48080,7 @@ _tmp_291_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_291[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_299[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -46915,7 +48089,7 @@ _tmp_291_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_291[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_299[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46925,7 +48099,7 @@ _tmp_291_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_291[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_299[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } _res = NULL; @@ -46934,9 +48108,9 @@ _tmp_291_rule(Parser *p) return _res; } -// _tmp_292: ',' star_target +// _tmp_300: ',' star_target static void * -_tmp_292_rule(Parser *p) +_tmp_300_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46953,7 +48127,7 @@ _tmp_292_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_292[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_300[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -46962,7 +48136,7 @@ _tmp_292_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -46972,7 +48146,7 @@ _tmp_292_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_292[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_300[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } _res = NULL; @@ -46981,9 +48155,9 @@ _tmp_292_rule(Parser *p) return _res; } -// _tmp_293: star_targets '=' +// _tmp_301: star_targets '=' static void * -_tmp_293_rule(Parser *p) +_tmp_301_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47000,7 +48174,7 @@ _tmp_293_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_293[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_301[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty star_targets_var; if ( @@ -47009,12 +48183,12 @@ _tmp_293_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_293[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_301[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); _res = _PyPegen_dummy_name(p, star_targets_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_293[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_301[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -47023,9 +48197,9 @@ _tmp_293_rule(Parser *p) return _res; } -// _tmp_294: star_targets '=' +// _tmp_302: star_targets '=' static void * -_tmp_294_rule(Parser *p) +_tmp_302_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47042,7 +48216,7 @@ _tmp_294_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_294[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_302[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty star_targets_var; if ( @@ -47051,12 +48225,12 @@ _tmp_294_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_302[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); _res = _PyPegen_dummy_name(p, star_targets_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_294[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_302[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -47065,9 +48239,9 @@ _tmp_294_rule(Parser *p) return _res; } -// _tmp_295: ')' | '**' +// _tmp_303: ')' | '**' static void * -_tmp_295_rule(Parser *p) +_tmp_303_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47084,18 +48258,18 @@ _tmp_295_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_295[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_303[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_303[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_295[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_303[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // '**' @@ -47103,18 +48277,18 @@ _tmp_295_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_295[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_303[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_303[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_295[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_303[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -47123,9 +48297,9 @@ _tmp_295_rule(Parser *p) return _res; } -// _tmp_296: ':' | '**' +// _tmp_304: ':' | '**' static void * -_tmp_296_rule(Parser *p) +_tmp_304_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47142,18 +48316,18 @@ _tmp_296_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_296[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_304[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_304[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_296[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_304[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '**' @@ -47161,18 +48335,18 @@ _tmp_296_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_296[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_304[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_304[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_296[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_304[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -47181,9 +48355,9 @@ _tmp_296_rule(Parser *p) return _res; } -// _tmp_297: expression ['as' star_target] +// _tmp_305: expression ['as' star_target] static void * -_tmp_297_rule(Parser *p) +_tmp_305_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47200,22 +48374,22 @@ _tmp_297_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_297[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_305[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_303_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_311_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_297[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_305[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_297[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_305[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); } _res = NULL; @@ -47224,9 +48398,9 @@ _tmp_297_rule(Parser *p) return _res; } -// _tmp_298: expressions ['as' star_target] +// _tmp_306: expressions ['as' star_target] static void * -_tmp_298_rule(Parser *p) +_tmp_306_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47243,22 +48417,22 @@ _tmp_298_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_298[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_306[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_304_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_312_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_306[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_298[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_306[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); } _res = NULL; @@ -47267,9 +48441,9 @@ _tmp_298_rule(Parser *p) return _res; } -// _tmp_299: expression ['as' star_target] +// _tmp_307: expression ['as' star_target] static void * -_tmp_299_rule(Parser *p) +_tmp_307_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47286,22 +48460,22 @@ _tmp_299_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_299[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_307[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_305_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_313_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_299[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_307[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_299[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_307[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); } _res = NULL; @@ -47310,9 +48484,9 @@ _tmp_299_rule(Parser *p) return _res; } -// _tmp_300: expressions ['as' star_target] +// _tmp_308: expressions ['as' star_target] static void * -_tmp_300_rule(Parser *p) +_tmp_308_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47329,22 +48503,22 @@ _tmp_300_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_300[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_308[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "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_306_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_314_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_308[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_300[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_308[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); } _res = NULL; @@ -47353,9 +48527,9 @@ _tmp_300_rule(Parser *p) return _res; } -// _tmp_301: 'as' NAME +// _tmp_309: 'as' NAME static void * -_tmp_301_rule(Parser *p) +_tmp_309_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47372,21 +48546,21 @@ _tmp_301_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_301[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_309[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_301[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_309[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); _res = _PyPegen_dummy_name(p, _keyword, name_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_301[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_309[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -47395,9 +48569,9 @@ _tmp_301_rule(Parser *p) return _res; } -// _tmp_302: assignment_expression | expression !':=' +// _tmp_310: assignment_expression | expression !':=' static void * -_tmp_302_rule(Parser *p) +_tmp_310_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47414,18 +48588,18 @@ _tmp_302_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_302[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_310[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); expr_ty assignment_expression_var; if ( (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression ) { - D(fprintf(stderr, "%*c+ _tmp_302[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_310[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); _res = assignment_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_302[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_310[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -47433,7 +48607,7 @@ _tmp_302_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_302[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_310[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -47441,12 +48615,12 @@ _tmp_302_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_302[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_310[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_302[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_310[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -47455,9 +48629,9 @@ _tmp_302_rule(Parser *p) return _res; } -// _tmp_303: 'as' star_target +// _tmp_311: 'as' star_target static void * -_tmp_303_rule(Parser *p) +_tmp_311_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47474,21 +48648,21 @@ _tmp_303_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_303[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_311[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_303[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_311[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); _res = _PyPegen_dummy_name(p, _keyword, star_target_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_303[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_311[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -47497,9 +48671,9 @@ _tmp_303_rule(Parser *p) return _res; } -// _tmp_304: 'as' star_target +// _tmp_312: 'as' star_target static void * -_tmp_304_rule(Parser *p) +_tmp_312_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47516,21 +48690,21 @@ _tmp_304_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_304[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_312[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_304[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_312[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); _res = _PyPegen_dummy_name(p, _keyword, star_target_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_304[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_312[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -47539,9 +48713,9 @@ _tmp_304_rule(Parser *p) return _res; } -// _tmp_305: 'as' star_target +// _tmp_313: 'as' star_target static void * -_tmp_305_rule(Parser *p) +_tmp_313_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47558,21 +48732,21 @@ _tmp_305_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_305[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_313[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_305[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_313[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); _res = _PyPegen_dummy_name(p, _keyword, star_target_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_305[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_313[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -47581,9 +48755,9 @@ _tmp_305_rule(Parser *p) return _res; } -// _tmp_306: 'as' star_target +// _tmp_314: 'as' star_target static void * -_tmp_306_rule(Parser *p) +_tmp_314_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47600,21 +48774,21 @@ _tmp_306_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_306[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_314[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 700)) // token='as' + (_keyword = _PyPegen_expect_token(p, 704)) // token='as' && (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_306[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_314[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); _res = _PyPegen_dummy_name(p, _keyword, star_target_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_306[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_314[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 31b4690..f32be48 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -59,6 +59,7 @@ void _PyAST_Fini(PyInterpreterState *interp) Py_CLEAR(state->Comp_type); Py_CLEAR(state->Compare_type); Py_CLEAR(state->Composition_type); + Py_CLEAR(state->CompoundExpr_type); Py_CLEAR(state->Constant_type); Py_CLEAR(state->Continue_type); Py_CLEAR(state->Del_singleton); @@ -666,6 +667,9 @@ static const char * const Constant_fields[]={ static const char * const Template_fields[]={ "last", }; +static const char * const CompoundExpr_fields[]={ + "value", +}; static const char * const Attribute_fields[]={ "value", "attr", @@ -1442,6 +1446,7 @@ init_types(struct ast_state *state) " | JoinedStr(expr* values)\n" " | Constant(constant value, string? kind)\n" " | Template(int last)\n" + " | CompoundExpr(stmt value)\n" " | Attribute(expr value, identifier attr, expr_context ctx, int aware)\n" " | Subscript(expr value, expr slice, expr_context ctx, int aware)\n" " | Starred(expr value, expr_context ctx)\n" @@ -1556,6 +1561,11 @@ init_types(struct ast_state *state) Template_fields, 1, "Template(int last)"); if (!state->Template_type) return 0; + state->CompoundExpr_type = make_type(state, "CompoundExpr", + state->expr_type, CompoundExpr_fields, + 1, + "CompoundExpr(stmt value)"); + if (!state->CompoundExpr_type) return 0; state->Attribute_type = make_type(state, "Attribute", state->expr_type, Attribute_fields, 4, "Attribute(expr value, identifier attr, expr_context ctx, int aware)"); @@ -3422,6 +3432,28 @@ _PyAST_Template(int last, int lineno, int col_offset, int end_lineno, int return p; } +expr_ty +_PyAST_CompoundExpr(stmt_ty value, 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 CompoundExpr"); + return NULL; + } + p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); + if (!p) + return NULL; + p->kind = CompoundExpr_kind; + p->v.CompoundExpr.value = value; + 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_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int aware, int lineno, int col_offset, int end_lineno, int @@ -5136,6 +5168,16 @@ ast2obj_expr(struct ast_state *state, void* _o) goto failed; Py_DECREF(value); break; + case CompoundExpr_kind: + tp = (PyTypeObject *)state->CompoundExpr_type; + result = PyType_GenericNew(tp, NULL, NULL); + if (!result) goto failed; + value = ast2obj_stmt(state, o->v.CompoundExpr.value); + if (!value) goto failed; + if (PyObject_SetAttr(result, state->value, value) == -1) + goto failed; + Py_DECREF(value); + break; case Attribute_kind: tp = (PyTypeObject *)state->Attribute_type; result = PyType_GenericNew(tp, NULL, NULL); @@ -10693,6 +10735,36 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (*out == NULL) goto failed; return 0; } + tp = state->CompoundExpr_type; + isinstance = PyObject_IsInstance(obj, tp); + if (isinstance == -1) { + return 1; + } + if (isinstance) { + stmt_ty value; + + if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { + return 1; + } + if (tmp == NULL) { + PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from CompoundExpr"); + return 1; + } + else { + int res; + if (_Py_EnterRecursiveCall(" while traversing 'CompoundExpr' node")) { + goto failed; + } + res = obj2ast_stmt(state, tmp, &value, arena); + _Py_LeaveRecursiveCall(); + if (res != 0) goto failed; + Py_CLEAR(tmp); + } + *out = _PyAST_CompoundExpr(value, lineno, col_offset, end_lineno, + end_col_offset, arena); + if (*out == NULL) goto failed; + return 0; + } tp = state->Attribute_type; isinstance = PyObject_IsInstance(obj, tp); if (isinstance == -1) { @@ -13733,6 +13805,10 @@ astmodule_exec(PyObject *m) if (PyModule_AddObjectRef(m, "Template", state->Template_type) < 0) { return -1; } + if (PyModule_AddObjectRef(m, "CompoundExpr", state->CompoundExpr_type) < 0) + { + return -1; + } if (PyModule_AddObjectRef(m, "Attribute", state->Attribute_type) < 0) { return -1; } diff --git a/Python/ast.c b/Python/ast.c index f515482..71e7c60 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -390,6 +390,9 @@ validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx) ret = validate_expr(state, exp->v.Composition.arg, Load) && validate_expr(state, exp->v.Composition.func, Load); break; + case CompoundExpr_kind: + ret = validate_stmt(state, exp->v.CompoundExpr.value); + break; /* This last case doesn't have any checking. */ case Template_kind: case Name_kind: diff --git a/Python/ast_opt.c b/Python/ast_opt.c index 2c68586..abcc691 100644 --- a/Python/ast_opt.c +++ b/Python/ast_opt.c @@ -1204,6 +1204,9 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state) CALL(astfold_expr, expr_ty, node_->v.Composition.func); CALL(fold_comp, expr_ty, node_); break; + case CompoundExpr_kind: + CALL(astfold_stmt, stmt_ty, node_->v.CompoundExpr.value); + break; case Constant_kind: case Template_kind: // nothing further to do diff --git a/Python/compile.c b/Python/compile.c index 71a112d..2fbdd5b 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -2409,7 +2409,7 @@ compiler_function_body(struct compiler *c, stmt_ty s, int is_async, Py_ssize_t f } static int -compiler_function(struct compiler *c, stmt_ty s, int is_async) +compiler_function(struct compiler *c, stmt_ty s, int is_async, int is_expr) { arguments_ty args; expr_ty returns; @@ -2529,6 +2529,9 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async) } RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); + if (is_expr) { + ADDOP_I(c, loc, COPY, 1); + } return compiler_nameop(c, loc, name, Store); } @@ -2670,7 +2673,7 @@ compiler_class_body(struct compiler *c, stmt_ty s, int firstlineno) } static int -compiler_class(struct compiler *c, stmt_ty s) +compiler_class(struct compiler *c, stmt_ty s, int is_expr) { asdl_expr_seq *decos = s->v.ClassDef.decorator_list; @@ -2764,6 +2767,11 @@ compiler_class(struct compiler *c, stmt_ty s) /* 6. apply decorators */ RETURN_IF_ERROR(compiler_apply_decorators(c, decos)); + /* 6.5. if it's an expression, make a copy of it first */ + if (is_expr) { + ADDOP_I(c, loc, COPY, 1); + } + /* 7. store into */ RETURN_IF_ERROR(compiler_nameop(c, loc, s->v.ClassDef.name, Store)); return SUCCESS; @@ -4116,9 +4124,9 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) switch (s->kind) { case FunctionDef_kind: - return compiler_function(c, s, 0); + return compiler_function(c, s, 0, 0); case ClassDef_kind: - return compiler_class(c, s); + return compiler_class(c, s, 0); case TypeAlias_kind: return compiler_typealias(c, s); case Return_kind: @@ -4200,7 +4208,7 @@ compiler_visit_stmt(struct compiler *c, stmt_ty s) case With_kind: return compiler_with(c, s, 0); case AsyncFunctionDef_kind: - return compiler_function(c, s, 1); + return compiler_function(c, s, 1, 0); case AsyncWith_kind: return compiler_async_with(c, s, 0); case AsyncFor_kind: @@ -6547,6 +6555,21 @@ compiler_visit_expr1(struct compiler *c, expr_ty e) return compiler_composition(c, e); case Template_kind: return compiler_template(c, e); + case CompoundExpr_kind: { + stmt_ty s = e->v.CompoundExpr.value; + switch (s->kind) { + case FunctionDef_kind: + case AsyncFunctionDef_kind: + return compiler_function( + c, s, s->kind == AsyncFunctionDef_kind, 1); + case ClassDef_kind: + return compiler_class(c, s, 1); + default: + return compiler_error(c, loc, + "invalid compound expression"); + } + return SUCCESS; + } case Call_kind: /* The following exprs can be assignment targets. */ case Attribute_kind: diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 875d708..d521eac 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -156,8 +156,6 @@ _PyRun_InteractiveLoopObject(FILE *fp, PyObject *filename, PyCompilerFlags *flag nomem_count = 0; } PyObject *exc = PyErr_GetRaisedException(); - fprintf(stderr, "!!%s ", _PyType_Name(Py_TYPE(exc))); - PyObject_Print(((PyBaseExceptionObject *)exc)->args, stderr, 0); PyErr_SetRaisedException(exc); PyErr_Print(); flush_io(); diff --git a/Python/symtable.c b/Python/symtable.c index 5feef8d..bf43617 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -2144,6 +2144,9 @@ symtable_visit_expr(struct symtable *st, expr_ty e) break; case Template_kind: break; + case CompoundExpr_kind: + VISIT(st, stmt, e->v.CompoundExpr.value); + break; } VISIT_QUIT(st, 1); }