From 3e29b8396cd065795f3985a352737bbe34171dda Mon Sep 17 00:00:00 2001 From: unknown Date: Thu, 2 May 2024 16:05:12 +0800 Subject: [PATCH] lambda variants (fixes and stuff) --- Grammar/python.gram | 47 +- Parser/parser.c | 5272 ++++++++++++++++++++++++------------------- 2 files changed, 3022 insertions(+), 2297 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index d61145e..1ecfb45 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -810,9 +810,9 @@ expressions[expr_ty]: expression[expr_ty] (memo): | invalid_expression | invalid_legacy_expression + | lambdef | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, a, c, EXTRA) } | disjunction - | lambdef yield_expr[expr_ty]: | 'yield' 'from' a=expression { _PyAST_YieldFrom(a, EXTRA) } @@ -828,6 +828,12 @@ star_expression[expr_ty] (memo): | '*' a=bitwise_or { _PyAST_Starred(a, Load, EXTRA) } | expression +# Special-case for `|`-style lambdas. + +star_sum[expr_ty] (memo): + | '*' a=sum { _PyAST_Starred(a, Load, EXTRA) } + | sum + star_named_expressions[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_named_expression+ [','] { a } star_named_expression[expr_ty]: @@ -1088,19 +1094,18 @@ lambda_param_maybe_default[NameDefaultPair*]: lambda_param[arg_ty]: a=NAME { _PyAST_arg(a->v.Name.id, NULL, NULL, EXTRA) } lambda_sum_parameters[arguments_ty]: - | a=lambda_sum_slash_no_default b[asdl_arg_seq*]=lambda_sum_param_no_default* c=lambda_sum_param_with_default* d=[lambda_star_etc] { + | a=lambda_sum_slash_no_default b[asdl_arg_seq*]=lambda_sum_param_no_default* c=lambda_sum_param_with_default* d=[lambda_sum_star_etc] { CHECK_VERSION(arguments_ty, 8, "Positional-only parameters are", _PyPegen_make_arguments(p, a, NULL, b, c, d)) } - | a=lambda_sum_slash_with_default b=lambda_sum_param_with_default* c=[lambda_star_etc] { + | a=lambda_sum_slash_with_default b=lambda_sum_param_with_default* c=[lambda_sum_star_etc] { CHECK_VERSION(arguments_ty, 8, "Positional-only parameters are", _PyPegen_make_arguments(p, NULL, a, NULL, b, c)) } - | a[asdl_arg_seq*]=lambda_sum_param_no_default+ b=lambda_sum_param_with_default* c=[lambda_star_etc] { + | a[asdl_arg_seq*]=lambda_sum_param_no_default+ b=lambda_sum_param_with_default* c=[lambda_sum_star_etc] { _PyPegen_make_arguments(p, NULL, NULL, a, b, c) } | a=lambda_sum_param_with_default+ b=[lambda_sum_star_etc] { _PyPegen_make_arguments(p, NULL, NULL, NULL, a, b)} | a=lambda_sum_star_etc { _PyPegen_make_arguments(p, NULL, NULL, NULL, NULL, a) } lambda_sum_slash_no_default[asdl_arg_seq*]: - | a[asdl_arg_seq*]=lambda_sum_param_no_default+ '/' ',' { a } - | a[asdl_arg_seq*]=lambda_sum_param_no_default+ '/' &'|' { a } - + | a[asdl_arg_seq*]=param_no_default+ '/' ',' { a } + | a[asdl_arg_seq*]=param_no_default+ '/' &'|' { a } lambda_sum_slash_with_default[SlashWithDefault*]: | a=lambda_sum_param_no_default* b=lambda_sum_param_with_default+ '/' ',' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) } | a=lambda_sum_param_no_default* b=lambda_sum_param_with_default+ '/' &'|' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) } @@ -1109,23 +1114,33 @@ lambda_sum_star_etc[StarEtc*]: | invalid_lambda_sum_star_etc | '*' a=lambda_sum_param_no_default b=lambda_sum_param_maybe_default* c=[lambda_sum_kwds] { _PyPegen_star_etc(p, a, b, c) } + | '*' a=lambda_sum_param_no_default_star_annotation b=lambda_sum_param_maybe_default* c=[lambda_sum_kwds] { + _PyPegen_star_etc(p, a, b, c) } | '*' ',' b=lambda_sum_param_maybe_default+ c=[lambda_sum_kwds] { _PyPegen_star_etc(p, NULL, b, c) } | a=lambda_sum_kwds { _PyPegen_star_etc(p, NULL, NULL, a) } lambda_sum_kwds[arg_ty]: - | invalid_lambda_kwds + | invalid_kwds | '**' a=lambda_sum_param_no_default { a } lambda_sum_param_no_default[arg_ty]: - | a=lambda_param ',' { a } - | a=lambda_param &'|' { a } + | a=sum_param ',' tc=TYPE_COMMENT? { _PyPegen_add_type_comment_to_arg(p, a, tc) } + | a=sum_param tc=TYPE_COMMENT? &'|' { _PyPegen_add_type_comment_to_arg(p, a, tc) } +lambda_sum_param_no_default_star_annotation[arg_ty]: + | a=sum_param_star_annotation ',' tc=TYPE_COMMENT? { _PyPegen_add_type_comment_to_arg(p, a, tc) } + | a=sum_param_star_annotation tc=TYPE_COMMENT? &'|' { _PyPegen_add_type_comment_to_arg(p, a, tc) } lambda_sum_param_with_default[NameDefaultPair*]: - | a=lambda_param c=default ',' { _PyPegen_name_default_pair(p, a, c, NULL) } - | a=lambda_param c=default &'|' { _PyPegen_name_default_pair(p, a, c, NULL) } + | a=sum_param c=sum_default ',' tc=TYPE_COMMENT? { _PyPegen_name_default_pair(p, a, c, tc) } + | a=sum_param c=sum_default tc=TYPE_COMMENT? &'|' { _PyPegen_name_default_pair(p, a, c, tc) } lambda_sum_param_maybe_default[NameDefaultPair*]: - | a=lambda_param c=default? ',' { _PyPegen_name_default_pair(p, a, c, NULL) } - | a=lambda_param c=default? &'|' { _PyPegen_name_default_pair(p, a, c, NULL) } + | a=sum_param c=sum_default? ',' tc=TYPE_COMMENT? { _PyPegen_name_default_pair(p, a, c, tc) } + | a=sum_param c=sum_default? tc=TYPE_COMMENT? &'|' { _PyPegen_name_default_pair(p, a, c, tc) } +sum_param[arg_ty]: a=NAME b=sum_annotation? { _PyAST_arg(a->v.Name.id, b, NULL, EXTRA) } +sum_param_star_annotation[arg_ty]: a=NAME b=star_sum_annotation { _PyAST_arg(a->v.Name.id, b, NULL, EXTRA) } +sum_annotation[expr_ty]: ':' a=sum { a } +star_sum_annotation[expr_ty]: ':' a=star_sum { a } +sum_default[expr_ty]: '=' a=sum { a } | invalid_sum_default # LITERALS # ======== @@ -1401,6 +1416,8 @@ invalid_expression: | a='lambda' [lambda_params] b=':' &(FSTRING_MIDDLE | fstring_replacement_field) { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "f-string: lambda expressions are not allowed without parentheses") } + + invalid_named_expression(memo): | a=expression ':=' expression { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( @@ -1466,6 +1483,8 @@ invalid_parameters: RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expected comma between / and *") } invalid_default: | a='=' &(')'|',') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expected default value expression") } +invalid_sum_default: + | a='=' &('|'|',') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expected default value expression") } invalid_star_etc: | a='*' (')' | ',' (')' | '**')) { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "named arguments must follow bare *") } | '*' ',' TYPE_COMMENT { RAISE_SYNTAX_ERROR("bare * has associated type comment") } diff --git a/Parser/parser.c b/Parser/parser.c index 7d11483..0b03768 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -215,509 +215,519 @@ static char *soft_keywords[] = { #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_sum_params_type 1172 -#define lambda_parameters_type 1173 -#define lambda_slash_no_default_type 1174 -#define lambda_slash_with_default_type 1175 -#define lambda_star_etc_type 1176 -#define lambda_kwds_type 1177 -#define lambda_param_no_default_type 1178 -#define lambda_param_with_default_type 1179 -#define lambda_param_maybe_default_type 1180 -#define lambda_param_type 1181 -#define lambda_sum_parameters_type 1182 -#define lambda_sum_slash_no_default_type 1183 -#define lambda_sum_slash_with_default_type 1184 -#define lambda_sum_star_etc_type 1185 -#define lambda_sum_kwds_type 1186 -#define lambda_sum_param_no_default_type 1187 -#define lambda_sum_param_with_default_type 1188 -#define lambda_sum_param_maybe_default_type 1189 -#define fstring_middle_type 1190 -#define fstring_replacement_field_type 1191 -#define fstring_conversion_type 1192 -#define fstring_full_format_spec_type 1193 -#define fstring_format_spec_type 1194 -#define string_type 1195 -#define strings_type 1196 -#define list_type 1197 -#define tuple_type 1198 -#define set_type 1199 -#define dict_type 1200 -#define double_starred_kvpairs_type 1201 -#define double_starred_kvpair_type 1202 -#define kvpair_type 1203 -#define for_if_clauses_type 1204 -#define for_if_clause_type 1205 -#define listcomp_type 1206 -#define tuplecomp_type 1207 -#define setcomp_type 1208 -#define genexp_type 1209 -#define dictcomp_type 1210 -#define arguments_type 1211 -#define args_type 1212 -#define kwargs_type 1213 -#define starred_expression_type 1214 -#define kwarg_or_starred_type 1215 -#define kwarg_or_double_starred_type 1216 -#define star_targets_type 1217 -#define star_targets_list_seq_type 1218 -#define star_targets_tuple_seq_type 1219 -#define star_target_type 1220 -#define target_with_star_atom_type 1221 -#define star_atom_type 1222 -#define single_target_type 1223 -#define single_subscript_attribute_target_type 1224 -#define t_primary_type 1225 // Left-recursive -#define t_lookahead_type 1226 -#define t_lookmain_type 1227 -#define del_targets_type 1228 -#define del_target_type 1229 -#define del_t_atom_type 1230 -#define type_expressions_type 1231 -#define func_type_comment_type 1232 -#define invalid_arguments_type 1233 -#define invalid_kwarg_type 1234 -#define expression_without_invalid_type 1235 -#define invalid_legacy_expression_type 1236 -#define invalid_expression_type 1237 -#define invalid_named_expression_type 1238 -#define invalid_assignment_type 1239 -#define invalid_ann_assign_target_type 1240 -#define invalid_del_stmt_type 1241 -#define invalid_block_type 1242 -#define invalid_comprehension_type 1243 -#define invalid_dict_comprehension_type 1244 -#define invalid_parameters_type 1245 -#define invalid_default_type 1246 -#define invalid_star_etc_type 1247 -#define invalid_kwds_type 1248 -#define invalid_parameters_helper_type 1249 -#define invalid_lambda_parameters_type 1250 -#define invalid_lambda_parameters_helper_type 1251 -#define invalid_lambda_star_etc_type 1252 -#define invalid_lambda_kwds_type 1253 -#define invalid_lambda_sum_parameters_type 1254 -#define invalid_lambda_sum_parameters_helper_type 1255 -#define invalid_lambda_sum_star_etc_type 1256 -#define invalid_double_type_comments_type 1257 -#define invalid_with_item_type 1258 -#define invalid_for_target_type 1259 -#define invalid_group_type 1260 -#define invalid_import_type 1261 -#define invalid_import_from_targets_type 1262 -#define invalid_with_stmt_type 1263 -#define invalid_with_stmt_indent_type 1264 -#define invalid_try_stmt_type 1265 -#define invalid_except_stmt_type 1266 -#define invalid_finally_stmt_type 1267 -#define invalid_except_stmt_indent_type 1268 -#define invalid_except_star_stmt_indent_type 1269 -#define invalid_match_stmt_type 1270 -#define invalid_case_block_type 1271 -#define invalid_as_pattern_type 1272 -#define invalid_class_pattern_type 1273 -#define invalid_class_argument_pattern_type 1274 -#define invalid_if_stmt_type 1275 -#define invalid_elif_stmt_type 1276 -#define invalid_else_stmt_type 1277 -#define invalid_while_stmt_type 1278 -#define invalid_for_stmt_type 1279 -#define invalid_def_raw_type 1280 -#define invalid_class_def_raw_nonewline_type 1281 -#define invalid_class_def_raw_type 1282 -#define invalid_double_starred_kvpairs_type 1283 -#define invalid_kvpair_type 1284 -#define invalid_starred_expression_type 1285 -#define invalid_replacement_field_type 1286 -#define invalid_conversion_character_type 1287 -#define _loop0_1_type 1288 -#define _loop0_2_type 1289 -#define _loop0_3_type 1290 -#define _loop1_4_type 1291 -#define _loop0_6_type 1292 -#define _gather_5_type 1293 -#define _loop0_8_type 1294 -#define _gather_7_type 1295 -#define _tmp_9_type 1296 -#define _tmp_10_type 1297 -#define _tmp_11_type 1298 -#define _tmp_12_type 1299 -#define _tmp_13_type 1300 -#define _tmp_14_type 1301 -#define _tmp_15_type 1302 -#define _tmp_16_type 1303 -#define _tmp_17_type 1304 -#define _tmp_18_type 1305 -#define _loop1_19_type 1306 -#define _tmp_20_type 1307 -#define _tmp_21_type 1308 -#define _tmp_22_type 1309 -#define _tmp_23_type 1310 -#define _tmp_24_type 1311 -#define _tmp_25_type 1312 -#define _tmp_26_type 1313 -#define _tmp_27_type 1314 -#define _tmp_28_type 1315 -#define _loop0_30_type 1316 -#define _gather_29_type 1317 -#define _loop0_32_type 1318 -#define _gather_31_type 1319 -#define _tmp_33_type 1320 -#define _tmp_34_type 1321 -#define _tmp_35_type 1322 -#define _loop0_37_type 1323 -#define _gather_36_type 1324 -#define _loop0_38_type 1325 -#define _loop1_39_type 1326 -#define _loop0_41_type 1327 -#define _gather_40_type 1328 -#define _tmp_42_type 1329 -#define _loop0_44_type 1330 -#define _gather_43_type 1331 -#define _tmp_45_type 1332 -#define _loop1_46_type 1333 -#define _tmp_47_type 1334 -#define _tmp_48_type 1335 -#define _tmp_49_type 1336 -#define _tmp_50_type 1337 -#define _tmp_51_type 1338 -#define _tmp_52_type 1339 -#define _loop0_53_type 1340 -#define _loop0_54_type 1341 -#define _loop0_55_type 1342 -#define _loop1_56_type 1343 -#define _loop0_57_type 1344 -#define _loop1_58_type 1345 -#define _loop1_59_type 1346 -#define _loop1_60_type 1347 -#define _loop0_61_type 1348 -#define _loop1_62_type 1349 -#define _loop0_63_type 1350 -#define _loop1_64_type 1351 -#define _loop0_65_type 1352 -#define _loop0_66_type 1353 -#define _loop1_67_type 1354 -#define _loop0_69_type 1355 -#define _gather_68_type 1356 -#define _loop0_71_type 1357 -#define _gather_70_type 1358 -#define _loop0_73_type 1359 -#define _gather_72_type 1360 -#define _loop0_75_type 1361 -#define _gather_74_type 1362 -#define _tmp_76_type 1363 -#define _loop1_77_type 1364 -#define _loop1_78_type 1365 -#define _tmp_79_type 1366 -#define _tmp_80_type 1367 -#define _loop1_81_type 1368 -#define _loop1_82_type 1369 -#define _loop0_84_type 1370 -#define _gather_83_type 1371 -#define _loop1_85_type 1372 -#define _loop1_86_type 1373 -#define _loop0_88_type 1374 -#define _gather_87_type 1375 -#define _tmp_89_type 1376 -#define _tmp_90_type 1377 -#define _tmp_91_type 1378 -#define _tmp_92_type 1379 -#define _loop0_94_type 1380 -#define _gather_93_type 1381 -#define _loop0_96_type 1382 -#define _gather_95_type 1383 -#define _tmp_97_type 1384 -#define _loop0_99_type 1385 -#define _gather_98_type 1386 -#define _loop0_101_type 1387 -#define _gather_100_type 1388 -#define _tmp_102_type 1389 -#define _loop0_104_type 1390 -#define _gather_103_type 1391 -#define _loop1_105_type 1392 -#define _loop1_106_type 1393 -#define _loop0_108_type 1394 -#define _gather_107_type 1395 -#define _loop1_109_type 1396 -#define _loop1_110_type 1397 -#define _loop1_111_type 1398 -#define _tmp_112_type 1399 -#define _tmp_113_type 1400 -#define _tmp_114_type 1401 -#define _tmp_115_type 1402 -#define _loop0_117_type 1403 -#define _gather_116_type 1404 -#define _tmp_118_type 1405 -#define _tmp_119_type 1406 -#define _tmp_120_type 1407 -#define _tmp_121_type 1408 -#define _tmp_122_type 1409 -#define _tmp_123_type 1410 -#define _tmp_124_type 1411 -#define _loop0_125_type 1412 -#define _loop0_126_type 1413 -#define _loop0_127_type 1414 -#define _loop1_128_type 1415 -#define _loop0_129_type 1416 -#define _loop1_130_type 1417 -#define _loop1_131_type 1418 -#define _loop1_132_type 1419 -#define _loop0_133_type 1420 -#define _loop1_134_type 1421 -#define _loop0_135_type 1422 -#define _loop1_136_type 1423 -#define _loop0_137_type 1424 -#define _loop1_138_type 1425 -#define _loop0_139_type 1426 -#define _loop0_140_type 1427 -#define _loop0_141_type 1428 -#define _loop1_142_type 1429 -#define _loop0_143_type 1430 -#define _loop1_144_type 1431 -#define _loop1_145_type 1432 -#define _loop1_146_type 1433 -#define _loop0_147_type 1434 -#define _loop1_148_type 1435 -#define _loop0_149_type 1436 -#define _loop1_150_type 1437 -#define _loop0_151_type 1438 -#define _loop1_152_type 1439 -#define _tmp_153_type 1440 -#define _loop0_154_type 1441 -#define _loop1_155_type 1442 -#define _tmp_156_type 1443 -#define _loop0_158_type 1444 -#define _gather_157_type 1445 -#define _loop1_159_type 1446 -#define _loop0_160_type 1447 -#define _loop0_161_type 1448 -#define _loop0_162_type 1449 -#define _tmp_163_type 1450 -#define _tmp_164_type 1451 -#define _loop0_166_type 1452 -#define _gather_165_type 1453 -#define _tmp_167_type 1454 -#define _loop0_169_type 1455 -#define _gather_168_type 1456 -#define _loop0_171_type 1457 -#define _gather_170_type 1458 -#define _loop0_173_type 1459 -#define _gather_172_type 1460 -#define _loop0_175_type 1461 -#define _gather_174_type 1462 -#define _tmp_176_type 1463 -#define _tmp_177_type 1464 -#define _loop0_178_type 1465 -#define _loop0_180_type 1466 -#define _gather_179_type 1467 -#define _loop1_181_type 1468 -#define _tmp_182_type 1469 -#define _tmp_183_type 1470 -#define _loop0_185_type 1471 -#define _gather_184_type 1472 -#define _loop0_187_type 1473 -#define _gather_186_type 1474 -#define _loop0_189_type 1475 -#define _gather_188_type 1476 -#define _loop0_191_type 1477 -#define _gather_190_type 1478 -#define _loop0_193_type 1479 -#define _gather_192_type 1480 -#define _tmp_194_type 1481 -#define _tmp_195_type 1482 -#define _tmp_196_type 1483 -#define _tmp_197_type 1484 -#define _tmp_198_type 1485 -#define _tmp_199_type 1486 -#define _tmp_200_type 1487 -#define _tmp_201_type 1488 -#define _tmp_202_type 1489 -#define _tmp_203_type 1490 -#define _tmp_204_type 1491 -#define _tmp_205_type 1492 -#define _loop0_206_type 1493 -#define _loop0_207_type 1494 -#define _loop0_208_type 1495 -#define _tmp_209_type 1496 -#define _tmp_210_type 1497 -#define _tmp_211_type 1498 -#define _tmp_212_type 1499 -#define _tmp_213_type 1500 -#define _loop0_214_type 1501 -#define _loop0_215_type 1502 -#define _loop0_216_type 1503 -#define _loop1_217_type 1504 -#define _tmp_218_type 1505 -#define _loop0_219_type 1506 -#define _tmp_220_type 1507 -#define _loop0_221_type 1508 -#define _loop1_222_type 1509 -#define _tmp_223_type 1510 -#define _tmp_224_type 1511 -#define _tmp_225_type 1512 -#define _loop0_226_type 1513 -#define _tmp_227_type 1514 -#define _tmp_228_type 1515 -#define _loop1_229_type 1516 -#define _tmp_230_type 1517 -#define _loop0_231_type 1518 -#define _loop0_232_type 1519 -#define _loop0_233_type 1520 -#define _loop0_235_type 1521 -#define _gather_234_type 1522 -#define _tmp_236_type 1523 -#define _loop0_237_type 1524 -#define _tmp_238_type 1525 -#define _loop0_239_type 1526 -#define _loop1_240_type 1527 -#define _loop1_241_type 1528 -#define _tmp_242_type 1529 -#define _tmp_243_type 1530 -#define _loop0_244_type 1531 -#define _tmp_245_type 1532 -#define _tmp_246_type 1533 -#define _tmp_247_type 1534 -#define _loop0_248_type 1535 -#define _loop0_249_type 1536 -#define _loop0_250_type 1537 -#define _loop0_252_type 1538 -#define _gather_251_type 1539 -#define _tmp_253_type 1540 -#define _loop0_254_type 1541 -#define _tmp_255_type 1542 -#define _loop0_256_type 1543 -#define _loop1_257_type 1544 -#define _loop1_258_type 1545 -#define _tmp_259_type 1546 -#define _tmp_260_type 1547 -#define _loop0_261_type 1548 -#define _tmp_262_type 1549 -#define _tmp_263_type 1550 -#define _loop0_265_type 1551 -#define _gather_264_type 1552 -#define _loop0_267_type 1553 -#define _gather_266_type 1554 -#define _loop0_269_type 1555 -#define _gather_268_type 1556 -#define _loop0_271_type 1557 -#define _gather_270_type 1558 -#define _loop0_273_type 1559 -#define _gather_272_type 1560 -#define _tmp_274_type 1561 -#define _loop0_275_type 1562 -#define _loop1_276_type 1563 -#define _tmp_277_type 1564 -#define _loop0_278_type 1565 -#define _loop1_279_type 1566 -#define _tmp_280_type 1567 -#define _tmp_281_type 1568 -#define _tmp_282_type 1569 -#define _tmp_283_type 1570 -#define _tmp_284_type 1571 -#define _tmp_285_type 1572 -#define _tmp_286_type 1573 -#define _tmp_287_type 1574 -#define _tmp_288_type 1575 -#define _tmp_289_type 1576 -#define _loop0_291_type 1577 -#define _gather_290_type 1578 -#define _tmp_292_type 1579 -#define _tmp_293_type 1580 -#define _tmp_294_type 1581 -#define _tmp_295_type 1582 -#define _tmp_296_type 1583 -#define _tmp_297_type 1584 -#define _tmp_298_type 1585 -#define _tmp_299_type 1586 -#define _tmp_300_type 1587 -#define _tmp_301_type 1588 -#define _tmp_302_type 1589 -#define _tmp_303_type 1590 -#define _tmp_304_type 1591 -#define _loop0_305_type 1592 -#define _tmp_306_type 1593 -#define _tmp_307_type 1594 -#define _tmp_308_type 1595 -#define _tmp_309_type 1596 -#define _tmp_310_type 1597 -#define _tmp_311_type 1598 -#define _tmp_312_type 1599 -#define _tmp_313_type 1600 -#define _tmp_314_type 1601 -#define _loop0_316_type 1602 -#define _gather_315_type 1603 -#define _tmp_317_type 1604 -#define _tmp_318_type 1605 -#define _tmp_319_type 1606 -#define _tmp_320_type 1607 -#define _tmp_321_type 1608 -#define _tmp_322_type 1609 -#define _tmp_323_type 1610 -#define _tmp_324_type 1611 -#define _tmp_325_type 1612 -#define _tmp_326_type 1613 -#define _tmp_327_type 1614 -#define _tmp_328_type 1615 -#define _tmp_329_type 1616 -#define _tmp_330_type 1617 -#define _tmp_331_type 1618 -#define _tmp_332_type 1619 -#define _tmp_333_type 1620 -#define _tmp_334_type 1621 -#define _tmp_335_type 1622 -#define _tmp_336_type 1623 -#define _tmp_337_type 1624 -#define _tmp_338_type 1625 -#define _tmp_339_type 1626 -#define _tmp_340_type 1627 -#define _tmp_341_type 1628 -#define _tmp_342_type 1629 -#define _tmp_343_type 1630 -#define _tmp_344_type 1631 -#define _tmp_345_type 1632 +#define star_sum_type 1130 +#define star_named_expressions_type 1131 +#define star_named_expression_type 1132 +#define star_assignment_expression_type 1133 +#define assignment_expression_type 1134 +#define named_expression_type 1135 +#define disjunction_type 1136 +#define conjunction_type 1137 +#define inversion_type 1138 +#define comparison_type 1139 +#define compare_op_composition_pair_type 1140 +#define eq_composition_type 1141 +#define noteq_composition_type 1142 +#define lte_composition_type 1143 +#define lt_composition_type 1144 +#define gte_composition_type 1145 +#define gt_composition_type 1146 +#define notin_composition_type 1147 +#define in_composition_type 1148 +#define isnotin_composition_type 1149 +#define isin_composition_type 1150 +#define isnot_composition_type 1151 +#define is_composition_type 1152 +#define composition_type 1153 // Left-recursive +#define bitwise_or_type 1154 // Left-recursive +#define bitwise_xor_type 1155 // Left-recursive +#define bitwise_and_type 1156 // Left-recursive +#define shift_expr_type 1157 // Left-recursive +#define sum_type 1158 // Left-recursive +#define term_type 1159 // Left-recursive +#define factor_type 1160 +#define coalesce_type 1161 +#define power_type 1162 +#define await_primary_type 1163 +#define primary_type 1164 // Left-recursive +#define slices_type 1165 +#define slice_type 1166 +#define simple_slice_type 1167 +#define atom_type 1168 +#define group_type 1169 +#define class_or_func_expr_type 1170 +#define lambdef_type 1171 +#define lambda_params_type 1172 +#define lambda_sum_params_type 1173 +#define lambda_parameters_type 1174 +#define lambda_slash_no_default_type 1175 +#define lambda_slash_with_default_type 1176 +#define lambda_star_etc_type 1177 +#define lambda_kwds_type 1178 +#define lambda_param_no_default_type 1179 +#define lambda_param_with_default_type 1180 +#define lambda_param_maybe_default_type 1181 +#define lambda_param_type 1182 +#define lambda_sum_parameters_type 1183 +#define lambda_sum_slash_no_default_type 1184 +#define lambda_sum_slash_with_default_type 1185 +#define lambda_sum_star_etc_type 1186 +#define lambda_sum_kwds_type 1187 +#define lambda_sum_param_no_default_type 1188 +#define lambda_sum_param_no_default_star_annotation_type 1189 +#define lambda_sum_param_with_default_type 1190 +#define lambda_sum_param_maybe_default_type 1191 +#define sum_param_type 1192 +#define sum_param_star_annotation_type 1193 +#define sum_annotation_type 1194 +#define star_sum_annotation_type 1195 +#define sum_default_type 1196 +#define fstring_middle_type 1197 +#define fstring_replacement_field_type 1198 +#define fstring_conversion_type 1199 +#define fstring_full_format_spec_type 1200 +#define fstring_format_spec_type 1201 +#define string_type 1202 +#define strings_type 1203 +#define list_type 1204 +#define tuple_type 1205 +#define set_type 1206 +#define dict_type 1207 +#define double_starred_kvpairs_type 1208 +#define double_starred_kvpair_type 1209 +#define kvpair_type 1210 +#define for_if_clauses_type 1211 +#define for_if_clause_type 1212 +#define listcomp_type 1213 +#define tuplecomp_type 1214 +#define setcomp_type 1215 +#define genexp_type 1216 +#define dictcomp_type 1217 +#define arguments_type 1218 +#define args_type 1219 +#define kwargs_type 1220 +#define starred_expression_type 1221 +#define kwarg_or_starred_type 1222 +#define kwarg_or_double_starred_type 1223 +#define star_targets_type 1224 +#define star_targets_list_seq_type 1225 +#define star_targets_tuple_seq_type 1226 +#define star_target_type 1227 +#define target_with_star_atom_type 1228 +#define star_atom_type 1229 +#define single_target_type 1230 +#define single_subscript_attribute_target_type 1231 +#define t_primary_type 1232 // Left-recursive +#define t_lookahead_type 1233 +#define t_lookmain_type 1234 +#define del_targets_type 1235 +#define del_target_type 1236 +#define del_t_atom_type 1237 +#define type_expressions_type 1238 +#define func_type_comment_type 1239 +#define invalid_arguments_type 1240 +#define invalid_kwarg_type 1241 +#define expression_without_invalid_type 1242 +#define invalid_legacy_expression_type 1243 +#define invalid_expression_type 1244 +#define invalid_named_expression_type 1245 +#define invalid_assignment_type 1246 +#define invalid_ann_assign_target_type 1247 +#define invalid_del_stmt_type 1248 +#define invalid_block_type 1249 +#define invalid_comprehension_type 1250 +#define invalid_dict_comprehension_type 1251 +#define invalid_parameters_type 1252 +#define invalid_default_type 1253 +#define invalid_sum_default_type 1254 +#define invalid_star_etc_type 1255 +#define invalid_kwds_type 1256 +#define invalid_parameters_helper_type 1257 +#define invalid_lambda_parameters_type 1258 +#define invalid_lambda_parameters_helper_type 1259 +#define invalid_lambda_star_etc_type 1260 +#define invalid_lambda_kwds_type 1261 +#define invalid_lambda_sum_parameters_type 1262 +#define invalid_lambda_sum_parameters_helper_type 1263 +#define invalid_lambda_sum_star_etc_type 1264 +#define invalid_double_type_comments_type 1265 +#define invalid_with_item_type 1266 +#define invalid_for_target_type 1267 +#define invalid_group_type 1268 +#define invalid_import_type 1269 +#define invalid_import_from_targets_type 1270 +#define invalid_with_stmt_type 1271 +#define invalid_with_stmt_indent_type 1272 +#define invalid_try_stmt_type 1273 +#define invalid_except_stmt_type 1274 +#define invalid_finally_stmt_type 1275 +#define invalid_except_stmt_indent_type 1276 +#define invalid_except_star_stmt_indent_type 1277 +#define invalid_match_stmt_type 1278 +#define invalid_case_block_type 1279 +#define invalid_as_pattern_type 1280 +#define invalid_class_pattern_type 1281 +#define invalid_class_argument_pattern_type 1282 +#define invalid_if_stmt_type 1283 +#define invalid_elif_stmt_type 1284 +#define invalid_else_stmt_type 1285 +#define invalid_while_stmt_type 1286 +#define invalid_for_stmt_type 1287 +#define invalid_def_raw_type 1288 +#define invalid_class_def_raw_nonewline_type 1289 +#define invalid_class_def_raw_type 1290 +#define invalid_double_starred_kvpairs_type 1291 +#define invalid_kvpair_type 1292 +#define invalid_starred_expression_type 1293 +#define invalid_replacement_field_type 1294 +#define invalid_conversion_character_type 1295 +#define _loop0_1_type 1296 +#define _loop0_2_type 1297 +#define _loop0_3_type 1298 +#define _loop1_4_type 1299 +#define _loop0_6_type 1300 +#define _gather_5_type 1301 +#define _loop0_8_type 1302 +#define _gather_7_type 1303 +#define _tmp_9_type 1304 +#define _tmp_10_type 1305 +#define _tmp_11_type 1306 +#define _tmp_12_type 1307 +#define _tmp_13_type 1308 +#define _tmp_14_type 1309 +#define _tmp_15_type 1310 +#define _tmp_16_type 1311 +#define _tmp_17_type 1312 +#define _tmp_18_type 1313 +#define _loop1_19_type 1314 +#define _tmp_20_type 1315 +#define _tmp_21_type 1316 +#define _tmp_22_type 1317 +#define _tmp_23_type 1318 +#define _tmp_24_type 1319 +#define _tmp_25_type 1320 +#define _tmp_26_type 1321 +#define _tmp_27_type 1322 +#define _tmp_28_type 1323 +#define _loop0_30_type 1324 +#define _gather_29_type 1325 +#define _loop0_32_type 1326 +#define _gather_31_type 1327 +#define _tmp_33_type 1328 +#define _tmp_34_type 1329 +#define _tmp_35_type 1330 +#define _loop0_37_type 1331 +#define _gather_36_type 1332 +#define _loop0_38_type 1333 +#define _loop1_39_type 1334 +#define _loop0_41_type 1335 +#define _gather_40_type 1336 +#define _tmp_42_type 1337 +#define _loop0_44_type 1338 +#define _gather_43_type 1339 +#define _tmp_45_type 1340 +#define _loop1_46_type 1341 +#define _tmp_47_type 1342 +#define _tmp_48_type 1343 +#define _tmp_49_type 1344 +#define _tmp_50_type 1345 +#define _tmp_51_type 1346 +#define _tmp_52_type 1347 +#define _loop0_53_type 1348 +#define _loop0_54_type 1349 +#define _loop0_55_type 1350 +#define _loop1_56_type 1351 +#define _loop0_57_type 1352 +#define _loop1_58_type 1353 +#define _loop1_59_type 1354 +#define _loop1_60_type 1355 +#define _loop0_61_type 1356 +#define _loop1_62_type 1357 +#define _loop0_63_type 1358 +#define _loop1_64_type 1359 +#define _loop0_65_type 1360 +#define _loop0_66_type 1361 +#define _loop1_67_type 1362 +#define _loop0_69_type 1363 +#define _gather_68_type 1364 +#define _loop0_71_type 1365 +#define _gather_70_type 1366 +#define _loop0_73_type 1367 +#define _gather_72_type 1368 +#define _loop0_75_type 1369 +#define _gather_74_type 1370 +#define _tmp_76_type 1371 +#define _loop1_77_type 1372 +#define _loop1_78_type 1373 +#define _tmp_79_type 1374 +#define _tmp_80_type 1375 +#define _loop1_81_type 1376 +#define _loop1_82_type 1377 +#define _loop0_84_type 1378 +#define _gather_83_type 1379 +#define _loop1_85_type 1380 +#define _loop1_86_type 1381 +#define _loop0_88_type 1382 +#define _gather_87_type 1383 +#define _tmp_89_type 1384 +#define _tmp_90_type 1385 +#define _tmp_91_type 1386 +#define _tmp_92_type 1387 +#define _loop0_94_type 1388 +#define _gather_93_type 1389 +#define _loop0_96_type 1390 +#define _gather_95_type 1391 +#define _tmp_97_type 1392 +#define _loop0_99_type 1393 +#define _gather_98_type 1394 +#define _loop0_101_type 1395 +#define _gather_100_type 1396 +#define _tmp_102_type 1397 +#define _loop0_104_type 1398 +#define _gather_103_type 1399 +#define _loop1_105_type 1400 +#define _loop1_106_type 1401 +#define _loop0_108_type 1402 +#define _gather_107_type 1403 +#define _loop1_109_type 1404 +#define _loop1_110_type 1405 +#define _loop1_111_type 1406 +#define _tmp_112_type 1407 +#define _tmp_113_type 1408 +#define _tmp_114_type 1409 +#define _tmp_115_type 1410 +#define _loop0_117_type 1411 +#define _gather_116_type 1412 +#define _tmp_118_type 1413 +#define _tmp_119_type 1414 +#define _tmp_120_type 1415 +#define _tmp_121_type 1416 +#define _tmp_122_type 1417 +#define _tmp_123_type 1418 +#define _tmp_124_type 1419 +#define _loop0_125_type 1420 +#define _loop0_126_type 1421 +#define _loop0_127_type 1422 +#define _loop1_128_type 1423 +#define _loop0_129_type 1424 +#define _loop1_130_type 1425 +#define _loop1_131_type 1426 +#define _loop1_132_type 1427 +#define _loop0_133_type 1428 +#define _loop1_134_type 1429 +#define _loop0_135_type 1430 +#define _loop1_136_type 1431 +#define _loop0_137_type 1432 +#define _loop1_138_type 1433 +#define _loop0_139_type 1434 +#define _loop0_140_type 1435 +#define _loop0_141_type 1436 +#define _loop1_142_type 1437 +#define _loop0_143_type 1438 +#define _loop1_144_type 1439 +#define _loop1_145_type 1440 +#define _loop1_146_type 1441 +#define _loop0_147_type 1442 +#define _loop1_148_type 1443 +#define _loop0_149_type 1444 +#define _loop1_150_type 1445 +#define _loop0_151_type 1446 +#define _loop0_152_type 1447 +#define _loop1_153_type 1448 +#define _tmp_154_type 1449 +#define _loop0_155_type 1450 +#define _loop1_156_type 1451 +#define _tmp_157_type 1452 +#define _loop0_159_type 1453 +#define _gather_158_type 1454 +#define _loop1_160_type 1455 +#define _loop0_161_type 1456 +#define _loop0_162_type 1457 +#define _loop0_163_type 1458 +#define _tmp_164_type 1459 +#define _tmp_165_type 1460 +#define _loop0_167_type 1461 +#define _gather_166_type 1462 +#define _tmp_168_type 1463 +#define _loop0_170_type 1464 +#define _gather_169_type 1465 +#define _loop0_172_type 1466 +#define _gather_171_type 1467 +#define _loop0_174_type 1468 +#define _gather_173_type 1469 +#define _loop0_176_type 1470 +#define _gather_175_type 1471 +#define _tmp_177_type 1472 +#define _tmp_178_type 1473 +#define _loop0_179_type 1474 +#define _loop0_181_type 1475 +#define _gather_180_type 1476 +#define _loop1_182_type 1477 +#define _tmp_183_type 1478 +#define _tmp_184_type 1479 +#define _loop0_186_type 1480 +#define _gather_185_type 1481 +#define _loop0_188_type 1482 +#define _gather_187_type 1483 +#define _loop0_190_type 1484 +#define _gather_189_type 1485 +#define _loop0_192_type 1486 +#define _gather_191_type 1487 +#define _loop0_194_type 1488 +#define _gather_193_type 1489 +#define _tmp_195_type 1490 +#define _tmp_196_type 1491 +#define _tmp_197_type 1492 +#define _tmp_198_type 1493 +#define _tmp_199_type 1494 +#define _tmp_200_type 1495 +#define _tmp_201_type 1496 +#define _tmp_202_type 1497 +#define _tmp_203_type 1498 +#define _tmp_204_type 1499 +#define _tmp_205_type 1500 +#define _tmp_206_type 1501 +#define _loop0_207_type 1502 +#define _loop0_208_type 1503 +#define _loop0_209_type 1504 +#define _tmp_210_type 1505 +#define _tmp_211_type 1506 +#define _tmp_212_type 1507 +#define _tmp_213_type 1508 +#define _tmp_214_type 1509 +#define _loop0_215_type 1510 +#define _loop0_216_type 1511 +#define _loop0_217_type 1512 +#define _loop1_218_type 1513 +#define _tmp_219_type 1514 +#define _loop0_220_type 1515 +#define _tmp_221_type 1516 +#define _loop0_222_type 1517 +#define _loop1_223_type 1518 +#define _tmp_224_type 1519 +#define _tmp_225_type 1520 +#define _tmp_226_type 1521 +#define _tmp_227_type 1522 +#define _loop0_228_type 1523 +#define _tmp_229_type 1524 +#define _tmp_230_type 1525 +#define _loop1_231_type 1526 +#define _tmp_232_type 1527 +#define _loop0_233_type 1528 +#define _loop0_234_type 1529 +#define _loop0_235_type 1530 +#define _loop0_237_type 1531 +#define _gather_236_type 1532 +#define _tmp_238_type 1533 +#define _loop0_239_type 1534 +#define _tmp_240_type 1535 +#define _loop0_241_type 1536 +#define _loop1_242_type 1537 +#define _loop1_243_type 1538 +#define _tmp_244_type 1539 +#define _tmp_245_type 1540 +#define _loop0_246_type 1541 +#define _tmp_247_type 1542 +#define _tmp_248_type 1543 +#define _tmp_249_type 1544 +#define _loop0_250_type 1545 +#define _loop0_251_type 1546 +#define _loop0_252_type 1547 +#define _loop0_254_type 1548 +#define _gather_253_type 1549 +#define _tmp_255_type 1550 +#define _loop0_256_type 1551 +#define _tmp_257_type 1552 +#define _loop0_258_type 1553 +#define _loop1_259_type 1554 +#define _loop1_260_type 1555 +#define _tmp_261_type 1556 +#define _tmp_262_type 1557 +#define _loop0_263_type 1558 +#define _tmp_264_type 1559 +#define _tmp_265_type 1560 +#define _loop0_267_type 1561 +#define _gather_266_type 1562 +#define _loop0_269_type 1563 +#define _gather_268_type 1564 +#define _loop0_271_type 1565 +#define _gather_270_type 1566 +#define _loop0_273_type 1567 +#define _gather_272_type 1568 +#define _loop0_275_type 1569 +#define _gather_274_type 1570 +#define _tmp_276_type 1571 +#define _loop0_277_type 1572 +#define _loop1_278_type 1573 +#define _tmp_279_type 1574 +#define _loop0_280_type 1575 +#define _loop1_281_type 1576 +#define _tmp_282_type 1577 +#define _tmp_283_type 1578 +#define _tmp_284_type 1579 +#define _tmp_285_type 1580 +#define _tmp_286_type 1581 +#define _tmp_287_type 1582 +#define _tmp_288_type 1583 +#define _tmp_289_type 1584 +#define _tmp_290_type 1585 +#define _tmp_291_type 1586 +#define _loop0_293_type 1587 +#define _gather_292_type 1588 +#define _tmp_294_type 1589 +#define _tmp_295_type 1590 +#define _tmp_296_type 1591 +#define _tmp_297_type 1592 +#define _tmp_298_type 1593 +#define _tmp_299_type 1594 +#define _tmp_300_type 1595 +#define _tmp_301_type 1596 +#define _tmp_302_type 1597 +#define _tmp_303_type 1598 +#define _tmp_304_type 1599 +#define _tmp_305_type 1600 +#define _tmp_306_type 1601 +#define _loop0_307_type 1602 +#define _tmp_308_type 1603 +#define _tmp_309_type 1604 +#define _tmp_310_type 1605 +#define _tmp_311_type 1606 +#define _tmp_312_type 1607 +#define _tmp_313_type 1608 +#define _tmp_314_type 1609 +#define _tmp_315_type 1610 +#define _tmp_316_type 1611 +#define _loop0_318_type 1612 +#define _gather_317_type 1613 +#define _tmp_319_type 1614 +#define _tmp_320_type 1615 +#define _tmp_321_type 1616 +#define _tmp_322_type 1617 +#define _tmp_323_type 1618 +#define _tmp_324_type 1619 +#define _tmp_325_type 1620 +#define _tmp_326_type 1621 +#define _tmp_327_type 1622 +#define _tmp_328_type 1623 +#define _tmp_329_type 1624 +#define _tmp_330_type 1625 +#define _tmp_331_type 1626 +#define _tmp_332_type 1627 +#define _tmp_333_type 1628 +#define _tmp_334_type 1629 +#define _tmp_335_type 1630 +#define _tmp_336_type 1631 +#define _tmp_337_type 1632 +#define _tmp_338_type 1633 +#define _tmp_339_type 1634 +#define _tmp_340_type 1635 +#define _tmp_341_type 1636 +#define _tmp_342_type 1637 +#define _tmp_343_type 1638 +#define _tmp_344_type 1639 +#define _tmp_345_type 1640 +#define _tmp_346_type 1641 +#define _tmp_347_type 1642 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -849,6 +859,7 @@ static expr_ty expression_rule(Parser *p); static expr_ty yield_expr_rule(Parser *p); static expr_ty star_expressions_rule(Parser *p); static expr_ty star_expression_rule(Parser *p); +static expr_ty star_sum_rule(Parser *p); static asdl_expr_seq* star_named_expressions_rule(Parser *p); static expr_ty star_named_expression_rule(Parser *p); static expr_ty star_assignment_expression_rule(Parser *p); @@ -907,8 +918,14 @@ static SlashWithDefault* lambda_sum_slash_with_default_rule(Parser *p); static StarEtc* lambda_sum_star_etc_rule(Parser *p); static arg_ty lambda_sum_kwds_rule(Parser *p); static arg_ty lambda_sum_param_no_default_rule(Parser *p); +static arg_ty lambda_sum_param_no_default_star_annotation_rule(Parser *p); static NameDefaultPair* lambda_sum_param_with_default_rule(Parser *p); static NameDefaultPair* lambda_sum_param_maybe_default_rule(Parser *p); +static arg_ty sum_param_rule(Parser *p); +static arg_ty sum_param_star_annotation_rule(Parser *p); +static expr_ty sum_annotation_rule(Parser *p); +static expr_ty star_sum_annotation_rule(Parser *p); +static expr_ty sum_default_rule(Parser *p); static expr_ty fstring_middle_rule(Parser *p); static expr_ty fstring_replacement_field_rule(Parser *p); static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p); @@ -966,6 +983,7 @@ static void *invalid_comprehension_rule(Parser *p); static void *invalid_dict_comprehension_rule(Parser *p); static void *invalid_parameters_rule(Parser *p); static void *invalid_default_rule(Parser *p); +static void *invalid_sum_default_rule(Parser *p); static void *invalid_star_etc_rule(Parser *p); static void *invalid_kwds_rule(Parser *p); static void *invalid_parameters_helper_rule(Parser *p); @@ -1158,49 +1176,49 @@ static asdl_seq *_loop1_148_rule(Parser *p); static asdl_seq *_loop0_149_rule(Parser *p); static asdl_seq *_loop1_150_rule(Parser *p); static asdl_seq *_loop0_151_rule(Parser *p); -static asdl_seq *_loop1_152_rule(Parser *p); -static void *_tmp_153_rule(Parser *p); -static asdl_seq *_loop0_154_rule(Parser *p); -static asdl_seq *_loop1_155_rule(Parser *p); -static void *_tmp_156_rule(Parser *p); -static asdl_seq *_loop0_158_rule(Parser *p); -static asdl_seq *_gather_157_rule(Parser *p); -static asdl_seq *_loop1_159_rule(Parser *p); -static asdl_seq *_loop0_160_rule(Parser *p); +static asdl_seq *_loop0_152_rule(Parser *p); +static asdl_seq *_loop1_153_rule(Parser *p); +static void *_tmp_154_rule(Parser *p); +static asdl_seq *_loop0_155_rule(Parser *p); +static asdl_seq *_loop1_156_rule(Parser *p); +static void *_tmp_157_rule(Parser *p); +static asdl_seq *_loop0_159_rule(Parser *p); +static asdl_seq *_gather_158_rule(Parser *p); +static asdl_seq *_loop1_160_rule(Parser *p); static asdl_seq *_loop0_161_rule(Parser *p); static asdl_seq *_loop0_162_rule(Parser *p); -static void *_tmp_163_rule(Parser *p); +static asdl_seq *_loop0_163_rule(Parser *p); static void *_tmp_164_rule(Parser *p); -static asdl_seq *_loop0_166_rule(Parser *p); -static asdl_seq *_gather_165_rule(Parser *p); -static void *_tmp_167_rule(Parser *p); -static asdl_seq *_loop0_169_rule(Parser *p); -static asdl_seq *_gather_168_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 asdl_seq *_loop0_175_rule(Parser *p); -static asdl_seq *_gather_174_rule(Parser *p); -static void *_tmp_176_rule(Parser *p); +static void *_tmp_165_rule(Parser *p); +static asdl_seq *_loop0_167_rule(Parser *p); +static asdl_seq *_gather_166_rule(Parser *p); +static void *_tmp_168_rule(Parser *p); +static asdl_seq *_loop0_170_rule(Parser *p); +static asdl_seq *_gather_169_rule(Parser *p); +static asdl_seq *_loop0_172_rule(Parser *p); +static asdl_seq *_gather_171_rule(Parser *p); +static asdl_seq *_loop0_174_rule(Parser *p); +static asdl_seq *_gather_173_rule(Parser *p); +static asdl_seq *_loop0_176_rule(Parser *p); +static asdl_seq *_gather_175_rule(Parser *p); static void *_tmp_177_rule(Parser *p); -static asdl_seq *_loop0_178_rule(Parser *p); -static asdl_seq *_loop0_180_rule(Parser *p); -static asdl_seq *_gather_179_rule(Parser *p); -static asdl_seq *_loop1_181_rule(Parser *p); -static void *_tmp_182_rule(Parser *p); +static void *_tmp_178_rule(Parser *p); +static asdl_seq *_loop0_179_rule(Parser *p); +static asdl_seq *_loop0_181_rule(Parser *p); +static asdl_seq *_gather_180_rule(Parser *p); +static asdl_seq *_loop1_182_rule(Parser *p); static void *_tmp_183_rule(Parser *p); -static asdl_seq *_loop0_185_rule(Parser *p); -static asdl_seq *_gather_184_rule(Parser *p); -static asdl_seq *_loop0_187_rule(Parser *p); -static asdl_seq *_gather_186_rule(Parser *p); -static asdl_seq *_loop0_189_rule(Parser *p); -static asdl_seq *_gather_188_rule(Parser *p); -static asdl_seq *_loop0_191_rule(Parser *p); -static asdl_seq *_gather_190_rule(Parser *p); -static asdl_seq *_loop0_193_rule(Parser *p); -static asdl_seq *_gather_192_rule(Parser *p); -static void *_tmp_194_rule(Parser *p); +static void *_tmp_184_rule(Parser *p); +static asdl_seq *_loop0_186_rule(Parser *p); +static asdl_seq *_gather_185_rule(Parser *p); +static asdl_seq *_loop0_188_rule(Parser *p); +static asdl_seq *_gather_187_rule(Parser *p); +static asdl_seq *_loop0_190_rule(Parser *p); +static asdl_seq *_gather_189_rule(Parser *p); +static asdl_seq *_loop0_192_rule(Parser *p); +static asdl_seq *_gather_191_rule(Parser *p); +static asdl_seq *_loop0_194_rule(Parser *p); +static asdl_seq *_gather_193_rule(Parser *p); static void *_tmp_195_rule(Parser *p); static void *_tmp_196_rule(Parser *p); static void *_tmp_197_rule(Parser *p); @@ -1212,66 +1230,66 @@ static void *_tmp_202_rule(Parser *p); static void *_tmp_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_206_rule(Parser *p); static asdl_seq *_loop0_207_rule(Parser *p); static asdl_seq *_loop0_208_rule(Parser *p); -static void *_tmp_209_rule(Parser *p); +static asdl_seq *_loop0_209_rule(Parser *p); static void *_tmp_210_rule(Parser *p); static void *_tmp_211_rule(Parser *p); static void *_tmp_212_rule(Parser *p); static void *_tmp_213_rule(Parser *p); -static asdl_seq *_loop0_214_rule(Parser *p); +static void *_tmp_214_rule(Parser *p); static asdl_seq *_loop0_215_rule(Parser *p); static asdl_seq *_loop0_216_rule(Parser *p); -static asdl_seq *_loop1_217_rule(Parser *p); -static void *_tmp_218_rule(Parser *p); -static asdl_seq *_loop0_219_rule(Parser *p); -static void *_tmp_220_rule(Parser *p); -static asdl_seq *_loop0_221_rule(Parser *p); -static asdl_seq *_loop1_222_rule(Parser *p); -static void *_tmp_223_rule(Parser *p); +static asdl_seq *_loop0_217_rule(Parser *p); +static asdl_seq *_loop1_218_rule(Parser *p); +static void *_tmp_219_rule(Parser *p); +static asdl_seq *_loop0_220_rule(Parser *p); +static void *_tmp_221_rule(Parser *p); +static asdl_seq *_loop0_222_rule(Parser *p); +static asdl_seq *_loop1_223_rule(Parser *p); static void *_tmp_224_rule(Parser *p); static void *_tmp_225_rule(Parser *p); -static asdl_seq *_loop0_226_rule(Parser *p); +static void *_tmp_226_rule(Parser *p); static void *_tmp_227_rule(Parser *p); -static void *_tmp_228_rule(Parser *p); -static asdl_seq *_loop1_229_rule(Parser *p); +static asdl_seq *_loop0_228_rule(Parser *p); +static void *_tmp_229_rule(Parser *p); static void *_tmp_230_rule(Parser *p); -static asdl_seq *_loop0_231_rule(Parser *p); -static asdl_seq *_loop0_232_rule(Parser *p); +static asdl_seq *_loop1_231_rule(Parser *p); +static void *_tmp_232_rule(Parser *p); static asdl_seq *_loop0_233_rule(Parser *p); +static asdl_seq *_loop0_234_rule(Parser *p); static asdl_seq *_loop0_235_rule(Parser *p); -static asdl_seq *_gather_234_rule(Parser *p); -static void *_tmp_236_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 asdl_seq *_loop1_241_rule(Parser *p); -static void *_tmp_242_rule(Parser *p); -static void *_tmp_243_rule(Parser *p); -static asdl_seq *_loop0_244_rule(Parser *p); +static void *_tmp_240_rule(Parser *p); +static asdl_seq *_loop0_241_rule(Parser *p); +static asdl_seq *_loop1_242_rule(Parser *p); +static asdl_seq *_loop1_243_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_246_rule(Parser *p); static void *_tmp_247_rule(Parser *p); -static asdl_seq *_loop0_248_rule(Parser *p); -static asdl_seq *_loop0_249_rule(Parser *p); +static void *_tmp_248_rule(Parser *p); +static void *_tmp_249_rule(Parser *p); static asdl_seq *_loop0_250_rule(Parser *p); +static asdl_seq *_loop0_251_rule(Parser *p); static asdl_seq *_loop0_252_rule(Parser *p); -static asdl_seq *_gather_251_rule(Parser *p); -static void *_tmp_253_rule(Parser *p); static asdl_seq *_loop0_254_rule(Parser *p); +static asdl_seq *_gather_253_rule(Parser *p); static void *_tmp_255_rule(Parser *p); static asdl_seq *_loop0_256_rule(Parser *p); -static asdl_seq *_loop1_257_rule(Parser *p); -static asdl_seq *_loop1_258_rule(Parser *p); -static void *_tmp_259_rule(Parser *p); -static void *_tmp_260_rule(Parser *p); -static asdl_seq *_loop0_261_rule(Parser *p); +static void *_tmp_257_rule(Parser *p); +static asdl_seq *_loop0_258_rule(Parser *p); +static asdl_seq *_loop1_259_rule(Parser *p); +static asdl_seq *_loop1_260_rule(Parser *p); +static void *_tmp_261_rule(Parser *p); static void *_tmp_262_rule(Parser *p); -static void *_tmp_263_rule(Parser *p); -static asdl_seq *_loop0_265_rule(Parser *p); -static asdl_seq *_gather_264_rule(Parser *p); +static asdl_seq *_loop0_263_rule(Parser *p); +static void *_tmp_264_rule(Parser *p); +static void *_tmp_265_rule(Parser *p); static asdl_seq *_loop0_267_rule(Parser *p); static asdl_seq *_gather_266_rule(Parser *p); static asdl_seq *_loop0_269_rule(Parser *p); @@ -1280,14 +1298,14 @@ static asdl_seq *_loop0_271_rule(Parser *p); static asdl_seq *_gather_270_rule(Parser *p); static asdl_seq *_loop0_273_rule(Parser *p); static asdl_seq *_gather_272_rule(Parser *p); -static void *_tmp_274_rule(Parser *p); static asdl_seq *_loop0_275_rule(Parser *p); -static asdl_seq *_loop1_276_rule(Parser *p); -static void *_tmp_277_rule(Parser *p); -static asdl_seq *_loop0_278_rule(Parser *p); -static asdl_seq *_loop1_279_rule(Parser *p); -static void *_tmp_280_rule(Parser *p); -static void *_tmp_281_rule(Parser *p); +static asdl_seq *_gather_274_rule(Parser *p); +static void *_tmp_276_rule(Parser *p); +static asdl_seq *_loop0_277_rule(Parser *p); +static asdl_seq *_loop1_278_rule(Parser *p); +static void *_tmp_279_rule(Parser *p); +static asdl_seq *_loop0_280_rule(Parser *p); +static asdl_seq *_loop1_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); @@ -1296,10 +1314,10 @@ static void *_tmp_286_rule(Parser *p); static void *_tmp_287_rule(Parser *p); static void *_tmp_288_rule(Parser *p); static void *_tmp_289_rule(Parser *p); -static asdl_seq *_loop0_291_rule(Parser *p); -static asdl_seq *_gather_290_rule(Parser *p); -static void *_tmp_292_rule(Parser *p); -static void *_tmp_293_rule(Parser *p); +static void *_tmp_290_rule(Parser *p); +static void *_tmp_291_rule(Parser *p); +static asdl_seq *_loop0_293_rule(Parser *p); +static asdl_seq *_gather_292_rule(Parser *p); static void *_tmp_294_rule(Parser *p); static void *_tmp_295_rule(Parser *p); static void *_tmp_296_rule(Parser *p); @@ -1311,9 +1329,9 @@ static void *_tmp_301_rule(Parser *p); static void *_tmp_302_rule(Parser *p); static void *_tmp_303_rule(Parser *p); static void *_tmp_304_rule(Parser *p); -static asdl_seq *_loop0_305_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 asdl_seq *_loop0_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); @@ -1321,10 +1339,10 @@ 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); -static asdl_seq *_loop0_316_rule(Parser *p); -static asdl_seq *_gather_315_rule(Parser *p); -static void *_tmp_317_rule(Parser *p); -static void *_tmp_318_rule(Parser *p); +static void *_tmp_315_rule(Parser *p); +static void *_tmp_316_rule(Parser *p); +static asdl_seq *_loop0_318_rule(Parser *p); +static asdl_seq *_gather_317_rule(Parser *p); static void *_tmp_319_rule(Parser *p); static void *_tmp_320_rule(Parser *p); static void *_tmp_321_rule(Parser *p); @@ -1352,6 +1370,8 @@ static void *_tmp_342_rule(Parser *p); static void *_tmp_343_rule(Parser *p); static void *_tmp_344_rule(Parser *p); static void *_tmp_345_rule(Parser *p); +static void *_tmp_346_rule(Parser *p); +static void *_tmp_347_rule(Parser *p); // file: statements? $ @@ -14139,9 +14159,9 @@ expressions_rule(Parser *p) // expression: // | invalid_expression // | invalid_legacy_expression +// | lambdef // | disjunction 'if' disjunction 'else' expression // | disjunction -// | lambdef static expr_ty expression_rule(Parser *p) { @@ -14206,6 +14226,25 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_legacy_expression")); } + { // lambdef + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> expression[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambdef")); + expr_ty lambdef_var; + if ( + (lambdef_var = lambdef_rule(p)) // lambdef + ) + { + D(fprintf(stderr, "%*c+ expression[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambdef")); + _res = lambdef_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s expression[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambdef")); + } { // disjunction 'if' disjunction 'else' expression if (p->error_indicator) { p->level--; @@ -14270,25 +14309,6 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "disjunction")); } - { // lambdef - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> expression[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambdef")); - expr_ty lambdef_var; - if ( - (lambdef_var = lambdef_rule(p)) // lambdef - ) - { - D(fprintf(stderr, "%*c+ expression[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambdef")); - _res = lambdef_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s expression[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambdef")); - } _res = NULL; done: _PyPegen_insert_memo(p, _mark, expression_type, _res); @@ -14616,6 +14636,95 @@ star_expression_rule(Parser *p) return _res; } +// star_sum: '*' sum | sum +static expr_ty +star_sum_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; + if (_PyPegen_is_memoized(p, star_sum_type, &_res)) { + p->level--; + return _res; + } + 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 + { // '*' sum + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> star_sum[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' sum")); + Token * _literal; + expr_ty a; + if ( + (_literal = _PyPegen_expect_token(p, 16)) // token='*' + && + (a = sum_rule(p)) // sum + ) + { + D(fprintf(stderr, "%*c+ star_sum[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' sum")); + 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_Starred ( a , Load , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s star_sum[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*' sum")); + } + { // sum + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> star_sum[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum")); + expr_ty sum_var; + if ( + (sum_var = sum_rule(p)) // sum + ) + { + D(fprintf(stderr, "%*c+ star_sum[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum")); + _res = sum_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s star_sum[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum")); + } + _res = NULL; + done: + _PyPegen_insert_memo(p, _mark, star_sum_type, _res); + p->level--; + return _res; +} + // star_named_expressions: ','.star_named_expression+ ','? static asdl_expr_seq* star_named_expressions_rule(Parser *p) @@ -19836,9 +19945,9 @@ lambda_param_rule(Parser *p) } // lambda_sum_parameters: -// | lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_star_etc? -// | lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_star_etc? -// | lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_star_etc? +// | lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_sum_star_etc? +// | lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_sum_star_etc? +// | lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_sum_star_etc? // | lambda_sum_param_with_default+ lambda_sum_star_etc? // | lambda_sum_star_etc static arguments_ty @@ -19854,12 +19963,12 @@ lambda_sum_parameters_rule(Parser *p) } arguments_ty _res = NULL; int _mark = p->mark; - { // lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_star_etc? + { // lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_sum_star_etc? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_star_etc?")); + D(fprintf(stderr, "%*c> lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_sum_star_etc?")); asdl_arg_seq* a; asdl_arg_seq* b; asdl_seq * c; @@ -19871,10 +19980,10 @@ lambda_sum_parameters_rule(Parser *p) && (c = _loop0_140_rule(p)) // lambda_sum_param_with_default* && - (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? + (d = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) { - D(fprintf(stderr, "%*c+ lambda_sum_parameters[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_star_etc?")); + D(fprintf(stderr, "%*c+ lambda_sum_parameters[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_sum_star_etc?")); _res = CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c , d ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -19885,14 +19994,14 @@ lambda_sum_parameters_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_parameters[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_star_etc?")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default lambda_sum_param_no_default* lambda_sum_param_with_default* lambda_sum_star_etc?")); } - { // lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_star_etc? + { // lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_sum_star_etc? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_star_etc?")); + D(fprintf(stderr, "%*c> lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_sum_star_etc?")); SlashWithDefault* a; asdl_seq * b; void *c; @@ -19901,10 +20010,10 @@ lambda_sum_parameters_rule(Parser *p) && (b = _loop0_141_rule(p)) // lambda_sum_param_with_default* && - (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? + (c = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) { - D(fprintf(stderr, "%*c+ lambda_sum_parameters[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_star_etc?")); + D(fprintf(stderr, "%*c+ lambda_sum_parameters[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_sum_star_etc?")); _res = CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -19915,14 +20024,14 @@ lambda_sum_parameters_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_parameters[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_star_etc?")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default lambda_sum_param_with_default* lambda_sum_star_etc?")); } - { // lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_star_etc? + { // lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_sum_star_etc? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_star_etc?")); + D(fprintf(stderr, "%*c> lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_sum_star_etc?")); asdl_arg_seq* a; asdl_seq * b; void *c; @@ -19931,10 +20040,10 @@ lambda_sum_parameters_rule(Parser *p) && (b = _loop0_143_rule(p)) // lambda_sum_param_with_default* && - (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? + (c = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) { - D(fprintf(stderr, "%*c+ lambda_sum_parameters[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_star_etc?")); + D(fprintf(stderr, "%*c+ lambda_sum_parameters[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_sum_star_etc?")); _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -19945,7 +20054,7 @@ lambda_sum_parameters_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_parameters[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_star_etc?")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ lambda_sum_param_with_default* lambda_sum_star_etc?")); } { // lambda_sum_param_with_default+ lambda_sum_star_etc? if (p->error_indicator) { @@ -20004,9 +20113,7 @@ lambda_sum_parameters_rule(Parser *p) return _res; } -// lambda_sum_slash_no_default: -// | lambda_sum_param_no_default+ '/' ',' -// | lambda_sum_param_no_default+ '/' &'|' +// lambda_sum_slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &'|' static asdl_arg_seq* lambda_sum_slash_no_default_rule(Parser *p) { @@ -20020,24 +20127,24 @@ lambda_sum_slash_no_default_rule(Parser *p) } asdl_arg_seq* _res = NULL; int _mark = p->mark; - { // lambda_sum_param_no_default+ '/' ',' + { // param_no_default+ '/' ',' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_slash_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ '/' ','")); + D(fprintf(stderr, "%*c> lambda_sum_slash_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default+ '/' ','")); Token * _literal; Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_145_rule(p)) // lambda_sum_param_no_default+ + (a = (asdl_arg_seq*)_loop1_145_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ lambda_sum_slash_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ '/' ','")); + D(fprintf(stderr, "%*c+ lambda_sum_slash_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default+ '/' ','")); _res = a; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -20048,25 +20155,25 @@ lambda_sum_slash_no_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_slash_no_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ '/' ','")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default+ '/' ','")); } - { // lambda_sum_param_no_default+ '/' &'|' + { // param_no_default+ '/' &'|' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_slash_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ '/' &'|'")); + D(fprintf(stderr, "%*c> lambda_sum_slash_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default+ '/' &'|'")); Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_146_rule(p)) // lambda_sum_param_no_default+ + (a = (asdl_arg_seq*)_loop1_146_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 18) // token='|' ) { - D(fprintf(stderr, "%*c+ lambda_sum_slash_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ '/' &'|'")); + D(fprintf(stderr, "%*c+ lambda_sum_slash_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default+ '/' &'|'")); _res = a; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -20077,7 +20184,7 @@ lambda_sum_slash_no_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_slash_no_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default+ '/' &'|'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default+ '/' &'|'")); } _res = NULL; done: @@ -20175,6 +20282,7 @@ lambda_sum_slash_with_default_rule(Parser *p) // lambda_sum_star_etc: // | invalid_lambda_sum_star_etc // | '*' lambda_sum_param_no_default lambda_sum_param_maybe_default* lambda_sum_kwds? +// | '*' lambda_sum_param_no_default_star_annotation lambda_sum_param_maybe_default* lambda_sum_kwds? // | '*' ',' lambda_sum_param_maybe_default+ lambda_sum_kwds? // | lambda_sum_kwds static StarEtc* @@ -20242,6 +20350,39 @@ lambda_sum_star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_sum_star_etc[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*' lambda_sum_param_no_default lambda_sum_param_maybe_default* lambda_sum_kwds?")); } + { // '*' lambda_sum_param_no_default_star_annotation lambda_sum_param_maybe_default* lambda_sum_kwds? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> lambda_sum_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' lambda_sum_param_no_default_star_annotation lambda_sum_param_maybe_default* lambda_sum_kwds?")); + Token * _literal; + arg_ty a; + asdl_seq * b; + void *c; + if ( + (_literal = _PyPegen_expect_token(p, 16)) // token='*' + && + (a = lambda_sum_param_no_default_star_annotation_rule(p)) // lambda_sum_param_no_default_star_annotation + && + (b = _loop0_152_rule(p)) // lambda_sum_param_maybe_default* + && + (c = lambda_sum_kwds_rule(p), !p->error_indicator) // lambda_sum_kwds? + ) + { + D(fprintf(stderr, "%*c+ lambda_sum_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' lambda_sum_param_no_default_star_annotation lambda_sum_param_maybe_default* lambda_sum_kwds?")); + _res = _PyPegen_star_etc ( p , a , b , c ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s lambda_sum_star_etc[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*' lambda_sum_param_no_default_star_annotation lambda_sum_param_maybe_default* lambda_sum_kwds?")); + } { // '*' ',' lambda_sum_param_maybe_default+ lambda_sum_kwds? if (p->error_indicator) { p->level--; @@ -20257,7 +20398,7 @@ lambda_sum_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_152_rule(p)) // lambda_sum_param_maybe_default+ + (b = _loop1_153_rule(p)) // lambda_sum_param_maybe_default+ && (c = lambda_sum_kwds_rule(p), !p->error_indicator) // lambda_sum_kwds? ) @@ -20305,7 +20446,7 @@ lambda_sum_star_etc_rule(Parser *p) return _res; } -// lambda_sum_kwds: invalid_lambda_kwds | '**' lambda_sum_param_no_default +// lambda_sum_kwds: invalid_kwds | '**' lambda_sum_param_no_default static arg_ty lambda_sum_kwds_rule(Parser *p) { @@ -20319,24 +20460,24 @@ lambda_sum_kwds_rule(Parser *p) } arg_ty _res = NULL; int _mark = p->mark; - if (p->call_invalid_rules) { // invalid_lambda_kwds + if (p->call_invalid_rules) { // invalid_kwds if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_kwds[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_lambda_kwds")); - void *invalid_lambda_kwds_var; + D(fprintf(stderr, "%*c> lambda_sum_kwds[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_kwds")); + void *invalid_kwds_var; if ( - (invalid_lambda_kwds_var = invalid_lambda_kwds_rule(p)) // invalid_lambda_kwds + (invalid_kwds_var = invalid_kwds_rule(p)) // invalid_kwds ) { - D(fprintf(stderr, "%*c+ lambda_sum_kwds[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_lambda_kwds")); - _res = invalid_lambda_kwds_var; + D(fprintf(stderr, "%*c+ lambda_sum_kwds[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_kwds")); + _res = invalid_kwds_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_kwds[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_lambda_kwds")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_kwds")); } { // '**' lambda_sum_param_no_default if (p->error_indicator) { @@ -20371,7 +20512,7 @@ lambda_sum_kwds_rule(Parser *p) return _res; } -// lambda_sum_param_no_default: lambda_param ',' | lambda_param &'|' +// lambda_sum_param_no_default: sum_param ',' TYPE_COMMENT? | sum_param TYPE_COMMENT? &'|' static arg_ty lambda_sum_param_no_default_rule(Parser *p) { @@ -20385,22 +20526,25 @@ lambda_sum_param_no_default_rule(Parser *p) } arg_ty _res = NULL; int _mark = p->mark; - { // lambda_param ',' + { // sum_param ',' TYPE_COMMENT? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_param_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param ','")); + D(fprintf(stderr, "%*c> lambda_sum_param_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param ',' TYPE_COMMENT?")); Token * _literal; arg_ty a; + void *tc; if ( - (a = lambda_param_rule(p)) // lambda_param + (a = sum_param_rule(p)) // sum_param && (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? ) { - D(fprintf(stderr, "%*c+ lambda_sum_param_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param ','")); - _res = a; + D(fprintf(stderr, "%*c+ lambda_sum_param_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param ',' TYPE_COMMENT?")); + _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20410,23 +20554,26 @@ lambda_sum_param_no_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_param_no_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param ','")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param ',' TYPE_COMMENT?")); } - { // lambda_param &'|' + { // sum_param TYPE_COMMENT? &'|' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_param_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param &'|'")); + D(fprintf(stderr, "%*c> lambda_sum_param_no_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param TYPE_COMMENT? &'|'")); arg_ty a; + void *tc; if ( - (a = lambda_param_rule(p)) // lambda_param + (a = sum_param_rule(p)) // sum_param + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? && _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 18) // token='|' ) { - D(fprintf(stderr, "%*c+ lambda_sum_param_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param &'|'")); - _res = a; + D(fprintf(stderr, "%*c+ lambda_sum_param_no_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param TYPE_COMMENT? &'|'")); + _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20436,7 +20583,7 @@ lambda_sum_param_no_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_param_no_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param &'|'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param TYPE_COMMENT? &'|'")); } _res = NULL; done: @@ -20444,7 +20591,90 @@ lambda_sum_param_no_default_rule(Parser *p) return _res; } -// lambda_sum_param_with_default: lambda_param default ',' | lambda_param default &'|' +// lambda_sum_param_no_default_star_annotation: +// | sum_param_star_annotation ',' TYPE_COMMENT? +// | sum_param_star_annotation TYPE_COMMENT? &'|' +static arg_ty +lambda_sum_param_no_default_star_annotation_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + arg_ty _res = NULL; + int _mark = p->mark; + { // sum_param_star_annotation ',' TYPE_COMMENT? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> lambda_sum_param_no_default_star_annotation[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param_star_annotation ',' TYPE_COMMENT?")); + Token * _literal; + arg_ty a; + void *tc; + if ( + (a = sum_param_star_annotation_rule(p)) // sum_param_star_annotation + && + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? + ) + { + D(fprintf(stderr, "%*c+ lambda_sum_param_no_default_star_annotation[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param_star_annotation ',' TYPE_COMMENT?")); + _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s lambda_sum_param_no_default_star_annotation[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param_star_annotation ',' TYPE_COMMENT?")); + } + { // sum_param_star_annotation TYPE_COMMENT? &'|' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> lambda_sum_param_no_default_star_annotation[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param_star_annotation TYPE_COMMENT? &'|'")); + arg_ty a; + void *tc; + if ( + (a = sum_param_star_annotation_rule(p)) // sum_param_star_annotation + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? + && + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 18) // token='|' + ) + { + D(fprintf(stderr, "%*c+ lambda_sum_param_no_default_star_annotation[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param_star_annotation TYPE_COMMENT? &'|'")); + _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s lambda_sum_param_no_default_star_annotation[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param_star_annotation TYPE_COMMENT? &'|'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// lambda_sum_param_with_default: +// | sum_param sum_default ',' TYPE_COMMENT? +// | sum_param sum_default TYPE_COMMENT? &'|' static NameDefaultPair* lambda_sum_param_with_default_rule(Parser *p) { @@ -20458,25 +20688,28 @@ lambda_sum_param_with_default_rule(Parser *p) } NameDefaultPair* _res = NULL; int _mark = p->mark; - { // lambda_param default ',' + { // sum_param sum_default ',' TYPE_COMMENT? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_param_with_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default ','")); + D(fprintf(stderr, "%*c> lambda_sum_param_with_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default ',' TYPE_COMMENT?")); Token * _literal; arg_ty a; expr_ty c; + void *tc; if ( - (a = lambda_param_rule(p)) // lambda_param + (a = sum_param_rule(p)) // sum_param && - (c = default_rule(p)) // default + (c = sum_default_rule(p)) // sum_default && (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? ) { - D(fprintf(stderr, "%*c+ lambda_sum_param_with_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default ','")); - _res = _PyPegen_name_default_pair ( p , a , c , NULL ); + D(fprintf(stderr, "%*c+ lambda_sum_param_with_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default ',' TYPE_COMMENT?")); + _res = _PyPegen_name_default_pair ( p , a , c , tc ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20486,26 +20719,29 @@ lambda_sum_param_with_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_param_with_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param default ','")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param sum_default ',' TYPE_COMMENT?")); } - { // lambda_param default &'|' + { // sum_param sum_default TYPE_COMMENT? &'|' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_param_with_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default &'|'")); + D(fprintf(stderr, "%*c> lambda_sum_param_with_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default TYPE_COMMENT? &'|'")); arg_ty a; expr_ty c; + void *tc; if ( - (a = lambda_param_rule(p)) // lambda_param + (a = sum_param_rule(p)) // sum_param && - (c = default_rule(p)) // default + (c = sum_default_rule(p)) // sum_default + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? && _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 18) // token='|' ) { - D(fprintf(stderr, "%*c+ lambda_sum_param_with_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default &'|'")); - _res = _PyPegen_name_default_pair ( p , a , c , NULL ); + D(fprintf(stderr, "%*c+ lambda_sum_param_with_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default TYPE_COMMENT? &'|'")); + _res = _PyPegen_name_default_pair ( p , a , c , tc ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20515,7 +20751,7 @@ lambda_sum_param_with_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_param_with_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param default &'|'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param sum_default TYPE_COMMENT? &'|'")); } _res = NULL; done: @@ -20523,7 +20759,9 @@ lambda_sum_param_with_default_rule(Parser *p) return _res; } -// lambda_sum_param_maybe_default: lambda_param default? ',' | lambda_param default? &'|' +// lambda_sum_param_maybe_default: +// | sum_param sum_default? ',' TYPE_COMMENT? +// | sum_param sum_default? TYPE_COMMENT? &'|' static NameDefaultPair* lambda_sum_param_maybe_default_rule(Parser *p) { @@ -20537,25 +20775,28 @@ lambda_sum_param_maybe_default_rule(Parser *p) } NameDefaultPair* _res = NULL; int _mark = p->mark; - { // lambda_param default? ',' + { // sum_param sum_default? ',' TYPE_COMMENT? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_param_maybe_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default? ','")); + D(fprintf(stderr, "%*c> lambda_sum_param_maybe_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default? ',' TYPE_COMMENT?")); Token * _literal; arg_ty a; void *c; + void *tc; if ( - (a = lambda_param_rule(p)) // lambda_param + (a = sum_param_rule(p)) // sum_param && - (c = default_rule(p), !p->error_indicator) // default? + (c = sum_default_rule(p), !p->error_indicator) // sum_default? && (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? ) { - D(fprintf(stderr, "%*c+ lambda_sum_param_maybe_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default? ','")); - _res = _PyPegen_name_default_pair ( p , a , c , NULL ); + D(fprintf(stderr, "%*c+ lambda_sum_param_maybe_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default? ',' TYPE_COMMENT?")); + _res = _PyPegen_name_default_pair ( p , a , c , tc ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20565,26 +20806,29 @@ lambda_sum_param_maybe_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_param_maybe_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param default? ','")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param sum_default? ',' TYPE_COMMENT?")); } - { // lambda_param default? &'|' + { // sum_param sum_default? TYPE_COMMENT? &'|' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> lambda_sum_param_maybe_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default? &'|'")); + D(fprintf(stderr, "%*c> lambda_sum_param_maybe_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default? TYPE_COMMENT? &'|'")); arg_ty a; void *c; + void *tc; if ( - (a = lambda_param_rule(p)) // lambda_param + (a = sum_param_rule(p)) // sum_param && - (c = default_rule(p), !p->error_indicator) // default? + (c = sum_default_rule(p), !p->error_indicator) // sum_default? + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? && _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 18) // token='|' ) { - D(fprintf(stderr, "%*c+ lambda_sum_param_maybe_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param default? &'|'")); - _res = _PyPegen_name_default_pair ( p , a , c , NULL ); + D(fprintf(stderr, "%*c+ lambda_sum_param_maybe_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "sum_param sum_default? TYPE_COMMENT? &'|'")); + _res = _PyPegen_name_default_pair ( p , a , c , tc ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -20594,7 +20838,297 @@ lambda_sum_param_maybe_default_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s lambda_sum_param_maybe_default[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param default? &'|'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "sum_param sum_default? TYPE_COMMENT? &'|'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// sum_param: NAME sum_annotation? +static arg_ty +sum_param_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + arg_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 + { // NAME sum_annotation? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> sum_param[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME sum_annotation?")); + expr_ty a; + void *b; + if ( + (a = _PyPegen_name_token(p)) // NAME + && + (b = sum_annotation_rule(p), !p->error_indicator) // sum_annotation? + ) + { + D(fprintf(stderr, "%*c+ sum_param[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME sum_annotation?")); + 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_arg ( a -> v . Name . id , b , NULL , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s sum_param[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME sum_annotation?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// sum_param_star_annotation: NAME star_sum_annotation +static arg_ty +sum_param_star_annotation_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + arg_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 + { // NAME star_sum_annotation + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> sum_param_star_annotation[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME star_sum_annotation")); + expr_ty a; + expr_ty b; + if ( + (a = _PyPegen_name_token(p)) // NAME + && + (b = star_sum_annotation_rule(p)) // star_sum_annotation + ) + { + D(fprintf(stderr, "%*c+ sum_param_star_annotation[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME star_sum_annotation")); + 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_arg ( a -> v . Name . id , b , NULL , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s sum_param_star_annotation[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME star_sum_annotation")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// sum_annotation: ':' sum +static expr_ty +sum_annotation_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; + { // ':' sum + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> sum_annotation[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' sum")); + Token * _literal; + expr_ty a; + if ( + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (a = sum_rule(p)) // sum + ) + { + D(fprintf(stderr, "%*c+ sum_annotation[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' sum")); + _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 sum_annotation[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':' sum")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// star_sum_annotation: ':' star_sum +static expr_ty +star_sum_annotation_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; + { // ':' star_sum + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> star_sum_annotation[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' star_sum")); + Token * _literal; + expr_ty a; + if ( + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (a = star_sum_rule(p)) // star_sum + ) + { + D(fprintf(stderr, "%*c+ star_sum_annotation[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' star_sum")); + _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 star_sum_annotation[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':' star_sum")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// sum_default: '=' sum | invalid_sum_default +static expr_ty +sum_default_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; + { // '=' sum + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> sum_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' sum")); + Token * _literal; + expr_ty a; + if ( + (_literal = _PyPegen_expect_token(p, 22)) // token='=' + && + (a = sum_rule(p)) // sum + ) + { + D(fprintf(stderr, "%*c+ sum_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' sum")); + _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 sum_default[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'=' sum")); + } + if (p->call_invalid_rules) { // invalid_sum_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> sum_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_sum_default")); + void *invalid_sum_default_var; + if ( + (invalid_sum_default_var = invalid_sum_default_rule(p)) // invalid_sum_default + ) + { + D(fprintf(stderr, "%*c+ sum_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_sum_default")); + _res = invalid_sum_default_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s sum_default[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_sum_default")); } _res = NULL; done: @@ -20705,7 +21239,7 @@ fstring_replacement_field_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (a = _tmp_153_rule(p)) // yield_expr | star_expressions + (a = _tmp_154_rule(p)) // yield_expr | star_expressions && (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // "="? && @@ -20844,7 +21378,7 @@ fstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_154_rule(p)) // fstring_format_spec* + (spec = _loop0_155_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*")); @@ -21017,7 +21551,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_155_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_156_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))+")); @@ -21152,7 +21686,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_156_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_157_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -21370,7 +21904,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_157_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_158_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -21532,7 +22066,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_159_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_160_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+")); @@ -21607,7 +22141,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_160_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_161_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))*")); @@ -21650,7 +22184,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_161_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_162_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))*")); @@ -21690,7 +22224,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_162_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_163_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))*")); @@ -21869,7 +22403,7 @@ tuplecomp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_163_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_164_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -22053,7 +22587,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_164_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_165_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -22305,9 +22839,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_165_rule(p)) // ','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_166_rule(p)) // ','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_167_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_168_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]")); @@ -22398,11 +22932,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_168_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_169_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_170_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_171_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+")); @@ -22424,13 +22958,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_172_var; + asdl_seq * _gather_173_var; if ( - (_gather_172_var = _gather_172_rule(p)) // ','.kwarg_or_starred+ + (_gather_173_var = _gather_173_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_172_var; + _res = _gather_173_var; goto done; } p->mark = _mark; @@ -22443,13 +22977,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_174_var; + asdl_seq * _gather_175_var; if ( - (_gather_174_var = _gather_174_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_175_var = _gather_175_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_174_var; + _res = _gather_175_var; goto done; } p->mark = _mark; @@ -22605,7 +23139,7 @@ kwarg_or_starred_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (b = _tmp_176_rule(p), !p->error_indicator) // [(simple_slice | expression)] + (b = _tmp_177_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)]")); @@ -22719,7 +23253,7 @@ kwarg_or_double_starred_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (b = _tmp_177_rule(p), !p->error_indicator) // [(simple_slice | expression)] + (b = _tmp_178_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)]")); @@ -22850,7 +23384,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_178_rule(p)) // ((',' star_target))* + (b = _loop0_179_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -22907,7 +23441,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_179_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_180_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -22958,7 +23492,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_181_rule(p)) // ((',' star_target))+ + (b = _loop1_182_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -23047,7 +23581,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_182_rule(p)) // !'*' star_target + (a = _tmp_183_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)")); @@ -23795,7 +24329,7 @@ t_primary_raw(Parser *p) && (n = _PyPegen_expect_token(p, 58), !p->error_indicator) // '?'? && - (b = _tmp_183_rule(p)) // genexp | tuplecomp + (b = _tmp_184_rule(p)) // genexp | tuplecomp && _PyPegen_lookahead(1, t_lookahead_rule, p) ) @@ -24045,7 +24579,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_184_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_185_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -24412,7 +24946,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_186_rule(p)) // ','.expression+ + (a = _gather_187_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24451,7 +24985,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_188_rule(p)) // ','.expression+ + (a = _gather_189_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24484,7 +25018,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_190_rule(p)) // ','.expression+ + (a = _gather_191_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24604,7 +25138,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_192_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_193_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+")); @@ -24656,7 +25190,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, _tmp_194_rule, p) + _PyPegen_lookahead(1, _tmp_195_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)")); @@ -24785,7 +25319,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_195_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_196_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]")); @@ -24845,13 +25379,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_196_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_197_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_197_rule, p) + _PyPegen_lookahead(1, _tmp_198_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 '=' &(',' | ')')")); @@ -24990,7 +25524,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_198_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_199_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -25050,7 +25584,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, _tmp_199_rule, p) + _PyPegen_lookahead(0, _tmp_200_rule, p) && (a = expression_rule(p)) // expression && @@ -25309,7 +25843,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, _tmp_200_rule, p) + _PyPegen_lookahead(0, _tmp_201_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -25345,7 +25879,7 @@ invalid_expression_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, _tmp_201_rule, p) + _PyPegen_lookahead(0, _tmp_202_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' | ':')")); @@ -25378,7 +25912,7 @@ invalid_expression_rule(Parser *p) && (b = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_202_rule, p) + _PyPegen_lookahead(1, _tmp_203_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)")); @@ -25467,7 +26001,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_203_rule, p) + _PyPegen_lookahead(0, _tmp_204_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 !('=' | ':=')")); @@ -25493,7 +26027,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, _tmp_204_rule, p) + _PyPegen_lookahead(0, _tmp_205_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -25501,7 +26035,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_205_rule, p) + _PyPegen_lookahead(0, _tmp_206_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 !('=' | ':=')")); @@ -25582,7 +26116,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_206_var; + asdl_seq * _loop0_207_var; expr_ty a; expr_ty expression_var; if ( @@ -25590,7 +26124,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_206_var = _loop0_206_rule(p)) // star_named_expressions* + (_loop0_207_var = _loop0_207_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25647,10 +26181,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_207_var; + asdl_seq * _loop0_208_var; expr_ty a; if ( - (_loop0_207_var = _loop0_207_rule(p)) // ((star_targets '='))* + (_loop0_208_var = _loop0_208_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -25677,10 +26211,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_208_var; + asdl_seq * _loop0_209_var; expr_ty a; if ( - (_loop0_208_var = _loop0_208_rule(p)) // ((star_targets '='))* + (_loop0_209_var = _loop0_209_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -25706,7 +26240,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_209_var; + void *_tmp_210_var; expr_ty a; AugOperator* augassign_var; if ( @@ -25714,7 +26248,7 @@ invalid_assignment_rule(Parser *p) && (augassign_var = augassign_rule(p)) // augassign && - (_tmp_209_var = _tmp_209_rule(p)) // yield_expr | star_expressions + (_tmp_210_var = _tmp_210_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)")); @@ -25940,11 +26474,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_210_var; + void *_tmp_211_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_210_var = _tmp_210_rule(p)) // '[' | '(' | '{' + (_tmp_211_var = _tmp_211_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -25971,12 +26505,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_211_var; + void *_tmp_212_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_211_var = _tmp_211_rule(p)) // '[' | '{' + (_tmp_212_var = _tmp_212_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -26006,12 +26540,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_212_var; + void *_tmp_213_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_212_var = _tmp_212_rule(p)) // '[' | '{' + (_tmp_213_var = _tmp_213_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -26148,13 +26682,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_214_var; - void *_tmp_213_var; + asdl_seq * _loop0_215_var; + void *_tmp_214_var; Token * a; if ( - (_tmp_213_var = _tmp_213_rule(p)) // slash_no_default | slash_with_default + (_tmp_214_var = _tmp_214_rule(p)) // slash_no_default | slash_with_default && - (_loop0_214_var = _loop0_214_rule(p)) // param_maybe_default* + (_loop0_215_var = _loop0_215_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -26178,7 +26712,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_215_var; + asdl_seq * _loop0_216_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -26186,7 +26720,7 @@ invalid_parameters_rule(Parser *p) if ( (_opt_var = slash_no_default_rule(p), !p->error_indicator) // slash_no_default? && - (_loop0_215_var = _loop0_215_rule(p)) // param_no_default* + (_loop0_216_var = _loop0_216_rule(p)) // param_no_default* && (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper && @@ -26212,18 +26746,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_216_var; - asdl_seq * _loop1_217_var; + asdl_seq * _loop0_217_var; + asdl_seq * _loop1_218_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_216_var = _loop0_216_rule(p)) // param_no_default* + (_loop0_217_var = _loop0_217_rule(p)) // param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_loop1_217_var = _loop1_217_rule(p)) // param_no_default+ + (_loop1_218_var = _loop1_218_rule(p)) // param_no_default+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -26250,22 +26784,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_219_var; - asdl_seq * _loop0_221_var; + asdl_seq * _loop0_220_var; + asdl_seq * _loop0_222_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_220_var; + void *_tmp_221_var; Token * a; if ( - (_opt_var = _tmp_218_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_219_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && - (_loop0_219_var = _loop0_219_rule(p)) // param_maybe_default* + (_loop0_220_var = _loop0_220_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_220_var = _tmp_220_rule(p)) // ',' | param_no_default + (_tmp_221_var = _tmp_221_rule(p)) // ',' | param_no_default && - (_loop0_221_var = _loop0_221_rule(p)) // param_maybe_default* + (_loop0_222_var = _loop0_222_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -26290,10 +26824,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_222_var; + asdl_seq * _loop1_223_var; Token * a; if ( - (_loop1_222_var = _loop1_222_rule(p)) // param_maybe_default+ + (_loop1_223_var = _loop1_223_rule(p)) // param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -26343,7 +26877,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_223_rule, p) + _PyPegen_lookahead(1, _tmp_224_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' &(')' | ',')")); @@ -26365,6 +26899,52 @@ invalid_default_rule(Parser *p) return _res; } +// invalid_sum_default: '=' &('|' | ',') +static void * +invalid_sum_default_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->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_sum_default[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' &('|' | ',')")); + Token * a; + if ( + (a = _PyPegen_expect_token(p, 22)) // token='=' + && + _PyPegen_lookahead(1, _tmp_225_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_sum_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' &('|' | ',')")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected default value expression" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_sum_default[%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; +} + // invalid_star_etc: // | '*' (')' | ',' (')' | '**')) // | '*' ',' TYPE_COMMENT @@ -26389,12 +26969,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_224_var; + void *_tmp_226_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_224_var = _tmp_224_rule(p)) // ')' | ',' (')' | '**') + (_tmp_226_var = _tmp_226_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (')' | ',' (')' | '**'))")); @@ -26477,20 +27057,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_226_var; - void *_tmp_225_var; + asdl_seq * _loop0_228_var; void *_tmp_227_var; + void *_tmp_229_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_225_var = _tmp_225_rule(p)) // param_no_default | ',' + (_tmp_227_var = _tmp_227_rule(p)) // param_no_default | ',' && - (_loop0_226_var = _loop0_226_rule(p)) // param_maybe_default* + (_loop0_228_var = _loop0_228_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_227_var = _tmp_227_rule(p)) // param_no_default | ',' + (_tmp_229_var = _tmp_229_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 | ',')")); @@ -26606,7 +27186,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_228_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_230_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**' param ',' ('*' | '**' | '/')")); @@ -26672,13 +27252,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_229_var; + asdl_seq * _loop1_231_var; if ( - (_loop1_229_var = _loop1_229_rule(p)) // param_with_default+ + (_loop1_231_var = _loop1_231_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_229_var; + _res = _loop1_231_var; goto done; } p->mark = _mark; @@ -26744,13 +27324,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_231_var; - void *_tmp_230_var; + asdl_seq * _loop0_233_var; + void *_tmp_232_var; Token * a; if ( - (_tmp_230_var = _tmp_230_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_232_var = _tmp_232_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && - (_loop0_231_var = _loop0_231_rule(p)) // lambda_param_maybe_default* + (_loop0_233_var = _loop0_233_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -26774,7 +27354,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_232_var; + asdl_seq * _loop0_234_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -26782,7 +27362,7 @@ invalid_lambda_parameters_rule(Parser *p) if ( (_opt_var = lambda_slash_no_default_rule(p), !p->error_indicator) // lambda_slash_no_default? && - (_loop0_232_var = _loop0_232_rule(p)) // lambda_param_no_default* + (_loop0_234_var = _loop0_234_rule(p)) // lambda_param_no_default* && (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper && @@ -26808,18 +27388,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_234_var; - asdl_seq * _loop0_233_var; + asdl_seq * _gather_236_var; + asdl_seq * _loop0_235_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_233_var = _loop0_233_rule(p)) // lambda_param_no_default* + (_loop0_235_var = _loop0_235_rule(p)) // lambda_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_234_var = _gather_234_rule(p)) // ','.lambda_param+ + (_gather_236_var = _gather_236_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -26846,22 +27426,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_237_var; asdl_seq * _loop0_239_var; + asdl_seq * _loop0_241_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_238_var; + void *_tmp_240_var; Token * a; if ( - (_opt_var = _tmp_236_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_238_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && - (_loop0_237_var = _loop0_237_rule(p)) // lambda_param_maybe_default* + (_loop0_239_var = _loop0_239_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_238_var = _tmp_238_rule(p)) // ',' | lambda_param_no_default + (_tmp_240_var = _tmp_240_rule(p)) // ',' | lambda_param_no_default && - (_loop0_239_var = _loop0_239_rule(p)) // lambda_param_maybe_default* + (_loop0_241_var = _loop0_241_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -26886,10 +27466,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_240_var; + asdl_seq * _loop1_242_var; Token * a; if ( - (_loop1_240_var = _loop1_240_rule(p)) // lambda_param_maybe_default+ + (_loop1_242_var = _loop1_242_rule(p)) // lambda_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -26961,13 +27541,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_241_var; + asdl_seq * _loop1_243_var; if ( - (_loop1_241_var = _loop1_241_rule(p)) // lambda_param_with_default+ + (_loop1_243_var = _loop1_243_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_241_var; + _res = _loop1_243_var; goto done; } p->mark = _mark; @@ -27004,11 +27584,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_242_var; + void *_tmp_244_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_242_var = _tmp_242_rule(p)) // ':' | ',' (':' | '**') + (_tmp_244_var = _tmp_244_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, "'*' (':' | ',' (':' | '**'))")); @@ -27061,20 +27641,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_244_var; - void *_tmp_243_var; + asdl_seq * _loop0_246_var; void *_tmp_245_var; + void *_tmp_247_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_243_var = _tmp_243_rule(p)) // lambda_param_no_default | ',' + (_tmp_245_var = _tmp_245_rule(p)) // lambda_param_no_default | ',' && - (_loop0_244_var = _loop0_244_rule(p)) // lambda_param_maybe_default* + (_loop0_246_var = _loop0_246_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_245_var = _tmp_245_rule(p)) // lambda_param_no_default | ',' + (_tmp_247_var = _tmp_247_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 | ',')")); @@ -27193,7 +27773,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_246_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_248_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 ',' ('*' | '**' | '/')")); @@ -27268,13 +27848,13 @@ invalid_lambda_sum_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(lambda_sum_slash_no_default | lambda_sum_slash_with_default) lambda_sum_param_maybe_default* '/'")); - asdl_seq * _loop0_248_var; - void *_tmp_247_var; + asdl_seq * _loop0_250_var; + void *_tmp_249_var; Token * a; if ( - (_tmp_247_var = _tmp_247_rule(p)) // lambda_sum_slash_no_default | lambda_sum_slash_with_default + (_tmp_249_var = _tmp_249_rule(p)) // lambda_sum_slash_no_default | lambda_sum_slash_with_default && - (_loop0_248_var = _loop0_248_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_250_var = _loop0_250_rule(p)) // lambda_sum_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -27298,7 +27878,7 @@ invalid_lambda_sum_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default? lambda_sum_param_no_default* invalid_lambda_sum_parameters_helper lambda_sum_param_no_default")); - asdl_seq * _loop0_249_var; + asdl_seq * _loop0_251_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -27306,7 +27886,7 @@ invalid_lambda_sum_parameters_rule(Parser *p) if ( (_opt_var = lambda_sum_slash_no_default_rule(p), !p->error_indicator) // lambda_sum_slash_no_default? && - (_loop0_249_var = _loop0_249_rule(p)) // lambda_sum_param_no_default* + (_loop0_251_var = _loop0_251_rule(p)) // lambda_sum_param_no_default* && (invalid_lambda_sum_parameters_helper_var = invalid_lambda_sum_parameters_helper_rule(p)) // invalid_lambda_sum_parameters_helper && @@ -27332,18 +27912,18 @@ invalid_lambda_sum_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_251_var; - asdl_seq * _loop0_250_var; + asdl_seq * _gather_253_var; + asdl_seq * _loop0_252_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_250_var = _loop0_250_rule(p)) // lambda_sum_param_no_default* + (_loop0_252_var = _loop0_252_rule(p)) // lambda_sum_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_251_var = _gather_251_rule(p)) // ','.lambda_param+ + (_gather_253_var = _gather_253_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -27370,22 +27950,22 @@ invalid_lambda_sum_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[(lambda_sum_slash_no_default | lambda_sum_slash_with_default)] lambda_sum_param_maybe_default* '*' (',' | lambda_sum_param_no_default) lambda_sum_param_maybe_default* '/'")); Token * _literal; - asdl_seq * _loop0_254_var; asdl_seq * _loop0_256_var; + asdl_seq * _loop0_258_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_255_var; + void *_tmp_257_var; Token * a; if ( - (_opt_var = _tmp_253_rule(p), !p->error_indicator) // [(lambda_sum_slash_no_default | lambda_sum_slash_with_default)] + (_opt_var = _tmp_255_rule(p), !p->error_indicator) // [(lambda_sum_slash_no_default | lambda_sum_slash_with_default)] && - (_loop0_254_var = _loop0_254_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_256_var = _loop0_256_rule(p)) // lambda_sum_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_255_var = _tmp_255_rule(p)) // ',' | lambda_sum_param_no_default + (_tmp_257_var = _tmp_257_rule(p)) // ',' | lambda_sum_param_no_default && - (_loop0_256_var = _loop0_256_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_258_var = _loop0_258_rule(p)) // lambda_sum_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -27410,10 +27990,10 @@ invalid_lambda_sum_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_sum_parameters[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default+ '/' '*'")); Token * _literal; - asdl_seq * _loop1_257_var; + asdl_seq * _loop1_259_var; Token * a; if ( - (_loop1_257_var = _loop1_257_rule(p)) // lambda_sum_param_maybe_default+ + (_loop1_259_var = _loop1_259_rule(p)) // lambda_sum_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -27485,13 +28065,13 @@ invalid_lambda_sum_parameters_helper_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_sum_parameters_helper[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default+")); - asdl_seq * _loop1_258_var; + asdl_seq * _loop1_260_var; if ( - (_loop1_258_var = _loop1_258_rule(p)) // lambda_sum_param_with_default+ + (_loop1_260_var = _loop1_260_rule(p)) // lambda_sum_param_with_default+ ) { D(fprintf(stderr, "%*c+ invalid_lambda_sum_parameters_helper[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default+")); - _res = _loop1_258_var; + _res = _loop1_260_var; goto done; } p->mark = _mark; @@ -27528,11 +28108,11 @@ invalid_lambda_sum_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_sum_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' ('|' | ',' ('|' | '**'))")); Token * _literal; - void *_tmp_259_var; + void *_tmp_261_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_259_var = _tmp_259_rule(p)) // '|' | ',' ('|' | '**') + (_tmp_261_var = _tmp_261_rule(p)) // '|' | ',' ('|' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_sum_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' ('|' | ',' ('|' | '**'))")); @@ -27585,20 +28165,20 @@ invalid_lambda_sum_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_sum_star_etc[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (lambda_sum_param_no_default | ',') lambda_sum_param_maybe_default* '*' (lambda_sum_param_no_default | ',')")); Token * _literal; - asdl_seq * _loop0_261_var; - void *_tmp_260_var; + asdl_seq * _loop0_263_var; void *_tmp_262_var; + void *_tmp_264_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_260_var = _tmp_260_rule(p)) // lambda_sum_param_no_default | ',' + (_tmp_262_var = _tmp_262_rule(p)) // lambda_sum_param_no_default | ',' && - (_loop0_261_var = _loop0_261_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_263_var = _loop0_263_rule(p)) // lambda_sum_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_262_var = _tmp_262_rule(p)) // lambda_sum_param_no_default | ',' + (_tmp_264_var = _tmp_264_rule(p)) // lambda_sum_param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_lambda_sum_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (lambda_sum_param_no_default | ',') lambda_sum_param_maybe_default* '*' (lambda_sum_param_no_default | ',')")); @@ -27706,7 +28286,7 @@ invalid_with_item_rule(Parser *p) && (a = expression_rule(p)) // expression && - _PyPegen_lookahead(1, _tmp_263_rule, p) + _PyPegen_lookahead(1, _tmp_265_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 &(',' | ')' | ':')")); @@ -27882,14 +28462,14 @@ 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_264_var; + asdl_seq * _gather_266_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( (a = _PyPegen_expect_token(p, 667)) // token='import' && - (_gather_264_var = _gather_264_rule(p)) // ','.dotted_name+ + (_gather_266_var = _gather_266_rule(p)) // ','.dotted_name+ && (_keyword = _PyPegen_expect_token(p, 668)) // token='from' && @@ -27987,7 +28567,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' ','.(expression ['as' star_target])+ NEWLINE")); - asdl_seq * _gather_266_var; + asdl_seq * _gather_268_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -27997,7 +28577,7 @@ invalid_with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 679)) // token='with' && - (_gather_266_var = _gather_266_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_268_var = _gather_268_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -28021,7 +28601,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_268_var; + asdl_seq * _gather_270_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -28037,7 +28617,7 @@ invalid_with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_268_var = _gather_268_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_270_var = _gather_270_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -28087,7 +28667,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' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); - asdl_seq * _gather_270_var; + asdl_seq * _gather_272_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -28098,7 +28678,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (a = _PyPegen_expect_token(p, 679)) // token='with' && - (_gather_270_var = _gather_270_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_272_var = _gather_272_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -28126,7 +28706,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_272_var; + asdl_seq * _gather_274_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -28143,7 +28723,7 @@ invalid_with_stmt_indent_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_272_var = _gather_272_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_274_var = _gather_274_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -28241,7 +28821,7 @@ invalid_try_stmt_rule(Parser *p) && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, _tmp_274_rule, p) + _PyPegen_lookahead(0, _tmp_276_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')")); @@ -28266,8 +28846,8 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_275_var; - asdl_seq * _loop1_276_var; + asdl_seq * _loop0_277_var; + asdl_seq * _loop1_278_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; @@ -28278,9 +28858,9 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_275_var = _loop0_275_rule(p)) // block* + (_loop0_277_var = _loop0_277_rule(p)) // block* && - (_loop1_276_var = _loop1_276_rule(p)) // except_block+ + (_loop1_278_var = _loop1_278_rule(p)) // except_block+ && (a = _PyPegen_expect_token(p, 701)) // token='except' && @@ -28288,7 +28868,7 @@ invalid_try_stmt_rule(Parser *p) && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_277_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_279_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -28315,8 +28895,8 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_278_var; - asdl_seq * _loop1_279_var; + asdl_seq * _loop0_280_var; + asdl_seq * _loop1_281_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; @@ -28325,13 +28905,13 @@ invalid_try_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_278_var = _loop0_278_rule(p)) // block* + (_loop0_280_var = _loop0_280_rule(p)) // block* && - (_loop1_279_var = _loop1_279_rule(p)) // except_star_block+ + (_loop1_281_var = _loop1_281_rule(p)) // except_star_block+ && (a = _PyPegen_expect_token(p, 701)) // token='except' && - (_opt_var = _tmp_280_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_282_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -28399,7 +28979,7 @@ invalid_except_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_opt_var_1 = _tmp_281_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var_1 = _tmp_283_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -28437,7 +29017,7 @@ invalid_except_stmt_rule(Parser *p) && (expression_var = expression_rule(p)) // expression && - (_opt_var_1 = _tmp_282_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var_1 = _tmp_284_rule(p), !p->error_indicator) // ['as' NAME] && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -28489,14 +29069,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_283_var; + void *_tmp_285_var; Token * a; if ( (a = _PyPegen_expect_token(p, 701)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_283_var = _tmp_283_rule(p)) // NEWLINE | ':' + (_tmp_285_var = _tmp_285_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 | ':')")); @@ -28603,7 +29183,7 @@ invalid_except_stmt_indent_rule(Parser *p) && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_284_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_286_rule(p), !p->error_indicator) // ['as' NAME] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -28698,7 +29278,7 @@ invalid_except_star_stmt_indent_rule(Parser *p) && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_285_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_287_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29067,7 +29647,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_286_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_288_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -29561,7 +30141,7 @@ invalid_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (_opt_var_2 = _tmp_287_rule(p), !p->error_indicator) // ['->' expression] + (_opt_var_2 = _tmp_289_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29619,7 +30199,7 @@ invalid_class_def_raw_nonewline_rule(Parser *p) && (name_var = _PyPegen_name_token(p)) // NAME && - (_opt_var = _tmp_288_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (_opt_var = _tmp_290_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -29695,7 +30275,7 @@ invalid_class_def_raw_rule(Parser *p) && (name_var = _PyPegen_name_token(p)) // NAME && - (_opt_var = _tmp_289_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (_opt_var = _tmp_291_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29746,11 +30326,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_290_var; + asdl_seq * _gather_292_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_290_var = _gather_290_rule(p)) // ','.double_starred_kvpair+ + (_gather_292_var = _gather_292_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -29758,7 +30338,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_290_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_292_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -29811,7 +30391,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_292_rule, p) + _PyPegen_lookahead(1, _tmp_294_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 ':' &('}' | ',')")); @@ -29922,7 +30502,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_293_rule, p) + _PyPegen_lookahead(1, _tmp_295_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ':' &('}' | ',')")); @@ -30140,7 +30720,7 @@ invalid_replacement_field_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - _PyPegen_lookahead(0, _tmp_294_rule, p) + _PyPegen_lookahead(0, _tmp_296_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)")); @@ -30163,13 +30743,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_295_var; + void *_tmp_297_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_295_var = _tmp_295_rule(p)) // yield_expr | star_expressions + (_tmp_297_var = _tmp_297_rule(p)) // yield_expr | star_expressions && - _PyPegen_lookahead(0, _tmp_296_rule, p) + _PyPegen_lookahead(0, _tmp_298_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) !('=' | '!' | ':' | '}')")); @@ -30193,15 +30773,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_297_var; + void *_tmp_299_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_297_var = _tmp_297_rule(p)) // yield_expr | star_expressions + (_tmp_299_var = _tmp_299_rule(p)) // yield_expr | star_expressions && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_298_rule, p) + _PyPegen_lookahead(0, _tmp_300_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) '=' !('!' | ':' | '}')")); @@ -30226,12 +30806,12 @@ invalid_replacement_field_rule(Parser *p) Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_299_var; + void *_tmp_301_var; void *invalid_conversion_character_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_299_var = _tmp_299_rule(p)) // yield_expr | star_expressions + (_tmp_301_var = _tmp_301_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && @@ -30239,7 +30819,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_299_var, _opt_var, invalid_conversion_character_var); + _res = _PyPegen_dummy_name(p, _literal, _tmp_301_var, _opt_var, invalid_conversion_character_var); goto done; } p->mark = _mark; @@ -30257,17 +30837,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_300_var; + void *_tmp_302_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_300_var = _tmp_300_rule(p)) // yield_expr | star_expressions + (_tmp_302_var = _tmp_302_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_301_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_303_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_302_rule, p) + _PyPegen_lookahead(0, _tmp_304_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] !(':' | '}')")); @@ -30291,24 +30871,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_305_var; + asdl_seq * _loop0_307_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; UNUSED(_opt_var_1); // Silence compiler warnings - void *_tmp_303_var; + void *_tmp_305_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_303_var = _tmp_303_rule(p)) // yield_expr | star_expressions + (_tmp_305_var = _tmp_305_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_304_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_306_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_305_var = _loop0_305_rule(p)) // fstring_format_spec* + (_loop0_307_var = _loop0_307_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -30337,15 +30917,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_306_var; + void *_tmp_308_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_306_var = _tmp_306_rule(p)) // yield_expr | star_expressions + (_tmp_308_var = _tmp_308_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_307_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_309_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -30393,7 +30973,7 @@ invalid_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_308_rule, p) + _PyPegen_lookahead(1, _tmp_310_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' &(':' | '}')")); @@ -31599,12 +32179,12 @@ _loop1_19_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_19[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); - void *_tmp_309_var; + void *_tmp_311_var; while ( - (_tmp_309_var = _tmp_309_rule(p)) // star_targets '=' + (_tmp_311_var = _tmp_311_rule(p)) // star_targets '=' ) { - _res = _tmp_309_var; + _res = _tmp_311_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31767,7 +32347,7 @@ _tmp_22_rule(Parser *p) 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_310_rule(p), !p->error_indicator) // [yield_expr | star_expressions] + (d = _tmp_312_rule(p), !p->error_indicator) // [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]")); @@ -33346,12 +33926,12 @@ _loop0_38_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_38[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); - void *_tmp_311_var; + void *_tmp_313_var; while ( - (_tmp_311_var = _tmp_311_rule(p)) // '.' | '...' + (_tmp_313_var = _tmp_313_rule(p)) // '.' | '...' ) { - _res = _tmp_311_var; + _res = _tmp_313_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33414,12 +33994,12 @@ _loop1_39_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_39[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); - void *_tmp_312_var; + void *_tmp_314_var; while ( - (_tmp_312_var = _tmp_312_rule(p)) // '.' | '...' + (_tmp_314_var = _tmp_314_rule(p)) // '.' | '...' ) { - _res = _tmp_312_var; + _res = _tmp_314_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33819,12 +34399,12 @@ _loop1_46_rule(Parser *p) return NULL; } 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_313_var; + void *_tmp_315_var; while ( - (_tmp_313_var = _tmp_313_rule(p)) // '@' named_expression NEWLINE + (_tmp_315_var = _tmp_315_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_313_var; + _res = _tmp_315_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36179,7 +36759,7 @@ _loop0_84_rule(Parser *p) while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_314_rule(p)) // bitwiseor_pattern | 'None' + (elem = _tmp_316_rule(p)) // bitwiseor_pattern | 'None' ) { _res = elem; @@ -36245,7 +36825,7 @@ _gather_83_rule(Parser *p) void *elem; asdl_seq * seq; if ( - (elem = _tmp_314_rule(p)) // bitwiseor_pattern | 'None' + (elem = _tmp_316_rule(p)) // bitwiseor_pattern | 'None' && (seq = _loop0_84_rule(p)) // _loop0_84 ) @@ -37357,7 +37937,7 @@ _tmp_102_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_stmt_seq* s; if ( - (s = (asdl_stmt_seq*)_gather_315_rule(p)) // ';'.simple_stmt+ + (s = (asdl_stmt_seq*)_gather_317_rule(p)) // ';'.simple_stmt+ && (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? ) @@ -37548,12 +38128,12 @@ _loop1_105_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_105[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' expression)")); - void *_tmp_317_var; + void *_tmp_319_var; while ( - (_tmp_317_var = _tmp_317_rule(p)) // ',' expression + (_tmp_319_var = _tmp_319_rule(p)) // ',' expression ) { - _res = _tmp_317_var; + _res = _tmp_319_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37621,12 +38201,12 @@ _loop1_106_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_106[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_expression)")); - void *_tmp_318_var; + void *_tmp_320_var; while ( - (_tmp_318_var = _tmp_318_rule(p)) // ',' star_expression + (_tmp_320_var = _tmp_320_rule(p)) // ',' star_expression ) { - _res = _tmp_318_var; + _res = _tmp_320_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37813,12 +38393,12 @@ _loop1_109_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_109[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('or' conjunction)")); - void *_tmp_319_var; + void *_tmp_321_var; while ( - (_tmp_319_var = _tmp_319_rule(p)) // 'or' conjunction + (_tmp_321_var = _tmp_321_rule(p)) // 'or' conjunction ) { - _res = _tmp_319_var; + _res = _tmp_321_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -37886,12 +38466,12 @@ _loop1_110_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_110[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('and' inversion)")); - void *_tmp_320_var; + void *_tmp_322_var; while ( - (_tmp_320_var = _tmp_320_rule(p)) // 'and' inversion + (_tmp_322_var = _tmp_322_rule(p)) // 'and' inversion ) { - _res = _tmp_320_var; + _res = _tmp_322_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38246,7 +38826,7 @@ _loop0_117_rule(Parser *p) while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_321_rule(p)) // slice | starred_expression + (elem = _tmp_323_rule(p)) // slice | starred_expression ) { _res = elem; @@ -38312,7 +38892,7 @@ _gather_116_rule(Parser *p) void *elem; asdl_seq * seq; if ( - (elem = _tmp_321_rule(p)) // slice | starred_expression + (elem = _tmp_323_rule(p)) // slice | starred_expression && (seq = _loop0_117_rule(p)) // _loop0_117 ) @@ -38787,7 +39367,7 @@ _tmp_124_rule(Parser *p) 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_322_rule, p) + _PyPegen_lookahead(1, _tmp_324_rule, p) && (function_def_nonewline_var = function_def_nonewline_rule(p)) // function_def_nonewline ) @@ -38808,7 +39388,7 @@ _tmp_124_rule(Parser *p) 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_323_rule, p) + _PyPegen_lookahead(1, _tmp_325_rule, p) && (class_def_nonewline_var = class_def_nonewline_rule(p)) // class_def_nonewline ) @@ -40232,7 +40812,7 @@ _loop1_144_rule(Parser *p) return _seq; } -// _loop1_145: lambda_sum_param_no_default +// _loop1_145: param_no_default static asdl_seq * _loop1_145_rule(Parser *p) { @@ -40255,18 +40835,18 @@ _loop1_145_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // lambda_sum_param_no_default + { // param_no_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_145[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); - arg_ty lambda_sum_param_no_default_var; + D(fprintf(stderr, "%*c> _loop1_145[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; while ( - (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default + (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - _res = lambda_sum_param_no_default_var; + _res = param_no_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -40284,7 +40864,7 @@ _loop1_145_rule(Parser *p) } p->mark = _mark; 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, "lambda_sum_param_no_default")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -40305,7 +40885,7 @@ _loop1_145_rule(Parser *p) return _seq; } -// _loop1_146: lambda_sum_param_no_default +// _loop1_146: param_no_default static asdl_seq * _loop1_146_rule(Parser *p) { @@ -40328,18 +40908,18 @@ _loop1_146_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // lambda_sum_param_no_default + { // param_no_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_146[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); - arg_ty lambda_sum_param_no_default_var; + D(fprintf(stderr, "%*c> _loop1_146[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; while ( - (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default + (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - _res = lambda_sum_param_no_default_var; + _res = param_no_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -40357,7 +40937,7 @@ _loop1_146_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s _loop1_146[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -40728,9 +41308,9 @@ _loop0_151_rule(Parser *p) return _seq; } -// _loop1_152: lambda_sum_param_maybe_default +// _loop0_152: lambda_sum_param_maybe_default static asdl_seq * -_loop1_152_rule(Parser *p) +_loop0_152_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40756,7 +41336,7 @@ _loop1_152_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_152[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_152[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); NameDefaultPair* lambda_sum_param_maybe_default_var; while ( (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default @@ -40779,7 +41359,75 @@ _loop1_152_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_152[%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, "lambda_sum_param_maybe_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_153: lambda_sum_param_maybe_default +static asdl_seq * +_loop1_153_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_sum_param_maybe_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_153[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + NameDefaultPair* lambda_sum_param_maybe_default_var; + while ( + (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default + ) + { + _res = lambda_sum_param_maybe_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_153[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -40801,9 +41449,9 @@ _loop1_152_rule(Parser *p) return _seq; } -// _tmp_153: yield_expr | star_expressions +// _tmp_154: yield_expr | star_expressions static void * -_tmp_153_rule(Parser *p) +_tmp_154_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40820,18 +41468,18 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_154[%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_153[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_154[%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_153[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_154[%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 +41487,18 @@ _tmp_153_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_153[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_154[%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_153[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_154[%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_153[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_154[%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 +41507,9 @@ _tmp_153_rule(Parser *p) return _res; } -// _loop0_154: fstring_format_spec +// _loop0_155: fstring_format_spec static asdl_seq * -_loop0_154_rule(Parser *p) +_loop0_155_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40887,7 +41535,7 @@ _loop0_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_154[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_155[%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 @@ -40910,7 +41558,7 @@ _loop0_154_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_154[%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, "fstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40927,9 +41575,9 @@ _loop0_154_rule(Parser *p) return _seq; } -// _loop1_155: (fstring | string) +// _loop1_156: (fstring | string) static asdl_seq * -_loop1_155_rule(Parser *p) +_loop1_156_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40955,13 +41603,13 @@ _loop1_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_155[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(fstring | string)")); - void *_tmp_324_var; + D(fprintf(stderr, "%*c> _loop1_156[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(fstring | string)")); + void *_tmp_326_var; while ( - (_tmp_324_var = _tmp_324_rule(p)) // fstring | string + (_tmp_326_var = _tmp_326_rule(p)) // fstring | string ) { - _res = _tmp_324_var; + _res = _tmp_326_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -40978,7 +41626,7 @@ _loop1_155_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_155[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_156[%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) { @@ -41000,9 +41648,9 @@ _loop1_155_rule(Parser *p) return _seq; } -// _tmp_156: star_named_expression ',' star_named_expressions? +// _tmp_157: star_named_expression ',' star_named_expressions? static void * -_tmp_156_rule(Parser *p) +_tmp_157_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41019,7 +41667,7 @@ _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, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_157[%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; @@ -41031,7 +41679,7 @@ _tmp_156_rule(Parser *p) (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? ) { - D(fprintf(stderr, "%*c+ _tmp_156[%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_157[%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; @@ -41041,7 +41689,7 @@ _tmp_156_rule(Parser *p) 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_157[%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; @@ -41050,9 +41698,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _loop0_158: ',' double_starred_kvpair +// _loop0_159: ',' double_starred_kvpair static asdl_seq * -_loop0_158_rule(Parser *p) +_loop0_159_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41078,7 +41726,7 @@ _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, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_159[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -41110,7 +41758,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_159[%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); @@ -41127,9 +41775,9 @@ _loop0_158_rule(Parser *p) return _seq; } -// _gather_157: double_starred_kvpair _loop0_158 +// _gather_158: double_starred_kvpair _loop0_159 static asdl_seq * -_gather_157_rule(Parser *p) +_gather_158_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41141,27 +41789,27 @@ _gather_157_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_158 + { // double_starred_kvpair _loop0_159 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_157[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_158")); + D(fprintf(stderr, "%*c> _gather_158[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_159")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_158_rule(p)) // _loop0_158 + (seq = _loop0_159_rule(p)) // _loop0_159 ) { - D(fprintf(stderr, "%*c+ _gather_157[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_158")); + D(fprintf(stderr, "%*c+ _gather_158[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_159")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_157[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_158")); + 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, "double_starred_kvpair _loop0_159")); } _res = NULL; done: @@ -41169,9 +41817,9 @@ _gather_157_rule(Parser *p) return _res; } -// _loop1_159: for_if_clause +// _loop1_160: for_if_clause static asdl_seq * -_loop1_159_rule(Parser *p) +_loop1_160_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41197,7 +41845,7 @@ _loop1_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_159[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_160[%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 @@ -41220,7 +41868,7 @@ _loop1_159_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_159[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_160[%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) { @@ -41242,9 +41890,9 @@ _loop1_159_rule(Parser *p) return _seq; } -// _loop0_160: ('if' disjunction) +// _loop0_161: ('if' disjunction) static asdl_seq * -_loop0_160_rule(Parser *p) +_loop0_161_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41270,13 +41918,13 @@ _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, "('if' disjunction)")); - void *_tmp_325_var; + D(fprintf(stderr, "%*c> _loop0_161[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_327_var; while ( - (_tmp_325_var = _tmp_325_rule(p)) // 'if' disjunction + (_tmp_327_var = _tmp_327_rule(p)) // 'if' disjunction ) { - _res = _tmp_325_var; + _res = _tmp_327_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -41293,7 +41941,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_161[%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); @@ -41310,9 +41958,9 @@ _loop0_160_rule(Parser *p) return _seq; } -// _loop0_161: ('if' disjunction) +// _loop0_162: ('if' disjunction) static asdl_seq * -_loop0_161_rule(Parser *p) +_loop0_162_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41338,13 +41986,13 @@ _loop0_161_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_161[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); - void *_tmp_326_var; + D(fprintf(stderr, "%*c> _loop0_162[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_328_var; while ( - (_tmp_326_var = _tmp_326_rule(p)) // 'if' disjunction + (_tmp_328_var = _tmp_328_rule(p)) // 'if' disjunction ) { - _res = _tmp_326_var; + _res = _tmp_328_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -41361,7 +42009,7 @@ _loop0_161_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_161[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_162[%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); @@ -41378,9 +42026,9 @@ _loop0_161_rule(Parser *p) return _seq; } -// _loop0_162: ('if' disjunction) +// _loop0_163: ('if' disjunction) static asdl_seq * -_loop0_162_rule(Parser *p) +_loop0_163_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41406,13 +42054,13 @@ _loop0_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_162[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); - void *_tmp_327_var; + D(fprintf(stderr, "%*c> _loop0_163[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_329_var; while ( - (_tmp_327_var = _tmp_327_rule(p)) // 'if' disjunction + (_tmp_329_var = _tmp_329_rule(p)) // 'if' disjunction ) { - _res = _tmp_327_var; + _res = _tmp_329_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -41429,7 +42077,7 @@ _loop0_162_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_162[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_163[%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); @@ -41446,9 +42094,9 @@ _loop0_162_rule(Parser *p) return _seq; } -// _tmp_163: assignment_expression | expression !':=' +// _tmp_164: assignment_expression | expression !':=' static void * -_tmp_163_rule(Parser *p) +_tmp_164_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41465,18 +42113,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, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_164[%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_163[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_164[%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_163[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_164[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -41484,7 +42132,7 @@ _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, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_164[%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 @@ -41492,12 +42140,12 @@ _tmp_163_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_164[%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_163[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_164[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -41506,9 +42154,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: assignment_expression | expression !':=' +// _tmp_165: assignment_expression | expression !':=' static void * -_tmp_164_rule(Parser *p) +_tmp_165_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41525,18 +42173,18 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_165[%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_164[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_165[%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_164[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_165[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -41544,7 +42192,7 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_165[%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 @@ -41552,12 +42200,12 @@ _tmp_164_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_165[%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_164[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_165[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -41566,10 +42214,10 @@ _tmp_164_rule(Parser *p) return _res; } -// _loop0_166: +// _loop0_167: // | ',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_166_rule(Parser *p) +_loop0_167_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41595,13 +42243,13 @@ _loop0_166_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_166[%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_167[%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_328_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' + (elem = _tmp_330_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -41627,7 +42275,7 @@ _loop0_166_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_166[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_167[%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); @@ -41644,10 +42292,10 @@ _loop0_166_rule(Parser *p) return _seq; } -// _gather_165: -// | (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_166 +// _gather_166: +// | (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167 static asdl_seq * -_gather_165_rule(Parser *p) +_gather_166_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41659,27 +42307,27 @@ _gather_165_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_166 + { // (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_165[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_166")); + D(fprintf(stderr, "%*c> _gather_166[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_328_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' + (elem = _tmp_330_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_166_rule(p)) // _loop0_166 + (seq = _loop0_167_rule(p)) // _loop0_167 ) { - D(fprintf(stderr, "%*c+ _gather_165[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_166")); + D(fprintf(stderr, "%*c+ _gather_166[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_166")); + 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, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167")); } _res = NULL; done: @@ -41687,9 +42335,9 @@ _gather_165_rule(Parser *p) return _res; } -// _tmp_167: ',' kwargs +// _tmp_168: ',' kwargs static void * -_tmp_167_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41706,7 +42354,7 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -41715,7 +42363,7 @@ _tmp_167_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_168[%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; @@ -41725,7 +42373,7 @@ _tmp_167_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_167[%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, "',' kwargs")); } _res = NULL; @@ -41734,9 +42382,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _loop0_169: ',' kwarg_or_starred +// _loop0_170: ',' kwarg_or_starred static asdl_seq * -_loop0_169_rule(Parser *p) +_loop0_170_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41762,7 +42410,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, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_170[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -41794,7 +42442,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_170[%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); @@ -41811,9 +42459,9 @@ _loop0_169_rule(Parser *p) return _seq; } -// _gather_168: kwarg_or_starred _loop0_169 +// _gather_169: kwarg_or_starred _loop0_170 static asdl_seq * -_gather_168_rule(Parser *p) +_gather_169_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41825,27 +42473,27 @@ _gather_168_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_169 + { // kwarg_or_starred _loop0_170 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, "kwarg_or_starred _loop0_169")); + D(fprintf(stderr, "%*c> _gather_169[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_170")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_169_rule(p)) // _loop0_169 + (seq = _loop0_170_rule(p)) // _loop0_170 ) { - D(fprintf(stderr, "%*c+ _gather_168[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_169")); + D(fprintf(stderr, "%*c+ _gather_169[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_170")); _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, "kwarg_or_starred _loop0_169")); + D(fprintf(stderr, "%*c%s _gather_169[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_170")); } _res = NULL; done: @@ -41853,9 +42501,9 @@ _gather_168_rule(Parser *p) return _res; } -// _loop0_171: ',' kwarg_or_double_starred +// _loop0_172: ',' kwarg_or_double_starred static asdl_seq * -_loop0_171_rule(Parser *p) +_loop0_172_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41881,7 +42529,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, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_172[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -41913,7 +42561,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_172[%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); @@ -41930,9 +42578,9 @@ _loop0_171_rule(Parser *p) return _seq; } -// _gather_170: kwarg_or_double_starred _loop0_171 +// _gather_171: kwarg_or_double_starred _loop0_172 static asdl_seq * -_gather_170_rule(Parser *p) +_gather_171_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41944,27 +42592,27 @@ _gather_170_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_171 + { // kwarg_or_double_starred _loop0_172 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, "kwarg_or_double_starred _loop0_171")); + D(fprintf(stderr, "%*c> _gather_171[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_172")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_171_rule(p)) // _loop0_171 + (seq = _loop0_172_rule(p)) // _loop0_172 ) { - D(fprintf(stderr, "%*c+ _gather_170[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_171")); + D(fprintf(stderr, "%*c+ _gather_171[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_172")); _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, "kwarg_or_double_starred _loop0_171")); + D(fprintf(stderr, "%*c%s _gather_171[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_172")); } _res = NULL; done: @@ -41972,9 +42620,9 @@ _gather_170_rule(Parser *p) return _res; } -// _loop0_173: ',' kwarg_or_starred +// _loop0_174: ',' kwarg_or_starred static asdl_seq * -_loop0_173_rule(Parser *p) +_loop0_174_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42000,7 +42648,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, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_174[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -42032,7 +42680,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_174[%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); @@ -42049,9 +42697,9 @@ _loop0_173_rule(Parser *p) return _seq; } -// _gather_172: kwarg_or_starred _loop0_173 +// _gather_173: kwarg_or_starred _loop0_174 static asdl_seq * -_gather_172_rule(Parser *p) +_gather_173_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42063,27 +42711,27 @@ _gather_172_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_173 + { // kwarg_or_starred _loop0_174 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, "kwarg_or_starred _loop0_173")); + D(fprintf(stderr, "%*c> _gather_173[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_174")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_173_rule(p)) // _loop0_173 + (seq = _loop0_174_rule(p)) // _loop0_174 ) { - D(fprintf(stderr, "%*c+ _gather_172[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_173")); + D(fprintf(stderr, "%*c+ _gather_173[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_174")); _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, "kwarg_or_starred _loop0_173")); + D(fprintf(stderr, "%*c%s _gather_173[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_174")); } _res = NULL; done: @@ -42091,9 +42739,9 @@ _gather_172_rule(Parser *p) return _res; } -// _loop0_175: ',' kwarg_or_double_starred +// _loop0_176: ',' kwarg_or_double_starred static asdl_seq * -_loop0_175_rule(Parser *p) +_loop0_176_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42119,7 +42767,7 @@ _loop0_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_175[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_176[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -42151,7 +42799,7 @@ _loop0_175_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_175[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_176[%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); @@ -42168,9 +42816,9 @@ _loop0_175_rule(Parser *p) return _seq; } -// _gather_174: kwarg_or_double_starred _loop0_175 +// _gather_175: kwarg_or_double_starred _loop0_176 static asdl_seq * -_gather_174_rule(Parser *p) +_gather_175_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42182,27 +42830,27 @@ _gather_174_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_175 + { // kwarg_or_double_starred _loop0_176 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_174[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_175")); + D(fprintf(stderr, "%*c> _gather_175[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_176")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_175_rule(p)) // _loop0_175 + (seq = _loop0_176_rule(p)) // _loop0_176 ) { - D(fprintf(stderr, "%*c+ _gather_174[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_175")); + D(fprintf(stderr, "%*c+ _gather_175[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_176")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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, "kwarg_or_double_starred _loop0_175")); + D(fprintf(stderr, "%*c%s _gather_175[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_176")); } _res = NULL; done: @@ -42210,9 +42858,9 @@ _gather_174_rule(Parser *p) return _res; } -// _tmp_176: simple_slice | expression +// _tmp_177: simple_slice | expression static void * -_tmp_176_rule(Parser *p) +_tmp_177_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42229,18 +42877,18 @@ _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, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_177[%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_176[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_177[%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_176[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_177[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // expression @@ -42248,18 +42896,18 @@ _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, "expression")); + D(fprintf(stderr, "%*c> _tmp_177[%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_176[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c+ _tmp_177[%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_176[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_177[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression")); } _res = NULL; @@ -42268,9 +42916,9 @@ _tmp_176_rule(Parser *p) return _res; } -// _tmp_177: simple_slice | expression +// _tmp_178: simple_slice | expression static void * -_tmp_177_rule(Parser *p) +_tmp_178_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42287,18 +42935,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, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_178[%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_177[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_178[%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_177[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_178[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // expression @@ -42306,18 +42954,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, "expression")); + D(fprintf(stderr, "%*c> _tmp_178[%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_177[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c+ _tmp_178[%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_177[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_178[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression")); } _res = NULL; @@ -42326,9 +42974,9 @@ _tmp_177_rule(Parser *p) return _res; } -// _loop0_178: (',' star_target) +// _loop0_179: (',' star_target) static asdl_seq * -_loop0_178_rule(Parser *p) +_loop0_179_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42354,13 +43002,13 @@ _loop0_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); - void *_tmp_329_var; + D(fprintf(stderr, "%*c> _loop0_179[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); + void *_tmp_331_var; while ( - (_tmp_329_var = _tmp_329_rule(p)) // ',' star_target + (_tmp_331_var = _tmp_331_rule(p)) // ',' star_target ) { - _res = _tmp_329_var; + _res = _tmp_331_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -42377,7 +43025,7 @@ _loop0_178_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_178[%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, "(',' star_target)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42394,9 +43042,9 @@ _loop0_178_rule(Parser *p) return _seq; } -// _loop0_180: ',' star_target +// _loop0_181: ',' star_target static asdl_seq * -_loop0_180_rule(Parser *p) +_loop0_181_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42422,7 +43070,7 @@ _loop0_180_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_180[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -42454,7 +43102,7 @@ _loop0_180_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_180[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_181[%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); @@ -42471,9 +43119,9 @@ _loop0_180_rule(Parser *p) return _seq; } -// _gather_179: star_target _loop0_180 +// _gather_180: star_target _loop0_181 static asdl_seq * -_gather_179_rule(Parser *p) +_gather_180_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42485,27 +43133,27 @@ _gather_179_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_180 + { // star_target _loop0_181 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_179[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_180")); + D(fprintf(stderr, "%*c> _gather_180[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_181")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_180_rule(p)) // _loop0_180 + (seq = _loop0_181_rule(p)) // _loop0_181 ) { - D(fprintf(stderr, "%*c+ _gather_179[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_180")); + D(fprintf(stderr, "%*c+ _gather_180[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_181")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_179[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_target _loop0_180")); + D(fprintf(stderr, "%*c%s _gather_180[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_target _loop0_181")); } _res = NULL; done: @@ -42513,9 +43161,9 @@ _gather_179_rule(Parser *p) return _res; } -// _loop1_181: (',' star_target) +// _loop1_182: (',' star_target) static asdl_seq * -_loop1_181_rule(Parser *p) +_loop1_182_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42541,13 +43189,13 @@ _loop1_181_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); - void *_tmp_330_var; + D(fprintf(stderr, "%*c> _loop1_182[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); + void *_tmp_332_var; while ( - (_tmp_330_var = _tmp_330_rule(p)) // ',' star_target + (_tmp_332_var = _tmp_332_rule(p)) // ',' star_target ) { - _res = _tmp_330_var; + _res = _tmp_332_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -42564,7 +43212,7 @@ _loop1_181_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_181[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_182[%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) { @@ -42586,9 +43234,9 @@ _loop1_181_rule(Parser *p) return _seq; } -// _tmp_182: !'*' star_target +// _tmp_183: !'*' star_target static void * -_tmp_182_rule(Parser *p) +_tmp_183_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42605,7 +43253,7 @@ _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, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_183[%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='*' @@ -42613,12 +43261,12 @@ _tmp_182_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_182[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_183[%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_182[%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, "!'*' star_target")); } _res = NULL; @@ -42627,9 +43275,9 @@ _tmp_182_rule(Parser *p) return _res; } -// _tmp_183: genexp | tuplecomp +// _tmp_184: genexp | tuplecomp static void * -_tmp_183_rule(Parser *p) +_tmp_184_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42646,18 +43294,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, "genexp")); + D(fprintf(stderr, "%*c> _tmp_184[%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_183[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_184[%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_183[%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, "genexp")); } { // tuplecomp @@ -42665,18 +43313,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, "tuplecomp")); + D(fprintf(stderr, "%*c> _tmp_184[%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_183[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c+ _tmp_184[%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_183[%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, "tuplecomp")); } _res = NULL; @@ -42685,9 +43333,9 @@ _tmp_183_rule(Parser *p) return _res; } -// _loop0_185: ',' del_target +// _loop0_186: ',' del_target static asdl_seq * -_loop0_185_rule(Parser *p) +_loop0_186_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42713,7 +43361,7 @@ _loop0_185_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_185[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -42745,7 +43393,7 @@ _loop0_185_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_185[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_186[%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); @@ -42762,9 +43410,9 @@ _loop0_185_rule(Parser *p) return _seq; } -// _gather_184: del_target _loop0_185 +// _gather_185: del_target _loop0_186 static asdl_seq * -_gather_184_rule(Parser *p) +_gather_185_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42776,27 +43424,27 @@ _gather_184_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_185 + { // del_target _loop0_186 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_185")); + D(fprintf(stderr, "%*c> _gather_185[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_186")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_185_rule(p)) // _loop0_185 + (seq = _loop0_186_rule(p)) // _loop0_186 ) { - D(fprintf(stderr, "%*c+ _gather_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_185")); + D(fprintf(stderr, "%*c+ _gather_185[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_186")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_184[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_target _loop0_185")); + D(fprintf(stderr, "%*c%s _gather_185[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_target _loop0_186")); } _res = NULL; done: @@ -42804,9 +43452,9 @@ _gather_184_rule(Parser *p) return _res; } -// _loop0_187: ',' expression +// _loop0_188: ',' expression static asdl_seq * -_loop0_187_rule(Parser *p) +_loop0_188_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42832,7 +43480,7 @@ _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, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -42864,7 +43512,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_188[%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); @@ -42881,9 +43529,9 @@ _loop0_187_rule(Parser *p) return _seq; } -// _gather_186: expression _loop0_187 +// _gather_187: expression _loop0_188 static asdl_seq * -_gather_186_rule(Parser *p) +_gather_187_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42895,27 +43543,27 @@ _gather_186_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_187 + { // expression _loop0_188 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_187")); + D(fprintf(stderr, "%*c> _gather_187[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_188")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_187_rule(p)) // _loop0_187 + (seq = _loop0_188_rule(p)) // _loop0_188 ) { - D(fprintf(stderr, "%*c+ _gather_186[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_187")); + D(fprintf(stderr, "%*c+ _gather_187[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_188")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_186[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_187")); + D(fprintf(stderr, "%*c%s _gather_187[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_188")); } _res = NULL; done: @@ -42923,9 +43571,9 @@ _gather_186_rule(Parser *p) return _res; } -// _loop0_189: ',' expression +// _loop0_190: ',' expression static asdl_seq * -_loop0_189_rule(Parser *p) +_loop0_190_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42951,7 +43599,7 @@ _loop0_189_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -42983,7 +43631,7 @@ _loop0_189_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_189[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_190[%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); @@ -43000,9 +43648,9 @@ _loop0_189_rule(Parser *p) return _seq; } -// _gather_188: expression _loop0_189 +// _gather_189: expression _loop0_190 static asdl_seq * -_gather_188_rule(Parser *p) +_gather_189_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43014,27 +43662,27 @@ _gather_188_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_189 + { // expression _loop0_190 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_189")); + D(fprintf(stderr, "%*c> _gather_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_190")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_189_rule(p)) // _loop0_189 + (seq = _loop0_190_rule(p)) // _loop0_190 ) { - D(fprintf(stderr, "%*c+ _gather_188[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_189")); + D(fprintf(stderr, "%*c+ _gather_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_190")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_188[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_189")); + D(fprintf(stderr, "%*c%s _gather_189[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_190")); } _res = NULL; done: @@ -43042,9 +43690,9 @@ _gather_188_rule(Parser *p) return _res; } -// _loop0_191: ',' expression +// _loop0_192: ',' expression static asdl_seq * -_loop0_191_rule(Parser *p) +_loop0_192_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43070,7 +43718,7 @@ _loop0_191_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -43102,7 +43750,7 @@ _loop0_191_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_191[%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, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43119,9 +43767,9 @@ _loop0_191_rule(Parser *p) return _seq; } -// _gather_190: expression _loop0_191 +// _gather_191: expression _loop0_192 static asdl_seq * -_gather_190_rule(Parser *p) +_gather_191_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43133,27 +43781,27 @@ _gather_190_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_191 + { // expression _loop0_192 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_191")); + D(fprintf(stderr, "%*c> _gather_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_192")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_191_rule(p)) // _loop0_191 + (seq = _loop0_192_rule(p)) // _loop0_192 ) { - D(fprintf(stderr, "%*c+ _gather_190[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_191")); + D(fprintf(stderr, "%*c+ _gather_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_192")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_190[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_191")); + D(fprintf(stderr, "%*c%s _gather_191[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_192")); } _res = NULL; done: @@ -43161,9 +43809,9 @@ _gather_190_rule(Parser *p) return _res; } -// _loop0_193: ',' expression +// _loop0_194: ',' expression static asdl_seq * -_loop0_193_rule(Parser *p) +_loop0_194_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43189,7 +43837,7 @@ _loop0_193_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_194[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -43221,7 +43869,7 @@ _loop0_193_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_193[%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, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43238,9 +43886,9 @@ _loop0_193_rule(Parser *p) return _seq; } -// _gather_192: expression _loop0_193 +// _gather_193: expression _loop0_194 static asdl_seq * -_gather_192_rule(Parser *p) +_gather_193_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43252,27 +43900,27 @@ _gather_192_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_193 + { // expression _loop0_194 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_193")); + D(fprintf(stderr, "%*c> _gather_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_194")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_193_rule(p)) // _loop0_193 + (seq = _loop0_194_rule(p)) // _loop0_194 ) { - D(fprintf(stderr, "%*c+ _gather_192[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_193")); + D(fprintf(stderr, "%*c+ _gather_193[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_194")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_192[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_193")); + D(fprintf(stderr, "%*c%s _gather_193[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_194")); } _res = NULL; done: @@ -43280,9 +43928,9 @@ _gather_192_rule(Parser *p) return _res; } -// _tmp_194: NEWLINE INDENT +// _tmp_195: NEWLINE INDENT static void * -_tmp_194_rule(Parser *p) +_tmp_195_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43299,7 +43947,7 @@ _tmp_194_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_194[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -43308,12 +43956,12 @@ _tmp_194_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_194[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_195[%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_194[%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, "NEWLINE INDENT")); } _res = NULL; @@ -43322,9 +43970,9 @@ _tmp_194_rule(Parser *p) return _res; } -// _tmp_195: args | expression for_if_clauses +// _tmp_196: args | expression for_if_clauses static void * -_tmp_195_rule(Parser *p) +_tmp_196_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43341,18 +43989,18 @@ _tmp_195_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); + D(fprintf(stderr, "%*c> _tmp_196[%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_195[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); + D(fprintf(stderr, "%*c+ _tmp_196[%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_195[%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, "args")); } { // expression for_if_clauses @@ -43360,7 +44008,7 @@ _tmp_195_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_196[%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 ( @@ -43369,12 +44017,12 @@ _tmp_195_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_195[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_196[%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_195[%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, "expression for_if_clauses")); } _res = NULL; @@ -43383,9 +44031,9 @@ _tmp_195_rule(Parser *p) return _res; } -// _tmp_196: args ',' +// _tmp_197: args ',' static void * -_tmp_196_rule(Parser *p) +_tmp_197_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43402,7 +44050,7 @@ _tmp_196_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_196[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); + D(fprintf(stderr, "%*c> _tmp_197[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -43411,12 +44059,12 @@ _tmp_196_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_196[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_197[%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_196[%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, "args ','")); } _res = NULL; @@ -43425,9 +44073,9 @@ _tmp_196_rule(Parser *p) return _res; } -// _tmp_197: ',' | ')' +// _tmp_198: ',' | ')' static void * -_tmp_197_rule(Parser *p) +_tmp_198_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43444,18 +44092,18 @@ _tmp_197_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_197[%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, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_197[%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_197[%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, "','")); } { // ')' @@ -43463,18 +44111,18 @@ _tmp_197_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_197[%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, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_197[%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_197[%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; @@ -43483,9 +44131,9 @@ _tmp_197_rule(Parser *p) return _res; } -// _tmp_198: 'True' | 'False' | 'None' +// _tmp_199: 'True' | 'False' | 'None' static void * -_tmp_198_rule(Parser *p) +_tmp_199_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43502,18 +44150,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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_199[%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_198[%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, "'True'")); } { // 'False' @@ -43521,18 +44169,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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_199[%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_198[%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, "'False'")); } { // 'None' @@ -43540,18 +44188,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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_199[%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_198[%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, "'None'")); } _res = NULL; @@ -43560,9 +44208,9 @@ _tmp_198_rule(Parser *p) return _res; } -// _tmp_199: NAME '=' +// _tmp_200: NAME '=' static void * -_tmp_199_rule(Parser *p) +_tmp_200_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43579,7 +44227,7 @@ _tmp_199_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_200[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -43588,12 +44236,12 @@ _tmp_199_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_199[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_200[%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_199[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_200[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME '='")); } _res = NULL; @@ -43602,9 +44250,9 @@ _tmp_199_rule(Parser *p) return _res; } -// _tmp_200: NAME STRING | SOFT_KEYWORD +// _tmp_201: NAME STRING | SOFT_KEYWORD static void * -_tmp_200_rule(Parser *p) +_tmp_201_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43621,7 +44269,7 @@ _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, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_201[%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 ( @@ -43630,12 +44278,12 @@ _tmp_200_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_200[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_201[%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_200[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_201[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME STRING")); } { // SOFT_KEYWORD @@ -43643,18 +44291,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, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_201[%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_200[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_201[%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_200[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_201[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); } _res = NULL; @@ -43663,9 +44311,9 @@ _tmp_200_rule(Parser *p) return _res; } -// _tmp_201: 'else' | ':' +// _tmp_202: 'else' | ':' static void * -_tmp_201_rule(Parser *p) +_tmp_202_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43682,18 +44330,18 @@ _tmp_201_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_201[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c> _tmp_202[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 709)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_201[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_202[%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_201[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_202[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'else'")); } { // ':' @@ -43701,18 +44349,18 @@ _tmp_201_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_201[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_202[%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_201[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_202[%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_201[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_202[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -43721,9 +44369,9 @@ _tmp_201_rule(Parser *p) return _res; } -// _tmp_202: FSTRING_MIDDLE | fstring_replacement_field +// _tmp_203: FSTRING_MIDDLE | fstring_replacement_field static void * -_tmp_202_rule(Parser *p) +_tmp_203_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43740,18 +44388,18 @@ _tmp_202_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_202[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c> _tmp_203[%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_202[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c+ _tmp_203[%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_202[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_203[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); } { // fstring_replacement_field @@ -43759,18 +44407,18 @@ _tmp_202_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_202[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); + D(fprintf(stderr, "%*c> _tmp_203[%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_202[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); + D(fprintf(stderr, "%*c+ _tmp_203[%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_202[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_203[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); } _res = NULL; @@ -43779,9 +44427,9 @@ _tmp_202_rule(Parser *p) return _res; } -// _tmp_203: '=' | ':=' +// _tmp_204: '=' | ':=' static void * -_tmp_203_rule(Parser *p) +_tmp_204_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43798,18 +44446,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_204[%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_203[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_204[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } { // ':=' @@ -43817,18 +44465,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_204[%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_203[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); + D(fprintf(stderr, "%*c+ _tmp_204[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':='")); } _res = NULL; @@ -43837,9 +44485,9 @@ _tmp_203_rule(Parser *p) return _res; } -// _tmp_204: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_205: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_204_rule(Parser *p) +_tmp_205_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43856,18 +44504,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, "list")); + D(fprintf(stderr, "%*c> _tmp_205[%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_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c+ _tmp_205[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "list")); } { // tuple @@ -43875,18 +44523,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, "tuple")); + D(fprintf(stderr, "%*c> _tmp_205[%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_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_205[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuple")); } { // genexp @@ -43894,18 +44542,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, "genexp")); + D(fprintf(stderr, "%*c> _tmp_205[%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_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_205[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } { // 'True' @@ -43913,18 +44561,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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 660)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_205[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'True'")); } { // 'None' @@ -43932,18 +44580,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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_205[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } { // 'False' @@ -43951,18 +44599,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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 662)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_205[%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_204[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_205[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'False'")); } _res = NULL; @@ -43971,9 +44619,9 @@ _tmp_204_rule(Parser *p) return _res; } -// _tmp_205: '=' | ':=' +// _tmp_206: '=' | ':=' static void * -_tmp_205_rule(Parser *p) +_tmp_206_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43990,18 +44638,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_206[%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_205[%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_205[%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, "'='")); } { // ':=' @@ -44009,18 +44657,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_206[%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_205[%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_205[%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, "':='")); } _res = NULL; @@ -44029,9 +44677,9 @@ _tmp_205_rule(Parser *p) return _res; } -// _loop0_206: star_named_expressions +// _loop0_207: star_named_expressions static asdl_seq * -_loop0_206_rule(Parser *p) +_loop0_207_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44057,7 +44705,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, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_207[%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 @@ -44080,7 +44728,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_207[%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); @@ -44097,9 +44745,9 @@ _loop0_206_rule(Parser *p) return _seq; } -// _loop0_207: (star_targets '=') +// _loop0_208: (star_targets '=') static asdl_seq * -_loop0_207_rule(Parser *p) +_loop0_208_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44125,13 +44773,13 @@ _loop0_207_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_207[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); - void *_tmp_331_var; + D(fprintf(stderr, "%*c> _loop0_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_333_var; while ( - (_tmp_331_var = _tmp_331_rule(p)) // star_targets '=' + (_tmp_333_var = _tmp_333_rule(p)) // star_targets '=' ) { - _res = _tmp_331_var; + _res = _tmp_333_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -44148,7 +44796,7 @@ _loop0_207_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_207[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_208[%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); @@ -44165,9 +44813,9 @@ _loop0_207_rule(Parser *p) return _seq; } -// _loop0_208: (star_targets '=') +// _loop0_209: (star_targets '=') static asdl_seq * -_loop0_208_rule(Parser *p) +_loop0_209_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44193,13 +44841,13 @@ _loop0_208_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); - void *_tmp_332_var; + D(fprintf(stderr, "%*c> _loop0_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_334_var; while ( - (_tmp_332_var = _tmp_332_rule(p)) // star_targets '=' + (_tmp_334_var = _tmp_334_rule(p)) // star_targets '=' ) { - _res = _tmp_332_var; + _res = _tmp_334_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -44216,7 +44864,7 @@ _loop0_208_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_208[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_209[%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); @@ -44233,9 +44881,9 @@ _loop0_208_rule(Parser *p) return _seq; } -// _tmp_209: yield_expr | star_expressions +// _tmp_210: yield_expr | star_expressions static void * -_tmp_209_rule(Parser *p) +_tmp_210_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44252,18 +44900,18 @@ _tmp_209_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_210[%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_209[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_210[%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_209[%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, "yield_expr")); } { // star_expressions @@ -44271,18 +44919,18 @@ _tmp_209_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_210[%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_209[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_210[%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_209[%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, "star_expressions")); } _res = NULL; @@ -44291,9 +44939,9 @@ _tmp_209_rule(Parser *p) return _res; } -// _tmp_210: '[' | '(' | '{' +// _tmp_211: '[' | '(' | '{' static void * -_tmp_210_rule(Parser *p) +_tmp_211_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44310,18 +44958,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, "'['")); + 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, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_210[%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_210[%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, "'['")); } { // '(' @@ -44329,18 +44977,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, "'('")); + 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, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_210[%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_210[%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, "'('")); } { // '{' @@ -44348,18 +44996,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, "'{'")); + 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, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_210[%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_210[%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; @@ -44368,9 +45016,9 @@ _tmp_210_rule(Parser *p) return _res; } -// _tmp_211: '[' | '{' +// _tmp_212: '[' | '{' static void * -_tmp_211_rule(Parser *p) +_tmp_212_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44387,18 +45035,18 @@ _tmp_211_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_211[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c> _tmp_212[%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_211[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c+ _tmp_212[%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_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_212[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'['")); } { // '{' @@ -44406,18 +45054,18 @@ _tmp_211_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_211[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c> _tmp_212[%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_211[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_212[%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_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_212[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -44426,9 +45074,9 @@ _tmp_211_rule(Parser *p) return _res; } -// _tmp_212: '[' | '{' +// _tmp_213: '[' | '{' static void * -_tmp_212_rule(Parser *p) +_tmp_213_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44445,18 +45093,18 @@ _tmp_212_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_212[%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, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_212[%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_212[%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, "'['")); } { // '{' @@ -44464,18 +45112,18 @@ _tmp_212_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_212[%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, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_212[%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_212[%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; @@ -44484,9 +45132,9 @@ _tmp_212_rule(Parser *p) return _res; } -// _tmp_213: slash_no_default | slash_with_default +// _tmp_214: slash_no_default | slash_with_default static void * -_tmp_213_rule(Parser *p) +_tmp_214_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44503,18 +45151,18 @@ _tmp_213_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_213[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_214[%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_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_214[%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_213[%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, "slash_no_default")); } { // slash_with_default @@ -44522,18 +45170,18 @@ _tmp_213_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_213[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_214[%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_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_214[%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_213[%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, "slash_with_default")); } _res = NULL; @@ -44542,9 +45190,9 @@ _tmp_213_rule(Parser *p) return _res; } -// _loop0_214: param_maybe_default +// _loop0_215: param_maybe_default static asdl_seq * -_loop0_214_rule(Parser *p) +_loop0_215_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44570,7 +45218,7 @@ _loop0_214_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_215[%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 @@ -44593,7 +45241,7 @@ _loop0_214_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_214[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_215[%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); @@ -44610,9 +45258,9 @@ _loop0_214_rule(Parser *p) return _seq; } -// _loop0_215: param_no_default +// _loop0_216: param_no_default static asdl_seq * -_loop0_215_rule(Parser *p) +_loop0_216_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44638,7 +45286,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, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_216[%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 @@ -44661,7 +45309,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_216[%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); @@ -44678,9 +45326,9 @@ _loop0_215_rule(Parser *p) return _seq; } -// _loop0_216: param_no_default +// _loop0_217: param_no_default static asdl_seq * -_loop0_216_rule(Parser *p) +_loop0_217_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44706,7 +45354,7 @@ _loop0_216_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_216[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_217[%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 @@ -44729,7 +45377,7 @@ _loop0_216_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_216[%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, "param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -44746,9 +45394,9 @@ _loop0_216_rule(Parser *p) return _seq; } -// _loop1_217: param_no_default +// _loop1_218: param_no_default static asdl_seq * -_loop1_217_rule(Parser *p) +_loop1_218_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44774,7 +45422,7 @@ _loop1_217_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_217[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_218[%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 @@ -44797,7 +45445,7 @@ _loop1_217_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_217[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_218[%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) { @@ -44819,9 +45467,9 @@ _loop1_217_rule(Parser *p) return _seq; } -// _tmp_218: slash_no_default | slash_with_default +// _tmp_219: slash_no_default | slash_with_default static void * -_tmp_218_rule(Parser *p) +_tmp_219_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44838,18 +45486,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, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_219[%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_218[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_219[%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_218[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_219[%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 @@ -44857,18 +45505,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, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_219[%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_218[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_219[%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_218[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_219[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_with_default")); } _res = NULL; @@ -44877,9 +45525,9 @@ _tmp_218_rule(Parser *p) return _res; } -// _loop0_219: param_maybe_default +// _loop0_220: param_maybe_default static asdl_seq * -_loop0_219_rule(Parser *p) +_loop0_220_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44905,7 +45553,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, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_220[%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 @@ -44928,7 +45576,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_220[%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); @@ -44945,9 +45593,9 @@ _loop0_219_rule(Parser *p) return _seq; } -// _tmp_220: ',' | param_no_default +// _tmp_221: ',' | param_no_default static void * -_tmp_220_rule(Parser *p) +_tmp_221_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44964,18 +45612,18 @@ _tmp_220_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_220[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_221[%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_220[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_221[%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_220[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_221[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // param_no_default @@ -44983,18 +45631,18 @@ _tmp_220_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_220[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_221[%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_220[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_221[%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_220[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_221[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } _res = NULL; @@ -45003,9 +45651,9 @@ _tmp_220_rule(Parser *p) return _res; } -// _loop0_221: param_maybe_default +// _loop0_222: param_maybe_default static asdl_seq * -_loop0_221_rule(Parser *p) +_loop0_222_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45031,7 +45679,7 @@ _loop0_221_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_221[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_222[%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 @@ -45054,7 +45702,7 @@ _loop0_221_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_221[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_222[%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); @@ -45071,9 +45719,9 @@ _loop0_221_rule(Parser *p) return _seq; } -// _loop1_222: param_maybe_default +// _loop1_223: param_maybe_default static asdl_seq * -_loop1_222_rule(Parser *p) +_loop1_223_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45099,7 +45747,7 @@ _loop1_222_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_222[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_223[%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 @@ -45122,7 +45770,7 @@ _loop1_222_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_222[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_223[%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) { @@ -45144,9 +45792,9 @@ _loop1_222_rule(Parser *p) return _seq; } -// _tmp_223: ')' | ',' +// _tmp_224: ')' | ',' static void * -_tmp_223_rule(Parser *p) +_tmp_224_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45163,18 +45811,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_224[%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_223[%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_223[%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, "')'")); } { // ',' @@ -45182,18 +45830,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_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_223[%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_223[%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, "','")); } _res = NULL; @@ -45202,9 +45850,67 @@ _tmp_223_rule(Parser *p) return _res; } -// _tmp_224: ')' | ',' (')' | '**') +// _tmp_225: '|' | ',' static void * -_tmp_224_rule(Parser *p) +_tmp_225_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->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_225[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 18)) // token='|' + ) + { + D(fprintf(stderr, "%*c+ _tmp_225[%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, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|'")); + } + { // ',' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_225[%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, "','")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_225[%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_226: ')' | ',' (')' | '**') +static void * +_tmp_226_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45221,18 +45927,18 @@ _tmp_224_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_224[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_226[%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_224[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_226[%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_224[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // ',' (')' | '**') @@ -45240,21 +45946,21 @@ _tmp_224_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_224[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); Token * _literal; - void *_tmp_333_var; + void *_tmp_335_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_333_var = _tmp_333_rule(p)) // ')' | '**' + (_tmp_335_var = _tmp_335_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_224[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_333_var); + D(fprintf(stderr, "%*c+ _tmp_226[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_335_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_224[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); } _res = NULL; @@ -45263,9 +45969,9 @@ _tmp_224_rule(Parser *p) return _res; } -// _tmp_225: param_no_default | ',' +// _tmp_227: param_no_default | ',' static void * -_tmp_225_rule(Parser *p) +_tmp_227_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45282,18 +45988,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_227[%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_225[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_227[%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_225[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_227[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } { // ',' @@ -45301,18 +46007,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_227[%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_227[%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_227[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -45321,9 +46027,9 @@ _tmp_225_rule(Parser *p) return _res; } -// _loop0_226: param_maybe_default +// _loop0_228: param_maybe_default static asdl_seq * -_loop0_226_rule(Parser *p) +_loop0_228_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45349,7 +46055,7 @@ _loop0_226_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_228[%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 @@ -45372,7 +46078,7 @@ _loop0_226_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_226[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_228[%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); @@ -45389,9 +46095,9 @@ _loop0_226_rule(Parser *p) return _seq; } -// _tmp_227: param_no_default | ',' +// _tmp_229: param_no_default | ',' static void * -_tmp_227_rule(Parser *p) +_tmp_229_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45408,18 +46114,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, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_229[%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_227[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_229[%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_227[%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, "param_no_default")); } { // ',' @@ -45427,18 +46133,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_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_227[%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_227[%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; @@ -45447,9 +46153,9 @@ _tmp_227_rule(Parser *p) return _res; } -// _tmp_228: '*' | '**' | '/' +// _tmp_230: '*' | '**' | '/' static void * -_tmp_228_rule(Parser *p) +_tmp_230_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45466,18 +46172,18 @@ _tmp_228_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c> _tmp_230[%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_228[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_230[%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_228[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_230[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*'")); } { // '**' @@ -45485,18 +46191,18 @@ _tmp_228_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_230[%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_228[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_230[%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_228[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_230[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } { // '/' @@ -45504,18 +46210,18 @@ _tmp_228_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c> _tmp_230[%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_228[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_230[%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_228[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_230[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'/'")); } _res = NULL; @@ -45524,9 +46230,9 @@ _tmp_228_rule(Parser *p) return _res; } -// _loop1_229: param_with_default +// _loop1_231: param_with_default static asdl_seq * -_loop1_229_rule(Parser *p) +_loop1_231_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45552,7 +46258,7 @@ _loop1_229_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop1_231[%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 @@ -45575,7 +46281,7 @@ _loop1_229_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_229[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_231[%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) { @@ -45597,9 +46303,9 @@ _loop1_229_rule(Parser *p) return _seq; } -// _tmp_230: lambda_slash_no_default | lambda_slash_with_default +// _tmp_232: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_230_rule(Parser *p) +_tmp_232_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45616,18 +46322,18 @@ _tmp_230_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_230[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_232[%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_230[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_232[%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_230[%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, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -45635,18 +46341,18 @@ _tmp_230_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_230[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_232[%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_230[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_232[%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_230[%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, "lambda_slash_with_default")); } _res = NULL; @@ -45655,9 +46361,9 @@ _tmp_230_rule(Parser *p) return _res; } -// _loop0_231: lambda_param_maybe_default +// _loop0_233: lambda_param_maybe_default static asdl_seq * -_loop0_231_rule(Parser *p) +_loop0_233_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45683,7 +46389,7 @@ _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, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_233[%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 @@ -45706,7 +46412,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_233[%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); @@ -45723,77 +46429,9 @@ _loop0_231_rule(Parser *p) return _seq; } -// _loop0_232: lambda_param_no_default +// _loop0_234: lambda_param_no_default static asdl_seq * -_loop0_232_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> _loop0_232[%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 _loop0_232[%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) { - 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_233: lambda_param_no_default -static asdl_seq * -_loop0_233_rule(Parser *p) +_loop0_234_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45819,7 +46457,7 @@ _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, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_234[%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 @@ -45842,7 +46480,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_234[%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); @@ -45859,9 +46497,77 @@ _loop0_233_rule(Parser *p) return _seq; } -// _loop0_235: ',' lambda_param +// _loop0_235: lambda_param_no_default static asdl_seq * _loop0_235_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> _loop0_235[%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 _loop0_235[%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) { + 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_237: ',' lambda_param +static asdl_seq * +_loop0_237_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45887,7 +46593,7 @@ _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, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_237[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -45919,7 +46625,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_237[%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); @@ -45936,9 +46642,9 @@ _loop0_235_rule(Parser *p) return _seq; } -// _gather_234: lambda_param _loop0_235 +// _gather_236: lambda_param _loop0_237 static asdl_seq * -_gather_234_rule(Parser *p) +_gather_236_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45950,27 +46656,27 @@ _gather_234_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_235 + { // lambda_param _loop0_237 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, "lambda_param _loop0_235")); + D(fprintf(stderr, "%*c> _gather_236[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_237")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_235_rule(p)) // _loop0_235 + (seq = _loop0_237_rule(p)) // _loop0_237 ) { - D(fprintf(stderr, "%*c+ _gather_234[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_235")); + D(fprintf(stderr, "%*c+ _gather_236[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_237")); _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, "lambda_param _loop0_235")); + 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, "lambda_param _loop0_237")); } _res = NULL; done: @@ -45978,9 +46684,9 @@ _gather_234_rule(Parser *p) return _res; } -// _tmp_236: lambda_slash_no_default | lambda_slash_with_default +// _tmp_238: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_236_rule(Parser *p) +_tmp_238_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45997,18 +46703,18 @@ _tmp_236_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_236[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_238[%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_236[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_238[%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_236[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_238[%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 @@ -46016,18 +46722,18 @@ _tmp_236_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_236[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_238[%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_236[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_238[%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_236[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_238[%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; @@ -46036,9 +46742,9 @@ _tmp_236_rule(Parser *p) return _res; } -// _loop0_237: lambda_param_maybe_default +// _loop0_239: lambda_param_maybe_default static asdl_seq * -_loop0_237_rule(Parser *p) +_loop0_239_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46064,7 +46770,7 @@ _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, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_239[%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 @@ -46087,7 +46793,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_239[%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); @@ -46104,9 +46810,9 @@ _loop0_237_rule(Parser *p) return _seq; } -// _tmp_238: ',' | lambda_param_no_default +// _tmp_240: ',' | lambda_param_no_default static void * -_tmp_238_rule(Parser *p) +_tmp_240_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46123,18 +46829,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, "','")); + D(fprintf(stderr, "%*c> _tmp_240[%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_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_240[%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_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_240[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // lambda_param_no_default @@ -46142,18 +46848,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, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_240[%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_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_240[%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_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_240[%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; @@ -46162,9 +46868,9 @@ _tmp_238_rule(Parser *p) return _res; } -// _loop0_239: lambda_param_maybe_default +// _loop0_241: lambda_param_maybe_default static asdl_seq * -_loop0_239_rule(Parser *p) +_loop0_241_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46190,7 +46896,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, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_241[%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 @@ -46213,7 +46919,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_241[%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); @@ -46230,9 +46936,9 @@ _loop0_239_rule(Parser *p) return _seq; } -// _loop1_240: lambda_param_maybe_default +// _loop1_242: lambda_param_maybe_default static asdl_seq * -_loop1_240_rule(Parser *p) +_loop1_242_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46258,7 +46964,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, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_242[%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 @@ -46281,7 +46987,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_242[%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) { @@ -46303,9 +47009,9 @@ _loop1_240_rule(Parser *p) return _seq; } -// _loop1_241: lambda_param_with_default +// _loop1_243: lambda_param_with_default static asdl_seq * -_loop1_241_rule(Parser *p) +_loop1_243_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46331,7 +47037,7 @@ _loop1_241_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_241[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_243[%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 @@ -46354,7 +47060,7 @@ _loop1_241_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_241[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_243[%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) { @@ -46376,9 +47082,9 @@ _loop1_241_rule(Parser *p) return _seq; } -// _tmp_242: ':' | ',' (':' | '**') +// _tmp_244: ':' | ',' (':' | '**') static void * -_tmp_242_rule(Parser *p) +_tmp_244_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46395,18 +47101,18 @@ _tmp_242_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_242[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_244[%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_242[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_244[%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_242[%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, "':'")); } { // ',' (':' | '**') @@ -46414,21 +47120,21 @@ _tmp_242_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_242[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); + D(fprintf(stderr, "%*c> _tmp_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); Token * _literal; - void *_tmp_334_var; + void *_tmp_336_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_334_var = _tmp_334_rule(p)) // ':' | '**' + (_tmp_336_var = _tmp_336_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_242[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_334_var); + D(fprintf(stderr, "%*c+ _tmp_244[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_336_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_242[%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, "',' (':' | '**')")); } _res = NULL; @@ -46437,9 +47143,9 @@ _tmp_242_rule(Parser *p) return _res; } -// _tmp_243: lambda_param_no_default | ',' +// _tmp_245: lambda_param_no_default | ',' static void * -_tmp_243_rule(Parser *p) +_tmp_245_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46456,18 +47162,18 @@ _tmp_243_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_243[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_245[%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_243[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_245[%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_243[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_245[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } { // ',' @@ -46475,18 +47181,18 @@ _tmp_243_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_243[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_245[%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_243[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_245[%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_243[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_245[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -46495,9 +47201,9 @@ _tmp_243_rule(Parser *p) return _res; } -// _loop0_244: lambda_param_maybe_default +// _loop0_246: lambda_param_maybe_default static asdl_seq * -_loop0_244_rule(Parser *p) +_loop0_246_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46523,7 +47229,7 @@ _loop0_244_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_246[%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 @@ -46546,7 +47252,7 @@ _loop0_244_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_244[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_246[%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); @@ -46563,9 +47269,9 @@ _loop0_244_rule(Parser *p) return _seq; } -// _tmp_245: lambda_param_no_default | ',' +// _tmp_247: lambda_param_no_default | ',' static void * -_tmp_245_rule(Parser *p) +_tmp_247_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46582,18 +47288,18 @@ _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, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_247[%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_245[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_247[%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_245[%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, "lambda_param_no_default")); } { // ',' @@ -46601,18 +47307,18 @@ _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, "','")); + D(fprintf(stderr, "%*c> _tmp_247[%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_245[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_247[%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_245[%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, "','")); } _res = NULL; @@ -46621,9 +47327,9 @@ _tmp_245_rule(Parser *p) return _res; } -// _tmp_246: '*' | '**' | '/' +// _tmp_248: '*' | '**' | '/' static void * -_tmp_246_rule(Parser *p) +_tmp_248_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46640,18 +47346,18 @@ _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, "'*'")); + D(fprintf(stderr, "%*c> _tmp_248[%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_246[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_248[%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_246[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*'")); } { // '**' @@ -46659,18 +47365,18 @@ _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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_248[%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_246[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_248[%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_246[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } { // '/' @@ -46678,18 +47384,18 @@ _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, "'/'")); + D(fprintf(stderr, "%*c> _tmp_248[%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_246[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_248[%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_246[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'/'")); } _res = NULL; @@ -46698,9 +47404,9 @@ _tmp_246_rule(Parser *p) return _res; } -// _tmp_247: lambda_sum_slash_no_default | lambda_sum_slash_with_default +// _tmp_249: lambda_sum_slash_no_default | lambda_sum_slash_with_default static void * -_tmp_247_rule(Parser *p) +_tmp_249_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46717,18 +47423,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, "lambda_sum_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); asdl_arg_seq* lambda_sum_slash_no_default_var; if ( (lambda_sum_slash_no_default_var = lambda_sum_slash_no_default_rule(p)) // lambda_sum_slash_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_249[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); _res = lambda_sum_slash_no_default_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_249[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); } { // lambda_sum_slash_with_default @@ -46736,18 +47442,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, "lambda_sum_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); SlashWithDefault* lambda_sum_slash_with_default_var; if ( (lambda_sum_slash_with_default_var = lambda_sum_slash_with_default_rule(p)) // lambda_sum_slash_with_default ) { - D(fprintf(stderr, "%*c+ _tmp_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_249[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); _res = lambda_sum_slash_with_default_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_249[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); } _res = NULL; @@ -46756,9 +47462,9 @@ _tmp_247_rule(Parser *p) return _res; } -// _loop0_248: lambda_sum_param_maybe_default +// _loop0_250: lambda_sum_param_maybe_default static asdl_seq * -_loop0_248_rule(Parser *p) +_loop0_250_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46784,7 +47490,7 @@ _loop0_248_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_248[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_250[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); NameDefaultPair* lambda_sum_param_maybe_default_var; while ( (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default @@ -46807,7 +47513,7 @@ _loop0_248_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_248[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_250[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46824,9 +47530,9 @@ _loop0_248_rule(Parser *p) return _seq; } -// _loop0_249: lambda_sum_param_no_default +// _loop0_251: lambda_sum_param_no_default static asdl_seq * -_loop0_249_rule(Parser *p) +_loop0_251_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46852,7 +47558,7 @@ _loop0_249_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_251[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); arg_ty lambda_sum_param_no_default_var; while ( (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default @@ -46875,7 +47581,7 @@ _loop0_249_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_249[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_251[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46892,9 +47598,9 @@ _loop0_249_rule(Parser *p) return _seq; } -// _loop0_250: lambda_sum_param_no_default +// _loop0_252: lambda_sum_param_no_default static asdl_seq * -_loop0_250_rule(Parser *p) +_loop0_252_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46920,7 +47626,7 @@ _loop0_250_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_250[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_252[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); arg_ty lambda_sum_param_no_default_var; while ( (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default @@ -46943,7 +47649,7 @@ _loop0_250_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_250[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_252[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46960,9 +47666,9 @@ _loop0_250_rule(Parser *p) return _seq; } -// _loop0_252: ',' lambda_param +// _loop0_254: ',' lambda_param static asdl_seq * -_loop0_252_rule(Parser *p) +_loop0_254_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46988,7 +47694,7 @@ _loop0_252_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_252[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_254[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -47020,7 +47726,7 @@ _loop0_252_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_252[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_254[%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); @@ -47037,9 +47743,9 @@ _loop0_252_rule(Parser *p) return _seq; } -// _gather_251: lambda_param _loop0_252 +// _gather_253: lambda_param _loop0_254 static asdl_seq * -_gather_251_rule(Parser *p) +_gather_253_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47051,27 +47757,27 @@ _gather_251_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_252 + { // lambda_param _loop0_254 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_251[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_252")); + D(fprintf(stderr, "%*c> _gather_253[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_254")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_252_rule(p)) // _loop0_252 + (seq = _loop0_254_rule(p)) // _loop0_254 ) { - D(fprintf(stderr, "%*c+ _gather_251[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_252")); + D(fprintf(stderr, "%*c+ _gather_253[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_254")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_251[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_252")); + D(fprintf(stderr, "%*c%s _gather_253[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_254")); } _res = NULL; done: @@ -47079,9 +47785,9 @@ _gather_251_rule(Parser *p) return _res; } -// _tmp_253: lambda_sum_slash_no_default | lambda_sum_slash_with_default +// _tmp_255: lambda_sum_slash_no_default | lambda_sum_slash_with_default static void * -_tmp_253_rule(Parser *p) +_tmp_255_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47098,18 +47804,18 @@ _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, "lambda_sum_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_255[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); asdl_arg_seq* lambda_sum_slash_no_default_var; if ( (lambda_sum_slash_no_default_var = lambda_sum_slash_no_default_rule(p)) // lambda_sum_slash_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_253[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_255[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); _res = lambda_sum_slash_no_default_var; 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_255[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); } { // lambda_sum_slash_with_default @@ -47117,18 +47823,18 @@ _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, "lambda_sum_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_255[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); SlashWithDefault* lambda_sum_slash_with_default_var; if ( (lambda_sum_slash_with_default_var = lambda_sum_slash_with_default_rule(p)) // lambda_sum_slash_with_default ) { - D(fprintf(stderr, "%*c+ _tmp_253[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_255[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); _res = lambda_sum_slash_with_default_var; 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_255[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); } _res = NULL; @@ -47137,9 +47843,9 @@ _tmp_253_rule(Parser *p) return _res; } -// _loop0_254: lambda_sum_param_maybe_default +// _loop0_256: lambda_sum_param_maybe_default static asdl_seq * -_loop0_254_rule(Parser *p) +_loop0_256_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47165,7 +47871,7 @@ _loop0_254_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_254[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_256[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); NameDefaultPair* lambda_sum_param_maybe_default_var; while ( (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default @@ -47188,7 +47894,7 @@ _loop0_254_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_254[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_256[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -47205,9 +47911,9 @@ _loop0_254_rule(Parser *p) return _seq; } -// _tmp_255: ',' | lambda_sum_param_no_default +// _tmp_257: ',' | lambda_sum_param_no_default static void * -_tmp_255_rule(Parser *p) +_tmp_257_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47224,18 +47930,18 @@ _tmp_255_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_255[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_257[%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_255[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_257[%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_255[%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, "','")); } { // lambda_sum_param_no_default @@ -47243,18 +47949,18 @@ _tmp_255_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_255[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); arg_ty lambda_sum_param_no_default_var; if ( (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_255[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_257[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); _res = lambda_sum_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_255[%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, "lambda_sum_param_no_default")); } _res = NULL; @@ -47263,9 +47969,9 @@ _tmp_255_rule(Parser *p) return _res; } -// _loop0_256: lambda_sum_param_maybe_default +// _loop0_258: lambda_sum_param_maybe_default static asdl_seq * -_loop0_256_rule(Parser *p) +_loop0_258_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47291,7 +47997,7 @@ _loop0_256_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_256[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_258[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); NameDefaultPair* lambda_sum_param_maybe_default_var; while ( (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default @@ -47314,7 +48020,7 @@ _loop0_256_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_256[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_258[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -47331,9 +48037,9 @@ _loop0_256_rule(Parser *p) return _seq; } -// _loop1_257: lambda_sum_param_maybe_default +// _loop1_259: lambda_sum_param_maybe_default static asdl_seq * -_loop1_257_rule(Parser *p) +_loop1_259_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47359,7 +48065,7 @@ _loop1_257_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_259[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); NameDefaultPair* lambda_sum_param_maybe_default_var; while ( (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default @@ -47382,7 +48088,7 @@ _loop1_257_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_257[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_259[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -47404,9 +48110,9 @@ _loop1_257_rule(Parser *p) return _seq; } -// _loop1_258: lambda_sum_param_with_default +// _loop1_260: lambda_sum_param_with_default static asdl_seq * -_loop1_258_rule(Parser *p) +_loop1_260_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47432,7 +48138,7 @@ _loop1_258_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_258[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_260[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); NameDefaultPair* lambda_sum_param_with_default_var; while ( (lambda_sum_param_with_default_var = lambda_sum_param_with_default_rule(p)) // lambda_sum_param_with_default @@ -47455,7 +48161,7 @@ _loop1_258_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_258[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_260[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -47477,9 +48183,9 @@ _loop1_258_rule(Parser *p) return _seq; } -// _tmp_259: '|' | ',' ('|' | '**') +// _tmp_261: '|' | ',' ('|' | '**') static void * -_tmp_259_rule(Parser *p) +_tmp_261_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47496,18 +48202,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, "'|'")); + D(fprintf(stderr, "%*c> _tmp_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 18)) // token='|' ) { - D(fprintf(stderr, "%*c+ _tmp_259[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + D(fprintf(stderr, "%*c+ _tmp_261[%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_259[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_261[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|'")); } { // ',' ('|' | '**') @@ -47515,21 +48221,21 @@ _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, "',' ('|' | '**')")); + D(fprintf(stderr, "%*c> _tmp_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); Token * _literal; - void *_tmp_335_var; + void *_tmp_337_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_335_var = _tmp_335_rule(p)) // '|' | '**' + (_tmp_337_var = _tmp_337_rule(p)) // '|' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_259[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_335_var); + D(fprintf(stderr, "%*c+ _tmp_261[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_337_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_261[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); } _res = NULL; @@ -47538,9 +48244,9 @@ _tmp_259_rule(Parser *p) return _res; } -// _tmp_260: lambda_sum_param_no_default | ',' +// _tmp_262: lambda_sum_param_no_default | ',' static void * -_tmp_260_rule(Parser *p) +_tmp_262_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47557,18 +48263,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, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_262[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); arg_ty lambda_sum_param_no_default_var; if ( (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_260[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); _res = lambda_sum_param_no_default_var; 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_262[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } { // ',' @@ -47576,18 +48282,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_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_260[%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_260[%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; @@ -47596,9 +48302,9 @@ _tmp_260_rule(Parser *p) return _res; } -// _loop0_261: lambda_sum_param_maybe_default +// _loop0_263: lambda_sum_param_maybe_default static asdl_seq * -_loop0_261_rule(Parser *p) +_loop0_263_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47624,7 +48330,7 @@ _loop0_261_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_263[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); NameDefaultPair* lambda_sum_param_maybe_default_var; while ( (lambda_sum_param_maybe_default_var = lambda_sum_param_maybe_default_rule(p)) // lambda_sum_param_maybe_default @@ -47647,7 +48353,7 @@ _loop0_261_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_261[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_263[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -47664,9 +48370,9 @@ _loop0_261_rule(Parser *p) return _seq; } -// _tmp_262: lambda_sum_param_no_default | ',' +// _tmp_264: lambda_sum_param_no_default | ',' static void * -_tmp_262_rule(Parser *p) +_tmp_264_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47683,18 +48389,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, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); arg_ty lambda_sum_param_no_default_var; if ( (lambda_sum_param_no_default_var = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); _res = lambda_sum_param_no_default_var; 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_264[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } { // ',' @@ -47702,18 +48408,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_264[%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_262[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_264[%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_264[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -47722,9 +48428,9 @@ _tmp_262_rule(Parser *p) return _res; } -// _tmp_263: ',' | ')' | ':' +// _tmp_265: ',' | ')' | ':' static void * -_tmp_263_rule(Parser *p) +_tmp_265_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47741,18 +48447,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, "','")); + D(fprintf(stderr, "%*c> _tmp_265[%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_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_265[%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_263[%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, "','")); } { // ')' @@ -47760,18 +48466,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, "')'")); + D(fprintf(stderr, "%*c> _tmp_265[%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_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_265[%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_263[%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, "')'")); } { // ':' @@ -47779,18 +48485,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_265[%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_263[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_265[%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_263[%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, "':'")); } _res = NULL; @@ -47799,9 +48505,9 @@ _tmp_263_rule(Parser *p) return _res; } -// _loop0_265: ',' dotted_name +// _loop0_267: ',' dotted_name static asdl_seq * -_loop0_265_rule(Parser *p) +_loop0_267_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47827,7 +48533,7 @@ _loop0_265_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_267[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -47859,7 +48565,7 @@ _loop0_265_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_265[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_267[%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); @@ -47876,9 +48582,9 @@ _loop0_265_rule(Parser *p) return _seq; } -// _gather_264: dotted_name _loop0_265 +// _gather_266: dotted_name _loop0_267 static asdl_seq * -_gather_264_rule(Parser *p) +_gather_266_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47890,27 +48596,27 @@ _gather_264_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_265 + { // dotted_name _loop0_267 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_265")); + D(fprintf(stderr, "%*c> _gather_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_267")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_265_rule(p)) // _loop0_265 + (seq = _loop0_267_rule(p)) // _loop0_267 ) { - D(fprintf(stderr, "%*c+ _gather_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_265")); + D(fprintf(stderr, "%*c+ _gather_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_267")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_264[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_name _loop0_265")); + D(fprintf(stderr, "%*c%s _gather_266[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_name _loop0_267")); } _res = NULL; done: @@ -47918,9 +48624,9 @@ _gather_264_rule(Parser *p) return _res; } -// _loop0_267: ',' (expression ['as' star_target]) +// _loop0_269: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_267_rule(Parser *p) +_loop0_269_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47946,13 +48652,13 @@ _loop0_267_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_267[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_269[%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_336_rule(p)) // expression ['as' star_target] + (elem = _tmp_338_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -47978,7 +48684,7 @@ _loop0_267_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_267[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_269[%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); @@ -47995,9 +48701,9 @@ _loop0_267_rule(Parser *p) return _seq; } -// _gather_266: (expression ['as' star_target]) _loop0_267 +// _gather_268: (expression ['as' star_target]) _loop0_269 static asdl_seq * -_gather_266_rule(Parser *p) +_gather_268_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48009,27 +48715,27 @@ _gather_266_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_267 + { // (expression ['as' star_target]) _loop0_269 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_266[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_267")); + D(fprintf(stderr, "%*c> _gather_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_269")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_336_rule(p)) // expression ['as' star_target] + (elem = _tmp_338_rule(p)) // expression ['as' star_target] && - (seq = _loop0_267_rule(p)) // _loop0_267 + (seq = _loop0_269_rule(p)) // _loop0_269 ) { - D(fprintf(stderr, "%*c+ _gather_266[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_267")); + D(fprintf(stderr, "%*c+ _gather_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_269")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_266[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_267")); + D(fprintf(stderr, "%*c%s _gather_268[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_269")); } _res = NULL; done: @@ -48037,9 +48743,9 @@ _gather_266_rule(Parser *p) return _res; } -// _loop0_269: ',' (expressions ['as' star_target]) +// _loop0_271: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_269_rule(Parser *p) +_loop0_271_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48065,13 +48771,13 @@ _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, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_271[%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_337_rule(p)) // expressions ['as' star_target] + (elem = _tmp_339_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -48097,7 +48803,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_271[%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); @@ -48114,9 +48820,9 @@ _loop0_269_rule(Parser *p) return _seq; } -// _gather_268: (expressions ['as' star_target]) _loop0_269 +// _gather_270: (expressions ['as' star_target]) _loop0_271 static asdl_seq * -_gather_268_rule(Parser *p) +_gather_270_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48128,27 +48834,27 @@ _gather_268_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_269 + { // (expressions ['as' star_target]) _loop0_271 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_269")); + D(fprintf(stderr, "%*c> _gather_270[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_271")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_337_rule(p)) // expressions ['as' star_target] + (elem = _tmp_339_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_269_rule(p)) // _loop0_269 + (seq = _loop0_271_rule(p)) // _loop0_271 ) { - D(fprintf(stderr, "%*c+ _gather_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_269")); + D(fprintf(stderr, "%*c+ _gather_270[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_271")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_268[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_269")); + D(fprintf(stderr, "%*c%s _gather_270[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_271")); } _res = NULL; done: @@ -48156,9 +48862,9 @@ _gather_268_rule(Parser *p) return _res; } -// _loop0_271: ',' (expression ['as' star_target]) +// _loop0_273: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_271_rule(Parser *p) +_loop0_273_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48184,13 +48890,13 @@ _loop0_271_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_271[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_273[%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_338_rule(p)) // expression ['as' star_target] + (elem = _tmp_340_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -48216,7 +48922,7 @@ _loop0_271_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_271[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_273[%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); @@ -48233,9 +48939,9 @@ _loop0_271_rule(Parser *p) return _seq; } -// _gather_270: (expression ['as' star_target]) _loop0_271 +// _gather_272: (expression ['as' star_target]) _loop0_273 static asdl_seq * -_gather_270_rule(Parser *p) +_gather_272_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48247,27 +48953,27 @@ _gather_270_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_271 + { // (expression ['as' star_target]) _loop0_273 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_270[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_271")); + D(fprintf(stderr, "%*c> _gather_272[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_273")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_338_rule(p)) // expression ['as' star_target] + (elem = _tmp_340_rule(p)) // expression ['as' star_target] && - (seq = _loop0_271_rule(p)) // _loop0_271 + (seq = _loop0_273_rule(p)) // _loop0_273 ) { - D(fprintf(stderr, "%*c+ _gather_270[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_271")); + D(fprintf(stderr, "%*c+ _gather_272[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_273")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_270[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_271")); + D(fprintf(stderr, "%*c%s _gather_272[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_273")); } _res = NULL; done: @@ -48275,9 +48981,9 @@ _gather_270_rule(Parser *p) return _res; } -// _loop0_273: ',' (expressions ['as' star_target]) +// _loop0_275: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_273_rule(Parser *p) +_loop0_275_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48303,13 +49009,13 @@ _loop0_273_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_273[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_275[%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_339_rule(p)) // expressions ['as' star_target] + (elem = _tmp_341_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -48335,7 +49041,7 @@ _loop0_273_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_273[%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, "',' (expressions ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -48352,9 +49058,9 @@ _loop0_273_rule(Parser *p) return _seq; } -// _gather_272: (expressions ['as' star_target]) _loop0_273 +// _gather_274: (expressions ['as' star_target]) _loop0_275 static asdl_seq * -_gather_272_rule(Parser *p) +_gather_274_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48366,27 +49072,27 @@ _gather_272_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_273 + { // (expressions ['as' star_target]) _loop0_275 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_272[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_273")); + D(fprintf(stderr, "%*c> _gather_274[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_275")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_339_rule(p)) // expressions ['as' star_target] + (elem = _tmp_341_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_273_rule(p)) // _loop0_273 + (seq = _loop0_275_rule(p)) // _loop0_275 ) { - D(fprintf(stderr, "%*c+ _gather_272[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_273")); + D(fprintf(stderr, "%*c+ _gather_274[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_275")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_272[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_273")); + D(fprintf(stderr, "%*c%s _gather_274[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_275")); } _res = NULL; done: @@ -48394,9 +49100,9 @@ _gather_272_rule(Parser *p) return _res; } -// _tmp_274: 'except' | 'finally' +// _tmp_276: 'except' | 'finally' static void * -_tmp_274_rule(Parser *p) +_tmp_276_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48413,18 +49119,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, "'except'")); + D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 701)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_274[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_276[%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_274[%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, "'except'")); } { // 'finally' @@ -48432,18 +49138,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, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 697)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_274[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_276[%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_274[%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, "'finally'")); } _res = NULL; @@ -48452,9 +49158,9 @@ _tmp_274_rule(Parser *p) return _res; } -// _loop0_275: block +// _loop0_277: block static asdl_seq * -_loop0_275_rule(Parser *p) +_loop0_277_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48480,7 +49186,7 @@ _loop0_275_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_275[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c> _loop0_277[%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 @@ -48503,7 +49209,7 @@ _loop0_275_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_275[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_277[%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); @@ -48520,9 +49226,9 @@ _loop0_275_rule(Parser *p) return _seq; } -// _loop1_276: except_block +// _loop1_278: except_block static asdl_seq * -_loop1_276_rule(Parser *p) +_loop1_278_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48548,7 +49254,7 @@ _loop1_276_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); + D(fprintf(stderr, "%*c> _loop1_278[%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 @@ -48571,7 +49277,7 @@ _loop1_276_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_276[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_278[%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) { @@ -48593,9 +49299,9 @@ _loop1_276_rule(Parser *p) return _seq; } -// _tmp_277: 'as' NAME +// _tmp_279: 'as' NAME static void * -_tmp_277_rule(Parser *p) +_tmp_279_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48612,7 +49318,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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_279[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( @@ -48621,12 +49327,12 @@ _tmp_277_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_277[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_279[%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_277[%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, "'as' NAME")); } _res = NULL; @@ -48635,9 +49341,9 @@ _tmp_277_rule(Parser *p) return _res; } -// _loop0_278: block +// _loop0_280: block static asdl_seq * -_loop0_278_rule(Parser *p) +_loop0_280_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48663,7 +49369,7 @@ _loop0_278_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_278[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c> _loop0_280[%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 @@ -48686,7 +49392,7 @@ _loop0_278_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_278[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_280[%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); @@ -48703,9 +49409,9 @@ _loop0_278_rule(Parser *p) return _seq; } -// _loop1_279: except_star_block +// _loop1_281: except_star_block static asdl_seq * -_loop1_279_rule(Parser *p) +_loop1_281_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48731,7 +49437,7 @@ _loop1_279_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_279[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); + D(fprintf(stderr, "%*c> _loop1_281[%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 @@ -48754,7 +49460,7 @@ _loop1_279_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_279[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_281[%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) { @@ -48776,9 +49482,9 @@ _loop1_279_rule(Parser *p) return _seq; } -// _tmp_280: expression ['as' NAME] +// _tmp_282: expression ['as' NAME] static void * -_tmp_280_rule(Parser *p) +_tmp_282_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48795,22 +49501,22 @@ _tmp_280_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_280[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_282[%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_340_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_342_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_280[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_282[%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_280[%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, "expression ['as' NAME]")); } _res = NULL; @@ -48819,9 +49525,9 @@ _tmp_280_rule(Parser *p) return _res; } -// _tmp_281: 'as' NAME +// _tmp_283: 'as' NAME static void * -_tmp_281_rule(Parser *p) +_tmp_283_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48838,7 +49544,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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_283[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( @@ -48847,12 +49553,12 @@ _tmp_281_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_281[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_283[%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_281[%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, "'as' NAME")); } _res = NULL; @@ -48861,9 +49567,9 @@ _tmp_281_rule(Parser *p) return _res; } -// _tmp_282: 'as' NAME +// _tmp_284: 'as' NAME static void * -_tmp_282_rule(Parser *p) +_tmp_284_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48880,7 +49586,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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_284[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( @@ -48889,12 +49595,12 @@ _tmp_282_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_282[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_284[%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_282[%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, "'as' NAME")); } _res = NULL; @@ -48903,9 +49609,9 @@ _tmp_282_rule(Parser *p) return _res; } -// _tmp_283: NEWLINE | ':' +// _tmp_285: NEWLINE | ':' static void * -_tmp_283_rule(Parser *p) +_tmp_285_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48922,18 +49628,18 @@ _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, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_285[%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_283[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_285[%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_283[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_285[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE")); } { // ':' @@ -48941,18 +49647,18 @@ _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, "':'")); + D(fprintf(stderr, "%*c> _tmp_285[%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_283[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_285[%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_283[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_285[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -48961,9 +49667,9 @@ _tmp_283_rule(Parser *p) return _res; } -// _tmp_284: 'as' NAME +// _tmp_286: 'as' NAME static void * -_tmp_284_rule(Parser *p) +_tmp_286_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48980,7 +49686,7 @@ _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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_286[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( @@ -48989,12 +49695,12 @@ _tmp_284_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_284[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_286[%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_284[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_286[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -49003,9 +49709,9 @@ _tmp_284_rule(Parser *p) return _res; } -// _tmp_285: 'as' NAME +// _tmp_287: 'as' NAME static void * -_tmp_285_rule(Parser *p) +_tmp_287_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49022,7 +49728,7 @@ _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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_287[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( @@ -49031,12 +49737,12 @@ _tmp_285_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_285[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_287[%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_285[%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, "'as' NAME")); } _res = NULL; @@ -49045,9 +49751,9 @@ _tmp_285_rule(Parser *p) return _res; } -// _tmp_286: positional_patterns ',' +// _tmp_288: positional_patterns ',' static void * -_tmp_286_rule(Parser *p) +_tmp_288_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49064,7 +49770,7 @@ _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, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_288[%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 ( @@ -49073,12 +49779,12 @@ _tmp_286_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_286[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_288[%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_286[%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, "positional_patterns ','")); } _res = NULL; @@ -49087,9 +49793,9 @@ _tmp_286_rule(Parser *p) return _res; } -// _tmp_287: '->' expression +// _tmp_289: '->' expression static void * -_tmp_287_rule(Parser *p) +_tmp_289_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49106,7 +49812,7 @@ _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, "'->' expression")); + D(fprintf(stderr, "%*c> _tmp_289[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); Token * _literal; expr_ty expression_var; if ( @@ -49115,12 +49821,12 @@ _tmp_287_rule(Parser *p) (expression_var = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_287[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c+ _tmp_289[%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_287[%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, "'->' expression")); } _res = NULL; @@ -49129,9 +49835,9 @@ _tmp_287_rule(Parser *p) return _res; } -// _tmp_288: '(' arguments? ')' +// _tmp_290: '(' arguments? ')' static void * -_tmp_288_rule(Parser *p) +_tmp_290_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49148,7 +49854,7 @@ _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, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *_opt_var; @@ -49161,12 +49867,12 @@ _tmp_288_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_288[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_290[%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_288[%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, "'(' arguments? ')'")); } _res = NULL; @@ -49175,9 +49881,9 @@ _tmp_288_rule(Parser *p) return _res; } -// _tmp_289: '(' arguments? ')' +// _tmp_291: '(' arguments? ')' static void * -_tmp_289_rule(Parser *p) +_tmp_291_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49194,7 +49900,7 @@ _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, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_291[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *_opt_var; @@ -49207,12 +49913,12 @@ _tmp_289_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_289[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_291[%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_289[%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, "'(' arguments? ')'")); } _res = NULL; @@ -49221,9 +49927,9 @@ _tmp_289_rule(Parser *p) return _res; } -// _loop0_291: ',' double_starred_kvpair +// _loop0_293: ',' double_starred_kvpair static asdl_seq * -_loop0_291_rule(Parser *p) +_loop0_293_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49249,7 +49955,7 @@ _loop0_291_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_291[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_293[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -49281,7 +49987,7 @@ _loop0_291_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_291[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_293[%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); @@ -49298,9 +50004,9 @@ _loop0_291_rule(Parser *p) return _seq; } -// _gather_290: double_starred_kvpair _loop0_291 +// _gather_292: double_starred_kvpair _loop0_293 static asdl_seq * -_gather_290_rule(Parser *p) +_gather_292_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49312,27 +50018,27 @@ _gather_290_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_291 + { // double_starred_kvpair _loop0_293 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_291")); + D(fprintf(stderr, "%*c> _gather_292[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_293")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_291_rule(p)) // _loop0_291 + (seq = _loop0_293_rule(p)) // _loop0_293 ) { - D(fprintf(stderr, "%*c+ _gather_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_291")); + D(fprintf(stderr, "%*c+ _gather_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_293")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_290[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_291")); + D(fprintf(stderr, "%*c%s _gather_292[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_293")); } _res = NULL; done: @@ -49340,9 +50046,9 @@ _gather_290_rule(Parser *p) return _res; } -// _tmp_292: '}' | ',' +// _tmp_294: '}' | ',' static void * -_tmp_292_rule(Parser *p) +_tmp_294_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49359,18 +50065,18 @@ _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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_294[%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_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_294[%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, ' ', + 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, "'}'")); } { // ',' @@ -49378,18 +50084,18 @@ _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, "','")); + D(fprintf(stderr, "%*c> _tmp_294[%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_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_294[%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, ' ', + 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, "','")); } _res = NULL; @@ -49398,9 +50104,9 @@ _tmp_292_rule(Parser *p) return _res; } -// _tmp_293: '}' | ',' +// _tmp_295: '}' | ',' static void * -_tmp_293_rule(Parser *p) +_tmp_295_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49417,18 +50123,18 @@ _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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_295[%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_293[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_295[%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, ' ', + 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, "'}'")); } { // ',' @@ -49436,18 +50142,18 @@ _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, "','")); + D(fprintf(stderr, "%*c> _tmp_295[%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_293[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_295[%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, ' ', + 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, "','")); } _res = NULL; @@ -49456,9 +50162,9 @@ _tmp_293_rule(Parser *p) return _res; } -// _tmp_294: yield_expr | star_expressions +// _tmp_296: yield_expr | star_expressions static void * -_tmp_294_rule(Parser *p) +_tmp_296_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49475,18 +50181,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_296[%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_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_296[%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_294[%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, "yield_expr")); } { // star_expressions @@ -49494,18 +50200,18 @@ _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_expressions")); + D(fprintf(stderr, "%*c> _tmp_296[%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_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_296[%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_294[%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, "star_expressions")); } _res = NULL; @@ -49514,9 +50220,9 @@ _tmp_294_rule(Parser *p) return _res; } -// _tmp_295: yield_expr | star_expressions +// _tmp_297: yield_expr | star_expressions static void * -_tmp_295_rule(Parser *p) +_tmp_297_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49533,18 +50239,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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_297[%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_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_297[%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_295[%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, "yield_expr")); } { // star_expressions @@ -49552,18 +50258,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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_297[%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_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_297[%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_295[%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, "star_expressions")); } _res = NULL; @@ -49572,9 +50278,9 @@ _tmp_295_rule(Parser *p) return _res; } -// _tmp_296: '=' | '!' | ':' | '}' +// _tmp_298: '=' | '!' | ':' | '}' static void * -_tmp_296_rule(Parser *p) +_tmp_298_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49591,18 +50297,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_298[%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_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_298[%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_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } { // '!' @@ -49610,18 +50316,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_298[%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_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_298[%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_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!'")); } { // ':' @@ -49629,18 +50335,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_298[%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_298[%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_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '}' @@ -49648,18 +50354,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_298[%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_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_298[%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_298[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } _res = NULL; @@ -49668,9 +50374,9 @@ _tmp_296_rule(Parser *p) return _res; } -// _tmp_297: yield_expr | star_expressions +// _tmp_299: yield_expr | star_expressions static void * -_tmp_297_rule(Parser *p) +_tmp_299_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49687,18 +50393,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_299[%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_297[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_299[%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_297[%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, "yield_expr")); } { // star_expressions @@ -49706,18 +50412,18 @@ _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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_299[%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_297[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_299[%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_297[%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_expressions")); } _res = NULL; @@ -49726,9 +50432,9 @@ _tmp_297_rule(Parser *p) return _res; } -// _tmp_298: '!' | ':' | '}' +// _tmp_300: '!' | ':' | '}' static void * -_tmp_298_rule(Parser *p) +_tmp_300_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49745,18 +50451,18 @@ _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, "'!'")); + D(fprintf(stderr, "%*c> _tmp_300[%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_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_300[%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_298[%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, "'!'")); } { // ':' @@ -49764,18 +50470,18 @@ _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, "':'")); + D(fprintf(stderr, "%*c> _tmp_300[%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_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_300[%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_298[%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, "':'")); } { // '}' @@ -49783,18 +50489,18 @@ _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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_300[%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_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_300[%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_298[%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, "'}'")); } _res = NULL; @@ -49803,9 +50509,9 @@ _tmp_298_rule(Parser *p) return _res; } -// _tmp_299: yield_expr | star_expressions +// _tmp_301: yield_expr | star_expressions static void * -_tmp_299_rule(Parser *p) +_tmp_301_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49822,18 +50528,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_301[%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_299[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_301[%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_299[%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, "yield_expr")); } { // star_expressions @@ -49841,18 +50547,18 @@ _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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_301[%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_299[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_301[%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_299[%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_expressions")); } _res = NULL; @@ -49861,9 +50567,9 @@ _tmp_299_rule(Parser *p) return _res; } -// _tmp_300: yield_expr | star_expressions +// _tmp_302: yield_expr | star_expressions static void * -_tmp_300_rule(Parser *p) +_tmp_302_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49880,18 +50586,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_302[%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_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_302[%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_300[%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, "yield_expr")); } { // star_expressions @@ -49899,18 +50605,18 @@ _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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_302[%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_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_302[%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_300[%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_expressions")); } _res = NULL; @@ -49919,9 +50625,9 @@ _tmp_300_rule(Parser *p) return _res; } -// _tmp_301: '!' NAME +// _tmp_303: '!' NAME static void * -_tmp_301_rule(Parser *p) +_tmp_303_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49938,7 +50644,7 @@ _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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_303[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -49947,12 +50653,12 @@ _tmp_301_rule(Parser *p) (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, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_303[%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_301[%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, "'!' NAME")); } _res = NULL; @@ -49961,9 +50667,9 @@ _tmp_301_rule(Parser *p) return _res; } -// _tmp_302: ':' | '}' +// _tmp_304: ':' | '}' static void * -_tmp_302_rule(Parser *p) +_tmp_304_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49980,18 +50686,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, "':'")); + 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_302[%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_302[%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, "':'")); } { // '}' @@ -49999,18 +50705,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, "'}'")); + 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, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_302[%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_302[%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; @@ -50019,9 +50725,9 @@ _tmp_302_rule(Parser *p) return _res; } -// _tmp_303: yield_expr | star_expressions +// _tmp_305: yield_expr | star_expressions static void * -_tmp_303_rule(Parser *p) +_tmp_305_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50038,18 +50744,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_305[%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_303[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_305[%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_303[%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, "yield_expr")); } { // star_expressions @@ -50057,18 +50763,18 @@ _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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_305[%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_303[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_305[%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_303[%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, "star_expressions")); } _res = NULL; @@ -50077,9 +50783,9 @@ _tmp_303_rule(Parser *p) return _res; } -// _tmp_304: '!' NAME +// _tmp_306: '!' NAME static void * -_tmp_304_rule(Parser *p) +_tmp_306_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50096,7 +50802,7 @@ _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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_306[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -50105,12 +50811,12 @@ _tmp_304_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_304[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_306[%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_304[%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, "'!' NAME")); } _res = NULL; @@ -50119,9 +50825,9 @@ _tmp_304_rule(Parser *p) return _res; } -// _loop0_305: fstring_format_spec +// _loop0_307: fstring_format_spec static asdl_seq * -_loop0_305_rule(Parser *p) +_loop0_307_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50147,7 +50853,7 @@ _loop0_305_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_305[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_307[%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 @@ -50170,7 +50876,7 @@ _loop0_305_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_305[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_307[%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); @@ -50187,9 +50893,9 @@ _loop0_305_rule(Parser *p) return _seq; } -// _tmp_306: yield_expr | star_expressions +// _tmp_308: yield_expr | star_expressions static void * -_tmp_306_rule(Parser *p) +_tmp_308_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50206,18 +50912,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_308[%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_306[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_308[%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_306[%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, "yield_expr")); } { // star_expressions @@ -50225,18 +50931,18 @@ _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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_308[%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_306[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_308[%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_306[%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, "star_expressions")); } _res = NULL; @@ -50245,9 +50951,9 @@ _tmp_306_rule(Parser *p) return _res; } -// _tmp_307: '!' NAME +// _tmp_309: '!' NAME static void * -_tmp_307_rule(Parser *p) +_tmp_309_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50264,7 +50970,7 @@ _tmp_307_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_307[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_309[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -50273,12 +50979,12 @@ _tmp_307_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_307[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_309[%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_307[%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, "'!' NAME")); } _res = NULL; @@ -50287,9 +50993,9 @@ _tmp_307_rule(Parser *p) return _res; } -// _tmp_308: ':' | '}' +// _tmp_310: ':' | '}' static void * -_tmp_308_rule(Parser *p) +_tmp_310_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50306,18 +51012,18 @@ _tmp_308_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_308[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_310[%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_308[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_310[%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_308[%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, "':'")); } { // '}' @@ -50325,18 +51031,18 @@ _tmp_308_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_308[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_310[%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_308[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_310[%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_308[%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, "'}'")); } _res = NULL; @@ -50345,9 +51051,9 @@ _tmp_308_rule(Parser *p) return _res; } -// _tmp_309: star_targets '=' +// _tmp_311: star_targets '=' static void * -_tmp_309_rule(Parser *p) +_tmp_311_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50364,7 +51070,7 @@ _tmp_309_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_309[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_311[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -50373,7 +51079,7 @@ _tmp_309_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_309[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_311[%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; @@ -50383,7 +51089,7 @@ _tmp_309_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_309[%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, "star_targets '='")); } _res = NULL; @@ -50392,9 +51098,9 @@ _tmp_309_rule(Parser *p) return _res; } -// _tmp_310: yield_expr | star_expressions +// _tmp_312: yield_expr | star_expressions static void * -_tmp_310_rule(Parser *p) +_tmp_312_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50411,18 +51117,18 @@ _tmp_310_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_310[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_312[%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_310[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_312[%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_310[%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, "yield_expr")); } { // star_expressions @@ -50430,18 +51136,18 @@ _tmp_310_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_310[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_312[%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_310[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_312[%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_310[%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, "star_expressions")); } _res = NULL; @@ -50450,9 +51156,9 @@ _tmp_310_rule(Parser *p) return _res; } -// _tmp_311: '.' | '...' +// _tmp_313: '.' | '...' static void * -_tmp_311_rule(Parser *p) +_tmp_313_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50469,18 +51175,18 @@ _tmp_311_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_311[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_313[%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_311[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_313[%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_311[%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, "'.'")); } { // '...' @@ -50488,18 +51194,18 @@ _tmp_311_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_311[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c> _tmp_313[%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_311[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_313[%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_311[%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, "'...'")); } _res = NULL; @@ -50508,9 +51214,9 @@ _tmp_311_rule(Parser *p) return _res; } -// _tmp_312: '.' | '...' +// _tmp_314: '.' | '...' static void * -_tmp_312_rule(Parser *p) +_tmp_314_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50527,18 +51233,18 @@ _tmp_312_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_312[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_314[%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_312[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_314[%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_312[%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, "'.'")); } { // '...' @@ -50546,18 +51252,18 @@ _tmp_312_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_312[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c> _tmp_314[%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_312[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_314[%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_312[%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, "'...'")); } _res = NULL; @@ -50566,9 +51272,9 @@ _tmp_312_rule(Parser *p) return _res; } -// _tmp_313: '@' named_expression NEWLINE +// _tmp_315: '@' named_expression NEWLINE static void * -_tmp_313_rule(Parser *p) +_tmp_315_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50585,7 +51291,7 @@ _tmp_313_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_313[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_315[%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; @@ -50597,7 +51303,7 @@ _tmp_313_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_313[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_315[%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; @@ -50607,7 +51313,7 @@ _tmp_313_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_313[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_315[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); } _res = NULL; @@ -50616,9 +51322,9 @@ _tmp_313_rule(Parser *p) return _res; } -// _tmp_314: bitwiseor_pattern | 'None' +// _tmp_316: bitwiseor_pattern | 'None' static void * -_tmp_314_rule(Parser *p) +_tmp_316_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50644,18 +51350,18 @@ _tmp_314_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_314[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + D(fprintf(stderr, "%*c> _tmp_316[%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_314[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + D(fprintf(stderr, "%*c+ _tmp_316[%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_314[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_316[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); } { // 'None' @@ -50663,13 +51369,13 @@ _tmp_314_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_314[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_316[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 661)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_314[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_316[%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--; @@ -50688,7 +51394,7 @@ _tmp_314_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_314[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_316[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } _res = NULL; @@ -50697,9 +51403,9 @@ _tmp_314_rule(Parser *p) return _res; } -// _loop0_316: ';' simple_stmt +// _loop0_318: ';' simple_stmt static asdl_seq * -_loop0_316_rule(Parser *p) +_loop0_318_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50725,7 +51431,7 @@ _loop0_316_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_316[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + D(fprintf(stderr, "%*c> _loop0_318[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); Token * _literal; stmt_ty elem; while ( @@ -50757,7 +51463,7 @@ _loop0_316_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_316[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_318[%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); @@ -50774,9 +51480,9 @@ _loop0_316_rule(Parser *p) return _seq; } -// _gather_315: simple_stmt _loop0_316 +// _gather_317: simple_stmt _loop0_318 static asdl_seq * -_gather_315_rule(Parser *p) +_gather_317_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50788,27 +51494,27 @@ _gather_315_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // simple_stmt _loop0_316 + { // simple_stmt _loop0_318 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_315[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_316")); + D(fprintf(stderr, "%*c> _gather_317[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_318")); stmt_ty elem; asdl_seq * seq; if ( (elem = simple_stmt_rule(p)) // simple_stmt && - (seq = _loop0_316_rule(p)) // _loop0_316 + (seq = _loop0_318_rule(p)) // _loop0_318 ) { - D(fprintf(stderr, "%*c+ _gather_315[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_316")); + D(fprintf(stderr, "%*c+ _gather_317[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_318")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_315[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_316")); + D(fprintf(stderr, "%*c%s _gather_317[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_318")); } _res = NULL; done: @@ -50816,9 +51522,9 @@ _gather_315_rule(Parser *p) return _res; } -// _tmp_317: ',' expression +// _tmp_319: ',' expression static void * -_tmp_317_rule(Parser *p) +_tmp_319_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50835,7 +51541,7 @@ _tmp_317_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_317[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _tmp_319[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty c; if ( @@ -50844,7 +51550,7 @@ _tmp_317_rule(Parser *p) (c = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_317[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c+ _tmp_319[%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; @@ -50854,7 +51560,7 @@ _tmp_317_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_317[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_319[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } _res = NULL; @@ -50863,9 +51569,9 @@ _tmp_317_rule(Parser *p) return _res; } -// _tmp_318: ',' star_expression +// _tmp_320: ',' star_expression static void * -_tmp_318_rule(Parser *p) +_tmp_320_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50882,7 +51588,7 @@ _tmp_318_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_318[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_320[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -50891,7 +51597,7 @@ _tmp_318_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_318[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_320[%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; @@ -50901,7 +51607,7 @@ _tmp_318_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_318[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_320[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_expression")); } _res = NULL; @@ -50910,9 +51616,9 @@ _tmp_318_rule(Parser *p) return _res; } -// _tmp_319: 'or' conjunction +// _tmp_321: 'or' conjunction static void * -_tmp_319_rule(Parser *p) +_tmp_321_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50929,7 +51635,7 @@ _tmp_319_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_319[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_321[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -50938,7 +51644,7 @@ _tmp_319_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_319[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_321[%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; @@ -50948,7 +51654,7 @@ _tmp_319_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_319[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_321[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'or' conjunction")); } _res = NULL; @@ -50957,9 +51663,9 @@ _tmp_319_rule(Parser *p) return _res; } -// _tmp_320: 'and' inversion +// _tmp_322: 'and' inversion static void * -_tmp_320_rule(Parser *p) +_tmp_322_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50976,7 +51682,7 @@ _tmp_320_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_320[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_322[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -50985,7 +51691,7 @@ _tmp_320_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_320[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_322[%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; @@ -50995,7 +51701,7 @@ _tmp_320_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_320[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_322[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'and' inversion")); } _res = NULL; @@ -51004,9 +51710,9 @@ _tmp_320_rule(Parser *p) return _res; } -// _tmp_321: slice | starred_expression +// _tmp_323: slice | starred_expression static void * -_tmp_321_rule(Parser *p) +_tmp_323_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51023,18 +51729,18 @@ _tmp_321_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_321[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c> _tmp_323[%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_321[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c+ _tmp_323[%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_321[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_323[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slice")); } { // starred_expression @@ -51042,18 +51748,18 @@ _tmp_321_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_321[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_323[%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_321[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_323[%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_321[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_323[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "starred_expression")); } _res = NULL; @@ -51062,9 +51768,9 @@ _tmp_321_rule(Parser *p) return _res; } -// _tmp_322: "def" | '@' | 'async' +// _tmp_324: "def" | '@' | 'async' static void * -_tmp_322_rule(Parser *p) +_tmp_324_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51081,18 +51787,18 @@ _tmp_322_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_322[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c> _tmp_324[%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_322[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c+ _tmp_324[%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_322[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_324[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"def\"")); } { // '@' @@ -51100,18 +51806,18 @@ _tmp_322_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_322[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c> _tmp_324[%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_322[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_324[%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_322[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_324[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } { // 'async' @@ -51119,18 +51825,18 @@ _tmp_322_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_322[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_324[%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_322[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_324[%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_322[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_324[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -51139,9 +51845,9 @@ _tmp_322_rule(Parser *p) return _res; } -// _tmp_323: 'class' | '@' +// _tmp_325: 'class' | '@' static void * -_tmp_323_rule(Parser *p) +_tmp_325_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51158,18 +51864,18 @@ _tmp_323_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_323[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c> _tmp_325[%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_323[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c+ _tmp_325[%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_323[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_325[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); } { // '@' @@ -51177,18 +51883,18 @@ _tmp_323_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_323[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c> _tmp_325[%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_323[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_325[%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_323[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_325[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } _res = NULL; @@ -51197,9 +51903,9 @@ _tmp_323_rule(Parser *p) return _res; } -// _tmp_324: fstring | string +// _tmp_326: fstring | string static void * -_tmp_324_rule(Parser *p) +_tmp_326_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51216,18 +51922,18 @@ _tmp_324_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_324[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); + D(fprintf(stderr, "%*c> _tmp_326[%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_324[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_326[%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_324[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_326[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring")); } { // string @@ -51235,18 +51941,18 @@ _tmp_324_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_324[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); + D(fprintf(stderr, "%*c> _tmp_326[%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_324[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); + D(fprintf(stderr, "%*c+ _tmp_326[%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_324[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_326[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "string")); } _res = NULL; @@ -51255,9 +51961,9 @@ _tmp_324_rule(Parser *p) return _res; } -// _tmp_325: 'if' disjunction +// _tmp_327: 'if' disjunction static void * -_tmp_325_rule(Parser *p) +_tmp_327_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51274,7 +51980,7 @@ _tmp_325_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_325[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_327[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -51283,7 +51989,7 @@ _tmp_325_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_325[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_327[%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; @@ -51293,7 +51999,7 @@ _tmp_325_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_325[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_327[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -51302,9 +52008,9 @@ _tmp_325_rule(Parser *p) return _res; } -// _tmp_326: 'if' disjunction +// _tmp_328: 'if' disjunction static void * -_tmp_326_rule(Parser *p) +_tmp_328_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51321,7 +52027,7 @@ _tmp_326_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_326[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_328[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -51330,7 +52036,7 @@ _tmp_326_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_326[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_328[%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; @@ -51340,7 +52046,7 @@ _tmp_326_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_326[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_328[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -51349,9 +52055,9 @@ _tmp_326_rule(Parser *p) return _res; } -// _tmp_327: 'if' disjunction +// _tmp_329: 'if' disjunction static void * -_tmp_327_rule(Parser *p) +_tmp_329_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51368,7 +52074,7 @@ _tmp_327_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_327[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_329[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( @@ -51377,7 +52083,7 @@ _tmp_327_rule(Parser *p) (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_327[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_329[%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; @@ -51387,7 +52093,7 @@ _tmp_327_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_327[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_329[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -51396,12 +52102,12 @@ _tmp_327_rule(Parser *p) return _res; } -// _tmp_328: +// _tmp_330: // | starred_expression // | simple_slice // | (assignment_expression | expression !':=') !'=' static void * -_tmp_328_rule(Parser *p) +_tmp_330_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51418,18 +52124,18 @@ _tmp_328_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_328[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_330[%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_328[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_330[%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_328[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_330[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "starred_expression")); } { // simple_slice @@ -51437,18 +52143,18 @@ _tmp_328_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_328[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_330[%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_328[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_330[%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_328[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_330[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // (assignment_expression | expression !':=') !'=' @@ -51456,20 +52162,20 @@ _tmp_328_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_328[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); - void *_tmp_341_var; + D(fprintf(stderr, "%*c> _tmp_330[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); + void *_tmp_343_var; if ( - (_tmp_341_var = _tmp_341_rule(p)) // assignment_expression | expression !':=' + (_tmp_343_var = _tmp_343_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_328[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_341_var; + D(fprintf(stderr, "%*c+ _tmp_330[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_343_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_328[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_330[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -51478,9 +52184,9 @@ _tmp_328_rule(Parser *p) return _res; } -// _tmp_329: ',' star_target +// _tmp_331: ',' star_target static void * -_tmp_329_rule(Parser *p) +_tmp_331_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51497,7 +52203,7 @@ _tmp_329_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_329[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_331[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -51506,7 +52212,7 @@ _tmp_329_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_329[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_331[%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; @@ -51516,7 +52222,7 @@ _tmp_329_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_329[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_331[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } _res = NULL; @@ -51525,9 +52231,9 @@ _tmp_329_rule(Parser *p) return _res; } -// _tmp_330: ',' star_target +// _tmp_332: ',' star_target static void * -_tmp_330_rule(Parser *p) +_tmp_332_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51544,7 +52250,7 @@ _tmp_330_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_330[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_332[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -51553,7 +52259,7 @@ _tmp_330_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_330[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_332[%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; @@ -51563,7 +52269,7 @@ _tmp_330_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_330[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_332[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } _res = NULL; @@ -51572,9 +52278,9 @@ _tmp_330_rule(Parser *p) return _res; } -// _tmp_331: star_targets '=' +// _tmp_333: star_targets '=' static void * -_tmp_331_rule(Parser *p) +_tmp_333_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51591,7 +52297,7 @@ _tmp_331_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_331[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_333[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty star_targets_var; if ( @@ -51600,12 +52306,12 @@ _tmp_331_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_331[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_333[%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_331[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_333[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -51614,9 +52320,9 @@ _tmp_331_rule(Parser *p) return _res; } -// _tmp_332: star_targets '=' +// _tmp_334: star_targets '=' static void * -_tmp_332_rule(Parser *p) +_tmp_334_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51633,7 +52339,7 @@ _tmp_332_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_332[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_334[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty star_targets_var; if ( @@ -51642,12 +52348,12 @@ _tmp_332_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_332[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_334[%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_332[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_334[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -51656,9 +52362,9 @@ _tmp_332_rule(Parser *p) return _res; } -// _tmp_333: ')' | '**' +// _tmp_335: ')' | '**' static void * -_tmp_333_rule(Parser *p) +_tmp_335_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51675,18 +52381,18 @@ _tmp_333_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_333[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_335[%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_333[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_335[%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_333[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_335[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // '**' @@ -51694,18 +52400,18 @@ _tmp_333_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_333[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_335[%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_333[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_335[%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_333[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_335[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -51714,9 +52420,9 @@ _tmp_333_rule(Parser *p) return _res; } -// _tmp_334: ':' | '**' +// _tmp_336: ':' | '**' static void * -_tmp_334_rule(Parser *p) +_tmp_336_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51733,18 +52439,18 @@ _tmp_334_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_334[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_336[%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_334[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_336[%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_334[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_336[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '**' @@ -51752,18 +52458,18 @@ _tmp_334_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_334[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_336[%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_334[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_336[%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_334[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_336[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -51772,9 +52478,9 @@ _tmp_334_rule(Parser *p) return _res; } -// _tmp_335: '|' | '**' +// _tmp_337: '|' | '**' static void * -_tmp_335_rule(Parser *p) +_tmp_337_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51791,18 +52497,18 @@ _tmp_335_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_335[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + D(fprintf(stderr, "%*c> _tmp_337[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 18)) // token='|' ) { - D(fprintf(stderr, "%*c+ _tmp_335[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + D(fprintf(stderr, "%*c+ _tmp_337[%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_335[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_337[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|'")); } { // '**' @@ -51810,18 +52516,18 @@ _tmp_335_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_335[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_337[%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_335[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_337[%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_335[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_337[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -51830,9 +52536,9 @@ _tmp_335_rule(Parser *p) return _res; } -// _tmp_336: expression ['as' star_target] +// _tmp_338: expression ['as' star_target] static void * -_tmp_336_rule(Parser *p) +_tmp_338_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51849,22 +52555,22 @@ _tmp_336_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_336[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_338[%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_342_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_344_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_336[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_338[%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_336[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_338[%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; @@ -51873,9 +52579,9 @@ _tmp_336_rule(Parser *p) return _res; } -// _tmp_337: expressions ['as' star_target] +// _tmp_339: expressions ['as' star_target] static void * -_tmp_337_rule(Parser *p) +_tmp_339_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51892,22 +52598,22 @@ _tmp_337_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_337[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_339[%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_343_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_345_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_337[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_339[%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_337[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_339[%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; @@ -51916,9 +52622,9 @@ _tmp_337_rule(Parser *p) return _res; } -// _tmp_338: expression ['as' star_target] +// _tmp_340: expression ['as' star_target] static void * -_tmp_338_rule(Parser *p) +_tmp_340_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51935,22 +52641,22 @@ _tmp_338_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_338[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_340[%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_344_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_346_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_338[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_340[%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_338[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_340[%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; @@ -51959,9 +52665,9 @@ _tmp_338_rule(Parser *p) return _res; } -// _tmp_339: expressions ['as' star_target] +// _tmp_341: expressions ['as' star_target] static void * -_tmp_339_rule(Parser *p) +_tmp_341_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51978,22 +52684,22 @@ _tmp_339_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_339[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_341[%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_345_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_347_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_339[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_341[%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_339[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_341[%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; @@ -52002,9 +52708,9 @@ _tmp_339_rule(Parser *p) return _res; } -// _tmp_340: 'as' NAME +// _tmp_342: 'as' NAME static void * -_tmp_340_rule(Parser *p) +_tmp_342_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52021,7 +52727,7 @@ _tmp_340_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_340[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_342[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( @@ -52030,12 +52736,12 @@ _tmp_340_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_340[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_342[%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_340[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_342[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -52044,9 +52750,9 @@ _tmp_340_rule(Parser *p) return _res; } -// _tmp_341: assignment_expression | expression !':=' +// _tmp_343: assignment_expression | expression !':=' static void * -_tmp_341_rule(Parser *p) +_tmp_343_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52063,18 +52769,18 @@ _tmp_341_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_341[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_343[%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_341[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_343[%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_341[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_343[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -52082,7 +52788,7 @@ _tmp_341_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_341[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_343[%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 @@ -52090,12 +52796,12 @@ _tmp_341_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_341[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_343[%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_341[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_343[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -52104,9 +52810,9 @@ _tmp_341_rule(Parser *p) return _res; } -// _tmp_342: 'as' star_target +// _tmp_344: 'as' star_target static void * -_tmp_342_rule(Parser *p) +_tmp_344_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52123,7 +52829,7 @@ _tmp_342_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_342[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_344[%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 ( @@ -52132,12 +52838,12 @@ _tmp_342_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_342[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_344[%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_342[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_344[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -52146,9 +52852,9 @@ _tmp_342_rule(Parser *p) return _res; } -// _tmp_343: 'as' star_target +// _tmp_345: 'as' star_target static void * -_tmp_343_rule(Parser *p) +_tmp_345_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52165,7 +52871,7 @@ _tmp_343_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_343[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_345[%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 ( @@ -52174,12 +52880,12 @@ _tmp_343_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_343[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_345[%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_343[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_345[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -52188,9 +52894,9 @@ _tmp_343_rule(Parser *p) return _res; } -// _tmp_344: 'as' star_target +// _tmp_346: 'as' star_target static void * -_tmp_344_rule(Parser *p) +_tmp_346_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52207,7 +52913,7 @@ _tmp_344_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_344[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_346[%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 ( @@ -52216,12 +52922,12 @@ _tmp_344_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_344[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_346[%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_344[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_346[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -52230,9 +52936,9 @@ _tmp_344_rule(Parser *p) return _res; } -// _tmp_345: 'as' star_target +// _tmp_347: 'as' star_target static void * -_tmp_345_rule(Parser *p) +_tmp_347_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52249,7 +52955,7 @@ _tmp_345_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_345[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_347[%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 ( @@ -52258,12 +52964,12 @@ _tmp_345_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_345[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_347[%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_345[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_347[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL;