diff --git a/Grammar/python.gram b/Grammar/python.gram index 1ecfb45..daf67a0 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -105,12 +105,11 @@ statement_newline[asdl_stmt_seq*]: | ENDMARKER { _PyPegen_interactive_exit(p) } simple_stmts[asdl_stmt_seq*]: - | a=simple_stmt !';' NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } # Not needed, there for speedup - | a[asdl_stmt_seq*]=';'.simple_stmt+ [';'] NEWLINE { a } + | a=simple_stmts_nonewline NEWLINE { a } -simple_stmts_nonewline[asdl_stmt_seq*]: - | a=simple_stmt !';' { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } # Not needed, there for speedup - | a[asdl_stmt_seq*]=';'.simple_stmt+ [';'] { a } +simple_stmt_complex[asdl_stmt_seq*]: + | parenthesized_stmt_nonewline + | a=simple_stmt { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } # NOTE: assignment MUST precede expression, else parsing a simple assignment # will throw a SyntaxError. @@ -144,6 +143,27 @@ compound_stmt[stmt_ty]: | &"switch" switch_stmt | match_stmt +statements_nonewline[asdl_stmt_seq*]: a=statement_nonewline+ { (asdl_stmt_seq*)_PyPegen_seq_flatten(p, a) } + +parenthesized_stmt_nonewline[asdl_stmt_seq*]: + | '(' a=statement_nonewline ')' { a } + +statement_nonewline[asdl_stmt_seq*] (memo): a=compound_stmt_nonewline { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } | a[asdl_stmt_seq*]=simple_stmts_nonewline { a } + +simple_stmts_nonewline[asdl_stmt_seq*] (memo): + | simple_stmt_complex !';' # Not needed, there for speedup + | a=';'.(b[asdl_stmt_seq*]=';'.simple_stmt+ { b } | parenthesized_stmt_nonewline)+ [';'] { (asdl_stmt_seq*)_PyPegen_seq_flatten(p, a) } + +compound_stmt_nonewline[stmt_ty]: + | &'if' if_stmt_nonewline + | &':' unless_stmt_nonewline + | &('with' | 'async') with_stmt_nonewline + | &('for' | 'async') for_stmt_nonewline + | &'try' try_stmt_nonewline + | &'while' while_stmt_nonewline + | &"switch" switch_stmt_nonewline + | match_stmt_nonewline + # SIMPLE STATEMENTS # ================= @@ -271,9 +291,7 @@ block[asdl_stmt_seq*] (memo): | simple_stmts | invalid_block -block_nonewline[asdl_stmt_seq*]: - | NEWLINE INDENT? a=statements DEDENT? { a } - | simple_stmts_nonewline +block_nonewline[asdl_stmt_seq*]: statements_nonewline decorators[asdl_expr_seq*]: a[asdl_expr_seq*]=('@' f=named_expression NEWLINE { f })+ { a } @@ -435,6 +453,17 @@ else_block[asdl_stmt_seq*]: | invalid_else_stmt | 'else' &&':' b=block { b } +if_stmt_nonewline[stmt_ty]: + | 'if' a=named_expression ':' b=block_nonewline c=elif_stmt_nonewline { + _PyAST_If(a, b, CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p, c)), EXTRA) } + | 'if' a=named_expression ':' b=block_nonewline c=[else_block] { _PyAST_If(a, b, c, EXTRA) } +elif_stmt_nonewline[stmt_ty]: + | 'elif' a=named_expression ':' b=block c=elif_stmt_nonewline { + _PyAST_If(a, b, CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p, c)), EXTRA) } + | 'elif' a=named_expression ':' b=block_nonewline c=[else_block_nonewline] { _PyAST_If(a, b, c, EXTRA) } +else_block_nonewline[asdl_stmt_seq*]: + | 'else' &&':' b=block_nonewline { b } + # While statement # --------------- @@ -442,6 +471,9 @@ while_stmt[stmt_ty]: | invalid_while_stmt | 'while' a=named_expression ':' b=block c=[else_block] { _PyAST_While(a, b, c, EXTRA) } +while_stmt_nonewline[stmt_ty]: + | 'while' a=named_expression ':' b=block_nonewline c=[else_block_nonewline] { _PyAST_While(a, b, c, EXTRA) } + # For statement # ------------- @@ -453,6 +485,13 @@ for_stmt[stmt_ty]: CHECK_VERSION(stmt_ty, 5, "Async for loops are", _PyAST_AsyncFor(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA)) } | invalid_for_target +for_stmt_nonewline[stmt_ty]: + | 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] b=block_nonewline el=[else_block_nonewline] { + _PyAST_For(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA) } + | 'async' 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] b=block_nonewline el=[else_block_nonewline] { + CHECK_VERSION(stmt_ty, 5, "Async for loops are", _PyAST_AsyncFor(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA)) } + | invalid_for_target + # With statement # -------------- @@ -468,6 +507,16 @@ with_stmt[stmt_ty]: CHECK_VERSION(stmt_ty, 5, "Async with statements are", _PyAST_AsyncWith(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA)) } | invalid_with_stmt +with_stmt_nonewline[stmt_ty]: + | 'with' '(' a[asdl_withitem_seq*]=','.with_item+ ','? ')' ':' b=block_nonewline { + CHECK_VERSION(stmt_ty, 9, "Parenthesized context managers are", _PyAST_With(a, b, NULL, EXTRA)) } + | 'with' a[asdl_withitem_seq*]=','.with_item+ ':' tc=[TYPE_COMMENT] b=block_nonewline { + _PyAST_With(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) } + | 'async' 'with' '(' a[asdl_withitem_seq*]=','.with_item+ ','? ')' ':' b=block_nonewline { + CHECK_VERSION(stmt_ty, 5, "Async with statements are", _PyAST_AsyncWith(a, b, NULL, EXTRA)) } + | 'async' 'with' a[asdl_withitem_seq*]=','.with_item+ ':' tc=[TYPE_COMMENT] b=block_nonewline { + CHECK_VERSION(stmt_ty, 5, "Async with statements are", _PyAST_AsyncWith(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA)) } + with_item[withitem_ty]: | e=expression 'as' t=star_target &(',' | ')' | ':') { _PyAST_withitem(e, t, p->arena) } | invalid_with_item @@ -484,6 +533,14 @@ try_stmt[stmt_ty]: CHECK_VERSION(stmt_ty, 11, "Exception groups are", _PyAST_TryStar(b, ex, el, f, EXTRA)) } +try_stmt_nonewline[stmt_ty]: + | invalid_try_stmt_nonewline + | 'try' &&':' b=block_nonewline f=finally_block_nonewline { _PyAST_Try(b, NULL, NULL, f, EXTRA) } + | 'try' &&':' b=block_nonewline ex[asdl_excepthandler_seq*]=except_block_nonewline+ el=[else_block_nonewline] f=[finally_block_nonewline] { _PyAST_Try(b, ex, el, f, EXTRA) } + | 'try' &&':' b=block_nonewline ex[asdl_excepthandler_seq*]=except_star_block_nonewline+ el=[else_block_nonewline] f=[finally_block_nonewline] { + CHECK_VERSION(stmt_ty, 11, "Exception groups are", + _PyAST_TryStar(b, ex, el, f, EXTRA)) } + # Except statement # ---------------- @@ -503,6 +560,18 @@ finally_block[asdl_stmt_seq*]: | invalid_finally_stmt | 'finally' &&':' a=block { a } +except_block_nonewline[excepthandler_ty]: + | 'except' e=expression t=['as' z=NAME { z }] ':' b=block_nonewline { + _PyAST_ExceptHandler(e, (t) ? ((expr_ty) t)->v.Name.id : NULL, b, EXTRA) } + | 'except' ':' b=block { _PyAST_ExceptHandler(NULL, NULL, b, EXTRA) } + | invalid_except_stmt_nonewline +except_star_block_nonewline[excepthandler_ty]: + | 'except' '*' e=expression t=['as' z=NAME { z }] ':' b=block_nonewline { + _PyAST_ExceptHandler(e, (t) ? ((expr_ty) t)->v.Name.id : NULL, b, EXTRA) } + | invalid_except_stmt_nonewline +finally_block_nonewline[asdl_stmt_seq*]: + | 'finally' &&':' a=block_nonewline { a } + # Switch statement # ---------------- @@ -517,6 +586,17 @@ switchcase_block[switch_case_ty]: bitwiseor_pattern | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) })+ ':' body=block { _PyAST_switch_case(exprs, body, p->arena) } +switch_stmt_nonewline[stmt_ty]: + | "switch" subject=named_expression ':' NEWLINE INDENT cases[asdl_switch_case_seq*]=switchcase_block_nonewline+ DEDENT { + _PyAST_Switch(subject, cases, EXTRA) } + | "switch" subject=named_expression ':' NEWLINE cases[asdl_switch_case_seq*]=switchcase_block_nonewline+ { + _PyAST_Switch(subject, cases, EXTRA) } + +switchcase_block_nonewline[switch_case_ty]: + | "case" exprs[asdl_expr_seq*]=','.( + bitwiseor_pattern | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) })+ ':' body=block_nonewline { + _PyAST_switch_case(exprs, body, p->arena) } + bitwiseor_pattern[expr_ty]: | a=bitwiseor_pattern '|' b=bitwisexor_pattern { _PyAST_BinOp(a, BitOr, b, EXTRA) } | bitwisexor_pattern @@ -576,6 +656,12 @@ match_stmt[stmt_ty]: CHECK_VERSION(stmt_ty, 10, "Pattern matching is", _PyAST_Match(subject, cases, EXTRA)) } | invalid_match_stmt +match_stmt_nonewline[stmt_ty]: + | "match" subject=subject_expr ':' NEWLINE INDENT cases[asdl_match_case_seq*]=case_block_nonewline+ DEDENT { + CHECK_VERSION(stmt_ty, 10, "Pattern matching is", _PyAST_Match(subject, cases, EXTRA)) } + | "match" subject=subject_expr ':' NEWLINE cases[asdl_match_case_seq*]=case_block_nonewline+ { + CHECK_VERSION(stmt_ty, 10, "Pattern matching is", _PyAST_Match(subject, cases, EXTRA)) } + subject_expr[expr_ty]: | value=star_named_expression ',' values=star_named_expressions? { _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, value, values)), Load, EXTRA) } @@ -586,6 +672,10 @@ case_block[match_case_ty]: | "case" pattern=patterns guard=guard? ':' body=block { _PyAST_match_case(pattern, guard, body, p->arena) } +case_block_nonewline[match_case_ty]: + | "case" pattern=patterns guard=guard? ':' body=block_nonewline { + _PyAST_match_case(pattern, guard, body, p->arena) } + guard[expr_ty]: 'if' guard=named_expression { guard } patterns[pattern_ty]: @@ -765,6 +855,10 @@ unless_stmt[stmt_ty]: | ':' b=(s[asdl_stmt_seq*]=';'.simple_stmt+ [';'] { s } | block) 'unless' a=named_expression { _PyAST_If(_PyAST_UnaryOp(Not, a, EXTRA), b, NULL, EXTRA) } +unless_stmt_nonewline[stmt_ty]: + | ':' b=(simple_stmts_nonewline | block_nonewline) 'unless' a=named_expression { + _PyAST_If(_PyAST_UnaryOp(Not, a, EXTRA), b, NULL, EXTRA) } + # Type statement # --------------- @@ -1585,12 +1679,22 @@ invalid_try_stmt: RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot have both 'except' and 'except*' on the same 'try'") } | 'try' ':' block* except_star_block+ a='except' [expression ['as' NAME]] ':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot have both 'except' and 'except*' on the same 'try'") } +invalid_try_stmt_nonewline: + | 'try' ':' block_nonewline !('except' | 'finally') { RAISE_SYNTAX_ERROR("expected 'except' or 'finally' block") } + | 'try' ':' block_nonewline* except_block_nonewline+ a='except' b='*' expression ['as' NAME] ':' { + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot have both 'except' and 'except*' on the same 'try'") } + | 'try' ':' block_nonewline* except_star_block_nonewline+ a='except' [expression ['as' NAME]] ':' { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot have both 'except' and 'except*' on the same 'try'") } invalid_except_stmt: | 'except' '*'? a=expression ',' expressions ['as' NAME ] ':' { RAISE_SYNTAX_ERROR_STARTING_FROM(a, "multiple exception types must be parenthesized") } | a='except' '*'? expression ['as' NAME ] NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") } | a='except' NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") } | a='except' '*' (NEWLINE | ':') { RAISE_SYNTAX_ERROR("expected one or more exception types") } +invalid_except_stmt_nonewline: + | 'except' '*'? a=expression ',' expressions ['as' NAME ] ':' { + RAISE_SYNTAX_ERROR_STARTING_FROM(a, "multiple exception types must be parenthesized") } + | a='except' '*' ':' { RAISE_SYNTAX_ERROR("expected one or more exception types") } invalid_finally_stmt: | a='finally' ':' NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block after 'finally' statement on line %d", a->lineno) } diff --git a/Parser/parser.c b/Parser/parser.c index 0b03768..5ef1a97 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -17,60 +17,60 @@ static KeywordToken *reserved_keywords[] = { (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) { - {"if", 706}, - {"as", 704}, - {"in", 717}, - {"is", 636}, - {"or", 623}, + {"if", 753}, + {"as", 751}, + {"in", 764}, + {"is", 671}, + {"or", 658}, {NULL, -1}, }, (KeywordToken[]) { - {"del", 663}, - {"for", 716}, - {"try", 688}, - {"and", 624}, - {"not", 635}, + {"del", 698}, + {"for", 763}, + {"try", 732}, + {"and", 659}, + {"not", 670}, {NULL, -1}, }, (KeywordToken[]) { - {"from", 668}, - {"pass", 558}, - {"goto", 567}, - {"with", 679}, - {"None", 661}, - {"True", 660}, - {"elif", 708}, - {"else", 709}, + {"from", 703}, + {"pass", 565}, + {"goto", 574}, + {"with", 714}, + {"None", 696}, + {"True", 695}, + {"elif", 755}, + {"else", 756}, {NULL, -1}, }, (KeywordToken[]) { - {"raise", 559}, - {"yield", 622}, - {"break", 538}, - {"async", 718}, - {"class", 720}, - {"while", 711}, - {"False", 662}, - {"await", 637}, + {"raise", 566}, + {"yield", 657}, + {"break", 545}, + {"async", 765}, + {"class", 767}, + {"while", 758}, + {"False", 697}, + {"await", 672}, {NULL, -1}, }, (KeywordToken[]) { - {"return", 560}, - {"import", 667}, - {"assert", 566}, - {"global", 548}, - {"except", 701}, - {"lambda", 659}, - {"unless", 617}, + {"return", 567}, + {"import", 702}, + {"assert", 573}, + {"global", 555}, + {"except", 748}, + {"lambda", 694}, + {"unless", 652}, {NULL, -1}, }, (KeywordToken[]) { - {"finally", 697}, + {"finally", 744}, {NULL, -1}, }, (KeywordToken[]) { - {"continue", 540}, - {"nonlocal", 555}, + {"continue", 547}, + {"nonlocal", 562}, {NULL, -1}, }, }; @@ -94,640 +94,695 @@ static char *soft_keywords[] = { #define statement_type 1006 #define statement_newline_type 1007 #define simple_stmts_type 1008 -#define simple_stmts_nonewline_type 1009 +#define simple_stmt_complex_type 1009 #define simple_stmt_type 1010 #define compound_stmt_type 1011 -#define assignment_type 1012 -#define annotated_rhs_type 1013 -#define augassign_type 1014 -#define unarassign_type 1015 -#define return_stmt_type 1016 -#define raise_stmt_type 1017 -#define global_stmt_type 1018 -#define nonlocal_stmt_type 1019 -#define del_kw_stmt_type 1020 -#define del_stmt_type 1021 -#define yield_stmt_type 1022 -#define assert_stmt_type 1023 -#define goto_stmt_type 1024 -#define label_stmt_type 1025 -#define import_stmt_type 1026 -#define import_name_type 1027 -#define import_from_type 1028 -#define import_from_targets_type 1029 -#define import_from_as_names_type 1030 -#define import_from_as_name_type 1031 -#define dotted_as_names_type 1032 -#define dotted_as_name_type 1033 -#define dotted_name_type 1034 // Left-recursive -#define block_type 1035 -#define block_nonewline_type 1036 -#define decorators_type 1037 -#define class_def_type 1038 -#define class_def_raw_type 1039 -#define class_def_nonewline_type 1040 -#define class_def_raw_nonewline_type 1041 -#define function_def_type 1042 -#define function_def_raw_type 1043 -#define function_def_nonewline_type 1044 -#define function_def_raw_nonewline_type 1045 -#define params_type 1046 -#define parameters_type 1047 -#define slash_no_default_type 1048 -#define slash_with_default_type 1049 -#define star_etc_type 1050 -#define kwds_type 1051 -#define param_no_default_type 1052 -#define param_no_default_star_annotation_type 1053 -#define param_with_default_type 1054 -#define param_maybe_default_type 1055 -#define param_type 1056 -#define param_star_annotation_type 1057 -#define annotation_type 1058 -#define star_annotation_type 1059 -#define default_type 1060 -#define if_stmt_type 1061 -#define elif_stmt_type 1062 -#define else_block_type 1063 -#define while_stmt_type 1064 -#define for_stmt_type 1065 -#define with_stmt_type 1066 -#define with_item_type 1067 -#define try_stmt_type 1068 -#define except_block_type 1069 -#define except_star_block_type 1070 -#define finally_block_type 1071 -#define switch_stmt_type 1072 -#define switchcase_block_type 1073 -#define bitwiseor_pattern_type 1074 // Left-recursive -#define bitwisexor_pattern_type 1075 // Left-recursive -#define bitwiseand_pattern_type 1076 // Left-recursive -#define shift_pattern_type 1077 // Left-recursive -#define sum_pattern_type 1078 // Left-recursive -#define term_pattern_type 1079 // Left-recursive -#define factor_pattern_type 1080 -#define power_pattern_type 1081 -#define number_pattern_type 1082 -#define match_stmt_type 1083 -#define subject_expr_type 1084 -#define case_block_type 1085 -#define guard_type 1086 -#define patterns_type 1087 -#define pattern_type 1088 -#define as_pattern_type 1089 -#define or_pattern_type 1090 -#define closed_pattern_type 1091 -#define literal_pattern_type 1092 -#define literal_expr_type 1093 -#define complex_number_type 1094 -#define signed_number_type 1095 -#define signed_real_number_type 1096 -#define real_number_type 1097 -#define imaginary_number_type 1098 -#define capture_pattern_type 1099 -#define pattern_capture_target_type 1100 -#define wildcard_pattern_type 1101 -#define value_pattern_type 1102 -#define attr_type 1103 // Left-recursive -#define name_or_attr_type 1104 // Left-recursive -#define group_pattern_type 1105 -#define sequence_pattern_type 1106 -#define open_sequence_pattern_type 1107 -#define maybe_sequence_pattern_type 1108 -#define maybe_star_pattern_type 1109 -#define star_pattern_type 1110 -#define mapping_pattern_type 1111 -#define items_pattern_type 1112 -#define key_value_pattern_type 1113 -#define double_star_pattern_type 1114 -#define class_pattern_type 1115 -#define positional_patterns_type 1116 -#define keyword_patterns_type 1117 -#define keyword_pattern_type 1118 -#define unless_stmt_type 1119 -#define type_alias_type 1120 -#define type_params_type 1121 -#define type_param_seq_type 1122 -#define type_param_type 1123 -#define type_param_bound_type 1124 -#define expressions_type 1125 -#define expression_type 1126 -#define yield_expr_type 1127 -#define star_expressions_type 1128 -#define star_expression_type 1129 -#define star_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 +#define statements_nonewline_type 1012 +#define parenthesized_stmt_nonewline_type 1013 +#define statement_nonewline_type 1014 +#define simple_stmts_nonewline_type 1015 +#define compound_stmt_nonewline_type 1016 +#define assignment_type 1017 +#define annotated_rhs_type 1018 +#define augassign_type 1019 +#define unarassign_type 1020 +#define return_stmt_type 1021 +#define raise_stmt_type 1022 +#define global_stmt_type 1023 +#define nonlocal_stmt_type 1024 +#define del_kw_stmt_type 1025 +#define del_stmt_type 1026 +#define yield_stmt_type 1027 +#define assert_stmt_type 1028 +#define goto_stmt_type 1029 +#define label_stmt_type 1030 +#define import_stmt_type 1031 +#define import_name_type 1032 +#define import_from_type 1033 +#define import_from_targets_type 1034 +#define import_from_as_names_type 1035 +#define import_from_as_name_type 1036 +#define dotted_as_names_type 1037 +#define dotted_as_name_type 1038 +#define dotted_name_type 1039 // Left-recursive +#define block_type 1040 +#define block_nonewline_type 1041 +#define decorators_type 1042 +#define class_def_type 1043 +#define class_def_raw_type 1044 +#define class_def_nonewline_type 1045 +#define class_def_raw_nonewline_type 1046 +#define function_def_type 1047 +#define function_def_raw_type 1048 +#define function_def_nonewline_type 1049 +#define function_def_raw_nonewline_type 1050 +#define params_type 1051 +#define parameters_type 1052 +#define slash_no_default_type 1053 +#define slash_with_default_type 1054 +#define star_etc_type 1055 +#define kwds_type 1056 +#define param_no_default_type 1057 +#define param_no_default_star_annotation_type 1058 +#define param_with_default_type 1059 +#define param_maybe_default_type 1060 +#define param_type 1061 +#define param_star_annotation_type 1062 +#define annotation_type 1063 +#define star_annotation_type 1064 +#define default_type 1065 +#define if_stmt_type 1066 +#define elif_stmt_type 1067 +#define else_block_type 1068 +#define if_stmt_nonewline_type 1069 +#define elif_stmt_nonewline_type 1070 +#define else_block_nonewline_type 1071 +#define while_stmt_type 1072 +#define while_stmt_nonewline_type 1073 +#define for_stmt_type 1074 +#define for_stmt_nonewline_type 1075 +#define with_stmt_type 1076 +#define with_stmt_nonewline_type 1077 +#define with_item_type 1078 +#define try_stmt_type 1079 +#define try_stmt_nonewline_type 1080 +#define except_block_type 1081 +#define except_star_block_type 1082 +#define finally_block_type 1083 +#define except_block_nonewline_type 1084 +#define except_star_block_nonewline_type 1085 +#define finally_block_nonewline_type 1086 +#define switch_stmt_type 1087 +#define switchcase_block_type 1088 +#define switch_stmt_nonewline_type 1089 +#define switchcase_block_nonewline_type 1090 +#define bitwiseor_pattern_type 1091 // Left-recursive +#define bitwisexor_pattern_type 1092 // Left-recursive +#define bitwiseand_pattern_type 1093 // Left-recursive +#define shift_pattern_type 1094 // Left-recursive +#define sum_pattern_type 1095 // Left-recursive +#define term_pattern_type 1096 // Left-recursive +#define factor_pattern_type 1097 +#define power_pattern_type 1098 +#define number_pattern_type 1099 +#define match_stmt_type 1100 +#define match_stmt_nonewline_type 1101 +#define subject_expr_type 1102 +#define case_block_type 1103 +#define case_block_nonewline_type 1104 +#define guard_type 1105 +#define patterns_type 1106 +#define pattern_type 1107 +#define as_pattern_type 1108 +#define or_pattern_type 1109 +#define closed_pattern_type 1110 +#define literal_pattern_type 1111 +#define literal_expr_type 1112 +#define complex_number_type 1113 +#define signed_number_type 1114 +#define signed_real_number_type 1115 +#define real_number_type 1116 +#define imaginary_number_type 1117 +#define capture_pattern_type 1118 +#define pattern_capture_target_type 1119 +#define wildcard_pattern_type 1120 +#define value_pattern_type 1121 +#define attr_type 1122 // Left-recursive +#define name_or_attr_type 1123 // Left-recursive +#define group_pattern_type 1124 +#define sequence_pattern_type 1125 +#define open_sequence_pattern_type 1126 +#define maybe_sequence_pattern_type 1127 +#define maybe_star_pattern_type 1128 +#define star_pattern_type 1129 +#define mapping_pattern_type 1130 +#define items_pattern_type 1131 +#define key_value_pattern_type 1132 +#define double_star_pattern_type 1133 +#define class_pattern_type 1134 +#define positional_patterns_type 1135 +#define keyword_patterns_type 1136 +#define keyword_pattern_type 1137 +#define unless_stmt_type 1138 +#define unless_stmt_nonewline_type 1139 +#define type_alias_type 1140 +#define type_params_type 1141 +#define type_param_seq_type 1142 +#define type_param_type 1143 +#define type_param_bound_type 1144 +#define expressions_type 1145 +#define expression_type 1146 +#define yield_expr_type 1147 +#define star_expressions_type 1148 +#define star_expression_type 1149 +#define star_sum_type 1150 +#define star_named_expressions_type 1151 +#define star_named_expression_type 1152 +#define star_assignment_expression_type 1153 +#define assignment_expression_type 1154 +#define named_expression_type 1155 +#define disjunction_type 1156 +#define conjunction_type 1157 +#define inversion_type 1158 +#define comparison_type 1159 +#define compare_op_composition_pair_type 1160 +#define eq_composition_type 1161 +#define noteq_composition_type 1162 +#define lte_composition_type 1163 +#define lt_composition_type 1164 +#define gte_composition_type 1165 +#define gt_composition_type 1166 +#define notin_composition_type 1167 +#define in_composition_type 1168 +#define isnotin_composition_type 1169 +#define isin_composition_type 1170 +#define isnot_composition_type 1171 +#define is_composition_type 1172 +#define composition_type 1173 // Left-recursive +#define bitwise_or_type 1174 // Left-recursive +#define bitwise_xor_type 1175 // Left-recursive +#define bitwise_and_type 1176 // Left-recursive +#define shift_expr_type 1177 // Left-recursive +#define sum_type 1178 // Left-recursive +#define term_type 1179 // Left-recursive +#define factor_type 1180 +#define coalesce_type 1181 +#define power_type 1182 +#define await_primary_type 1183 +#define primary_type 1184 // Left-recursive +#define slices_type 1185 +#define slice_type 1186 +#define simple_slice_type 1187 +#define atom_type 1188 +#define group_type 1189 +#define class_or_func_expr_type 1190 +#define lambdef_type 1191 +#define lambda_params_type 1192 +#define lambda_sum_params_type 1193 +#define lambda_parameters_type 1194 +#define lambda_slash_no_default_type 1195 +#define lambda_slash_with_default_type 1196 +#define lambda_star_etc_type 1197 +#define lambda_kwds_type 1198 +#define lambda_param_no_default_type 1199 +#define lambda_param_with_default_type 1200 +#define lambda_param_maybe_default_type 1201 +#define lambda_param_type 1202 +#define lambda_sum_parameters_type 1203 +#define lambda_sum_slash_no_default_type 1204 +#define lambda_sum_slash_with_default_type 1205 +#define lambda_sum_star_etc_type 1206 +#define lambda_sum_kwds_type 1207 +#define lambda_sum_param_no_default_type 1208 +#define lambda_sum_param_no_default_star_annotation_type 1209 +#define lambda_sum_param_with_default_type 1210 +#define lambda_sum_param_maybe_default_type 1211 +#define sum_param_type 1212 +#define sum_param_star_annotation_type 1213 +#define sum_annotation_type 1214 +#define star_sum_annotation_type 1215 +#define sum_default_type 1216 +#define fstring_middle_type 1217 +#define fstring_replacement_field_type 1218 +#define fstring_conversion_type 1219 +#define fstring_full_format_spec_type 1220 +#define fstring_format_spec_type 1221 +#define string_type 1222 +#define strings_type 1223 +#define list_type 1224 +#define tuple_type 1225 +#define set_type 1226 +#define dict_type 1227 +#define double_starred_kvpairs_type 1228 +#define double_starred_kvpair_type 1229 +#define kvpair_type 1230 +#define for_if_clauses_type 1231 +#define for_if_clause_type 1232 +#define listcomp_type 1233 +#define tuplecomp_type 1234 +#define setcomp_type 1235 +#define genexp_type 1236 +#define dictcomp_type 1237 +#define arguments_type 1238 +#define args_type 1239 +#define kwargs_type 1240 +#define starred_expression_type 1241 +#define kwarg_or_starred_type 1242 +#define kwarg_or_double_starred_type 1243 +#define star_targets_type 1244 +#define star_targets_list_seq_type 1245 +#define star_targets_tuple_seq_type 1246 +#define star_target_type 1247 +#define target_with_star_atom_type 1248 +#define star_atom_type 1249 +#define single_target_type 1250 +#define single_subscript_attribute_target_type 1251 +#define t_primary_type 1252 // Left-recursive +#define t_lookahead_type 1253 +#define t_lookmain_type 1254 +#define del_targets_type 1255 +#define del_target_type 1256 +#define del_t_atom_type 1257 +#define type_expressions_type 1258 +#define func_type_comment_type 1259 +#define invalid_arguments_type 1260 +#define invalid_kwarg_type 1261 +#define expression_without_invalid_type 1262 +#define invalid_legacy_expression_type 1263 +#define invalid_expression_type 1264 +#define invalid_named_expression_type 1265 +#define invalid_assignment_type 1266 +#define invalid_ann_assign_target_type 1267 +#define invalid_del_stmt_type 1268 +#define invalid_block_type 1269 +#define invalid_comprehension_type 1270 +#define invalid_dict_comprehension_type 1271 +#define invalid_parameters_type 1272 +#define invalid_default_type 1273 +#define invalid_sum_default_type 1274 +#define invalid_star_etc_type 1275 +#define invalid_kwds_type 1276 +#define invalid_parameters_helper_type 1277 +#define invalid_lambda_parameters_type 1278 +#define invalid_lambda_parameters_helper_type 1279 +#define invalid_lambda_star_etc_type 1280 +#define invalid_lambda_kwds_type 1281 +#define invalid_lambda_sum_parameters_type 1282 +#define invalid_lambda_sum_parameters_helper_type 1283 +#define invalid_lambda_sum_star_etc_type 1284 +#define invalid_double_type_comments_type 1285 +#define invalid_with_item_type 1286 +#define invalid_for_target_type 1287 +#define invalid_group_type 1288 +#define invalid_import_type 1289 +#define invalid_import_from_targets_type 1290 +#define invalid_with_stmt_type 1291 +#define invalid_with_stmt_indent_type 1292 +#define invalid_try_stmt_type 1293 +#define invalid_try_stmt_nonewline_type 1294 +#define invalid_except_stmt_type 1295 +#define invalid_except_stmt_nonewline_type 1296 +#define invalid_finally_stmt_type 1297 +#define invalid_except_stmt_indent_type 1298 +#define invalid_except_star_stmt_indent_type 1299 +#define invalid_match_stmt_type 1300 +#define invalid_case_block_type 1301 +#define invalid_as_pattern_type 1302 +#define invalid_class_pattern_type 1303 +#define invalid_class_argument_pattern_type 1304 +#define invalid_if_stmt_type 1305 +#define invalid_elif_stmt_type 1306 +#define invalid_else_stmt_type 1307 +#define invalid_while_stmt_type 1308 +#define invalid_for_stmt_type 1309 +#define invalid_def_raw_type 1310 +#define invalid_class_def_raw_nonewline_type 1311 +#define invalid_class_def_raw_type 1312 +#define invalid_double_starred_kvpairs_type 1313 +#define invalid_kvpair_type 1314 +#define invalid_starred_expression_type 1315 +#define invalid_replacement_field_type 1316 +#define invalid_conversion_character_type 1317 +#define _loop0_1_type 1318 +#define _loop0_2_type 1319 +#define _loop0_3_type 1320 +#define _loop1_4_type 1321 +#define _tmp_5_type 1322 +#define _tmp_6_type 1323 +#define _tmp_7_type 1324 +#define _tmp_8_type 1325 +#define _tmp_9_type 1326 +#define _tmp_10_type 1327 +#define _tmp_11_type 1328 +#define _loop1_12_type 1329 +#define _loop0_14_type 1330 +#define _gather_13_type 1331 +#define _tmp_15_type 1332 +#define _tmp_16_type 1333 +#define _tmp_17_type 1334 +#define _tmp_18_type 1335 +#define _tmp_19_type 1336 +#define _loop1_20_type 1337 +#define _tmp_21_type 1338 +#define _tmp_22_type 1339 +#define _tmp_23_type 1340 +#define _tmp_24_type 1341 +#define _tmp_25_type 1342 +#define _tmp_26_type 1343 +#define _tmp_27_type 1344 +#define _tmp_28_type 1345 +#define _tmp_29_type 1346 +#define _loop0_31_type 1347 +#define _gather_30_type 1348 +#define _loop0_33_type 1349 +#define _gather_32_type 1350 +#define _tmp_34_type 1351 +#define _tmp_35_type 1352 +#define _tmp_36_type 1353 +#define _loop0_38_type 1354 +#define _gather_37_type 1355 +#define _loop0_39_type 1356 +#define _loop1_40_type 1357 +#define _loop0_42_type 1358 +#define _gather_41_type 1359 +#define _tmp_43_type 1360 +#define _loop0_45_type 1361 +#define _gather_44_type 1362 +#define _tmp_46_type 1363 +#define _loop1_47_type 1364 +#define _tmp_48_type 1365 +#define _tmp_49_type 1366 +#define _tmp_50_type 1367 +#define _tmp_51_type 1368 +#define _tmp_52_type 1369 +#define _tmp_53_type 1370 +#define _loop0_54_type 1371 +#define _loop0_55_type 1372 +#define _loop0_56_type 1373 +#define _loop1_57_type 1374 +#define _loop0_58_type 1375 +#define _loop1_59_type 1376 +#define _loop1_60_type 1377 +#define _loop1_61_type 1378 +#define _loop0_62_type 1379 +#define _loop1_63_type 1380 +#define _loop0_64_type 1381 +#define _loop1_65_type 1382 +#define _loop0_66_type 1383 +#define _loop0_67_type 1384 +#define _loop1_68_type 1385 +#define _loop0_70_type 1386 +#define _gather_69_type 1387 +#define _loop0_72_type 1388 +#define _gather_71_type 1389 +#define _loop0_74_type 1390 +#define _gather_73_type 1391 +#define _loop0_76_type 1392 +#define _gather_75_type 1393 +#define _loop0_78_type 1394 +#define _gather_77_type 1395 +#define _loop0_80_type 1396 +#define _gather_79_type 1397 +#define _loop0_82_type 1398 +#define _gather_81_type 1399 +#define _loop0_84_type 1400 +#define _gather_83_type 1401 +#define _tmp_85_type 1402 +#define _loop1_86_type 1403 +#define _loop1_87_type 1404 +#define _loop1_88_type 1405 +#define _loop1_89_type 1406 +#define _tmp_90_type 1407 +#define _tmp_91_type 1408 +#define _tmp_92_type 1409 +#define _tmp_93_type 1410 +#define _loop1_94_type 1411 +#define _loop1_95_type 1412 +#define _loop0_97_type 1413 +#define _gather_96_type 1414 +#define _loop1_98_type 1415 +#define _loop1_99_type 1416 +#define _loop0_101_type 1417 +#define _gather_100_type 1418 +#define _loop1_102_type 1419 +#define _loop1_103_type 1420 +#define _loop1_104_type 1421 +#define _loop1_105_type 1422 +#define _loop0_107_type 1423 +#define _gather_106_type 1424 +#define _tmp_108_type 1425 +#define _tmp_109_type 1426 +#define _tmp_110_type 1427 +#define _tmp_111_type 1428 +#define _loop0_113_type 1429 +#define _gather_112_type 1430 +#define _loop0_115_type 1431 +#define _gather_114_type 1432 +#define _tmp_116_type 1433 +#define _loop0_118_type 1434 +#define _gather_117_type 1435 +#define _loop0_120_type 1436 +#define _gather_119_type 1437 +#define _tmp_121_type 1438 +#define _tmp_122_type 1439 +#define _loop0_124_type 1440 +#define _gather_123_type 1441 +#define _loop1_125_type 1442 +#define _loop1_126_type 1443 +#define _loop0_128_type 1444 +#define _gather_127_type 1445 +#define _loop1_129_type 1446 +#define _loop1_130_type 1447 +#define _loop1_131_type 1448 +#define _tmp_132_type 1449 +#define _tmp_133_type 1450 +#define _tmp_134_type 1451 +#define _tmp_135_type 1452 +#define _loop0_137_type 1453 +#define _gather_136_type 1454 +#define _tmp_138_type 1455 +#define _tmp_139_type 1456 +#define _tmp_140_type 1457 +#define _tmp_141_type 1458 +#define _tmp_142_type 1459 +#define _tmp_143_type 1460 +#define _tmp_144_type 1461 +#define _loop0_145_type 1462 +#define _loop0_146_type 1463 +#define _loop0_147_type 1464 +#define _loop1_148_type 1465 +#define _loop0_149_type 1466 +#define _loop1_150_type 1467 +#define _loop1_151_type 1468 +#define _loop1_152_type 1469 +#define _loop0_153_type 1470 +#define _loop1_154_type 1471 +#define _loop0_155_type 1472 +#define _loop1_156_type 1473 +#define _loop0_157_type 1474 +#define _loop1_158_type 1475 +#define _loop0_159_type 1476 +#define _loop0_160_type 1477 +#define _loop0_161_type 1478 +#define _loop1_162_type 1479 +#define _loop0_163_type 1480 +#define _loop1_164_type 1481 +#define _loop1_165_type 1482 +#define _loop1_166_type 1483 +#define _loop0_167_type 1484 +#define _loop1_168_type 1485 +#define _loop0_169_type 1486 +#define _loop1_170_type 1487 +#define _loop0_171_type 1488 +#define _loop0_172_type 1489 +#define _loop1_173_type 1490 +#define _tmp_174_type 1491 +#define _loop0_175_type 1492 +#define _loop1_176_type 1493 +#define _tmp_177_type 1494 +#define _loop0_179_type 1495 +#define _gather_178_type 1496 +#define _loop1_180_type 1497 +#define _loop0_181_type 1498 +#define _loop0_182_type 1499 +#define _loop0_183_type 1500 +#define _tmp_184_type 1501 +#define _tmp_185_type 1502 +#define _loop0_187_type 1503 +#define _gather_186_type 1504 +#define _tmp_188_type 1505 +#define _loop0_190_type 1506 +#define _gather_189_type 1507 +#define _loop0_192_type 1508 +#define _gather_191_type 1509 +#define _loop0_194_type 1510 +#define _gather_193_type 1511 +#define _loop0_196_type 1512 +#define _gather_195_type 1513 +#define _tmp_197_type 1514 +#define _tmp_198_type 1515 +#define _loop0_199_type 1516 +#define _loop0_201_type 1517 +#define _gather_200_type 1518 +#define _loop1_202_type 1519 +#define _tmp_203_type 1520 +#define _tmp_204_type 1521 +#define _loop0_206_type 1522 +#define _gather_205_type 1523 +#define _loop0_208_type 1524 +#define _gather_207_type 1525 +#define _loop0_210_type 1526 +#define _gather_209_type 1527 +#define _loop0_212_type 1528 +#define _gather_211_type 1529 +#define _loop0_214_type 1530 +#define _gather_213_type 1531 +#define _tmp_215_type 1532 +#define _tmp_216_type 1533 +#define _tmp_217_type 1534 +#define _tmp_218_type 1535 +#define _tmp_219_type 1536 +#define _tmp_220_type 1537 +#define _tmp_221_type 1538 +#define _tmp_222_type 1539 +#define _tmp_223_type 1540 +#define _tmp_224_type 1541 +#define _tmp_225_type 1542 +#define _tmp_226_type 1543 +#define _loop0_227_type 1544 +#define _loop0_228_type 1545 +#define _loop0_229_type 1546 +#define _tmp_230_type 1547 +#define _tmp_231_type 1548 +#define _tmp_232_type 1549 +#define _tmp_233_type 1550 +#define _tmp_234_type 1551 +#define _loop0_235_type 1552 +#define _loop0_236_type 1553 +#define _loop0_237_type 1554 +#define _loop1_238_type 1555 +#define _tmp_239_type 1556 +#define _loop0_240_type 1557 +#define _tmp_241_type 1558 +#define _loop0_242_type 1559 +#define _loop1_243_type 1560 +#define _tmp_244_type 1561 +#define _tmp_245_type 1562 +#define _tmp_246_type 1563 +#define _tmp_247_type 1564 +#define _loop0_248_type 1565 +#define _tmp_249_type 1566 +#define _tmp_250_type 1567 +#define _loop1_251_type 1568 +#define _tmp_252_type 1569 +#define _loop0_253_type 1570 +#define _loop0_254_type 1571 +#define _loop0_255_type 1572 +#define _loop0_257_type 1573 +#define _gather_256_type 1574 +#define _tmp_258_type 1575 +#define _loop0_259_type 1576 +#define _tmp_260_type 1577 +#define _loop0_261_type 1578 +#define _loop1_262_type 1579 +#define _loop1_263_type 1580 +#define _tmp_264_type 1581 +#define _tmp_265_type 1582 +#define _loop0_266_type 1583 +#define _tmp_267_type 1584 +#define _tmp_268_type 1585 +#define _tmp_269_type 1586 +#define _loop0_270_type 1587 +#define _loop0_271_type 1588 +#define _loop0_272_type 1589 +#define _loop0_274_type 1590 +#define _gather_273_type 1591 +#define _tmp_275_type 1592 +#define _loop0_276_type 1593 +#define _tmp_277_type 1594 +#define _loop0_278_type 1595 +#define _loop1_279_type 1596 +#define _loop1_280_type 1597 +#define _tmp_281_type 1598 +#define _tmp_282_type 1599 +#define _loop0_283_type 1600 +#define _tmp_284_type 1601 +#define _tmp_285_type 1602 +#define _loop0_287_type 1603 +#define _gather_286_type 1604 +#define _loop0_289_type 1605 +#define _gather_288_type 1606 +#define _loop0_291_type 1607 +#define _gather_290_type 1608 +#define _loop0_293_type 1609 +#define _gather_292_type 1610 +#define _loop0_295_type 1611 +#define _gather_294_type 1612 +#define _tmp_296_type 1613 +#define _loop0_297_type 1614 +#define _loop1_298_type 1615 +#define _tmp_299_type 1616 +#define _loop0_300_type 1617 +#define _loop1_301_type 1618 +#define _tmp_302_type 1619 +#define _tmp_303_type 1620 +#define _loop0_304_type 1621 +#define _loop1_305_type 1622 +#define _tmp_306_type 1623 +#define _loop0_307_type 1624 +#define _loop1_308_type 1625 +#define _tmp_309_type 1626 +#define _tmp_310_type 1627 +#define _tmp_311_type 1628 +#define _tmp_312_type 1629 +#define _tmp_313_type 1630 +#define _tmp_314_type 1631 +#define _tmp_315_type 1632 +#define _tmp_316_type 1633 +#define _tmp_317_type 1634 +#define _tmp_318_type 1635 +#define _tmp_319_type 1636 +#define _loop0_321_type 1637 +#define _gather_320_type 1638 +#define _tmp_322_type 1639 +#define _tmp_323_type 1640 +#define _tmp_324_type 1641 +#define _tmp_325_type 1642 +#define _tmp_326_type 1643 +#define _tmp_327_type 1644 +#define _tmp_328_type 1645 +#define _tmp_329_type 1646 +#define _tmp_330_type 1647 +#define _tmp_331_type 1648 +#define _tmp_332_type 1649 +#define _tmp_333_type 1650 +#define _tmp_334_type 1651 +#define _loop0_335_type 1652 +#define _tmp_336_type 1653 +#define _tmp_337_type 1654 +#define _tmp_338_type 1655 +#define _tmp_339_type 1656 +#define _tmp_340_type 1657 +#define _tmp_341_type 1658 +#define _tmp_342_type 1659 +#define _tmp_343_type 1660 +#define _tmp_344_type 1661 +#define _tmp_345_type 1662 +#define _tmp_346_type 1663 +#define _loop0_348_type 1664 +#define _gather_347_type 1665 +#define _tmp_349_type 1666 +#define _tmp_350_type 1667 +#define _tmp_351_type 1668 +#define _tmp_352_type 1669 +#define _tmp_353_type 1670 +#define _tmp_354_type 1671 +#define _tmp_355_type 1672 +#define _tmp_356_type 1673 +#define _tmp_357_type 1674 +#define _tmp_358_type 1675 +#define _tmp_359_type 1676 +#define _tmp_360_type 1677 +#define _tmp_361_type 1678 +#define _tmp_362_type 1679 +#define _tmp_363_type 1680 +#define _tmp_364_type 1681 +#define _tmp_365_type 1682 +#define _tmp_366_type 1683 +#define _tmp_367_type 1684 +#define _tmp_368_type 1685 +#define _tmp_369_type 1686 +#define _tmp_370_type 1687 +#define _tmp_371_type 1688 +#define _tmp_372_type 1689 +#define _tmp_373_type 1690 +#define _loop0_375_type 1691 +#define _gather_374_type 1692 +#define _tmp_376_type 1693 +#define _tmp_377_type 1694 +#define _tmp_378_type 1695 +#define _tmp_379_type 1696 +#define _tmp_380_type 1697 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -738,9 +793,14 @@ static asdl_stmt_seq* statements_rule(Parser *p); static asdl_stmt_seq* statement_rule(Parser *p); static asdl_stmt_seq* statement_newline_rule(Parser *p); static asdl_stmt_seq* simple_stmts_rule(Parser *p); -static asdl_stmt_seq* simple_stmts_nonewline_rule(Parser *p); +static asdl_stmt_seq* simple_stmt_complex_rule(Parser *p); static stmt_ty simple_stmt_rule(Parser *p); static stmt_ty compound_stmt_rule(Parser *p); +static asdl_stmt_seq* statements_nonewline_rule(Parser *p); +static asdl_stmt_seq* parenthesized_stmt_nonewline_rule(Parser *p); +static asdl_stmt_seq* statement_nonewline_rule(Parser *p); +static asdl_stmt_seq* simple_stmts_nonewline_rule(Parser *p); +static stmt_ty compound_stmt_nonewline_rule(Parser *p); static stmt_ty assignment_rule(Parser *p); static expr_ty annotated_rhs_rule(Parser *p); static AugOperator* augassign_rule(Parser *p); @@ -793,16 +853,28 @@ static expr_ty default_rule(Parser *p); static stmt_ty if_stmt_rule(Parser *p); static stmt_ty elif_stmt_rule(Parser *p); static asdl_stmt_seq* else_block_rule(Parser *p); +static stmt_ty if_stmt_nonewline_rule(Parser *p); +static stmt_ty elif_stmt_nonewline_rule(Parser *p); +static asdl_stmt_seq* else_block_nonewline_rule(Parser *p); static stmt_ty while_stmt_rule(Parser *p); +static stmt_ty while_stmt_nonewline_rule(Parser *p); static stmt_ty for_stmt_rule(Parser *p); +static stmt_ty for_stmt_nonewline_rule(Parser *p); static stmt_ty with_stmt_rule(Parser *p); +static stmt_ty with_stmt_nonewline_rule(Parser *p); static withitem_ty with_item_rule(Parser *p); static stmt_ty try_stmt_rule(Parser *p); +static stmt_ty try_stmt_nonewline_rule(Parser *p); static excepthandler_ty except_block_rule(Parser *p); static excepthandler_ty except_star_block_rule(Parser *p); static asdl_stmt_seq* finally_block_rule(Parser *p); +static excepthandler_ty except_block_nonewline_rule(Parser *p); +static excepthandler_ty except_star_block_nonewline_rule(Parser *p); +static asdl_stmt_seq* finally_block_nonewline_rule(Parser *p); static stmt_ty switch_stmt_rule(Parser *p); static switch_case_ty switchcase_block_rule(Parser *p); +static stmt_ty switch_stmt_nonewline_rule(Parser *p); +static switch_case_ty switchcase_block_nonewline_rule(Parser *p); static expr_ty bitwiseor_pattern_rule(Parser *p); static expr_ty bitwisexor_pattern_rule(Parser *p); static expr_ty bitwiseand_pattern_rule(Parser *p); @@ -813,8 +885,10 @@ static expr_ty factor_pattern_rule(Parser *p); static expr_ty power_pattern_rule(Parser *p); static expr_ty number_pattern_rule(Parser *p); static stmt_ty match_stmt_rule(Parser *p); +static stmt_ty match_stmt_nonewline_rule(Parser *p); static expr_ty subject_expr_rule(Parser *p); static match_case_ty case_block_rule(Parser *p); +static match_case_ty case_block_nonewline_rule(Parser *p); static expr_ty guard_rule(Parser *p); static pattern_ty patterns_rule(Parser *p); static pattern_ty pattern_rule(Parser *p); @@ -849,6 +923,7 @@ static asdl_pattern_seq* positional_patterns_rule(Parser *p); static asdl_seq* keyword_patterns_rule(Parser *p); static KeyPatternPair* keyword_pattern_rule(Parser *p); static stmt_ty unless_stmt_rule(Parser *p); +static stmt_ty unless_stmt_nonewline_rule(Parser *p); static stmt_ty type_alias_rule(Parser *p); static asdl_type_param_seq* type_params_rule(Parser *p); static asdl_type_param_seq* type_param_seq_rule(Parser *p); @@ -1003,7 +1078,9 @@ static void *invalid_import_from_targets_rule(Parser *p); static void *invalid_with_stmt_rule(Parser *p); static void *invalid_with_stmt_indent_rule(Parser *p); static void *invalid_try_stmt_rule(Parser *p); +static void *invalid_try_stmt_nonewline_rule(Parser *p); static void *invalid_except_stmt_rule(Parser *p); +static void *invalid_except_stmt_nonewline_rule(Parser *p); static void *invalid_finally_stmt_rule(Parser *p); static void *invalid_except_stmt_indent_rule(Parser *p); static void *invalid_except_star_stmt_indent_rule(Parser *p); @@ -1029,22 +1106,22 @@ static asdl_seq *_loop0_1_rule(Parser *p); static asdl_seq *_loop0_2_rule(Parser *p); static asdl_seq *_loop0_3_rule(Parser *p); static asdl_seq *_loop1_4_rule(Parser *p); -static asdl_seq *_loop0_6_rule(Parser *p); -static asdl_seq *_gather_5_rule(Parser *p); -static asdl_seq *_loop0_8_rule(Parser *p); -static asdl_seq *_gather_7_rule(Parser *p); +static void *_tmp_5_rule(Parser *p); +static void *_tmp_6_rule(Parser *p); +static void *_tmp_7_rule(Parser *p); +static void *_tmp_8_rule(Parser *p); static void *_tmp_9_rule(Parser *p); static void *_tmp_10_rule(Parser *p); static void *_tmp_11_rule(Parser *p); -static void *_tmp_12_rule(Parser *p); -static void *_tmp_13_rule(Parser *p); -static void *_tmp_14_rule(Parser *p); +static asdl_seq *_loop1_12_rule(Parser *p); +static asdl_seq *_loop0_14_rule(Parser *p); +static asdl_seq *_gather_13_rule(Parser *p); static void *_tmp_15_rule(Parser *p); static void *_tmp_16_rule(Parser *p); static void *_tmp_17_rule(Parser *p); static void *_tmp_18_rule(Parser *p); -static asdl_seq *_loop1_19_rule(Parser *p); -static void *_tmp_20_rule(Parser *p); +static void *_tmp_19_rule(Parser *p); +static asdl_seq *_loop1_20_rule(Parser *p); static void *_tmp_21_rule(Parser *p); static void *_tmp_22_rule(Parser *p); static void *_tmp_23_rule(Parser *p); @@ -1053,286 +1130,286 @@ static void *_tmp_25_rule(Parser *p); static void *_tmp_26_rule(Parser *p); static void *_tmp_27_rule(Parser *p); static void *_tmp_28_rule(Parser *p); -static asdl_seq *_loop0_30_rule(Parser *p); -static asdl_seq *_gather_29_rule(Parser *p); -static asdl_seq *_loop0_32_rule(Parser *p); -static asdl_seq *_gather_31_rule(Parser *p); -static void *_tmp_33_rule(Parser *p); +static void *_tmp_29_rule(Parser *p); +static asdl_seq *_loop0_31_rule(Parser *p); +static asdl_seq *_gather_30_rule(Parser *p); +static asdl_seq *_loop0_33_rule(Parser *p); +static asdl_seq *_gather_32_rule(Parser *p); static void *_tmp_34_rule(Parser *p); static void *_tmp_35_rule(Parser *p); -static asdl_seq *_loop0_37_rule(Parser *p); -static asdl_seq *_gather_36_rule(Parser *p); +static void *_tmp_36_rule(Parser *p); static asdl_seq *_loop0_38_rule(Parser *p); -static asdl_seq *_loop1_39_rule(Parser *p); -static asdl_seq *_loop0_41_rule(Parser *p); -static asdl_seq *_gather_40_rule(Parser *p); -static void *_tmp_42_rule(Parser *p); -static asdl_seq *_loop0_44_rule(Parser *p); -static asdl_seq *_gather_43_rule(Parser *p); -static void *_tmp_45_rule(Parser *p); -static asdl_seq *_loop1_46_rule(Parser *p); -static void *_tmp_47_rule(Parser *p); +static asdl_seq *_gather_37_rule(Parser *p); +static asdl_seq *_loop0_39_rule(Parser *p); +static asdl_seq *_loop1_40_rule(Parser *p); +static asdl_seq *_loop0_42_rule(Parser *p); +static asdl_seq *_gather_41_rule(Parser *p); +static void *_tmp_43_rule(Parser *p); +static asdl_seq *_loop0_45_rule(Parser *p); +static asdl_seq *_gather_44_rule(Parser *p); +static void *_tmp_46_rule(Parser *p); +static asdl_seq *_loop1_47_rule(Parser *p); static void *_tmp_48_rule(Parser *p); static void *_tmp_49_rule(Parser *p); static void *_tmp_50_rule(Parser *p); static void *_tmp_51_rule(Parser *p); static void *_tmp_52_rule(Parser *p); -static asdl_seq *_loop0_53_rule(Parser *p); +static void *_tmp_53_rule(Parser *p); static asdl_seq *_loop0_54_rule(Parser *p); static asdl_seq *_loop0_55_rule(Parser *p); -static asdl_seq *_loop1_56_rule(Parser *p); -static asdl_seq *_loop0_57_rule(Parser *p); -static asdl_seq *_loop1_58_rule(Parser *p); +static asdl_seq *_loop0_56_rule(Parser *p); +static asdl_seq *_loop1_57_rule(Parser *p); +static asdl_seq *_loop0_58_rule(Parser *p); static asdl_seq *_loop1_59_rule(Parser *p); static asdl_seq *_loop1_60_rule(Parser *p); -static asdl_seq *_loop0_61_rule(Parser *p); -static asdl_seq *_loop1_62_rule(Parser *p); -static asdl_seq *_loop0_63_rule(Parser *p); -static asdl_seq *_loop1_64_rule(Parser *p); -static asdl_seq *_loop0_65_rule(Parser *p); +static asdl_seq *_loop1_61_rule(Parser *p); +static asdl_seq *_loop0_62_rule(Parser *p); +static asdl_seq *_loop1_63_rule(Parser *p); +static asdl_seq *_loop0_64_rule(Parser *p); +static asdl_seq *_loop1_65_rule(Parser *p); static asdl_seq *_loop0_66_rule(Parser *p); -static asdl_seq *_loop1_67_rule(Parser *p); -static asdl_seq *_loop0_69_rule(Parser *p); -static asdl_seq *_gather_68_rule(Parser *p); -static asdl_seq *_loop0_71_rule(Parser *p); -static asdl_seq *_gather_70_rule(Parser *p); -static asdl_seq *_loop0_73_rule(Parser *p); -static asdl_seq *_gather_72_rule(Parser *p); -static asdl_seq *_loop0_75_rule(Parser *p); -static asdl_seq *_gather_74_rule(Parser *p); -static void *_tmp_76_rule(Parser *p); -static asdl_seq *_loop1_77_rule(Parser *p); -static asdl_seq *_loop1_78_rule(Parser *p); -static void *_tmp_79_rule(Parser *p); -static void *_tmp_80_rule(Parser *p); -static asdl_seq *_loop1_81_rule(Parser *p); -static asdl_seq *_loop1_82_rule(Parser *p); +static asdl_seq *_loop0_67_rule(Parser *p); +static asdl_seq *_loop1_68_rule(Parser *p); +static asdl_seq *_loop0_70_rule(Parser *p); +static asdl_seq *_gather_69_rule(Parser *p); +static asdl_seq *_loop0_72_rule(Parser *p); +static asdl_seq *_gather_71_rule(Parser *p); +static asdl_seq *_loop0_74_rule(Parser *p); +static asdl_seq *_gather_73_rule(Parser *p); +static asdl_seq *_loop0_76_rule(Parser *p); +static asdl_seq *_gather_75_rule(Parser *p); +static asdl_seq *_loop0_78_rule(Parser *p); +static asdl_seq *_gather_77_rule(Parser *p); +static asdl_seq *_loop0_80_rule(Parser *p); +static asdl_seq *_gather_79_rule(Parser *p); +static asdl_seq *_loop0_82_rule(Parser *p); +static asdl_seq *_gather_81_rule(Parser *p); static asdl_seq *_loop0_84_rule(Parser *p); static asdl_seq *_gather_83_rule(Parser *p); -static asdl_seq *_loop1_85_rule(Parser *p); +static void *_tmp_85_rule(Parser *p); static asdl_seq *_loop1_86_rule(Parser *p); -static asdl_seq *_loop0_88_rule(Parser *p); -static asdl_seq *_gather_87_rule(Parser *p); -static void *_tmp_89_rule(Parser *p); +static asdl_seq *_loop1_87_rule(Parser *p); +static asdl_seq *_loop1_88_rule(Parser *p); +static asdl_seq *_loop1_89_rule(Parser *p); static void *_tmp_90_rule(Parser *p); static void *_tmp_91_rule(Parser *p); static void *_tmp_92_rule(Parser *p); -static asdl_seq *_loop0_94_rule(Parser *p); -static asdl_seq *_gather_93_rule(Parser *p); -static asdl_seq *_loop0_96_rule(Parser *p); -static asdl_seq *_gather_95_rule(Parser *p); -static void *_tmp_97_rule(Parser *p); -static asdl_seq *_loop0_99_rule(Parser *p); -static asdl_seq *_gather_98_rule(Parser *p); +static void *_tmp_93_rule(Parser *p); +static asdl_seq *_loop1_94_rule(Parser *p); +static asdl_seq *_loop1_95_rule(Parser *p); +static asdl_seq *_loop0_97_rule(Parser *p); +static asdl_seq *_gather_96_rule(Parser *p); +static asdl_seq *_loop1_98_rule(Parser *p); +static asdl_seq *_loop1_99_rule(Parser *p); static asdl_seq *_loop0_101_rule(Parser *p); static asdl_seq *_gather_100_rule(Parser *p); -static void *_tmp_102_rule(Parser *p); -static asdl_seq *_loop0_104_rule(Parser *p); -static asdl_seq *_gather_103_rule(Parser *p); +static asdl_seq *_loop1_102_rule(Parser *p); +static asdl_seq *_loop1_103_rule(Parser *p); +static asdl_seq *_loop1_104_rule(Parser *p); static asdl_seq *_loop1_105_rule(Parser *p); -static asdl_seq *_loop1_106_rule(Parser *p); -static asdl_seq *_loop0_108_rule(Parser *p); -static asdl_seq *_gather_107_rule(Parser *p); -static asdl_seq *_loop1_109_rule(Parser *p); -static asdl_seq *_loop1_110_rule(Parser *p); -static asdl_seq *_loop1_111_rule(Parser *p); -static void *_tmp_112_rule(Parser *p); -static void *_tmp_113_rule(Parser *p); -static void *_tmp_114_rule(Parser *p); -static void *_tmp_115_rule(Parser *p); -static asdl_seq *_loop0_117_rule(Parser *p); -static asdl_seq *_gather_116_rule(Parser *p); -static void *_tmp_118_rule(Parser *p); -static void *_tmp_119_rule(Parser *p); -static void *_tmp_120_rule(Parser *p); +static asdl_seq *_loop0_107_rule(Parser *p); +static asdl_seq *_gather_106_rule(Parser *p); +static void *_tmp_108_rule(Parser *p); +static void *_tmp_109_rule(Parser *p); +static void *_tmp_110_rule(Parser *p); +static void *_tmp_111_rule(Parser *p); +static asdl_seq *_loop0_113_rule(Parser *p); +static asdl_seq *_gather_112_rule(Parser *p); +static asdl_seq *_loop0_115_rule(Parser *p); +static asdl_seq *_gather_114_rule(Parser *p); +static void *_tmp_116_rule(Parser *p); +static asdl_seq *_loop0_118_rule(Parser *p); +static asdl_seq *_gather_117_rule(Parser *p); +static asdl_seq *_loop0_120_rule(Parser *p); +static asdl_seq *_gather_119_rule(Parser *p); static void *_tmp_121_rule(Parser *p); static void *_tmp_122_rule(Parser *p); -static void *_tmp_123_rule(Parser *p); -static void *_tmp_124_rule(Parser *p); -static asdl_seq *_loop0_125_rule(Parser *p); -static asdl_seq *_loop0_126_rule(Parser *p); -static asdl_seq *_loop0_127_rule(Parser *p); -static asdl_seq *_loop1_128_rule(Parser *p); -static asdl_seq *_loop0_129_rule(Parser *p); +static asdl_seq *_loop0_124_rule(Parser *p); +static asdl_seq *_gather_123_rule(Parser *p); +static asdl_seq *_loop1_125_rule(Parser *p); +static asdl_seq *_loop1_126_rule(Parser *p); +static asdl_seq *_loop0_128_rule(Parser *p); +static asdl_seq *_gather_127_rule(Parser *p); +static asdl_seq *_loop1_129_rule(Parser *p); static asdl_seq *_loop1_130_rule(Parser *p); static asdl_seq *_loop1_131_rule(Parser *p); -static asdl_seq *_loop1_132_rule(Parser *p); -static asdl_seq *_loop0_133_rule(Parser *p); -static asdl_seq *_loop1_134_rule(Parser *p); -static asdl_seq *_loop0_135_rule(Parser *p); -static asdl_seq *_loop1_136_rule(Parser *p); +static void *_tmp_132_rule(Parser *p); +static void *_tmp_133_rule(Parser *p); +static void *_tmp_134_rule(Parser *p); +static void *_tmp_135_rule(Parser *p); static asdl_seq *_loop0_137_rule(Parser *p); -static asdl_seq *_loop1_138_rule(Parser *p); -static asdl_seq *_loop0_139_rule(Parser *p); -static asdl_seq *_loop0_140_rule(Parser *p); -static asdl_seq *_loop0_141_rule(Parser *p); -static asdl_seq *_loop1_142_rule(Parser *p); -static asdl_seq *_loop0_143_rule(Parser *p); -static asdl_seq *_loop1_144_rule(Parser *p); -static asdl_seq *_loop1_145_rule(Parser *p); -static asdl_seq *_loop1_146_rule(Parser *p); +static asdl_seq *_gather_136_rule(Parser *p); +static void *_tmp_138_rule(Parser *p); +static void *_tmp_139_rule(Parser *p); +static void *_tmp_140_rule(Parser *p); +static void *_tmp_141_rule(Parser *p); +static void *_tmp_142_rule(Parser *p); +static void *_tmp_143_rule(Parser *p); +static void *_tmp_144_rule(Parser *p); +static asdl_seq *_loop0_145_rule(Parser *p); +static asdl_seq *_loop0_146_rule(Parser *p); static asdl_seq *_loop0_147_rule(Parser *p); 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 *_loop0_152_rule(Parser *p); -static asdl_seq *_loop1_153_rule(Parser *p); -static void *_tmp_154_rule(Parser *p); +static asdl_seq *_loop1_151_rule(Parser *p); +static asdl_seq *_loop1_152_rule(Parser *p); +static asdl_seq *_loop0_153_rule(Parser *p); +static asdl_seq *_loop1_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_157_rule(Parser *p); +static asdl_seq *_loop1_158_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_160_rule(Parser *p); static asdl_seq *_loop0_161_rule(Parser *p); -static asdl_seq *_loop0_162_rule(Parser *p); +static asdl_seq *_loop1_162_rule(Parser *p); static asdl_seq *_loop0_163_rule(Parser *p); -static void *_tmp_164_rule(Parser *p); -static void *_tmp_165_rule(Parser *p); +static asdl_seq *_loop1_164_rule(Parser *p); +static asdl_seq *_loop1_165_rule(Parser *p); +static asdl_seq *_loop1_166_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 *_loop1_168_rule(Parser *p); +static asdl_seq *_loop0_169_rule(Parser *p); +static asdl_seq *_loop1_170_rule(Parser *p); +static asdl_seq *_loop0_171_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 asdl_seq *_loop1_173_rule(Parser *p); +static void *_tmp_174_rule(Parser *p); +static asdl_seq *_loop0_175_rule(Parser *p); +static asdl_seq *_loop1_176_rule(Parser *p); static void *_tmp_177_rule(Parser *p); -static void *_tmp_178_rule(Parser *p); static asdl_seq *_loop0_179_rule(Parser *p); +static asdl_seq *_gather_178_rule(Parser *p); +static asdl_seq *_loop1_180_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_182_rule(Parser *p); +static asdl_seq *_loop0_183_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 void *_tmp_185_rule(Parser *p); +static asdl_seq *_loop0_187_rule(Parser *p); +static asdl_seq *_gather_186_rule(Parser *p); +static void *_tmp_188_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 asdl_seq *_loop0_196_rule(Parser *p); +static asdl_seq *_gather_195_rule(Parser *p); static void *_tmp_197_rule(Parser *p); static void *_tmp_198_rule(Parser *p); -static void *_tmp_199_rule(Parser *p); -static void *_tmp_200_rule(Parser *p); -static void *_tmp_201_rule(Parser *p); -static void *_tmp_202_rule(Parser *p); +static asdl_seq *_loop0_199_rule(Parser *p); +static asdl_seq *_loop0_201_rule(Parser *p); +static asdl_seq *_gather_200_rule(Parser *p); +static asdl_seq *_loop1_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 void *_tmp_206_rule(Parser *p); -static asdl_seq *_loop0_207_rule(Parser *p); +static asdl_seq *_loop0_206_rule(Parser *p); +static asdl_seq *_gather_205_rule(Parser *p); static asdl_seq *_loop0_208_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 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 *_loop0_217_rule(Parser *p); -static asdl_seq *_loop1_218_rule(Parser *p); +static asdl_seq *_gather_207_rule(Parser *p); +static asdl_seq *_loop0_210_rule(Parser *p); +static asdl_seq *_gather_209_rule(Parser *p); +static asdl_seq *_loop0_212_rule(Parser *p); +static asdl_seq *_gather_211_rule(Parser *p); +static asdl_seq *_loop0_214_rule(Parser *p); +static asdl_seq *_gather_213_rule(Parser *p); +static void *_tmp_215_rule(Parser *p); +static void *_tmp_216_rule(Parser *p); +static void *_tmp_217_rule(Parser *p); +static void *_tmp_218_rule(Parser *p); static void *_tmp_219_rule(Parser *p); -static asdl_seq *_loop0_220_rule(Parser *p); +static void *_tmp_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_222_rule(Parser *p); +static void *_tmp_223_rule(Parser *p); static void *_tmp_224_rule(Parser *p); static void *_tmp_225_rule(Parser *p); static void *_tmp_226_rule(Parser *p); -static void *_tmp_227_rule(Parser *p); +static asdl_seq *_loop0_227_rule(Parser *p); static asdl_seq *_loop0_228_rule(Parser *p); -static void *_tmp_229_rule(Parser *p); +static asdl_seq *_loop0_229_rule(Parser *p); static void *_tmp_230_rule(Parser *p); -static asdl_seq *_loop1_231_rule(Parser *p); +static void *_tmp_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 void *_tmp_233_rule(Parser *p); +static void *_tmp_234_rule(Parser *p); static asdl_seq *_loop0_235_rule(Parser *p); +static asdl_seq *_loop0_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 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_238_rule(Parser *p); +static void *_tmp_239_rule(Parser *p); +static asdl_seq *_loop0_240_rule(Parser *p); +static void *_tmp_241_rule(Parser *p); +static asdl_seq *_loop0_242_rule(Parser *p); static asdl_seq *_loop1_243_rule(Parser *p); static void *_tmp_244_rule(Parser *p); static void *_tmp_245_rule(Parser *p); -static asdl_seq *_loop0_246_rule(Parser *p); +static void *_tmp_246_rule(Parser *p); static void *_tmp_247_rule(Parser *p); -static void *_tmp_248_rule(Parser *p); +static asdl_seq *_loop0_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 void *_tmp_250_rule(Parser *p); +static asdl_seq *_loop1_251_rule(Parser *p); +static void *_tmp_252_rule(Parser *p); +static asdl_seq *_loop0_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 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 asdl_seq *_loop0_263_rule(Parser *p); +static asdl_seq *_loop0_255_rule(Parser *p); +static asdl_seq *_loop0_257_rule(Parser *p); +static asdl_seq *_gather_256_rule(Parser *p); +static void *_tmp_258_rule(Parser *p); +static asdl_seq *_loop0_259_rule(Parser *p); +static void *_tmp_260_rule(Parser *p); +static asdl_seq *_loop0_261_rule(Parser *p); +static asdl_seq *_loop1_262_rule(Parser *p); +static asdl_seq *_loop1_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); -static asdl_seq *_gather_268_rule(Parser *p); +static asdl_seq *_loop0_266_rule(Parser *p); +static void *_tmp_267_rule(Parser *p); +static void *_tmp_268_rule(Parser *p); +static void *_tmp_269_rule(Parser *p); +static asdl_seq *_loop0_270_rule(Parser *p); 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 asdl_seq *_loop0_275_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 asdl_seq *_loop0_272_rule(Parser *p); +static asdl_seq *_loop0_274_rule(Parser *p); +static asdl_seq *_gather_273_rule(Parser *p); +static void *_tmp_275_rule(Parser *p); +static asdl_seq *_loop0_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 asdl_seq *_loop1_280_rule(Parser *p); +static void *_tmp_281_rule(Parser *p); static void *_tmp_282_rule(Parser *p); -static void *_tmp_283_rule(Parser *p); +static asdl_seq *_loop0_283_rule(Parser *p); static void *_tmp_284_rule(Parser *p); static void *_tmp_285_rule(Parser *p); -static void *_tmp_286_rule(Parser *p); -static void *_tmp_287_rule(Parser *p); -static void *_tmp_288_rule(Parser *p); -static void *_tmp_289_rule(Parser *p); -static void *_tmp_290_rule(Parser *p); -static void *_tmp_291_rule(Parser *p); +static asdl_seq *_loop0_287_rule(Parser *p); +static asdl_seq *_gather_286_rule(Parser *p); +static asdl_seq *_loop0_289_rule(Parser *p); +static asdl_seq *_gather_288_rule(Parser *p); +static asdl_seq *_loop0_291_rule(Parser *p); +static asdl_seq *_gather_290_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 asdl_seq *_loop0_295_rule(Parser *p); +static asdl_seq *_gather_294_rule(Parser *p); static void *_tmp_296_rule(Parser *p); -static void *_tmp_297_rule(Parser *p); -static void *_tmp_298_rule(Parser *p); +static asdl_seq *_loop0_297_rule(Parser *p); +static asdl_seq *_loop1_298_rule(Parser *p); static void *_tmp_299_rule(Parser *p); -static void *_tmp_300_rule(Parser *p); -static void *_tmp_301_rule(Parser *p); +static asdl_seq *_loop0_300_rule(Parser *p); +static asdl_seq *_loop1_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 void *_tmp_305_rule(Parser *p); +static asdl_seq *_loop0_304_rule(Parser *p); +static asdl_seq *_loop1_305_rule(Parser *p); static void *_tmp_306_rule(Parser *p); static asdl_seq *_loop0_307_rule(Parser *p); -static void *_tmp_308_rule(Parser *p); +static asdl_seq *_loop1_308_rule(Parser *p); static void *_tmp_309_rule(Parser *p); static void *_tmp_310_rule(Parser *p); static void *_tmp_311_rule(Parser *p); @@ -1341,11 +1418,11 @@ static void *_tmp_313_rule(Parser *p); static void *_tmp_314_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_317_rule(Parser *p); +static void *_tmp_318_rule(Parser *p); static void *_tmp_319_rule(Parser *p); -static void *_tmp_320_rule(Parser *p); -static void *_tmp_321_rule(Parser *p); +static asdl_seq *_loop0_321_rule(Parser *p); +static asdl_seq *_gather_320_rule(Parser *p); static void *_tmp_322_rule(Parser *p); static void *_tmp_323_rule(Parser *p); static void *_tmp_324_rule(Parser *p); @@ -1359,7 +1436,7 @@ static void *_tmp_331_rule(Parser *p); static void *_tmp_332_rule(Parser *p); static void *_tmp_333_rule(Parser *p); static void *_tmp_334_rule(Parser *p); -static void *_tmp_335_rule(Parser *p); +static asdl_seq *_loop0_335_rule(Parser *p); static void *_tmp_336_rule(Parser *p); static void *_tmp_337_rule(Parser *p); static void *_tmp_338_rule(Parser *p); @@ -1371,7 +1448,40 @@ 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); +static asdl_seq *_loop0_348_rule(Parser *p); +static asdl_seq *_gather_347_rule(Parser *p); +static void *_tmp_349_rule(Parser *p); +static void *_tmp_350_rule(Parser *p); +static void *_tmp_351_rule(Parser *p); +static void *_tmp_352_rule(Parser *p); +static void *_tmp_353_rule(Parser *p); +static void *_tmp_354_rule(Parser *p); +static void *_tmp_355_rule(Parser *p); +static void *_tmp_356_rule(Parser *p); +static void *_tmp_357_rule(Parser *p); +static void *_tmp_358_rule(Parser *p); +static void *_tmp_359_rule(Parser *p); +static void *_tmp_360_rule(Parser *p); +static void *_tmp_361_rule(Parser *p); +static void *_tmp_362_rule(Parser *p); +static void *_tmp_363_rule(Parser *p); +static void *_tmp_364_rule(Parser *p); +static void *_tmp_365_rule(Parser *p); +static void *_tmp_366_rule(Parser *p); +static void *_tmp_367_rule(Parser *p); +static void *_tmp_368_rule(Parser *p); +static void *_tmp_369_rule(Parser *p); +static void *_tmp_370_rule(Parser *p); +static void *_tmp_371_rule(Parser *p); +static void *_tmp_372_rule(Parser *p); +static void *_tmp_373_rule(Parser *p); +static asdl_seq *_loop0_375_rule(Parser *p); +static asdl_seq *_gather_374_rule(Parser *p); +static void *_tmp_376_rule(Parser *p); +static void *_tmp_377_rule(Parser *p); +static void *_tmp_378_rule(Parser *p); +static void *_tmp_379_rule(Parser *p); +static void *_tmp_380_rule(Parser *p); // file: statements? $ @@ -1871,7 +1981,7 @@ statement_newline_rule(Parser *p) return _res; } -// simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE +// simple_stmts: simple_stmts_nonewline NEWLINE static asdl_stmt_seq* simple_stmts_rule(Parser *p) { @@ -1885,54 +1995,21 @@ simple_stmts_rule(Parser *p) } asdl_stmt_seq* _res = NULL; int _mark = p->mark; - { // simple_stmt !';' NEWLINE + { // simple_stmts_nonewline NEWLINE if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> simple_stmts[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt !';' NEWLINE")); - stmt_ty a; - Token * newline_var; - if ( - (a = simple_stmt_rule(p)) // simple_stmt - && - _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';' - && - (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' - ) - { - D(fprintf(stderr, "%*c+ simple_stmts[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt !';' NEWLINE")); - _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s simple_stmts[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt !';' NEWLINE")); - } - { // ';'.simple_stmt+ ';'? NEWLINE - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> simple_stmts[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'? NEWLINE")); - void *_opt_var; - UNUSED(_opt_var); // Silence compiler warnings + D(fprintf(stderr, "%*c> simple_stmts[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline NEWLINE")); asdl_stmt_seq* a; Token * newline_var; if ( - (a = (asdl_stmt_seq*)_gather_5_rule(p)) // ';'.simple_stmt+ - && - (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? + (a = simple_stmts_nonewline_rule(p)) // simple_stmts_nonewline && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ simple_stmts[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'? NEWLINE")); + D(fprintf(stderr, "%*c+ simple_stmts[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline NEWLINE")); _res = a; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -1943,7 +2020,7 @@ simple_stmts_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s simple_stmts[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'? NEWLINE")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline NEWLINE")); } _res = NULL; done: @@ -1951,9 +2028,9 @@ simple_stmts_rule(Parser *p) return _res; } -// simple_stmts_nonewline: simple_stmt !';' | ';'.simple_stmt+ ';'? +// simple_stmt_complex: parenthesized_stmt_nonewline | simple_stmt static asdl_stmt_seq* -simple_stmts_nonewline_rule(Parser *p) +simple_stmt_complex_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -1965,49 +2042,38 @@ simple_stmts_nonewline_rule(Parser *p) } asdl_stmt_seq* _res = NULL; int _mark = p->mark; - { // simple_stmt !';' + { // parenthesized_stmt_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> simple_stmts_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt !';'")); - stmt_ty a; + D(fprintf(stderr, "%*c> simple_stmt_complex[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "parenthesized_stmt_nonewline")); + asdl_stmt_seq* parenthesized_stmt_nonewline_var; if ( - (a = simple_stmt_rule(p)) // simple_stmt - && - _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';' + (parenthesized_stmt_nonewline_var = parenthesized_stmt_nonewline_rule(p)) // parenthesized_stmt_nonewline ) { - D(fprintf(stderr, "%*c+ simple_stmts_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt !';'")); - _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } + D(fprintf(stderr, "%*c+ simple_stmt_complex[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "parenthesized_stmt_nonewline")); + _res = parenthesized_stmt_nonewline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s simple_stmts_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt !';'")); + D(fprintf(stderr, "%*c%s simple_stmt_complex[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "parenthesized_stmt_nonewline")); } - { // ';'.simple_stmt+ ';'? + { // simple_stmt if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> simple_stmts_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); - void *_opt_var; - UNUSED(_opt_var); // Silence compiler warnings - asdl_stmt_seq* a; + D(fprintf(stderr, "%*c> simple_stmt_complex[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt")); + stmt_ty a; if ( - (a = (asdl_stmt_seq*)_gather_7_rule(p)) // ';'.simple_stmt+ - && - (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? + (a = simple_stmt_rule(p)) // simple_stmt ) { - D(fprintf(stderr, "%*c+ simple_stmts_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); - _res = a; + D(fprintf(stderr, "%*c+ simple_stmt_complex[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt")); + _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -2016,8 +2082,8 @@ simple_stmts_nonewline_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s simple_stmts_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + D(fprintf(stderr, "%*c%s simple_stmt_complex[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt")); } _res = NULL; done: @@ -2168,15 +2234,15 @@ simple_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'return' ('return' del_kw_stmt | return_stmt)")); - void *_tmp_9_var; + void *_tmp_5_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 560) // token='return' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 567) // token='return' && - (_tmp_9_var = _tmp_9_rule(p)) // 'return' del_kw_stmt | return_stmt + (_tmp_5_var = _tmp_5_rule(p)) // 'return' del_kw_stmt | return_stmt ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'return' ('return' del_kw_stmt | return_stmt)")); - _res = _tmp_9_var; + _res = _tmp_5_var; goto done; } p->mark = _mark; @@ -2191,7 +2257,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('import' | 'from') import_stmt")); stmt_ty import_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_10_rule, p) + _PyPegen_lookahead(1, _tmp_6_rule, p) && (import_stmt_var = import_stmt_rule(p)) // import_stmt ) @@ -2212,7 +2278,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'raise' raise_stmt")); stmt_ty raise_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 559) // token='raise' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 566) // token='raise' && (raise_stmt_var = raise_stmt_rule(p)) // raise_stmt ) @@ -2233,7 +2299,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 558)) // token='pass' + (_keyword = _PyPegen_expect_token(p, 565)) // token='pass' ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); @@ -2264,15 +2330,15 @@ simple_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'del' (del_kw_stmt | del_stmt)")); - void *_tmp_11_var; + void *_tmp_7_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 663) // token='del' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 698) // token='del' && - (_tmp_11_var = _tmp_11_rule(p)) // del_kw_stmt | del_stmt + (_tmp_7_var = _tmp_7_rule(p)) // del_kw_stmt | del_stmt ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'del' (del_kw_stmt | del_stmt)")); - _res = _tmp_11_var; + _res = _tmp_7_var; goto done; } p->mark = _mark; @@ -2287,7 +2353,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'yield' yield_stmt")); stmt_ty yield_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 622) // token='yield' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 657) // token='yield' && (yield_stmt_var = yield_stmt_rule(p)) // yield_stmt ) @@ -2308,7 +2374,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'assert' assert_stmt")); stmt_ty assert_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 566) // token='assert' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 573) // token='assert' && (assert_stmt_var = assert_stmt_rule(p)) // assert_stmt ) @@ -2329,7 +2395,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 538)) // token='break' + (_keyword = _PyPegen_expect_token(p, 545)) // token='break' ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); @@ -2362,7 +2428,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 540)) // token='continue' + (_keyword = _PyPegen_expect_token(p, 547)) // token='continue' ) { D(fprintf(stderr, "%*c+ simple_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); @@ -2395,7 +2461,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'global' global_stmt")); stmt_ty global_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 548) // token='global' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 555) // token='global' && (global_stmt_var = global_stmt_rule(p)) // global_stmt ) @@ -2416,7 +2482,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'nonlocal' nonlocal_stmt")); stmt_ty nonlocal_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 555) // token='nonlocal' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 562) // token='nonlocal' && (nonlocal_stmt_var = nonlocal_stmt_rule(p)) // nonlocal_stmt ) @@ -2437,7 +2503,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'goto' goto_stmt")); stmt_ty goto_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 567) // token='goto' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 574) // token='goto' && (goto_stmt_var = goto_stmt_rule(p)) // goto_stmt ) @@ -2489,7 +2555,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def")); stmt_ty function_def_var; if ( - _PyPegen_lookahead(1, _tmp_12_rule, p) + _PyPegen_lookahead(1, _tmp_8_rule, p) && (function_def_var = function_def_rule(p)) // function_def ) @@ -2510,7 +2576,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'if' if_stmt")); stmt_ty if_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 706) // token='if' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 753) // token='if' && (if_stmt_var = if_stmt_rule(p)) // if_stmt ) @@ -2552,7 +2618,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def")); stmt_ty class_def_var; if ( - _PyPegen_lookahead(1, _tmp_13_rule, p) + _PyPegen_lookahead(1, _tmp_9_rule, p) && (class_def_var = class_def_rule(p)) // class_def ) @@ -2573,7 +2639,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('with' | 'async') with_stmt")); stmt_ty with_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_14_rule, p) + _PyPegen_lookahead(1, _tmp_10_rule, p) && (with_stmt_var = with_stmt_rule(p)) // with_stmt ) @@ -2594,7 +2660,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('for' | 'async') for_stmt")); stmt_ty for_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_15_rule, p) + _PyPegen_lookahead(1, _tmp_11_rule, p) && (for_stmt_var = for_stmt_rule(p)) // for_stmt ) @@ -2615,7 +2681,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'try' try_stmt")); stmt_ty try_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 688) // token='try' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 732) // token='try' && (try_stmt_var = try_stmt_rule(p)) // try_stmt ) @@ -2636,7 +2702,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'while' while_stmt")); stmt_ty while_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 711) // token='while' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 758) // token='while' && (while_stmt_var = while_stmt_rule(p)) // while_stmt ) @@ -2695,6 +2761,443 @@ compound_stmt_rule(Parser *p) return _res; } +// statements_nonewline: statement_nonewline+ +static asdl_stmt_seq* +statements_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + int _mark = p->mark; + { // statement_nonewline+ + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> statements_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "statement_nonewline+")); + asdl_seq * a; + if ( + (a = _loop1_12_rule(p)) // statement_nonewline+ + ) + { + D(fprintf(stderr, "%*c+ statements_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "statement_nonewline+")); + _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s statements_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "statement_nonewline+")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// parenthesized_stmt_nonewline: '(' statement_nonewline ')' +static asdl_stmt_seq* +parenthesized_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + int _mark = p->mark; + { // '(' statement_nonewline ')' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> parenthesized_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' statement_nonewline ')'")); + Token * _literal; + Token * _literal_1; + asdl_stmt_seq* a; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = statement_nonewline_rule(p)) // statement_nonewline + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + D(fprintf(stderr, "%*c+ parenthesized_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' statement_nonewline ')'")); + _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 parenthesized_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' statement_nonewline ')'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// statement_nonewline: compound_stmt_nonewline | simple_stmts_nonewline +static asdl_stmt_seq* +statement_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + if (_PyPegen_is_memoized(p, statement_nonewline_type, &_res)) { + p->level--; + return _res; + } + int _mark = p->mark; + { // compound_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> statement_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "compound_stmt_nonewline")); + stmt_ty a; + if ( + (a = compound_stmt_nonewline_rule(p)) // compound_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ statement_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "compound_stmt_nonewline")); + _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s statement_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "compound_stmt_nonewline")); + } + { // simple_stmts_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> statement_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + asdl_stmt_seq* a; + if ( + (a = (asdl_stmt_seq*)simple_stmts_nonewline_rule(p)) // simple_stmts_nonewline + ) + { + D(fprintf(stderr, "%*c+ statement_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + _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 statement_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + } + _res = NULL; + done: + _PyPegen_insert_memo(p, _mark, statement_nonewline_type, _res); + p->level--; + return _res; +} + +// simple_stmts_nonewline: +// | simple_stmt_complex !';' +// | ';'.(';'.simple_stmt+ | parenthesized_stmt_nonewline)+ ';'? +static asdl_stmt_seq* +simple_stmts_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + if (_PyPegen_is_memoized(p, simple_stmts_nonewline_type, &_res)) { + p->level--; + return _res; + } + int _mark = p->mark; + { // simple_stmt_complex !';' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> simple_stmts_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt_complex !';'")); + asdl_stmt_seq* simple_stmt_complex_var; + if ( + (simple_stmt_complex_var = simple_stmt_complex_rule(p)) // simple_stmt_complex + && + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';' + ) + { + D(fprintf(stderr, "%*c+ simple_stmts_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt_complex !';'")); + _res = simple_stmt_complex_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s simple_stmts_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt_complex !';'")); + } + { // ';'.(';'.simple_stmt+ | parenthesized_stmt_nonewline)+ ';'? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> simple_stmts_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.(';'.simple_stmt+ | parenthesized_stmt_nonewline)+ ';'?")); + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_seq * a; + if ( + (a = _gather_13_rule(p)) // ';'.(';'.simple_stmt+ | parenthesized_stmt_nonewline)+ + && + (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? + ) + { + D(fprintf(stderr, "%*c+ simple_stmts_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.(';'.simple_stmt+ | parenthesized_stmt_nonewline)+ ';'?")); + _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s simple_stmts_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'.(';'.simple_stmt+ | parenthesized_stmt_nonewline)+ ';'?")); + } + _res = NULL; + done: + _PyPegen_insert_memo(p, _mark, simple_stmts_nonewline_type, _res); + p->level--; + return _res; +} + +// compound_stmt_nonewline: +// | &'if' if_stmt_nonewline +// | &':' unless_stmt_nonewline +// | &('with' | 'async') with_stmt_nonewline +// | &('for' | 'async') for_stmt_nonewline +// | &'try' try_stmt_nonewline +// | &'while' while_stmt_nonewline +// | &"switch" switch_stmt_nonewline +// | match_stmt_nonewline +static stmt_ty +compound_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + { // &'if' if_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'if' if_stmt_nonewline")); + stmt_ty if_stmt_nonewline_var; + if ( + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 753) // token='if' + && + (if_stmt_nonewline_var = if_stmt_nonewline_rule(p)) // if_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'if' if_stmt_nonewline")); + _res = if_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&'if' if_stmt_nonewline")); + } + { // &':' unless_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&':' unless_stmt_nonewline")); + stmt_ty unless_stmt_nonewline_var; + if ( + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':' + && + (unless_stmt_nonewline_var = unless_stmt_nonewline_rule(p)) // unless_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&':' unless_stmt_nonewline")); + _res = unless_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&':' unless_stmt_nonewline")); + } + { // &('with' | 'async') with_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('with' | 'async') with_stmt_nonewline")); + stmt_ty with_stmt_nonewline_var; + if ( + _PyPegen_lookahead(1, _tmp_15_rule, p) + && + (with_stmt_nonewline_var = with_stmt_nonewline_rule(p)) // with_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('with' | 'async') with_stmt_nonewline")); + _res = with_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&('with' | 'async') with_stmt_nonewline")); + } + { // &('for' | 'async') for_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('for' | 'async') for_stmt_nonewline")); + stmt_ty for_stmt_nonewline_var; + if ( + _PyPegen_lookahead(1, _tmp_16_rule, p) + && + (for_stmt_nonewline_var = for_stmt_nonewline_rule(p)) // for_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('for' | 'async') for_stmt_nonewline")); + _res = for_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&('for' | 'async') for_stmt_nonewline")); + } + { // &'try' try_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'try' try_stmt_nonewline")); + stmt_ty try_stmt_nonewline_var; + if ( + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 732) // token='try' + && + (try_stmt_nonewline_var = try_stmt_nonewline_rule(p)) // try_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'try' try_stmt_nonewline")); + _res = try_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&'try' try_stmt_nonewline")); + } + { // &'while' while_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'while' while_stmt_nonewline")); + stmt_ty while_stmt_nonewline_var; + if ( + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 758) // token='while' + && + (while_stmt_nonewline_var = while_stmt_nonewline_rule(p)) // while_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'while' while_stmt_nonewline")); + _res = while_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&'while' while_stmt_nonewline")); + } + { // &"switch" switch_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&\"switch\" switch_stmt_nonewline")); + stmt_ty switch_stmt_nonewline_var; + if ( + _PyPegen_lookahead_with_string(1, _PyPegen_expect_soft_keyword, p, "switch") + && + (switch_stmt_nonewline_var = switch_stmt_nonewline_rule(p)) // switch_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&\"switch\" switch_stmt_nonewline")); + _res = switch_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&\"switch\" switch_stmt_nonewline")); + } + { // match_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> compound_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "match_stmt_nonewline")); + stmt_ty match_stmt_nonewline_var; + if ( + (match_stmt_nonewline_var = match_stmt_nonewline_rule(p)) // match_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ compound_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "match_stmt_nonewline")); + _res = match_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s compound_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "match_stmt_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // assignment: // | NAME ':' expression ['=' annotated_rhs] // | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs] @@ -2742,7 +3245,7 @@ assignment_rule(Parser *p) && (b = expression_rule(p)) // expression && - (c = _tmp_16_rule(p), !p->error_indicator) // ['=' annotated_rhs] + (c = _tmp_17_rule(p), !p->error_indicator) // ['=' annotated_rhs] ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME ':' expression ['=' annotated_rhs]")); @@ -2778,13 +3281,13 @@ assignment_rule(Parser *p) expr_ty b; void *c; if ( - (a = _tmp_17_rule(p)) // '(' single_target ')' | single_subscript_attribute_target + (a = _tmp_18_rule(p)) // '(' single_target ')' | single_subscript_attribute_target && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (b = expression_rule(p)) // expression && - (c = _tmp_18_rule(p), !p->error_indicator) // ['=' annotated_rhs] + (c = _tmp_19_rule(p), !p->error_indicator) // ['=' annotated_rhs] ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); @@ -2819,9 +3322,9 @@ assignment_rule(Parser *p) void *b; void *tc; if ( - (a = (asdl_expr_seq*)_loop1_19_rule(p)) // ((star_targets '='))+ + (a = (asdl_expr_seq*)_loop1_20_rule(p)) // ((star_targets '='))+ && - (b = _tmp_20_rule(p)) // yield_expr | star_expressions + (b = _tmp_21_rule(p)) // yield_expr | star_expressions && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' && @@ -2863,11 +3366,11 @@ assignment_rule(Parser *p) if ( (a = single_target_rule(p)) // single_target && - (t = _tmp_21_rule(p)) // '|>=' + (t = _tmp_22_rule(p)) // '|>=' && (_cut_var = 1) && - (c = _tmp_22_rule(p)) // [yield_expr | star_expressions] + (c = _tmp_23_rule(p)) // [yield_expr | star_expressions] ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_target ('|>=') ~ ([yield_expr | star_expressions])")); @@ -2909,7 +3412,7 @@ assignment_rule(Parser *p) && (b = unarassign_rule(p)) // unarassign && - _PyPegen_lookahead(1, _tmp_23_rule, p) + _PyPegen_lookahead(1, _tmp_24_rule, p) ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_target unarassign &(';' | NEWLINE)")); @@ -2951,7 +3454,7 @@ assignment_rule(Parser *p) && (_cut_var = 1) && - (c = _tmp_24_rule(p)) // yield_expr | star_expressions + (c = _tmp_25_rule(p)) // yield_expr | star_expressions ) { D(fprintf(stderr, "%*c+ assignment[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_target augassign ~ (yield_expr | star_expressions)")); @@ -3478,9 +3981,9 @@ unarassign_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> unarassign[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('+=' | '+' '=')")); - void *_tmp_25_var; + void *_tmp_26_var; if ( - (_tmp_25_var = _tmp_25_rule(p)) // '+=' | '+' '=' + (_tmp_26_var = _tmp_26_rule(p)) // '+=' | '+' '=' ) { D(fprintf(stderr, "%*c+ unarassign[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('+=' | '+' '=')")); @@ -3502,9 +4005,9 @@ unarassign_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> unarassign[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('-=' | '-' '=')")); - void *_tmp_26_var; + void *_tmp_27_var; if ( - (_tmp_26_var = _tmp_26_rule(p)) // '-=' | '-' '=' + (_tmp_27_var = _tmp_27_rule(p)) // '-=' | '-' '=' ) { D(fprintf(stderr, "%*c+ unarassign[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('-=' | '-' '=')")); @@ -3553,9 +4056,9 @@ unarassign_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> unarassign[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('!=' | '!' '=')")); - void *_tmp_27_var; + void *_tmp_28_var; if ( - (_tmp_27_var = _tmp_27_rule(p)) // '!=' | '!' '=' + (_tmp_28_var = _tmp_28_rule(p)) // '!=' | '!' '=' ) { D(fprintf(stderr, "%*c+ unarassign[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('!=' | '!' '=')")); @@ -3609,7 +4112,7 @@ return_stmt_rule(Parser *p) Token * _keyword; void *a; if ( - (_keyword = _PyPegen_expect_token(p, 560)) // token='return' + (_keyword = _PyPegen_expect_token(p, 567)) // token='return' && (a = star_expressions_rule(p), !p->error_indicator) // star_expressions? ) @@ -3675,11 +4178,11 @@ raise_stmt_rule(Parser *p) expr_ty a; void *b; if ( - (_keyword = _PyPegen_expect_token(p, 559)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 566)) // token='raise' && (a = expression_rule(p)) // expression && - (b = _tmp_28_rule(p), !p->error_indicator) // ['from' expression] + (b = _tmp_29_rule(p), !p->error_indicator) // ['from' expression] ) { D(fprintf(stderr, "%*c+ raise_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise' expression ['from' expression]")); @@ -3712,7 +4215,7 @@ raise_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> raise_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 559)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 566)) // token='raise' ) { D(fprintf(stderr, "%*c+ raise_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); @@ -3775,9 +4278,9 @@ global_stmt_rule(Parser *p) Token * _keyword; asdl_expr_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 548)) // token='global' + (_keyword = _PyPegen_expect_token(p, 555)) // token='global' && - (a = (asdl_expr_seq*)_gather_29_rule(p)) // ','.NAME+ + (a = (asdl_expr_seq*)_gather_30_rule(p)) // ','.NAME+ ) { D(fprintf(stderr, "%*c+ global_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global' ','.NAME+")); @@ -3840,9 +4343,9 @@ nonlocal_stmt_rule(Parser *p) Token * _keyword; asdl_expr_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 555)) // token='nonlocal' + (_keyword = _PyPegen_expect_token(p, 562)) // token='nonlocal' && - (a = (asdl_expr_seq*)_gather_31_rule(p)) // ','.NAME+ + (a = (asdl_expr_seq*)_gather_32_rule(p)) // ','.NAME+ ) { D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal' ','.NAME+")); @@ -3906,9 +4409,9 @@ del_kw_stmt_rule(Parser *p) Token * _keyword; Token* a; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='del' + (_keyword = _PyPegen_expect_token(p, 698)) // token='del' && - (a = (Token*)_tmp_33_rule(p)) // 'False' | 'None' | 'True' | 'and' | 'as' | 'assert' | 'async' | 'await' | 'break' | 'class' | 'continue' | 'del' | 'elif' | 'else' | 'except' | 'finally' | 'for' | 'from' | 'global' | 'goto' | 'if' | 'import' | 'in' | 'is' | 'lambda' | 'nonlocal' | 'not' | 'or' | 'pass' | 'raise' | 'return' | 'try' | 'while' | 'with' | 'yield' + (a = (Token*)_tmp_34_rule(p)) // 'False' | 'None' | 'True' | 'and' | 'as' | 'assert' | 'async' | 'await' | 'break' | 'class' | 'continue' | 'del' | 'elif' | 'else' | 'except' | 'finally' | 'for' | 'from' | 'global' | 'goto' | 'if' | 'import' | 'in' | 'is' | 'lambda' | 'nonlocal' | 'not' | 'or' | 'pass' | 'raise' | 'return' | 'try' | 'while' | 'with' | 'yield' ) { D(fprintf(stderr, "%*c+ del_kw_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del' ('False' | 'None' | 'True' | 'and' | 'as' | 'assert' | 'async' | 'await' | 'break' | 'class' | 'continue' | 'del' | 'elif' | 'else' | 'except' | 'finally' | 'for' | 'from' | 'global' | 'goto' | 'if' | 'import' | 'in' | 'is' | 'lambda' | 'nonlocal' | 'not' | 'or' | 'pass' | 'raise' | 'return' | 'try' | 'while' | 'with' | 'yield')")); @@ -3971,11 +4474,11 @@ del_stmt_rule(Parser *p) Token * _keyword; asdl_expr_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='del' + (_keyword = _PyPegen_expect_token(p, 698)) // token='del' && (a = del_targets_rule(p)) // del_targets && - _PyPegen_lookahead(1, _tmp_34_rule, p) + _PyPegen_lookahead(1, _tmp_35_rule, p) ) { D(fprintf(stderr, "%*c+ del_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del' del_targets &(';' | NEWLINE)")); @@ -4120,11 +4623,11 @@ assert_stmt_rule(Parser *p) expr_ty a; void *b; if ( - (_keyword = _PyPegen_expect_token(p, 566)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 573)) // token='assert' && (a = expression_rule(p)) // expression && - (b = _tmp_35_rule(p), !p->error_indicator) // [',' expression] + (b = _tmp_36_rule(p), !p->error_indicator) // [',' expression] ) { D(fprintf(stderr, "%*c+ assert_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert' expression [',' expression]")); @@ -4187,7 +4690,7 @@ goto_stmt_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 567)) // token='goto' + (_keyword = _PyPegen_expect_token(p, 574)) // token='goto' && (a = _PyPegen_name_token(p)) // NAME ) @@ -4254,7 +4757,7 @@ label_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_soft_keyword(p, "label")) // soft_keyword='"label"' && - (a = (asdl_expr_seq*)_gather_36_rule(p)) // ','.NAME+ + (a = (asdl_expr_seq*)_gather_37_rule(p)) // ','.NAME+ ) { D(fprintf(stderr, "%*c+ label_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"label\" ','.NAME+")); @@ -4394,7 +4897,7 @@ import_name_rule(Parser *p) Token * _keyword; asdl_alias_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 667)) // token='import' + (_keyword = _PyPegen_expect_token(p, 702)) // token='import' && (a = dotted_as_names_rule(p)) // dotted_as_names ) @@ -4464,13 +4967,13 @@ import_from_rule(Parser *p) expr_ty b; asdl_alias_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword = _PyPegen_expect_token(p, 703)) // token='from' && - (a = _loop0_38_rule(p)) // (('.' | '...'))* + (a = _loop0_39_rule(p)) // (('.' | '...'))* && (b = dotted_name_rule(p)) // dotted_name && - (_keyword_1 = _PyPegen_expect_token(p, 667)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 702)) // token='import' && (c = import_from_targets_rule(p)) // import_from_targets ) @@ -4508,11 +5011,11 @@ import_from_rule(Parser *p) asdl_seq * a; asdl_alias_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword = _PyPegen_expect_token(p, 703)) // token='from' && - (a = _loop1_39_rule(p)) // (('.' | '...'))+ + (a = _loop1_40_rule(p)) // (('.' | '...'))+ && - (_keyword_1 = _PyPegen_expect_token(p, 667)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 702)) // token='import' && (b = import_from_targets_rule(p)) // import_from_targets ) @@ -4707,7 +5210,7 @@ import_from_as_names_rule(Parser *p) D(fprintf(stderr, "%*c> import_from_as_names[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.import_from_as_name+")); asdl_alias_seq* a; if ( - (a = (asdl_alias_seq*)_gather_40_rule(p)) // ','.import_from_as_name+ + (a = (asdl_alias_seq*)_gather_41_rule(p)) // ','.import_from_as_name+ ) { D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.import_from_as_name+")); @@ -4763,7 +5266,7 @@ import_from_as_name_rule(Parser *p) if ( (a = _PyPegen_name_token(p)) // NAME && - (b = _tmp_42_rule(p), !p->error_indicator) // ['as' NAME] + (b = _tmp_43_rule(p), !p->error_indicator) // ['as' NAME] ) { D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME ['as' NAME]")); @@ -4816,7 +5319,7 @@ dotted_as_names_rule(Parser *p) D(fprintf(stderr, "%*c> dotted_as_names[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.dotted_as_name+")); asdl_alias_seq* a; if ( - (a = (asdl_alias_seq*)_gather_43_rule(p)) // ','.dotted_as_name+ + (a = (asdl_alias_seq*)_gather_44_rule(p)) // ','.dotted_as_name+ ) { D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.dotted_as_name+")); @@ -4872,7 +5375,7 @@ dotted_as_name_rule(Parser *p) if ( (a = dotted_name_rule(p)) // dotted_name && - (b = _tmp_45_rule(p), !p->error_indicator) // ['as' NAME] + (b = _tmp_46_rule(p), !p->error_indicator) // ['as' NAME] ) { D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name ['as' NAME]")); @@ -5105,7 +5608,7 @@ block_rule(Parser *p) return _res; } -// block_nonewline: NEWLINE INDENT? statements DEDENT? | simple_stmts_nonewline +// block_nonewline: statements_nonewline static asdl_stmt_seq* block_nonewline_rule(Parser *p) { @@ -5119,59 +5622,24 @@ block_nonewline_rule(Parser *p) } asdl_stmt_seq* _res = NULL; int _mark = p->mark; - { // NEWLINE INDENT? statements DEDENT? - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT? statements DEDENT?")); - void *_opt_var; - UNUSED(_opt_var); // Silence compiler warnings - void *_opt_var_1; - UNUSED(_opt_var_1); // Silence compiler warnings - asdl_stmt_seq* a; - Token * newline_var; - if ( - (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' - && - (_opt_var = _PyPegen_expect_token(p, INDENT), !p->error_indicator) // INDENT? - && - (a = statements_rule(p)) // statements - && - (_opt_var_1 = _PyPegen_expect_token(p, DEDENT), !p->error_indicator) // DEDENT? - ) - { - D(fprintf(stderr, "%*c+ block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT? statements DEDENT?")); - _res = a; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE INDENT? statements DEDENT?")); - } - { // simple_stmts_nonewline + { // statements_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); - asdl_stmt_seq* simple_stmts_nonewline_var; + D(fprintf(stderr, "%*c> block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "statements_nonewline")); + asdl_stmt_seq* statements_nonewline_var; if ( - (simple_stmts_nonewline_var = simple_stmts_nonewline_rule(p)) // simple_stmts_nonewline + (statements_nonewline_var = statements_nonewline_rule(p)) // statements_nonewline ) { - D(fprintf(stderr, "%*c+ block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); - _res = simple_stmts_nonewline_var; + D(fprintf(stderr, "%*c+ block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "statements_nonewline")); + _res = statements_nonewline_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "statements_nonewline")); } _res = NULL; done: @@ -5201,7 +5669,7 @@ decorators_rule(Parser *p) D(fprintf(stderr, "%*c> decorators[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(('@' named_expression NEWLINE))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_46_rule(p)) // (('@' named_expression NEWLINE))+ + (a = (asdl_expr_seq*)_loop1_47_rule(p)) // (('@' named_expression NEWLINE))+ ) { D(fprintf(stderr, "%*c+ decorators[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(('@' named_expression NEWLINE))+")); @@ -5346,13 +5814,13 @@ class_def_raw_rule(Parser *p) asdl_stmt_seq* c; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 720)) // token='class' + (_keyword = _PyPegen_expect_token(p, 767)) // token='class' && (a = _PyPegen_name_token(p)) // NAME && (t = type_params_rule(p), !p->error_indicator) // type_params? && - (b = _tmp_47_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (b = _tmp_48_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -5510,13 +5978,13 @@ class_def_raw_nonewline_rule(Parser *p) asdl_stmt_seq* c; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 720)) // token='class' + (_keyword = _PyPegen_expect_token(p, 767)) // token='class' && (a = _PyPegen_name_token(p)) // NAME && (t = type_params_rule(p), !p->error_indicator) // type_params? && - (b = _tmp_48_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (b = _tmp_49_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -5691,7 +6159,7 @@ function_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_49_rule(p), !p->error_indicator) // ['->' expression] + (a = _tmp_50_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -5740,7 +6208,7 @@ function_def_raw_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' && (_keyword_1 = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' && @@ -5754,7 +6222,7 @@ function_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_50_rule(p), !p->error_indicator) // ['->' expression] + (a = _tmp_51_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -5913,7 +6381,7 @@ function_def_raw_nonewline_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_51_rule(p), !p->error_indicator) // ['->' expression] + (a = _tmp_52_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -5962,7 +6430,7 @@ function_def_raw_nonewline_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' && (_keyword_1 = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' && @@ -5976,7 +6444,7 @@ function_def_raw_nonewline_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_52_rule(p), !p->error_indicator) // ['->' expression] + (a = _tmp_53_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -6103,9 +6571,9 @@ parameters_rule(Parser *p) if ( (a = slash_no_default_rule(p)) // slash_no_default && - (b = (asdl_arg_seq*)_loop0_53_rule(p)) // param_no_default* + (b = (asdl_arg_seq*)_loop0_54_rule(p)) // param_no_default* && - (c = _loop0_54_rule(p)) // param_with_default* + (c = _loop0_55_rule(p)) // param_with_default* && (d = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -6135,7 +6603,7 @@ parameters_rule(Parser *p) if ( (a = slash_with_default_rule(p)) // slash_with_default && - (b = _loop0_55_rule(p)) // param_with_default* + (b = _loop0_56_rule(p)) // param_with_default* && (c = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -6163,9 +6631,9 @@ parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_56_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_57_rule(p)) // param_no_default+ && - (b = _loop0_57_rule(p)) // param_with_default* + (b = _loop0_58_rule(p)) // param_with_default* && (c = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -6192,7 +6660,7 @@ parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_58_rule(p)) // param_with_default+ + (a = _loop1_59_rule(p)) // param_with_default+ && (b = star_etc_rule(p), !p->error_indicator) // star_etc? ) @@ -6264,7 +6732,7 @@ slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_59_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_60_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -6293,7 +6761,7 @@ slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_60_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_61_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -6346,9 +6814,9 @@ slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_61_rule(p)) // param_no_default* + (a = _loop0_62_rule(p)) // param_no_default* && - (b = _loop1_62_rule(p)) // param_with_default+ + (b = _loop1_63_rule(p)) // param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -6378,9 +6846,9 @@ slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_63_rule(p)) // param_no_default* + (a = _loop0_64_rule(p)) // param_no_default* && - (b = _loop1_64_rule(p)) // param_with_default+ + (b = _loop1_65_rule(p)) // param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -6459,7 +6927,7 @@ star_etc_rule(Parser *p) && (a = param_no_default_rule(p)) // param_no_default && - (b = _loop0_65_rule(p)) // param_maybe_default* + (b = _loop0_66_rule(p)) // param_maybe_default* && (c = kwds_rule(p), !p->error_indicator) // kwds? ) @@ -6492,7 +6960,7 @@ star_etc_rule(Parser *p) && (a = param_no_default_star_annotation_rule(p)) // param_no_default_star_annotation && - (b = _loop0_66_rule(p)) // param_maybe_default* + (b = _loop0_67_rule(p)) // param_maybe_default* && (c = kwds_rule(p), !p->error_indicator) // kwds? ) @@ -6525,7 +6993,7 @@ star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_67_rule(p)) // param_maybe_default+ + (b = _loop1_68_rule(p)) // param_maybe_default+ && (c = kwds_rule(p), !p->error_indicator) // kwds? ) @@ -7318,7 +7786,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -7363,7 +7831,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -7459,7 +7927,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 755)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -7504,7 +7972,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 755)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -7586,7 +8054,7 @@ else_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 709)) // token='else' + (_keyword = _PyPegen_expect_token(p, 756)) // token='else' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7612,6 +8080,298 @@ else_block_rule(Parser *p) return _res; } +// if_stmt_nonewline: +// | 'if' named_expression ':' block_nonewline elif_stmt_nonewline +// | 'if' named_expression ':' block_nonewline else_block? +static stmt_ty +if_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'if' named_expression ':' block_nonewline elif_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> if_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' named_expression ':' block_nonewline elif_stmt_nonewline")); + Token * _keyword; + Token * _literal; + expr_ty a; + asdl_stmt_seq* b; + stmt_ty c; + if ( + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' + && + (a = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (c = elif_stmt_nonewline_rule(p)) // elif_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ if_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' named_expression ':' block_nonewline elif_stmt_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s if_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' named_expression ':' block_nonewline elif_stmt_nonewline")); + } + { // 'if' named_expression ':' block_nonewline else_block? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> if_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' named_expression ':' block_nonewline else_block?")); + Token * _keyword; + Token * _literal; + expr_ty a; + asdl_stmt_seq* b; + void *c; + if ( + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' + && + (a = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (c = else_block_rule(p), !p->error_indicator) // else_block? + ) + { + D(fprintf(stderr, "%*c+ if_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' named_expression ':' block_nonewline else_block?")); + 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_If ( a , b , c , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s if_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' named_expression ':' block_nonewline else_block?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// elif_stmt_nonewline: +// | 'elif' named_expression ':' block elif_stmt_nonewline +// | 'elif' named_expression ':' block_nonewline else_block_nonewline? +static stmt_ty +elif_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'elif' named_expression ':' block elif_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> elif_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif' named_expression ':' block elif_stmt_nonewline")); + Token * _keyword; + Token * _literal; + expr_ty a; + asdl_stmt_seq* b; + stmt_ty c; + if ( + (_keyword = _PyPegen_expect_token(p, 755)) // token='elif' + && + (a = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_rule(p)) // block + && + (c = elif_stmt_nonewline_rule(p)) // elif_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ elif_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif' named_expression ':' block elif_stmt_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s elif_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'elif' named_expression ':' block elif_stmt_nonewline")); + } + { // 'elif' named_expression ':' block_nonewline else_block_nonewline? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> elif_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif' named_expression ':' block_nonewline else_block_nonewline?")); + Token * _keyword; + Token * _literal; + expr_ty a; + asdl_stmt_seq* b; + void *c; + if ( + (_keyword = _PyPegen_expect_token(p, 755)) // token='elif' + && + (a = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (c = else_block_nonewline_rule(p), !p->error_indicator) // else_block_nonewline? + ) + { + D(fprintf(stderr, "%*c+ elif_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif' named_expression ':' block_nonewline else_block_nonewline?")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_If ( a , b , c , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s elif_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'elif' named_expression ':' block_nonewline else_block_nonewline?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// else_block_nonewline: 'else' &&':' block_nonewline +static asdl_stmt_seq* +else_block_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_stmt_seq* _res = NULL; + int _mark = p->mark; + { // 'else' &&':' block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> else_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else' &&':' block_nonewline")); + Token * _keyword; + Token * _literal; + asdl_stmt_seq* b; + if ( + (_keyword = _PyPegen_expect_token(p, 756)) // token='else' + && + (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ else_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else' &&':' block_nonewline")); + _res = b; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s else_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'else' &&':' block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block? static stmt_ty while_stmt_rule(Parser *p) @@ -7666,7 +8426,7 @@ while_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 711)) // token='while' + (_keyword = _PyPegen_expect_token(p, 758)) // token='while' && (a = named_expression_rule(p)) // named_expression && @@ -7705,6 +8465,81 @@ while_stmt_rule(Parser *p) return _res; } +// while_stmt_nonewline: +// | 'while' named_expression ':' block_nonewline else_block_nonewline? +static stmt_ty +while_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'while' named_expression ':' block_nonewline else_block_nonewline? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> while_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while' named_expression ':' block_nonewline else_block_nonewline?")); + Token * _keyword; + Token * _literal; + expr_ty a; + asdl_stmt_seq* b; + void *c; + if ( + (_keyword = _PyPegen_expect_token(p, 758)) // token='while' + && + (a = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (c = else_block_nonewline_rule(p), !p->error_indicator) // else_block_nonewline? + ) + { + D(fprintf(stderr, "%*c+ while_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while' named_expression ':' block_nonewline else_block_nonewline?")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_While ( a , b , c , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s while_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'while' named_expression ':' block_nonewline else_block_nonewline?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // for_stmt: // | invalid_for_stmt // | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? @@ -7767,11 +8602,11 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 764)) // token='in' && (_cut_var = 1) && @@ -7829,13 +8664,13 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 763)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 764)) // token='in' && (_cut_var = 1) && @@ -7901,6 +8736,182 @@ for_stmt_rule(Parser *p) return _res; } +// for_stmt_nonewline: +// | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline? +// | 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline? +// | invalid_for_target +static stmt_ty +for_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> for_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline?")); + int _cut_var = 0; + Token * _keyword; + Token * _keyword_1; + Token * _literal; + asdl_stmt_seq* b; + void *el; + expr_ty ex; + expr_ty t; + void *tc; + if ( + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' + && + (t = star_targets_rule(p)) // star_targets + && + (_keyword_1 = _PyPegen_expect_token(p, 764)) // token='in' + && + (_cut_var = 1) + && + (ex = star_expressions_rule(p)) // star_expressions + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (el = else_block_nonewline_rule(p), !p->error_indicator) // else_block_nonewline? + ) + { + D(fprintf(stderr, "%*c+ for_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline?")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s for_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline?")); + if (_cut_var) { + p->level--; + return NULL; + } + } + { // 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> for_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline?")); + int _cut_var = 0; + Token * _keyword; + Token * _keyword_1; + Token * _keyword_2; + Token * _literal; + asdl_stmt_seq* b; + void *el; + expr_ty ex; + expr_ty t; + void *tc; + if ( + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' + && + (_keyword_1 = _PyPegen_expect_token(p, 763)) // token='for' + && + (t = star_targets_rule(p)) // star_targets + && + (_keyword_2 = _PyPegen_expect_token(p, 764)) // token='in' + && + (_cut_var = 1) + && + (ex = star_expressions_rule(p)) // star_expressions + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (el = else_block_nonewline_rule(p), !p->error_indicator) // else_block_nonewline? + ) + { + D(fprintf(stderr, "%*c+ for_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline?")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 5 , "Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s for_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block_nonewline else_block_nonewline?")); + if (_cut_var) { + p->level--; + return NULL; + } + } + if (p->call_invalid_rules) { // invalid_for_target + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> for_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_for_target")); + void *invalid_for_target_var; + if ( + (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target + ) + { + D(fprintf(stderr, "%*c+ for_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_for_target")); + _res = invalid_for_target_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s for_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_for_target")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // with_stmt: // | invalid_with_stmt_indent // | 'with' '(' ','.with_item+ ','? ')' ':' block @@ -7964,11 +8975,11 @@ with_stmt_rule(Parser *p) asdl_withitem_seq* a; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = (asdl_withitem_seq*)_gather_68_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_69_rule(p)) // ','.with_item+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -8013,9 +9024,9 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' && - (a = (asdl_withitem_seq*)_gather_70_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_71_rule(p)) // ','.with_item+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -8062,13 +9073,13 @@ with_stmt_rule(Parser *p) asdl_withitem_seq* a; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 714)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = (asdl_withitem_seq*)_gather_72_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_73_rule(p)) // ','.with_item+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -8114,11 +9125,11 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 714)) // token='with' && - (a = (asdl_withitem_seq*)_gather_74_rule(p)) // ','.with_item+ + (a = (asdl_withitem_seq*)_gather_75_rule(p)) // ','.with_item+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -8174,6 +9185,239 @@ with_stmt_rule(Parser *p) return _res; } +// with_stmt_nonewline: +// | 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline +// | 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline +// | 'async' 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline +// | 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline +static stmt_ty +with_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> with_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with' '(' ','.with_item+ ','? ')' ':' block_nonewline")); + Token * _keyword; + Token * _literal; + Token * _literal_1; + Token * _literal_2; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_withitem_seq* a; + asdl_stmt_seq* b; + if ( + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' + && + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = (asdl_withitem_seq*)_gather_77_rule(p)) // ','.with_item+ + && + (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + && + (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ with_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with' '(' ','.with_item+ ','? ')' ':' block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 9 , "Parenthesized context managers are" , _PyAST_With ( a , 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 with_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with' '(' ','.with_item+ ','? ')' ':' block_nonewline")); + } + { // 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> with_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline")); + Token * _keyword; + Token * _literal; + asdl_withitem_seq* a; + asdl_stmt_seq* b; + void *tc; + if ( + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' + && + (a = (asdl_withitem_seq*)_gather_79_rule(p)) // ','.with_item+ + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ with_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s with_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline")); + } + { // 'async' 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> with_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline")); + Token * _keyword; + Token * _keyword_1; + Token * _literal; + Token * _literal_1; + Token * _literal_2; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_withitem_seq* a; + asdl_stmt_seq* b; + if ( + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' + && + (_keyword_1 = _PyPegen_expect_token(p, 714)) // token='with' + && + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = (asdl_withitem_seq*)_gather_81_rule(p)) // ','.with_item+ + && + (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + && + (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ with_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , 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 with_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block_nonewline")); + } + { // 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> with_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline")); + Token * _keyword; + Token * _keyword_1; + Token * _literal; + asdl_withitem_seq* a; + asdl_stmt_seq* b; + void *tc; + if ( + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' + && + (_keyword_1 = _PyPegen_expect_token(p, 714)) // token='with' + && + (a = (asdl_withitem_seq*)_gather_83_rule(p)) // ','.with_item+ + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT? + && + (b = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ with_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s with_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // with_item: // | expression 'as' star_target &(',' | ')' | ':') // | invalid_with_item @@ -8203,11 +9447,11 @@ with_item_rule(Parser *p) if ( (e = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (t = star_target_rule(p)) // star_target && - _PyPegen_lookahead(1, _tmp_76_rule, p) + _PyPegen_lookahead(1, _tmp_85_rule, p) ) { D(fprintf(stderr, "%*c+ with_item[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression 'as' star_target &(',' | ')' | ':')")); @@ -8329,7 +9573,7 @@ try_stmt_rule(Parser *p) asdl_stmt_seq* b; asdl_stmt_seq* f; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -8373,13 +9617,13 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && (b = block_rule(p)) // block && - (ex = (asdl_excepthandler_seq*)_loop1_77_rule(p)) // except_block+ + (ex = (asdl_excepthandler_seq*)_loop1_86_rule(p)) // except_block+ && (el = else_block_rule(p), !p->error_indicator) // else_block? && @@ -8421,13 +9665,13 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && (b = block_rule(p)) // block && - (ex = (asdl_excepthandler_seq*)_loop1_78_rule(p)) // except_star_block+ + (ex = (asdl_excepthandler_seq*)_loop1_87_rule(p)) // except_star_block+ && (el = else_block_rule(p), !p->error_indicator) // else_block? && @@ -8462,13 +9706,13 @@ try_stmt_rule(Parser *p) return _res; } -// except_block: -// | invalid_except_stmt_indent -// | 'except' expression ['as' NAME] ':' block -// | 'except' ':' block -// | invalid_except_stmt -static excepthandler_ty -except_block_rule(Parser *p) +// try_stmt_nonewline: +// | invalid_try_stmt_nonewline +// | 'try' &&':' block_nonewline finally_block_nonewline +// | 'try' &&':' block_nonewline except_block_nonewline+ else_block_nonewline? finally_block_nonewline? +// | 'try' &&':' block_nonewline except_star_block_nonewline+ else_block_nonewline? finally_block_nonewline? +static stmt_ty +try_stmt_nonewline_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -8478,7 +9722,7 @@ except_block_rule(Parser *p) p->level--; return NULL; } - excepthandler_ty _res = NULL; + stmt_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -8489,49 +9733,46 @@ except_block_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - if (p->call_invalid_rules) { // invalid_except_stmt_indent + if (p->call_invalid_rules) { // invalid_try_stmt_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_indent")); - void *invalid_except_stmt_indent_var; + D(fprintf(stderr, "%*c> try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_try_stmt_nonewline")); + void *invalid_try_stmt_nonewline_var; if ( - (invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p)) // invalid_except_stmt_indent + (invalid_try_stmt_nonewline_var = invalid_try_stmt_nonewline_rule(p)) // invalid_try_stmt_nonewline ) { - D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_indent")); - _res = invalid_except_stmt_indent_var; + D(fprintf(stderr, "%*c+ try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_try_stmt_nonewline")); + _res = invalid_try_stmt_nonewline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_except_stmt_indent")); + D(fprintf(stderr, "%*c%s try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_try_stmt_nonewline")); } - { // 'except' expression ['as' NAME] ':' block + { // 'try' &&':' block_nonewline finally_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block")); + D(fprintf(stderr, "%*c> try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline finally_block_nonewline")); Token * _keyword; Token * _literal; asdl_stmt_seq* b; - expr_ty e; - void *t; + asdl_stmt_seq* f; if ( - (_keyword = _PyPegen_expect_token(p, 701)) // token='except' - && - (e = expression_rule(p)) // expression + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && - (t = _tmp_79_rule(p), !p->error_indicator) // ['as' NAME] + (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (b = block_nonewline_rule(p)) // block_nonewline && - (b = block_rule(p)) // block + (f = finally_block_nonewline_rule(p)) // finally_block_nonewline ) { - D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block")); + D(fprintf(stderr, "%*c+ try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline finally_block_nonewline")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -8541,7 +9782,7 @@ except_block_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA ); + _res = _PyAST_Try ( b , NULL , NULL , f , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -8550,27 +9791,36 @@ except_block_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block")); + D(fprintf(stderr, "%*c%s try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline finally_block_nonewline")); } - { // 'except' ':' block + { // 'try' &&':' block_nonewline except_block_nonewline+ else_block_nonewline? finally_block_nonewline? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' ':' block")); + D(fprintf(stderr, "%*c> try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline except_block_nonewline+ else_block_nonewline? finally_block_nonewline?")); Token * _keyword; Token * _literal; asdl_stmt_seq* b; + void *el; + asdl_excepthandler_seq* ex; + void *f; if ( - (_keyword = _PyPegen_expect_token(p, 701)) // token='except' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && - (b = block_rule(p)) // block + (b = block_nonewline_rule(p)) // block_nonewline + && + (ex = (asdl_excepthandler_seq*)_loop1_88_rule(p)) // except_block_nonewline+ + && + (el = else_block_nonewline_rule(p), !p->error_indicator) // else_block_nonewline? + && + (f = finally_block_nonewline_rule(p), !p->error_indicator) // finally_block_nonewline? ) { - D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' ':' block")); + D(fprintf(stderr, "%*c+ try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline except_block_nonewline+ else_block_nonewline? finally_block_nonewline?")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -8580,7 +9830,7 @@ except_block_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA ); + _res = _PyAST_Try ( b , ex , el , f , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -8589,27 +9839,56 @@ except_block_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' ':' block")); + D(fprintf(stderr, "%*c%s try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline except_block_nonewline+ else_block_nonewline? finally_block_nonewline?")); } - if (p->call_invalid_rules) { // invalid_except_stmt + { // 'try' &&':' block_nonewline except_star_block_nonewline+ else_block_nonewline? finally_block_nonewline? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt")); - void *invalid_except_stmt_var; + D(fprintf(stderr, "%*c> try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline except_star_block_nonewline+ else_block_nonewline? finally_block_nonewline?")); + Token * _keyword; + Token * _literal; + asdl_stmt_seq* b; + void *el; + asdl_excepthandler_seq* ex; + void *f; if ( - (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' + && + (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline + && + (ex = (asdl_excepthandler_seq*)_loop1_89_rule(p)) // except_star_block_nonewline+ + && + (el = else_block_nonewline_rule(p), !p->error_indicator) // else_block_nonewline? + && + (f = finally_block_nonewline_rule(p), !p->error_indicator) // finally_block_nonewline? ) { - D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt")); - _res = invalid_except_stmt_var; + D(fprintf(stderr, "%*c+ try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline except_star_block_nonewline+ else_block_nonewline? finally_block_nonewline?")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 11 , "Exception groups are" , _PyAST_TryStar ( b , ex , el , f , EXTRA ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_except_stmt")); + D(fprintf(stderr, "%*c%s try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try' &&':' block_nonewline except_star_block_nonewline+ else_block_nonewline? finally_block_nonewline?")); } _res = NULL; done: @@ -8617,12 +9896,13 @@ except_block_rule(Parser *p) return _res; } -// except_star_block: -// | invalid_except_star_stmt_indent -// | 'except' '*' expression ['as' NAME] ':' block +// except_block: +// | invalid_except_stmt_indent +// | 'except' expression ['as' NAME] ':' block +// | 'except' ':' block // | invalid_except_stmt static excepthandler_ty -except_star_block_rule(Parser *p) +except_block_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -8643,7 +9923,161 @@ except_star_block_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - if (p->call_invalid_rules) { // invalid_except_star_stmt_indent + if (p->call_invalid_rules) { // invalid_except_stmt_indent + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_indent")); + void *invalid_except_stmt_indent_var; + if ( + (invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p)) // invalid_except_stmt_indent + ) + { + D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_indent")); + _res = invalid_except_stmt_indent_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_except_stmt_indent")); + } + { // 'except' expression ['as' NAME] ':' block + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block")); + Token * _keyword; + Token * _literal; + asdl_stmt_seq* b; + expr_ty e; + void *t; + if ( + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' + && + (e = expression_rule(p)) // expression + && + (t = _tmp_90_rule(p), !p->error_indicator) // ['as' NAME] + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_rule(p)) // block + ) + { + D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block")); + 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_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block")); + } + { // 'except' ':' block + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' ':' block")); + Token * _keyword; + Token * _literal; + asdl_stmt_seq* b; + if ( + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_rule(p)) // block + ) + { + D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' ':' block")); + 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_ExceptHandler ( NULL , NULL , b , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' ':' block")); + } + if (p->call_invalid_rules) { // invalid_except_stmt + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> except_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt")); + void *invalid_except_stmt_var; + if ( + (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt + ) + { + D(fprintf(stderr, "%*c+ except_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt")); + _res = invalid_except_stmt_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s except_block[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_except_stmt")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// except_star_block: +// | invalid_except_star_stmt_indent +// | 'except' '*' expression ['as' NAME] ':' block +// | invalid_except_stmt +static excepthandler_ty +except_star_block_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + excepthandler_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + if (p->call_invalid_rules) { // invalid_except_star_stmt_indent if (p->error_indicator) { p->level--; return NULL; @@ -8675,13 +10109,13 @@ except_star_block_rule(Parser *p) expr_ty e; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 701)) // token='except' + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (e = expression_rule(p)) // expression && - (t = _tmp_80_rule(p), !p->error_indicator) // ['as' NAME] + (t = _tmp_91_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -8778,7 +10212,7 @@ finally_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 697)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 744)) // token='finally' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -8804,11 +10238,12 @@ finally_block_rule(Parser *p) return _res; } -// switch_stmt: -// | "switch" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT -// | "switch" named_expression ':' NEWLINE switchcase_block+ -static stmt_ty -switch_stmt_rule(Parser *p) +// except_block_nonewline: +// | 'except' expression ['as' NAME] ':' block_nonewline +// | 'except' ':' block +// | invalid_except_stmt_nonewline +static excepthandler_ty +except_block_nonewline_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -8818,7 +10253,7 @@ switch_stmt_rule(Parser *p) p->level--; return NULL; } - stmt_ty _res = NULL; + excepthandler_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -8829,36 +10264,30 @@ switch_stmt_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // "switch" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT + { // 'except' expression ['as' NAME] ':' block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> switch_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT")); - expr_ty _keyword; + D(fprintf(stderr, "%*c> except_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block_nonewline")); + Token * _keyword; Token * _literal; - asdl_switch_case_seq* cases; - Token * dedent_var; - Token * indent_var; - Token * newline_var; - expr_ty subject; + asdl_stmt_seq* b; + expr_ty e; + void *t; if ( - (_keyword = _PyPegen_expect_soft_keyword(p, "switch")) // soft_keyword='"switch"' - && - (subject = named_expression_rule(p)) // named_expression - && - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' && - (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + (e = expression_rule(p)) // expression && - (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' + (t = _tmp_92_rule(p), !p->error_indicator) // ['as' NAME] && - (cases = (asdl_switch_case_seq*)_loop1_81_rule(p)) // switchcase_block+ + (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' + (b = block_nonewline_rule(p)) // block_nonewline ) { - D(fprintf(stderr, "%*c+ switch_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT")); + D(fprintf(stderr, "%*c+ except_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block_nonewline")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -8868,7 +10297,7 @@ switch_stmt_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Switch ( subject , cases , EXTRA ); + _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -8877,33 +10306,27 @@ switch_stmt_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s switch_stmt[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT")); + D(fprintf(stderr, "%*c%s except_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' expression ['as' NAME] ':' block_nonewline")); } - { // "switch" named_expression ':' NEWLINE switchcase_block+ + { // 'except' ':' block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> switch_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); - expr_ty _keyword; + D(fprintf(stderr, "%*c> except_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' ':' block")); + Token * _keyword; Token * _literal; - asdl_switch_case_seq* cases; - Token * newline_var; - expr_ty subject; + asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_soft_keyword(p, "switch")) // soft_keyword='"switch"' - && - (subject = named_expression_rule(p)) // named_expression + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' - && - (cases = (asdl_switch_case_seq*)_loop1_82_rule(p)) // switchcase_block+ + (b = block_rule(p)) // block ) { - D(fprintf(stderr, "%*c+ switch_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); + D(fprintf(stderr, "%*c+ except_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' ':' block")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -8913,7 +10336,7 @@ switch_stmt_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Switch ( subject , cases , EXTRA ); + _res = _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -8922,8 +10345,27 @@ switch_stmt_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s switch_stmt[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); + D(fprintf(stderr, "%*c%s except_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' ':' block")); + } + if (p->call_invalid_rules) { // invalid_except_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> except_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_nonewline")); + void *invalid_except_stmt_nonewline_var; + if ( + (invalid_except_stmt_nonewline_var = invalid_except_stmt_nonewline_rule(p)) // invalid_except_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ except_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_nonewline")); + _res = invalid_except_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s except_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_except_stmt_nonewline")); } _res = NULL; done: @@ -8931,9 +10373,11 @@ switch_stmt_rule(Parser *p) return _res; } -// switchcase_block: "case" ','.(bitwiseor_pattern | 'None')+ ':' block -static switch_case_ty -switchcase_block_rule(Parser *p) +// except_star_block_nonewline: +// | 'except' '*' expression ['as' NAME] ':' block_nonewline +// | invalid_except_stmt_nonewline +static excepthandler_ty +except_star_block_nonewline_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -8943,30 +10387,54 @@ switchcase_block_rule(Parser *p) p->level--; return NULL; } - switch_case_ty _res = NULL; + excepthandler_ty _res = NULL; int _mark = p->mark; - { // "case" ','.(bitwiseor_pattern | 'None')+ ':' block + 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 + { // 'except' '*' expression ['as' NAME] ':' block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> switchcase_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block")); - expr_ty _keyword; + D(fprintf(stderr, "%*c> except_star_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*' expression ['as' NAME] ':' block_nonewline")); + Token * _keyword; Token * _literal; - asdl_stmt_seq* body; - asdl_expr_seq* exprs; + Token * _literal_1; + asdl_stmt_seq* b; + expr_ty e; + void *t; if ( - (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' && - (exprs = (asdl_expr_seq*)_gather_83_rule(p)) // ','.(bitwiseor_pattern | 'None')+ + (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (e = expression_rule(p)) // expression && - (body = block_rule(p)) // block + (t = _tmp_93_rule(p), !p->error_indicator) // ['as' NAME] + && + (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = block_nonewline_rule(p)) // block_nonewline ) { - D(fprintf(stderr, "%*c+ switchcase_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block")); - _res = _PyAST_switch_case ( exprs , body , p -> arena ); + D(fprintf(stderr, "%*c+ except_star_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*' expression ['as' NAME] ':' block_nonewline")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -8975,8 +10443,27 @@ switchcase_block_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s switchcase_block[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block")); + D(fprintf(stderr, "%*c%s except_star_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' '*' expression ['as' NAME] ':' block_nonewline")); + } + if (p->call_invalid_rules) { // invalid_except_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> except_star_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_nonewline")); + void *invalid_except_stmt_nonewline_var; + if ( + (invalid_except_stmt_nonewline_var = invalid_except_stmt_nonewline_rule(p)) // invalid_except_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ except_star_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "invalid_except_stmt_nonewline")); + _res = invalid_except_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s except_star_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "invalid_except_stmt_nonewline")); } _res = NULL; done: @@ -8984,46 +10471,61 @@ switchcase_block_rule(Parser *p) return _res; } -// Left-recursive -// bitwiseor_pattern: bitwiseor_pattern '|' bitwisexor_pattern | bitwisexor_pattern -static expr_ty bitwiseor_pattern_raw(Parser *); -static expr_ty -bitwiseor_pattern_rule(Parser *p) +// finally_block_nonewline: 'finally' &&':' block_nonewline +static asdl_stmt_seq* +finally_block_nonewline_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; PyErr_NoMemory(); } - expr_ty _res = NULL; - if (_PyPegen_is_memoized(p, bitwiseor_pattern_type, &_res)) { + if (p->error_indicator) { p->level--; - return _res; + return NULL; } + asdl_stmt_seq* _res = NULL; int _mark = p->mark; - int _resmark = p->mark; - while (1) { - int tmpvar_1 = _PyPegen_update_memo(p, _mark, bitwiseor_pattern_type, _res); - if (tmpvar_1) { - p->level--; - return _res; - } - p->mark = _mark; - void *_raw = bitwiseor_pattern_raw(p); + { // 'finally' &&':' block_nonewline if (p->error_indicator) { p->level--; return NULL; } - if (_raw == NULL || p->mark <= _resmark) - break; - _resmark = p->mark; - _res = _raw; + D(fprintf(stderr, "%*c> finally_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally' &&':' block_nonewline")); + Token * _keyword; + Token * _literal; + asdl_stmt_seq* a; + if ( + (_keyword = _PyPegen_expect_token(p, 744)) // token='finally' + && + (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' + && + (a = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ finally_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally' &&':' block_nonewline")); + _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 finally_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'finally' &&':' block_nonewline")); } - p->mark = _resmark; + _res = NULL; + done: p->level--; return _res; } -static expr_ty -bitwiseor_pattern_raw(Parser *p) + +// switch_stmt: +// | "switch" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT +// | "switch" named_expression ':' NEWLINE switchcase_block+ +static stmt_ty +switch_stmt_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -9033,7 +10535,7 @@ bitwiseor_pattern_raw(Parser *p) p->level--; return NULL; } - expr_ty _res = NULL; + stmt_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -9044,24 +10546,36 @@ bitwiseor_pattern_raw(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // bitwiseor_pattern '|' bitwisexor_pattern + { // "switch" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> bitwiseor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern '|' bitwisexor_pattern")); + D(fprintf(stderr, "%*c> switch_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT")); + expr_ty _keyword; Token * _literal; - expr_ty a; - expr_ty b; + asdl_switch_case_seq* cases; + Token * dedent_var; + Token * indent_var; + Token * newline_var; + expr_ty subject; if ( - (a = bitwiseor_pattern_rule(p)) // bitwiseor_pattern + (_keyword = _PyPegen_expect_soft_keyword(p, "switch")) // soft_keyword='"switch"' && - (_literal = _PyPegen_expect_token(p, 18)) // token='|' + (subject = named_expression_rule(p)) // named_expression && - (b = bitwisexor_pattern_rule(p)) // bitwisexor_pattern + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' + && + (cases = (asdl_switch_case_seq*)_loop1_94_rule(p)) // switchcase_block+ + && + (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' ) { - D(fprintf(stderr, "%*c+ bitwiseor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern '|' bitwisexor_pattern")); + D(fprintf(stderr, "%*c+ switch_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -9071,7 +10585,7 @@ bitwiseor_pattern_raw(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_BinOp ( a , BitOr , b , EXTRA ); + _res = _PyAST_Switch ( subject , cases , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -9080,27 +10594,53 @@ bitwiseor_pattern_raw(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s bitwiseor_pattern[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwiseor_pattern '|' bitwisexor_pattern")); + D(fprintf(stderr, "%*c%s switch_stmt[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block+ DEDENT")); } - { // bitwisexor_pattern + { // "switch" named_expression ':' NEWLINE switchcase_block+ if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> bitwiseor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern")); - expr_ty bitwisexor_pattern_var; + D(fprintf(stderr, "%*c> switch_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); + expr_ty _keyword; + Token * _literal; + asdl_switch_case_seq* cases; + Token * newline_var; + expr_ty subject; if ( - (bitwisexor_pattern_var = bitwisexor_pattern_rule(p)) // bitwisexor_pattern + (_keyword = _PyPegen_expect_soft_keyword(p, "switch")) // soft_keyword='"switch"' + && + (subject = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (cases = (asdl_switch_case_seq*)_loop1_95_rule(p)) // switchcase_block+ ) { - D(fprintf(stderr, "%*c+ bitwiseor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern")); - _res = bitwisexor_pattern_var; + D(fprintf(stderr, "%*c+ switch_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); + 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_Switch ( subject , cases , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s bitwiseor_pattern[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwisexor_pattern")); + D(fprintf(stderr, "%*c%s switch_stmt[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block+")); } _res = NULL; done: @@ -9108,46 +10648,64 @@ bitwiseor_pattern_raw(Parser *p) return _res; } -// Left-recursive -// bitwisexor_pattern: bitwisexor_pattern '^' bitwiseand_pattern | bitwiseand_pattern -static expr_ty bitwisexor_pattern_raw(Parser *); -static expr_ty -bitwisexor_pattern_rule(Parser *p) +// switchcase_block: "case" ','.(bitwiseor_pattern | 'None')+ ':' block +static switch_case_ty +switchcase_block_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; PyErr_NoMemory(); } - expr_ty _res = NULL; - if (_PyPegen_is_memoized(p, bitwisexor_pattern_type, &_res)) { + if (p->error_indicator) { p->level--; - return _res; + return NULL; } + switch_case_ty _res = NULL; int _mark = p->mark; - int _resmark = p->mark; - while (1) { - int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwisexor_pattern_type, _res); - if (tmpvar_2) { - p->level--; - return _res; - } - p->mark = _mark; - void *_raw = bitwisexor_pattern_raw(p); + { // "case" ','.(bitwiseor_pattern | 'None')+ ':' block if (p->error_indicator) { p->level--; return NULL; } - if (_raw == NULL || p->mark <= _resmark) - break; - _resmark = p->mark; - _res = _raw; + D(fprintf(stderr, "%*c> switchcase_block[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block")); + expr_ty _keyword; + Token * _literal; + asdl_stmt_seq* body; + asdl_expr_seq* exprs; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' + && + (exprs = (asdl_expr_seq*)_gather_96_rule(p)) // ','.(bitwiseor_pattern | 'None')+ + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (body = block_rule(p)) // block + ) + { + D(fprintf(stderr, "%*c+ switchcase_block[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block")); + _res = _PyAST_switch_case ( exprs , body , p -> arena ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s switchcase_block[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block")); } - p->mark = _resmark; + _res = NULL; + done: p->level--; return _res; } -static expr_ty -bitwisexor_pattern_raw(Parser *p) + +// switch_stmt_nonewline: +// | "switch" named_expression ':' NEWLINE INDENT switchcase_block_nonewline+ DEDENT +// | "switch" named_expression ':' NEWLINE switchcase_block_nonewline+ +static stmt_ty +switch_stmt_nonewline_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -9157,7 +10715,7 @@ bitwisexor_pattern_raw(Parser *p) p->level--; return NULL; } - expr_ty _res = NULL; + stmt_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -9168,24 +10726,36 @@ bitwisexor_pattern_raw(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // bitwisexor_pattern '^' bitwiseand_pattern + { // "switch" named_expression ':' NEWLINE INDENT switchcase_block_nonewline+ DEDENT if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> bitwisexor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern '^' bitwiseand_pattern")); + D(fprintf(stderr, "%*c> switch_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block_nonewline+ DEDENT")); + expr_ty _keyword; Token * _literal; - expr_ty a; - expr_ty b; + asdl_switch_case_seq* cases; + Token * dedent_var; + Token * indent_var; + Token * newline_var; + expr_ty subject; if ( - (a = bitwisexor_pattern_rule(p)) // bitwisexor_pattern + (_keyword = _PyPegen_expect_soft_keyword(p, "switch")) // soft_keyword='"switch"' && - (_literal = _PyPegen_expect_token(p, 32)) // token='^' + (subject = named_expression_rule(p)) // named_expression && - (b = bitwiseand_pattern_rule(p)) // bitwiseand_pattern + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' + && + (cases = (asdl_switch_case_seq*)_loop1_98_rule(p)) // switchcase_block_nonewline+ + && + (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' ) { - D(fprintf(stderr, "%*c+ bitwisexor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern '^' bitwiseand_pattern")); + D(fprintf(stderr, "%*c+ switch_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block_nonewline+ DEDENT")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -9195,7 +10765,7 @@ bitwisexor_pattern_raw(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_BinOp ( a , BitXor , b , EXTRA ); + _res = _PyAST_Switch ( subject , cases , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -9204,21 +10774,349 @@ bitwisexor_pattern_raw(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s bitwisexor_pattern[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwisexor_pattern '^' bitwiseand_pattern")); + D(fprintf(stderr, "%*c%s switch_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE INDENT switchcase_block_nonewline+ DEDENT")); } - { // bitwiseand_pattern + { // "switch" named_expression ':' NEWLINE switchcase_block_nonewline+ if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> bitwisexor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseand_pattern")); - expr_ty bitwiseand_pattern_var; + D(fprintf(stderr, "%*c> switch_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block_nonewline+")); + expr_ty _keyword; + Token * _literal; + asdl_switch_case_seq* cases; + Token * newline_var; + expr_ty subject; if ( - (bitwiseand_pattern_var = bitwiseand_pattern_rule(p)) // bitwiseand_pattern - ) - { - D(fprintf(stderr, "%*c+ bitwisexor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseand_pattern")); + (_keyword = _PyPegen_expect_soft_keyword(p, "switch")) // soft_keyword='"switch"' + && + (subject = named_expression_rule(p)) // named_expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (cases = (asdl_switch_case_seq*)_loop1_99_rule(p)) // switchcase_block_nonewline+ + ) + { + D(fprintf(stderr, "%*c+ switch_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block_nonewline+")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_Switch ( subject , cases , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s switch_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"switch\" named_expression ':' NEWLINE switchcase_block_nonewline+")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// switchcase_block_nonewline: +// | "case" ','.(bitwiseor_pattern | 'None')+ ':' block_nonewline +static switch_case_ty +switchcase_block_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + switch_case_ty _res = NULL; + int _mark = p->mark; + { // "case" ','.(bitwiseor_pattern | 'None')+ ':' block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> switchcase_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block_nonewline")); + expr_ty _keyword; + Token * _literal; + asdl_stmt_seq* body; + asdl_expr_seq* exprs; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' + && + (exprs = (asdl_expr_seq*)_gather_100_rule(p)) // ','.(bitwiseor_pattern | 'None')+ + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (body = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ switchcase_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block_nonewline")); + _res = _PyAST_switch_case ( exprs , body , p -> arena ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s switchcase_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"case\" ','.(bitwiseor_pattern | 'None')+ ':' block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// Left-recursive +// bitwiseor_pattern: bitwiseor_pattern '|' bitwisexor_pattern | bitwisexor_pattern +static expr_ty bitwiseor_pattern_raw(Parser *); +static expr_ty +bitwiseor_pattern_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + expr_ty _res = NULL; + if (_PyPegen_is_memoized(p, bitwiseor_pattern_type, &_res)) { + p->level--; + return _res; + } + int _mark = p->mark; + int _resmark = p->mark; + while (1) { + int tmpvar_1 = _PyPegen_update_memo(p, _mark, bitwiseor_pattern_type, _res); + if (tmpvar_1) { + p->level--; + return _res; + } + p->mark = _mark; + void *_raw = bitwiseor_pattern_raw(p); + if (p->error_indicator) { + p->level--; + return NULL; + } + if (_raw == NULL || p->mark <= _resmark) + break; + _resmark = p->mark; + _res = _raw; + } + p->mark = _resmark; + p->level--; + return _res; +} +static expr_ty +bitwiseor_pattern_raw(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // bitwiseor_pattern '|' bitwisexor_pattern + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> bitwiseor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern '|' bitwisexor_pattern")); + Token * _literal; + expr_ty a; + expr_ty b; + if ( + (a = bitwiseor_pattern_rule(p)) // bitwiseor_pattern + && + (_literal = _PyPegen_expect_token(p, 18)) // token='|' + && + (b = bitwisexor_pattern_rule(p)) // bitwisexor_pattern + ) + { + D(fprintf(stderr, "%*c+ bitwiseor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern '|' bitwisexor_pattern")); + 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_BinOp ( a , BitOr , b , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s bitwiseor_pattern[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwiseor_pattern '|' bitwisexor_pattern")); + } + { // bitwisexor_pattern + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> bitwiseor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern")); + expr_ty bitwisexor_pattern_var; + if ( + (bitwisexor_pattern_var = bitwisexor_pattern_rule(p)) // bitwisexor_pattern + ) + { + D(fprintf(stderr, "%*c+ bitwiseor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern")); + _res = bitwisexor_pattern_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s bitwiseor_pattern[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwisexor_pattern")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// Left-recursive +// bitwisexor_pattern: bitwisexor_pattern '^' bitwiseand_pattern | bitwiseand_pattern +static expr_ty bitwisexor_pattern_raw(Parser *); +static expr_ty +bitwisexor_pattern_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + expr_ty _res = NULL; + if (_PyPegen_is_memoized(p, bitwisexor_pattern_type, &_res)) { + p->level--; + return _res; + } + int _mark = p->mark; + int _resmark = p->mark; + while (1) { + int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwisexor_pattern_type, _res); + if (tmpvar_2) { + p->level--; + return _res; + } + p->mark = _mark; + void *_raw = bitwisexor_pattern_raw(p); + if (p->error_indicator) { + p->level--; + return NULL; + } + if (_raw == NULL || p->mark <= _resmark) + break; + _resmark = p->mark; + _res = _raw; + } + p->mark = _resmark; + p->level--; + return _res; +} +static expr_ty +bitwisexor_pattern_raw(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // bitwisexor_pattern '^' bitwiseand_pattern + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> bitwisexor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern '^' bitwiseand_pattern")); + Token * _literal; + expr_ty a; + expr_ty b; + if ( + (a = bitwisexor_pattern_rule(p)) // bitwisexor_pattern + && + (_literal = _PyPegen_expect_token(p, 32)) // token='^' + && + (b = bitwiseand_pattern_rule(p)) // bitwiseand_pattern + ) + { + D(fprintf(stderr, "%*c+ bitwisexor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwisexor_pattern '^' bitwiseand_pattern")); + 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_BinOp ( a , BitXor , b , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s bitwisexor_pattern[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwisexor_pattern '^' bitwiseand_pattern")); + } + { // bitwiseand_pattern + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> bitwisexor_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseand_pattern")); + expr_ty bitwiseand_pattern_var; + if ( + (bitwiseand_pattern_var = bitwiseand_pattern_rule(p)) // bitwiseand_pattern + ) + { + D(fprintf(stderr, "%*c+ bitwisexor_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseand_pattern")); _res = bitwiseand_pattern_var; goto done; } @@ -10291,7 +12189,7 @@ number_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> number_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 660)) // token='True' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { D(fprintf(stderr, "%*c+ number_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -10324,7 +12222,7 @@ number_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> number_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 662)) // token='False' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { D(fprintf(stderr, "%*c+ number_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -10429,7 +12327,7 @@ match_stmt_rule(Parser *p) && (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' && - (cases = (asdl_match_case_seq*)_loop1_85_rule(p)) // case_block+ + (cases = (asdl_match_case_seq*)_loop1_102_rule(p)) // case_block+ && (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' ) @@ -10476,7 +12374,7 @@ match_stmt_rule(Parser *p) && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' && - (cases = (asdl_match_case_seq*)_loop1_86_rule(p)) // case_block+ + (cases = (asdl_match_case_seq*)_loop1_103_rule(p)) // case_block+ ) { D(fprintf(stderr, "%*c+ match_stmt[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE case_block+")); @@ -10526,6 +12424,133 @@ match_stmt_rule(Parser *p) return _res; } +// match_stmt_nonewline: +// | "match" subject_expr ':' NEWLINE INDENT case_block_nonewline+ DEDENT +// | "match" subject_expr ':' NEWLINE case_block_nonewline+ +static stmt_ty +match_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // "match" subject_expr ':' NEWLINE INDENT case_block_nonewline+ DEDENT + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> match_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE INDENT case_block_nonewline+ DEDENT")); + expr_ty _keyword; + Token * _literal; + asdl_match_case_seq* cases; + Token * dedent_var; + Token * indent_var; + Token * newline_var; + expr_ty subject; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' + && + (subject = subject_expr_rule(p)) // subject_expr + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' + && + (cases = (asdl_match_case_seq*)_loop1_104_rule(p)) // case_block_nonewline+ + && + (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT' + ) + { + D(fprintf(stderr, "%*c+ match_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE INDENT case_block_nonewline+ DEDENT")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s match_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE INDENT case_block_nonewline+ DEDENT")); + } + { // "match" subject_expr ':' NEWLINE case_block_nonewline+ + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> match_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE case_block_nonewline+")); + expr_ty _keyword; + Token * _literal; + asdl_match_case_seq* cases; + Token * newline_var; + expr_ty subject; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' + && + (subject = subject_expr_rule(p)) // subject_expr + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + && + (cases = (asdl_match_case_seq*)_loop1_105_rule(p)) // case_block_nonewline+ + ) + { + D(fprintf(stderr, "%*c+ match_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE case_block_nonewline+")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s match_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"match\" subject_expr ':' NEWLINE case_block_nonewline+")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // subject_expr: star_named_expression ',' star_named_expressions? | named_expression static expr_ty subject_expr_rule(Parser *p) @@ -10688,6 +12713,62 @@ case_block_rule(Parser *p) return _res; } +// case_block_nonewline: "case" patterns guard? ':' block_nonewline +static match_case_ty +case_block_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + match_case_ty _res = NULL; + int _mark = p->mark; + { // "case" patterns guard? ':' block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> case_block_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" patterns guard? ':' block_nonewline")); + expr_ty _keyword; + Token * _literal; + asdl_stmt_seq* body; + void *guard; + pattern_ty pattern; + if ( + (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' + && + (pattern = patterns_rule(p)) // patterns + && + (guard = guard_rule(p), !p->error_indicator) // guard? + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (body = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ case_block_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"case\" patterns guard? ':' block_nonewline")); + _res = _PyAST_match_case ( pattern , guard , body , p -> arena ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s case_block_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"case\" patterns guard? ':' block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // guard: 'if' named_expression static expr_ty guard_rule(Parser *p) @@ -10711,7 +12792,7 @@ guard_rule(Parser *p) Token * _keyword; expr_ty guard; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (guard = named_expression_rule(p)) // named_expression ) @@ -10909,7 +12990,7 @@ as_pattern_rule(Parser *p) if ( (pattern = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (target = pattern_capture_target_rule(p)) // pattern_capture_target ) @@ -10992,7 +13073,7 @@ or_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> or_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'.closed_pattern+")); asdl_pattern_seq* patterns; if ( - (patterns = (asdl_pattern_seq*)_gather_87_rule(p)) // '|'.closed_pattern+ + (patterns = (asdl_pattern_seq*)_gather_106_rule(p)) // '|'.closed_pattern+ ) { D(fprintf(stderr, "%*c+ or_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'.closed_pattern+")); @@ -11247,7 +13328,7 @@ literal_pattern_rule(Parser *p) if ( (value = signed_number_rule(p)) // signed_number && - _PyPegen_lookahead(0, _tmp_89_rule, p) + _PyPegen_lookahead(0, _tmp_108_rule, p) ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "signed_number !('+' | '-')")); @@ -11346,7 +13427,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 661)) // token='None' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); @@ -11379,7 +13460,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 660)) // token='True' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -11412,7 +13493,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 662)) // token='False' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -11482,7 +13563,7 @@ literal_expr_rule(Parser *p) if ( (signed_number_var = signed_number_rule(p)) // signed_number && - _PyPegen_lookahead(0, _tmp_90_rule, p) + _PyPegen_lookahead(0, _tmp_109_rule, p) ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "signed_number !('+' | '-')")); @@ -11539,7 +13620,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 661)) // token='None' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); @@ -11572,7 +13653,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 660)) // token='True' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -11605,7 +13686,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 662)) // token='False' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -12089,7 +14170,7 @@ pattern_capture_target_rule(Parser *p) && (name = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(0, _tmp_91_rule, p) + _PyPegen_lookahead(0, _tmp_110_rule, p) ) { D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "!\"_\" NAME !('.' | '(' | '=')")); @@ -12206,7 +14287,7 @@ value_pattern_rule(Parser *p) if ( (attr = attr_rule(p)) // attr && - _PyPegen_lookahead(0, _tmp_92_rule, p) + _PyPegen_lookahead(0, _tmp_111_rule, p) ) { D(fprintf(stderr, "%*c+ value_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr !('.' | '(' | '=')")); @@ -12632,7 +14713,7 @@ maybe_sequence_pattern_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * patterns; if ( - (patterns = _gather_93_rule(p)) // ','.maybe_star_pattern+ + (patterns = _gather_112_rule(p)) // ','.maybe_star_pattern+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -13044,13 +15125,13 @@ items_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> items_pattern[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.key_value_pattern+")); - asdl_seq * _gather_95_var; + asdl_seq * _gather_114_var; if ( - (_gather_95_var = _gather_95_rule(p)) // ','.key_value_pattern+ + (_gather_114_var = _gather_114_rule(p)) // ','.key_value_pattern+ ) { D(fprintf(stderr, "%*c+ items_pattern[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.key_value_pattern+")); - _res = _gather_95_var; + _res = _gather_114_var; goto done; } p->mark = _mark; @@ -13087,7 +15168,7 @@ key_value_pattern_rule(Parser *p) void *key; pattern_ty pattern; if ( - (key = _tmp_97_rule(p)) // literal_expr | attr + (key = _tmp_116_rule(p)) // literal_expr | attr && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -13418,7 +15499,7 @@ positional_patterns_rule(Parser *p) D(fprintf(stderr, "%*c> positional_patterns[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.pattern+")); asdl_pattern_seq* args; if ( - (args = (asdl_pattern_seq*)_gather_98_rule(p)) // ','.pattern+ + (args = (asdl_pattern_seq*)_gather_117_rule(p)) // ','.pattern+ ) { D(fprintf(stderr, "%*c+ positional_patterns[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.pattern+")); @@ -13460,13 +15541,13 @@ keyword_patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> keyword_patterns[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.keyword_pattern+")); - asdl_seq * _gather_100_var; + asdl_seq * _gather_119_var; if ( - (_gather_100_var = _gather_100_rule(p)) // ','.keyword_pattern+ + (_gather_119_var = _gather_119_rule(p)) // ','.keyword_pattern+ ) { D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','.keyword_pattern+")); - _res = _gather_100_var; + _res = _gather_119_var; goto done; } p->mark = _mark; @@ -13565,9 +15646,9 @@ unless_stmt_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (b = _tmp_102_rule(p)) // ';'.simple_stmt+ ';'? | block + (b = _tmp_121_rule(p)) // ';'.simple_stmt+ ';'? | block && - (_keyword = _PyPegen_expect_token(p, 617)) // token='unless' + (_keyword = _PyPegen_expect_token(p, 652)) // token='unless' && (a = named_expression_rule(p)) // named_expression ) @@ -13600,6 +15681,78 @@ unless_stmt_rule(Parser *p) return _res; } +// unless_stmt_nonewline: +// | ':' (simple_stmts_nonewline | block_nonewline) 'unless' named_expression +static stmt_ty +unless_stmt_nonewline_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + stmt_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // ':' (simple_stmts_nonewline | block_nonewline) 'unless' named_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> unless_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' (simple_stmts_nonewline | block_nonewline) 'unless' named_expression")); + Token * _keyword; + Token * _literal; + expr_ty a; + void *b; + if ( + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (b = _tmp_122_rule(p)) // simple_stmts_nonewline | block_nonewline + && + (_keyword = _PyPegen_expect_token(p, 652)) // token='unless' + && + (a = named_expression_rule(p)) // named_expression + ) + { + D(fprintf(stderr, "%*c+ unless_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' (simple_stmts_nonewline | block_nonewline) 'unless' named_expression")); + 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_If ( _PyAST_UnaryOp ( Not , a , EXTRA ) , 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 unless_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':' (simple_stmts_nonewline | block_nonewline) 'unless' named_expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // type_alias: "type" NAME type_params? '=' expression static stmt_ty type_alias_rule(Parser *p) @@ -13748,7 +15901,7 @@ type_param_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_type_param_seq* a; if ( - (a = (asdl_type_param_seq*)_gather_103_rule(p)) // ','.type_param+ + (a = (asdl_type_param_seq*)_gather_123_rule(p)) // ','.type_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -14068,7 +16221,7 @@ expressions_rule(Parser *p) if ( (a = expression_rule(p)) // expression && - (b = _loop1_105_rule(p)) // ((',' expression))+ + (b = _loop1_125_rule(p)) // ((',' expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -14259,11 +16412,11 @@ expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 709)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 756)) // token='else' && (c = expression_rule(p)) // expression ) @@ -14349,9 +16502,9 @@ yield_expr_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='yield' + (_keyword = _PyPegen_expect_token(p, 657)) // token='yield' && - (_keyword_1 = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword_1 = _PyPegen_expect_token(p, 703)) // token='from' && (a = expression_rule(p)) // expression ) @@ -14387,7 +16540,7 @@ yield_expr_rule(Parser *p) Token * _keyword; void *a; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='yield' + (_keyword = _PyPegen_expect_token(p, 657)) // token='yield' && (a = star_expressions_rule(p), !p->error_indicator) // star_expressions? ) @@ -14459,7 +16612,7 @@ star_expressions_rule(Parser *p) if ( (a = star_expression_rule(p)) // star_expression && - (b = _loop1_106_rule(p)) // ((',' star_expression))+ + (b = _loop1_126_rule(p)) // ((',' star_expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -14749,7 +16902,7 @@ star_named_expressions_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_107_rule(p)) // ','.star_named_expression+ + (a = (asdl_expr_seq*)_gather_127_rule(p)) // ','.star_named_expression+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -15171,7 +17324,7 @@ disjunction_rule(Parser *p) if ( (a = conjunction_rule(p)) // conjunction && - (b = _loop1_109_rule(p)) // (('or' conjunction))+ + (b = _loop1_129_rule(p)) // (('or' conjunction))+ ) { D(fprintf(stderr, "%*c+ disjunction[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "conjunction (('or' conjunction))+")); @@ -15260,7 +17413,7 @@ conjunction_rule(Parser *p) if ( (a = inversion_rule(p)) // inversion && - (b = _loop1_110_rule(p)) // (('and' inversion))+ + (b = _loop1_130_rule(p)) // (('and' inversion))+ ) { D(fprintf(stderr, "%*c+ conjunction[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "inversion (('and' inversion))+")); @@ -15347,7 +17500,7 @@ inversion_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 635)) // token='not' + (_keyword = _PyPegen_expect_token(p, 670)) // token='not' && (a = inversion_rule(p)) // inversion ) @@ -15434,7 +17587,7 @@ comparison_rule(Parser *p) if ( (a = composition_rule(p)) // composition && - (b = _loop1_111_rule(p)) // compare_op_composition_pair+ + (b = _loop1_131_rule(p)) // compare_op_composition_pair+ ) { D(fprintf(stderr, "%*c+ comparison[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "composition compare_op_composition_pair+")); @@ -15811,10 +17964,10 @@ noteq_composition_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> noteq_composition[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('!=') composition")); - void *_tmp_112_var; + void *_tmp_132_var; expr_ty a; if ( - (_tmp_112_var = _tmp_112_rule(p)) // '!=' + (_tmp_132_var = _tmp_132_rule(p)) // '!=' && (a = composition_rule(p)) // composition ) @@ -16050,9 +18203,9 @@ notin_composition_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 635)) // token='not' + (_keyword = _PyPegen_expect_token(p, 670)) // token='not' && - (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 764)) // token='in' && (a = composition_rule(p)) // composition ) @@ -16099,7 +18252,7 @@ in_composition_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword = _PyPegen_expect_token(p, 764)) // token='in' && (a = composition_rule(p)) // composition ) @@ -16148,11 +18301,11 @@ isnotin_composition_rule(Parser *p) Token * _keyword_2; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 636)) // token='is' + (_keyword = _PyPegen_expect_token(p, 671)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 635)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 670)) // token='not' && - (_keyword_2 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 764)) // token='in' && (a = composition_rule(p)) // composition ) @@ -16200,9 +18353,9 @@ isin_composition_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 636)) // token='is' + (_keyword = _PyPegen_expect_token(p, 671)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 764)) // token='in' && (a = composition_rule(p)) // composition ) @@ -16250,9 +18403,9 @@ isnot_composition_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 636)) // token='is' + (_keyword = _PyPegen_expect_token(p, 671)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 635)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 670)) // token='not' && (a = composition_rule(p)) // composition ) @@ -16299,7 +18452,7 @@ is_composition_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 636)) // token='is' + (_keyword = _PyPegen_expect_token(p, 671)) // token='is' && (a = composition_rule(p)) // composition ) @@ -16395,9 +18548,9 @@ composition_raw(Parser *p) if ( (a = composition_rule(p)) // composition && - (t = _tmp_113_rule(p)) // '|>' + (t = _tmp_133_rule(p)) // '|>' && - (b = _tmp_114_rule(p)) // bitwise_or? + (b = _tmp_134_rule(p)) // bitwise_or? ) { D(fprintf(stderr, "%*c+ composition[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "composition ('|>') (bitwise_or?)")); @@ -17838,7 +19991,7 @@ await_primary_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 637)) // token='await' + (_keyword = _PyPegen_expect_token(p, 672)) // token='await' && (a = primary_rule(p)) // primary ) @@ -18012,7 +20165,7 @@ primary_raw(Parser *p) && (n = _PyPegen_expect_token(p, 58), !p->error_indicator) // '?'? && - (b = _tmp_115_rule(p)) // class_or_func_expr | tuplecomp | genexp + (b = _tmp_135_rule(p)) // class_or_func_expr | tuplecomp | genexp ) { D(fprintf(stderr, "%*c+ primary[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "primary '?'? (class_or_func_expr | tuplecomp | genexp)")); @@ -18211,7 +20364,7 @@ slices_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_116_rule(p)) // ','.(slice | starred_expression)+ + (a = (asdl_expr_seq*)_gather_136_rule(p)) // ','.(slice | starred_expression)+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -18342,7 +20495,7 @@ simple_slice_rule(Parser *p) && (b = expression_rule(p), !p->error_indicator) // expression? && - (c = _tmp_118_rule(p), !p->error_indicator) // [':' expression?] + (c = _tmp_138_rule(p), !p->error_indicator) // [':' expression?] ) { D(fprintf(stderr, "%*c+ simple_slice[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression? ':' expression? [':' expression?]")); @@ -18434,7 +20587,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 660)) // token='True' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); @@ -18467,7 +20620,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 662)) // token='False' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); @@ -18500,7 +20653,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 661)) // token='None' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); @@ -18566,7 +20719,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(STRING | FSTRING_START) strings")); expr_ty strings_var; if ( - _PyPegen_lookahead(1, _tmp_119_rule, p) + _PyPegen_lookahead(1, _tmp_139_rule, p) && (strings_var = strings_rule(p)) // strings ) @@ -18604,15 +20757,15 @@ atom_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'(' (class_or_func_expr | tuple | group | tuplecomp | genexp)")); - void *_tmp_120_var; + void *_tmp_140_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='(' && - (_tmp_120_var = _tmp_120_rule(p)) // class_or_func_expr | tuple | group | tuplecomp | genexp + (_tmp_140_var = _tmp_140_rule(p)) // class_or_func_expr | tuple | group | tuplecomp | genexp ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'(' (class_or_func_expr | tuple | group | tuplecomp | genexp)")); - _res = _tmp_120_var; + _res = _tmp_140_var; goto done; } p->mark = _mark; @@ -18625,15 +20778,15 @@ atom_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'[' (list | listcomp)")); - void *_tmp_121_var; + void *_tmp_141_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='[' && - (_tmp_121_var = _tmp_121_rule(p)) // list | listcomp + (_tmp_141_var = _tmp_141_rule(p)) // list | listcomp ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'[' (list | listcomp)")); - _res = _tmp_121_var; + _res = _tmp_141_var; goto done; } p->mark = _mark; @@ -18646,15 +20799,15 @@ atom_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> atom[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'{' (dict | set | dictcomp | setcomp)")); - void *_tmp_122_var; + void *_tmp_142_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{' && - (_tmp_122_var = _tmp_122_rule(p)) // dict | set | dictcomp | setcomp + (_tmp_142_var = _tmp_142_rule(p)) // dict | set | dictcomp | setcomp ) { D(fprintf(stderr, "%*c+ atom[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&'{' (dict | set | dictcomp | setcomp)")); - _res = _tmp_122_var; + _res = _tmp_142_var; goto done; } p->mark = _mark; @@ -18726,7 +20879,7 @@ group_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_123_rule(p)) // yield_expr | slice + (a = _tmp_143_rule(p)) // yield_expr | slice && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -18805,7 +20958,7 @@ class_or_func_expr_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_124_rule(p)) // &("def" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline + (a = _tmp_144_rule(p)) // &("def" | '@' | 'async') function_def_nonewline | &('class' | '@') class_def_nonewline && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -18875,7 +21028,7 @@ lambdef_rule(Parser *p) void *a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 659)) // token='lambda' + (_keyword = _PyPegen_expect_token(p, 694)) // token='lambda' && (a = lambda_params_rule(p), !p->error_indicator) // lambda_params? && @@ -19147,9 +21300,9 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default && - (b = (asdl_arg_seq*)_loop0_125_rule(p)) // lambda_param_no_default* + (b = (asdl_arg_seq*)_loop0_145_rule(p)) // lambda_param_no_default* && - (c = _loop0_126_rule(p)) // lambda_param_with_default* + (c = _loop0_146_rule(p)) // lambda_param_with_default* && (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -19179,7 +21332,7 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default && - (b = _loop0_127_rule(p)) // lambda_param_with_default* + (b = _loop0_147_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -19207,9 +21360,9 @@ lambda_parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_128_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_148_rule(p)) // lambda_param_no_default+ && - (b = _loop0_129_rule(p)) // lambda_param_with_default* + (b = _loop0_149_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -19236,7 +21389,7 @@ lambda_parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_130_rule(p)) // lambda_param_with_default+ + (a = _loop1_150_rule(p)) // lambda_param_with_default+ && (b = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -19310,7 +21463,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_131_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_151_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -19339,7 +21492,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_132_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_152_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -19392,9 +21545,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_133_rule(p)) // lambda_param_no_default* + (a = _loop0_153_rule(p)) // lambda_param_no_default* && - (b = _loop1_134_rule(p)) // lambda_param_with_default+ + (b = _loop1_154_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -19424,9 +21577,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_135_rule(p)) // lambda_param_no_default* + (a = _loop0_155_rule(p)) // lambda_param_no_default* && - (b = _loop1_136_rule(p)) // lambda_param_with_default+ + (b = _loop1_156_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -19504,7 +21657,7 @@ lambda_star_etc_rule(Parser *p) && (a = lambda_param_no_default_rule(p)) // lambda_param_no_default && - (b = _loop0_137_rule(p)) // lambda_param_maybe_default* + (b = _loop0_157_rule(p)) // lambda_param_maybe_default* && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -19537,7 +21690,7 @@ lambda_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_138_rule(p)) // lambda_param_maybe_default+ + (b = _loop1_158_rule(p)) // lambda_param_maybe_default+ && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -19976,9 +22129,9 @@ lambda_sum_parameters_rule(Parser *p) if ( (a = lambda_sum_slash_no_default_rule(p)) // lambda_sum_slash_no_default && - (b = (asdl_arg_seq*)_loop0_139_rule(p)) // lambda_sum_param_no_default* + (b = (asdl_arg_seq*)_loop0_159_rule(p)) // lambda_sum_param_no_default* && - (c = _loop0_140_rule(p)) // lambda_sum_param_with_default* + (c = _loop0_160_rule(p)) // lambda_sum_param_with_default* && (d = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) @@ -20008,7 +22161,7 @@ lambda_sum_parameters_rule(Parser *p) if ( (a = lambda_sum_slash_with_default_rule(p)) // lambda_sum_slash_with_default && - (b = _loop0_141_rule(p)) // lambda_sum_param_with_default* + (b = _loop0_161_rule(p)) // lambda_sum_param_with_default* && (c = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) @@ -20036,9 +22189,9 @@ lambda_sum_parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_142_rule(p)) // lambda_sum_param_no_default+ + (a = (asdl_arg_seq*)_loop1_162_rule(p)) // lambda_sum_param_no_default+ && - (b = _loop0_143_rule(p)) // lambda_sum_param_with_default* + (b = _loop0_163_rule(p)) // lambda_sum_param_with_default* && (c = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) @@ -20065,7 +22218,7 @@ lambda_sum_parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_144_rule(p)) // lambda_sum_param_with_default+ + (a = _loop1_164_rule(p)) // lambda_sum_param_with_default+ && (b = lambda_sum_star_etc_rule(p), !p->error_indicator) // lambda_sum_star_etc? ) @@ -20137,7 +22290,7 @@ lambda_sum_slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_145_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_165_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -20166,7 +22319,7 @@ lambda_sum_slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_146_rule(p)) // param_no_default+ + (a = (asdl_arg_seq*)_loop1_166_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -20219,9 +22372,9 @@ lambda_sum_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_147_rule(p)) // lambda_sum_param_no_default* + (a = _loop0_167_rule(p)) // lambda_sum_param_no_default* && - (b = _loop1_148_rule(p)) // lambda_sum_param_with_default+ + (b = _loop1_168_rule(p)) // lambda_sum_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -20251,9 +22404,9 @@ lambda_sum_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_149_rule(p)) // lambda_sum_param_no_default* + (a = _loop0_169_rule(p)) // lambda_sum_param_no_default* && - (b = _loop1_150_rule(p)) // lambda_sum_param_with_default+ + (b = _loop1_170_rule(p)) // lambda_sum_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -20332,7 +22485,7 @@ lambda_sum_star_etc_rule(Parser *p) && (a = lambda_sum_param_no_default_rule(p)) // lambda_sum_param_no_default && - (b = _loop0_151_rule(p)) // lambda_sum_param_maybe_default* + (b = _loop0_171_rule(p)) // lambda_sum_param_maybe_default* && (c = lambda_sum_kwds_rule(p), !p->error_indicator) // lambda_sum_kwds? ) @@ -20365,7 +22518,7 @@ lambda_sum_star_etc_rule(Parser *p) && (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* + (b = _loop0_172_rule(p)) // lambda_sum_param_maybe_default* && (c = lambda_sum_kwds_rule(p), !p->error_indicator) // lambda_sum_kwds? ) @@ -20398,7 +22551,7 @@ lambda_sum_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_153_rule(p)) // lambda_sum_param_maybe_default+ + (b = _loop1_173_rule(p)) // lambda_sum_param_maybe_default+ && (c = lambda_sum_kwds_rule(p), !p->error_indicator) // lambda_sum_kwds? ) @@ -21239,7 +23392,7 @@ fstring_replacement_field_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (a = _tmp_154_rule(p)) // yield_expr | star_expressions + (a = _tmp_174_rule(p)) // yield_expr | star_expressions && (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // "="? && @@ -21378,7 +23531,7 @@ fstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_155_rule(p)) // fstring_format_spec* + (spec = _loop0_175_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*")); @@ -21551,7 +23704,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_156_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_176_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))+")); @@ -21686,7 +23839,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_157_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_177_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -21904,7 +24057,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_158_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_178_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -22066,7 +24219,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_160_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_180_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+")); @@ -22129,19 +24282,19 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 763)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 764)) // token='in' && (_cut_var = 1) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_161_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_181_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))*")); @@ -22174,17 +24327,17 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 764)) // token='in' && (_cut_var = 1) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_162_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_182_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))*")); @@ -22224,7 +24377,7 @@ for_if_clause_rule(Parser *p) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_163_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_183_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))*")); @@ -22403,7 +24556,7 @@ tuplecomp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_164_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_184_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -22587,7 +24740,7 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_165_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_185_rule(p)) // assignment_expression | expression !':=' && (b = for_if_clauses_rule(p)) // for_if_clauses && @@ -22839,9 +24992,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_166_rule(p)) // ','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_186_rule(p)) // ','.(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_168_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_188_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]")); @@ -22932,11 +25085,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_169_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_189_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_171_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_191_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+")); @@ -22958,13 +25111,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_173_var; + asdl_seq * _gather_193_var; if ( - (_gather_173_var = _gather_173_rule(p)) // ','.kwarg_or_starred+ + (_gather_193_var = _gather_193_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_173_var; + _res = _gather_193_var; goto done; } p->mark = _mark; @@ -22977,13 +25130,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_175_var; + asdl_seq * _gather_195_var; if ( - (_gather_175_var = _gather_175_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_195_var = _gather_195_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_175_var; + _res = _gather_195_var; goto done; } p->mark = _mark; @@ -23139,7 +25292,7 @@ kwarg_or_starred_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (b = _tmp_177_rule(p), !p->error_indicator) // [(simple_slice | expression)] + (b = _tmp_197_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)]")); @@ -23253,7 +25406,7 @@ kwarg_or_double_starred_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (b = _tmp_178_rule(p), !p->error_indicator) // [(simple_slice | expression)] + (b = _tmp_198_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)]")); @@ -23384,7 +25537,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_179_rule(p)) // ((',' star_target))* + (b = _loop0_199_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -23441,7 +25594,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_180_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_200_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -23492,7 +25645,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_182_rule(p)) // ((',' star_target))+ + (b = _loop1_202_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -23581,7 +25734,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_183_rule(p)) // !'*' star_target + (a = _tmp_203_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)")); @@ -24329,7 +26482,7 @@ t_primary_raw(Parser *p) && (n = _PyPegen_expect_token(p, 58), !p->error_indicator) // '?'? && - (b = _tmp_184_rule(p)) // genexp | tuplecomp + (b = _tmp_204_rule(p)) // genexp | tuplecomp && _PyPegen_lookahead(1, t_lookahead_rule, p) ) @@ -24579,7 +26732,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_185_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_205_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -24946,7 +27099,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_187_rule(p)) // ','.expression+ + (a = _gather_207_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24985,7 +27138,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_189_rule(p)) // ','.expression+ + (a = _gather_209_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -25018,7 +27171,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_191_rule(p)) // ','.expression+ + (a = _gather_211_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -25138,7 +27291,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_193_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_213_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+")); @@ -25190,7 +27343,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, _tmp_195_rule, p) + _PyPegen_lookahead(1, _tmp_215_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)")); @@ -25319,7 +27472,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_196_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_216_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]")); @@ -25379,13 +27532,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_197_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_217_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_198_rule, p) + _PyPegen_lookahead(1, _tmp_218_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 '=' &(',' | ')')")); @@ -25524,7 +27677,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_199_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_219_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -25584,7 +27737,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, _tmp_200_rule, p) + _PyPegen_lookahead(0, _tmp_220_rule, p) && (a = expression_rule(p)) // expression && @@ -25688,11 +27841,11 @@ expression_without_invalid_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 709)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 756)) // token='else' && (c = expression_rule(p)) // expression ) @@ -25843,7 +27996,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, _tmp_201_rule, p) + _PyPegen_lookahead(0, _tmp_221_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -25875,11 +28028,11 @@ invalid_expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, _tmp_202_rule, p) + _PyPegen_lookahead(0, _tmp_222_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' | ':')")); @@ -25906,13 +28059,13 @@ invalid_expression_rule(Parser *p) Token * a; Token * b; if ( - (a = _PyPegen_expect_token(p, 659)) // token='lambda' + (a = _PyPegen_expect_token(p, 694)) // token='lambda' && (_opt_var = lambda_params_rule(p), !p->error_indicator) // lambda_params? && (b = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_203_rule, p) + _PyPegen_lookahead(1, _tmp_223_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)")); @@ -26001,7 +28154,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_204_rule, p) + _PyPegen_lookahead(0, _tmp_224_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 !('=' | ':=')")); @@ -26027,7 +28180,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, _tmp_205_rule, p) + _PyPegen_lookahead(0, _tmp_225_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -26035,7 +28188,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_206_rule, p) + _PyPegen_lookahead(0, _tmp_226_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 !('=' | ':=')")); @@ -26116,7 +28269,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_207_var; + asdl_seq * _loop0_227_var; expr_ty a; expr_ty expression_var; if ( @@ -26124,7 +28277,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_207_var = _loop0_207_rule(p)) // star_named_expressions* + (_loop0_227_var = _loop0_227_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -26181,10 +28334,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_208_var; + asdl_seq * _loop0_228_var; expr_ty a; if ( - (_loop0_208_var = _loop0_208_rule(p)) // ((star_targets '='))* + (_loop0_228_var = _loop0_228_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -26211,10 +28364,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_209_var; + asdl_seq * _loop0_229_var; expr_ty a; if ( - (_loop0_209_var = _loop0_209_rule(p)) // ((star_targets '='))* + (_loop0_229_var = _loop0_229_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -26240,7 +28393,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_210_var; + void *_tmp_230_var; expr_ty a; AugOperator* augassign_var; if ( @@ -26248,7 +28401,7 @@ invalid_assignment_rule(Parser *p) && (augassign_var = augassign_rule(p)) // augassign && - (_tmp_210_var = _tmp_210_rule(p)) // yield_expr | star_expressions + (_tmp_230_var = _tmp_230_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)")); @@ -26381,7 +28534,7 @@ invalid_del_stmt_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='del' + (_keyword = _PyPegen_expect_token(p, 698)) // token='del' && (a = star_expressions_rule(p)) // star_expressions ) @@ -26474,11 +28627,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_211_var; + void *_tmp_231_var; expr_ty a; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_211_var = _tmp_211_rule(p)) // '[' | '(' | '{' + (_tmp_231_var = _tmp_231_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -26505,12 +28658,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_212_var; + void *_tmp_232_var; expr_ty a; asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_212_var = _tmp_212_rule(p)) // '[' | '{' + (_tmp_232_var = _tmp_232_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -26540,12 +28693,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_213_var; + void *_tmp_233_var; expr_ty a; Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_213_var = _tmp_213_rule(p)) // '[' | '{' + (_tmp_233_var = _tmp_233_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && @@ -26682,13 +28835,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_215_var; - void *_tmp_214_var; + asdl_seq * _loop0_235_var; + void *_tmp_234_var; Token * a; if ( - (_tmp_214_var = _tmp_214_rule(p)) // slash_no_default | slash_with_default + (_tmp_234_var = _tmp_234_rule(p)) // slash_no_default | slash_with_default && - (_loop0_215_var = _loop0_215_rule(p)) // param_maybe_default* + (_loop0_235_var = _loop0_235_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -26712,7 +28865,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_216_var; + asdl_seq * _loop0_236_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -26720,7 +28873,7 @@ invalid_parameters_rule(Parser *p) if ( (_opt_var = slash_no_default_rule(p), !p->error_indicator) // slash_no_default? && - (_loop0_216_var = _loop0_216_rule(p)) // param_no_default* + (_loop0_236_var = _loop0_236_rule(p)) // param_no_default* && (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper && @@ -26746,18 +28899,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_217_var; - asdl_seq * _loop1_218_var; + asdl_seq * _loop0_237_var; + asdl_seq * _loop1_238_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_217_var = _loop0_217_rule(p)) // param_no_default* + (_loop0_237_var = _loop0_237_rule(p)) // param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_loop1_218_var = _loop1_218_rule(p)) // param_no_default+ + (_loop1_238_var = _loop1_238_rule(p)) // param_no_default+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -26784,22 +28937,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_220_var; - asdl_seq * _loop0_222_var; + asdl_seq * _loop0_240_var; + asdl_seq * _loop0_242_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_221_var; + void *_tmp_241_var; Token * a; if ( - (_opt_var = _tmp_219_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_239_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && - (_loop0_220_var = _loop0_220_rule(p)) // param_maybe_default* + (_loop0_240_var = _loop0_240_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_221_var = _tmp_221_rule(p)) // ',' | param_no_default + (_tmp_241_var = _tmp_241_rule(p)) // ',' | param_no_default && - (_loop0_222_var = _loop0_222_rule(p)) // param_maybe_default* + (_loop0_242_var = _loop0_242_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -26824,10 +28977,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_223_var; + asdl_seq * _loop1_243_var; Token * a; if ( - (_loop1_223_var = _loop1_223_rule(p)) // param_maybe_default+ + (_loop1_243_var = _loop1_243_rule(p)) // param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -26877,7 +29030,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_224_rule, p) + _PyPegen_lookahead(1, _tmp_244_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' &(')' | ',')")); @@ -26923,7 +29076,7 @@ invalid_sum_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_225_rule, p) + _PyPegen_lookahead(1, _tmp_245_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_sum_default[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' &('|' | ',')")); @@ -26969,12 +29122,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_226_var; + void *_tmp_246_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_226_var = _tmp_226_rule(p)) // ')' | ',' (')' | '**') + (_tmp_246_var = _tmp_246_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*' (')' | ',' (')' | '**'))")); @@ -27057,20 +29210,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_228_var; - void *_tmp_227_var; - void *_tmp_229_var; + asdl_seq * _loop0_248_var; + void *_tmp_247_var; + void *_tmp_249_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_227_var = _tmp_227_rule(p)) // param_no_default | ',' + (_tmp_247_var = _tmp_247_rule(p)) // param_no_default | ',' && - (_loop0_228_var = _loop0_228_rule(p)) // param_maybe_default* + (_loop0_248_var = _loop0_248_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_229_var = _tmp_229_rule(p)) // param_no_default | ',' + (_tmp_249_var = _tmp_249_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 | ',')")); @@ -27186,7 +29339,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_230_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_250_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**' param ',' ('*' | '**' | '/')")); @@ -27252,13 +29405,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_231_var; + asdl_seq * _loop1_251_var; if ( - (_loop1_231_var = _loop1_231_rule(p)) // param_with_default+ + (_loop1_251_var = _loop1_251_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_231_var; + _res = _loop1_251_var; goto done; } p->mark = _mark; @@ -27324,13 +29477,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_233_var; - void *_tmp_232_var; + asdl_seq * _loop0_253_var; + void *_tmp_252_var; Token * a; if ( - (_tmp_232_var = _tmp_232_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_252_var = _tmp_252_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && - (_loop0_233_var = _loop0_233_rule(p)) // lambda_param_maybe_default* + (_loop0_253_var = _loop0_253_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -27354,7 +29507,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_234_var; + asdl_seq * _loop0_254_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -27362,7 +29515,7 @@ invalid_lambda_parameters_rule(Parser *p) if ( (_opt_var = lambda_slash_no_default_rule(p), !p->error_indicator) // lambda_slash_no_default? && - (_loop0_234_var = _loop0_234_rule(p)) // lambda_param_no_default* + (_loop0_254_var = _loop0_254_rule(p)) // lambda_param_no_default* && (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper && @@ -27388,18 +29541,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_236_var; - asdl_seq * _loop0_235_var; + asdl_seq * _gather_256_var; + asdl_seq * _loop0_255_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_235_var = _loop0_235_rule(p)) // lambda_param_no_default* + (_loop0_255_var = _loop0_255_rule(p)) // lambda_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_236_var = _gather_236_rule(p)) // ','.lambda_param+ + (_gather_256_var = _gather_256_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -27426,22 +29579,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_239_var; - asdl_seq * _loop0_241_var; + asdl_seq * _loop0_259_var; + asdl_seq * _loop0_261_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_240_var; + void *_tmp_260_var; Token * a; if ( - (_opt_var = _tmp_238_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_258_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && - (_loop0_239_var = _loop0_239_rule(p)) // lambda_param_maybe_default* + (_loop0_259_var = _loop0_259_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_240_var = _tmp_240_rule(p)) // ',' | lambda_param_no_default + (_tmp_260_var = _tmp_260_rule(p)) // ',' | lambda_param_no_default && - (_loop0_241_var = _loop0_241_rule(p)) // lambda_param_maybe_default* + (_loop0_261_var = _loop0_261_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -27466,10 +29619,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_242_var; + asdl_seq * _loop1_262_var; Token * a; if ( - (_loop1_242_var = _loop1_242_rule(p)) // lambda_param_maybe_default+ + (_loop1_262_var = _loop1_262_rule(p)) // lambda_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -27541,13 +29694,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_243_var; + asdl_seq * _loop1_263_var; if ( - (_loop1_243_var = _loop1_243_rule(p)) // lambda_param_with_default+ + (_loop1_263_var = _loop1_263_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_243_var; + _res = _loop1_263_var; goto done; } p->mark = _mark; @@ -27584,11 +29737,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_244_var; + void *_tmp_264_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_244_var = _tmp_244_rule(p)) // ':' | ',' (':' | '**') + (_tmp_264_var = _tmp_264_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, "'*' (':' | ',' (':' | '**'))")); @@ -27641,20 +29794,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_246_var; - void *_tmp_245_var; - void *_tmp_247_var; + asdl_seq * _loop0_266_var; + void *_tmp_265_var; + void *_tmp_267_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_245_var = _tmp_245_rule(p)) // lambda_param_no_default | ',' + (_tmp_265_var = _tmp_265_rule(p)) // lambda_param_no_default | ',' && - (_loop0_246_var = _loop0_246_rule(p)) // lambda_param_maybe_default* + (_loop0_266_var = _loop0_266_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_247_var = _tmp_247_rule(p)) // lambda_param_no_default | ',' + (_tmp_267_var = _tmp_267_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 | ',')")); @@ -27773,7 +29926,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_248_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_268_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 ',' ('*' | '**' | '/')")); @@ -27848,13 +30001,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_250_var; - void *_tmp_249_var; + asdl_seq * _loop0_270_var; + void *_tmp_269_var; Token * a; if ( - (_tmp_249_var = _tmp_249_rule(p)) // lambda_sum_slash_no_default | lambda_sum_slash_with_default + (_tmp_269_var = _tmp_269_rule(p)) // lambda_sum_slash_no_default | lambda_sum_slash_with_default && - (_loop0_250_var = _loop0_250_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_270_var = _loop0_270_rule(p)) // lambda_sum_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -27878,7 +30031,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_251_var; + asdl_seq * _loop0_271_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -27886,7 +30039,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_251_var = _loop0_251_rule(p)) // lambda_sum_param_no_default* + (_loop0_271_var = _loop0_271_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 && @@ -27912,18 +30065,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_253_var; - asdl_seq * _loop0_252_var; + asdl_seq * _gather_273_var; + asdl_seq * _loop0_272_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_252_var = _loop0_252_rule(p)) // lambda_sum_param_no_default* + (_loop0_272_var = _loop0_272_rule(p)) // lambda_sum_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_253_var = _gather_253_rule(p)) // ','.lambda_param+ + (_gather_273_var = _gather_273_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -27950,22 +30103,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_256_var; - asdl_seq * _loop0_258_var; + asdl_seq * _loop0_276_var; + asdl_seq * _loop0_278_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_257_var; + void *_tmp_277_var; Token * a; if ( - (_opt_var = _tmp_255_rule(p), !p->error_indicator) // [(lambda_sum_slash_no_default | lambda_sum_slash_with_default)] + (_opt_var = _tmp_275_rule(p), !p->error_indicator) // [(lambda_sum_slash_no_default | lambda_sum_slash_with_default)] && - (_loop0_256_var = _loop0_256_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_276_var = _loop0_276_rule(p)) // lambda_sum_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_257_var = _tmp_257_rule(p)) // ',' | lambda_sum_param_no_default + (_tmp_277_var = _tmp_277_rule(p)) // ',' | lambda_sum_param_no_default && - (_loop0_258_var = _loop0_258_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_278_var = _loop0_278_rule(p)) // lambda_sum_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -27990,10 +30143,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_259_var; + asdl_seq * _loop1_279_var; Token * a; if ( - (_loop1_259_var = _loop1_259_rule(p)) // lambda_sum_param_maybe_default+ + (_loop1_279_var = _loop1_279_rule(p)) // lambda_sum_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -28065,13 +30218,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_260_var; + asdl_seq * _loop1_280_var; if ( - (_loop1_260_var = _loop1_260_rule(p)) // lambda_sum_param_with_default+ + (_loop1_280_var = _loop1_280_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_260_var; + _res = _loop1_280_var; goto done; } p->mark = _mark; @@ -28108,11 +30261,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_261_var; + void *_tmp_281_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_261_var = _tmp_261_rule(p)) // '|' | ',' ('|' | '**') + (_tmp_281_var = _tmp_281_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, "'*' ('|' | ',' ('|' | '**'))")); @@ -28165,20 +30318,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_263_var; - void *_tmp_262_var; - void *_tmp_264_var; + asdl_seq * _loop0_283_var; + void *_tmp_282_var; + void *_tmp_284_var; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_262_var = _tmp_262_rule(p)) // lambda_sum_param_no_default | ',' + (_tmp_282_var = _tmp_282_rule(p)) // lambda_sum_param_no_default | ',' && - (_loop0_263_var = _loop0_263_rule(p)) // lambda_sum_param_maybe_default* + (_loop0_283_var = _loop0_283_rule(p)) // lambda_sum_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_264_var = _tmp_264_rule(p)) // lambda_sum_param_no_default | ',' + (_tmp_284_var = _tmp_284_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 | ',')")); @@ -28282,11 +30435,11 @@ invalid_with_item_rule(Parser *p) if ( (expression_var = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (a = expression_rule(p)) // expression && - _PyPegen_lookahead(1, _tmp_265_rule, p) + _PyPegen_lookahead(1, _tmp_285_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 &(',' | ')' | ':')")); @@ -28333,9 +30486,9 @@ invalid_for_target_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings expr_ty a; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' && (a = star_expressions_rule(p)) // star_expressions ) @@ -28462,16 +30615,16 @@ invalid_import_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_import[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import' ','.dotted_name+ 'from' dotted_name")); - asdl_seq * _gather_266_var; + asdl_seq * _gather_286_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( - (a = _PyPegen_expect_token(p, 667)) // token='import' + (a = _PyPegen_expect_token(p, 702)) // token='import' && - (_gather_266_var = _gather_266_rule(p)) // ','.dotted_name+ + (_gather_286_var = _gather_286_rule(p)) // ','.dotted_name+ && - (_keyword = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword = _PyPegen_expect_token(p, 703)) // token='from' && (dotted_name_var = dotted_name_rule(p)) // dotted_name ) @@ -28567,17 +30720,17 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE")); - asdl_seq * _gather_268_var; + asdl_seq * _gather_288_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' && - (_gather_268_var = _gather_268_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_288_var = _gather_288_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -28601,7 +30754,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_270_var; + asdl_seq * _gather_290_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -28611,13 +30764,13 @@ invalid_with_stmt_rule(Parser *p) UNUSED(_opt_var_1); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_270_var = _gather_270_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_290_var = _gather_290_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -28667,18 +30820,18 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); - asdl_seq * _gather_272_var; + asdl_seq * _gather_292_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 679)) // token='with' + (a = _PyPegen_expect_token(p, 714)) // token='with' && - (_gather_272_var = _gather_272_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_292_var = _gather_292_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -28706,7 +30859,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_274_var; + asdl_seq * _gather_294_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -28717,13 +30870,13 @@ invalid_with_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 679)) // token='with' + (a = _PyPegen_expect_token(p, 714)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_274_var = _gather_274_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_294_var = _gather_294_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -28783,7 +30936,7 @@ invalid_try_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 688)) // token='try' + (a = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -28815,13 +30968,13 @@ invalid_try_stmt_rule(Parser *p) Token * _literal; asdl_stmt_seq* block_var; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, _tmp_276_rule, p) + _PyPegen_lookahead(0, _tmp_296_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')")); @@ -28846,29 +30999,29 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_277_var; - asdl_seq * _loop1_278_var; + asdl_seq * _loop0_297_var; + asdl_seq * _loop1_298_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_277_var = _loop0_277_rule(p)) // block* + (_loop0_297_var = _loop0_297_rule(p)) // block* && - (_loop1_278_var = _loop1_278_rule(p)) // except_block+ + (_loop1_298_var = _loop1_298_rule(p)) // except_block+ && - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (b = _PyPegen_expect_token(p, 16)) // token='*' && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_279_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_299_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -28895,23 +31048,23 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_280_var; - asdl_seq * _loop1_281_var; + asdl_seq * _loop0_300_var; + asdl_seq * _loop1_301_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_280_var = _loop0_280_rule(p)) // block* + (_loop0_300_var = _loop0_300_rule(p)) // block* && - (_loop1_281_var = _loop1_281_rule(p)) // except_star_block+ + (_loop1_301_var = _loop1_301_rule(p)) // except_star_block+ && - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && - (_opt_var = _tmp_282_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_302_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -28935,6 +31088,153 @@ invalid_try_stmt_rule(Parser *p) return _res; } +// invalid_try_stmt_nonewline: +// | 'try' ':' block_nonewline !('except' | 'finally') +// | 'try' ':' block_nonewline* except_block_nonewline+ 'except' '*' expression ['as' NAME] ':' +// | 'try' ':' block_nonewline* except_star_block_nonewline+ 'except' [expression ['as' NAME]] ':' +static void * +invalid_try_stmt_nonewline_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; + { // 'try' ':' block_nonewline !('except' | 'finally') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline !('except' | 'finally')")); + Token * _keyword; + Token * _literal; + asdl_stmt_seq* block_nonewline_var; + if ( + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (block_nonewline_var = block_nonewline_rule(p)) // block_nonewline + && + _PyPegen_lookahead(0, _tmp_303_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline !('except' | 'finally')")); + _res = RAISE_SYNTAX_ERROR ( "expected 'except' or 'finally' block" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline !('except' | 'finally')")); + } + { // 'try' ':' block_nonewline* except_block_nonewline+ 'except' '*' expression ['as' NAME] ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline* except_block_nonewline+ 'except' '*' expression ['as' NAME] ':'")); + Token * _keyword; + Token * _literal; + Token * _literal_1; + asdl_seq * _loop0_304_var; + asdl_seq * _loop1_305_var; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + Token * a; + Token * b; + expr_ty expression_var; + if ( + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (_loop0_304_var = _loop0_304_rule(p)) // block_nonewline* + && + (_loop1_305_var = _loop1_305_rule(p)) // except_block_nonewline+ + && + (a = _PyPegen_expect_token(p, 748)) // token='except' + && + (b = _PyPegen_expect_token(p, 16)) // token='*' + && + (expression_var = expression_rule(p)) // expression + && + (_opt_var = _tmp_306_rule(p), !p->error_indicator) // ['as' NAME] + && + (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + D(fprintf(stderr, "%*c+ invalid_try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline* except_block_nonewline+ 'except' '*' expression ['as' NAME] ':'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot have both 'except' and 'except*' on the same 'try'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline* except_block_nonewline+ 'except' '*' expression ['as' NAME] ':'")); + } + { // 'try' ':' block_nonewline* except_star_block_nonewline+ 'except' [expression ['as' NAME]] ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_try_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline* except_star_block_nonewline+ 'except' [expression ['as' NAME]] ':'")); + Token * _keyword; + Token * _literal; + Token * _literal_1; + asdl_seq * _loop0_307_var; + asdl_seq * _loop1_308_var; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + Token * a; + if ( + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (_loop0_307_var = _loop0_307_rule(p)) // block_nonewline* + && + (_loop1_308_var = _loop1_308_rule(p)) // except_star_block_nonewline+ + && + (a = _PyPegen_expect_token(p, 748)) // token='except' + && + (_opt_var = _tmp_309_rule(p), !p->error_indicator) // [expression ['as' NAME]] + && + (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + D(fprintf(stderr, "%*c+ invalid_try_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline* except_star_block_nonewline+ 'except' [expression ['as' NAME]] ':'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot have both 'except' and 'except*' on the same 'try'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_try_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try' ':' block_nonewline* except_star_block_nonewline+ 'except' [expression ['as' NAME]] ':'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // invalid_except_stmt: // | 'except' '*'? expression ',' expressions ['as' NAME] ':' // | 'except' '*'? expression ['as' NAME] NEWLINE @@ -28969,7 +31269,7 @@ invalid_except_stmt_rule(Parser *p) expr_ty a; expr_ty expressions_var; if ( - (_keyword = _PyPegen_expect_token(p, 701)) // token='except' + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' && (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? && @@ -28979,7 +31279,7 @@ invalid_except_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_opt_var_1 = _tmp_283_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var_1 = _tmp_310_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -29011,13 +31311,13 @@ invalid_except_stmt_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? && (expression_var = expression_rule(p)) // expression && - (_opt_var_1 = _tmp_284_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var_1 = _tmp_311_rule(p), !p->error_indicator) // ['as' NAME] && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -29044,7 +31344,7 @@ invalid_except_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -29069,14 +31369,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_285_var; + void *_tmp_312_var; Token * a; if ( - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_285_var = _tmp_285_rule(p)) // NEWLINE | ':' + (_tmp_312_var = _tmp_312_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 | ':')")); @@ -29098,6 +31398,102 @@ invalid_except_stmt_rule(Parser *p) return _res; } +// invalid_except_stmt_nonewline: +// | 'except' '*'? expression ',' expressions ['as' NAME] ':' +// | 'except' '*' ':' +static void * +invalid_except_stmt_nonewline_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; + { // 'except' '*'? expression ',' expressions ['as' NAME] ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_except_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*'? expression ',' expressions ['as' NAME] ':'")); + Token * _keyword; + Token * _literal; + Token * _literal_1; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *_opt_var_1; + UNUSED(_opt_var_1); // Silence compiler warnings + expr_ty a; + expr_ty expressions_var; + if ( + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' + && + (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'? + && + (a = expression_rule(p)) // expression + && + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (expressions_var = expressions_rule(p)) // expressions + && + (_opt_var_1 = _tmp_313_rule(p), !p->error_indicator) // ['as' NAME] + && + (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + D(fprintf(stderr, "%*c+ invalid_except_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*'? expression ',' expressions ['as' NAME] ':'")); + _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "multiple exception types must be parenthesized" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_except_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' '*'? expression ',' expressions ['as' NAME] ':'")); + } + { // 'except' '*' ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_except_stmt_nonewline[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*' ':'")); + Token * _literal; + Token * _literal_1; + Token * a; + if ( + (a = _PyPegen_expect_token(p, 748)) // token='except' + && + (_literal = _PyPegen_expect_token(p, 16)) // token='*' + && + (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + D(fprintf(stderr, "%*c+ invalid_except_stmt_nonewline[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except' '*' ':'")); + _res = RAISE_SYNTAX_ERROR ( "expected one or more exception types" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_except_stmt_nonewline[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except' '*' ':'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // invalid_finally_stmt: 'finally' ':' NEWLINE !INDENT static void * invalid_finally_stmt_rule(Parser *p) @@ -29122,7 +31518,7 @@ invalid_finally_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 697)) // token='finally' + (a = _PyPegen_expect_token(p, 744)) // token='finally' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29179,11 +31575,11 @@ invalid_except_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_286_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_314_rule(p), !p->error_indicator) // ['as' NAME] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29215,7 +31611,7 @@ invalid_except_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29272,13 +31668,13 @@ invalid_except_star_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 701)) // token='except' + (a = _PyPegen_expect_token(p, 748)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_287_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_315_rule(p), !p->error_indicator) // ['as' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29514,7 +31910,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (a = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' ) @@ -29544,7 +31940,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p) && @@ -29647,7 +32043,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_288_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_316_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -29701,7 +32097,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -29732,7 +32128,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty a_1; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 706)) // token='if' + (a = _PyPegen_expect_token(p, 753)) // token='if' && (a_1 = named_expression_rule(p)) // named_expression && @@ -29788,7 +32184,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 755)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -29819,7 +32215,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 708)) // token='elif' + (a = _PyPegen_expect_token(p, 755)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -29873,7 +32269,7 @@ invalid_else_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 709)) // token='else' + (a = _PyPegen_expect_token(p, 756)) // token='else' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -29927,7 +32323,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 711)) // token='while' + (_keyword = _PyPegen_expect_token(p, 758)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -29958,7 +32354,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 711)) // token='while' + (a = _PyPegen_expect_token(p, 758)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -30018,13 +32414,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 764)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -30059,13 +32455,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 716)) // token='for' + (a = _PyPegen_expect_token(p, 763)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword = _PyPegen_expect_token(p, 764)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -30129,7 +32525,7 @@ invalid_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 718), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 765), !p->error_indicator) // 'async'? && (a = _PyPegen_expect_soft_keyword(p, "def")) // soft_keyword='"def"' && @@ -30141,7 +32537,7 @@ invalid_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (_opt_var_2 = _tmp_289_rule(p), !p->error_indicator) // ['->' expression] + (_opt_var_2 = _tmp_317_rule(p), !p->error_indicator) // ['->' expression] && (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -30195,11 +32591,11 @@ invalid_class_def_raw_nonewline_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 720)) // token='class' + (_keyword = _PyPegen_expect_token(p, 767)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && - (_opt_var = _tmp_290_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (_opt_var = _tmp_318_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -30271,11 +32667,11 @@ invalid_class_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 720)) // token='class' + (a = _PyPegen_expect_token(p, 767)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && - (_opt_var = _tmp_291_rule(p), !p->error_indicator) // ['(' arguments? ')'] + (_opt_var = _tmp_319_rule(p), !p->error_indicator) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -30326,11 +32722,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_292_var; + asdl_seq * _gather_320_var; Token * _literal; void *invalid_kvpair_var; if ( - (_gather_292_var = _gather_292_rule(p)) // ','.double_starred_kvpair+ + (_gather_320_var = _gather_320_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -30338,7 +32734,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_292_var, _literal, invalid_kvpair_var); + _res = _PyPegen_dummy_name(p, _gather_320_var, _literal, invalid_kvpair_var); goto done; } p->mark = _mark; @@ -30391,7 +32787,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_294_rule, p) + _PyPegen_lookahead(1, _tmp_322_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 ':' &('}' | ',')")); @@ -30502,7 +32898,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_295_rule, p) + _PyPegen_lookahead(1, _tmp_323_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression ':' &('}' | ',')")); @@ -30720,7 +33116,7 @@ invalid_replacement_field_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - _PyPegen_lookahead(0, _tmp_296_rule, p) + _PyPegen_lookahead(0, _tmp_324_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)")); @@ -30743,13 +33139,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_297_var; + void *_tmp_325_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_297_var = _tmp_297_rule(p)) // yield_expr | star_expressions + (_tmp_325_var = _tmp_325_rule(p)) // yield_expr | star_expressions && - _PyPegen_lookahead(0, _tmp_298_rule, p) + _PyPegen_lookahead(0, _tmp_326_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) !('=' | '!' | ':' | '}')")); @@ -30773,15 +33169,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_299_var; + void *_tmp_327_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_299_var = _tmp_299_rule(p)) // yield_expr | star_expressions + (_tmp_327_var = _tmp_327_rule(p)) // yield_expr | star_expressions && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_300_rule, p) + _PyPegen_lookahead(0, _tmp_328_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) '=' !('!' | ':' | '}')")); @@ -30806,12 +33202,12 @@ invalid_replacement_field_rule(Parser *p) Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_301_var; + void *_tmp_329_var; void *invalid_conversion_character_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_301_var = _tmp_301_rule(p)) // yield_expr | star_expressions + (_tmp_329_var = _tmp_329_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && @@ -30819,7 +33215,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_301_var, _opt_var, invalid_conversion_character_var); + _res = _PyPegen_dummy_name(p, _literal, _tmp_329_var, _opt_var, invalid_conversion_character_var); goto done; } p->mark = _mark; @@ -30837,17 +33233,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_302_var; + void *_tmp_330_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_302_var = _tmp_302_rule(p)) // yield_expr | star_expressions + (_tmp_330_var = _tmp_330_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_303_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_331_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_304_rule, p) + _PyPegen_lookahead(0, _tmp_332_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] !(':' | '}')")); @@ -30871,24 +33267,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_307_var; + asdl_seq * _loop0_335_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; UNUSED(_opt_var_1); // Silence compiler warnings - void *_tmp_305_var; + void *_tmp_333_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_305_var = _tmp_305_rule(p)) // yield_expr | star_expressions + (_tmp_333_var = _tmp_333_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_306_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_334_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_307_var = _loop0_307_rule(p)) // fstring_format_spec* + (_loop0_335_var = _loop0_335_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -30917,15 +33313,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_308_var; + void *_tmp_336_var; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_tmp_308_var = _tmp_308_rule(p)) // yield_expr | star_expressions + (_tmp_336_var = _tmp_336_rule(p)) // yield_expr | star_expressions && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_309_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_337_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -30973,7 +33369,7 @@ invalid_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_310_rule, p) + _PyPegen_lookahead(1, _tmp_338_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' &(':' | '}')")); @@ -31298,247 +33694,9 @@ _loop1_4_rule(Parser *p) return _seq; } -// _loop0_6: ';' simple_stmt -static asdl_seq * -_loop0_6_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void *_res = NULL; - int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // ';' simple_stmt - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _loop0_6[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); - Token * _literal; - stmt_ty elem; - while ( - (_literal = _PyPegen_expect_token(p, 13)) // token=';' - && - (elem = simple_stmt_rule(p)) // simple_stmt - ) - { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_6[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';' simple_stmt")); - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _gather_5: simple_stmt _loop0_6 -static asdl_seq * -_gather_5_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // simple_stmt _loop0_6 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_5[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_6")); - stmt_ty elem; - asdl_seq * seq; - if ( - (elem = simple_stmt_rule(p)) // simple_stmt - && - (seq = _loop0_6_rule(p)) // _loop0_6 - ) - { - D(fprintf(stderr, "%*c+ _gather_5[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_6")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_5[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_6")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop0_8: ';' simple_stmt -static asdl_seq * -_loop0_8_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void *_res = NULL; - int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // ';' simple_stmt - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _loop0_8[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); - Token * _literal; - stmt_ty elem; - while ( - (_literal = _PyPegen_expect_token(p, 13)) // token=';' - && - (elem = simple_stmt_rule(p)) // simple_stmt - ) - { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_8[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';' simple_stmt")); - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _gather_7: simple_stmt _loop0_8 -static asdl_seq * -_gather_7_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // simple_stmt _loop0_8 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_7[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_8")); - stmt_ty elem; - asdl_seq * seq; - if ( - (elem = simple_stmt_rule(p)) // simple_stmt - && - (seq = _loop0_8_rule(p)) // _loop0_8 - ) - { - D(fprintf(stderr, "%*c+ _gather_7[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_8")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_7[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_8")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_9: 'return' del_kw_stmt | return_stmt +// _tmp_5: 'return' del_kw_stmt | return_stmt static void * -_tmp_9_rule(Parser *p) +_tmp_5_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31564,16 +33722,16 @@ _tmp_9_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_9[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); + D(fprintf(stderr, "%*c> _tmp_5[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); Token * _keyword; stmt_ty del_kw_stmt_var; if ( - (_keyword = _PyPegen_expect_token(p, 560)) // token='return' + (_keyword = _PyPegen_expect_token(p, 567)) // token='return' && (del_kw_stmt_var = del_kw_stmt_rule(p)) // del_kw_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_9[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); + D(fprintf(stderr, "%*c+ _tmp_5[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -31592,7 +33750,7 @@ _tmp_9_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_5[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'return' del_kw_stmt")); } { // return_stmt @@ -31600,18 +33758,18 @@ _tmp_9_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_9[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); + D(fprintf(stderr, "%*c> _tmp_5[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); stmt_ty return_stmt_var; if ( (return_stmt_var = return_stmt_rule(p)) // return_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_9[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); + D(fprintf(stderr, "%*c+ _tmp_5[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "return_stmt")); _res = return_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_5[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "return_stmt")); } _res = NULL; @@ -31620,9 +33778,9 @@ _tmp_9_rule(Parser *p) return _res; } -// _tmp_10: 'import' | 'from' +// _tmp_6: 'import' | 'from' static void * -_tmp_10_rule(Parser *p) +_tmp_6_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31639,18 +33797,18 @@ _tmp_10_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c> _tmp_6[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 667)) // token='import' + (_keyword = _PyPegen_expect_token(p, 702)) // token='import' ) { - D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c+ _tmp_6[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_6[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'import'")); } { // 'from' @@ -31658,18 +33816,18 @@ _tmp_10_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c> _tmp_6[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword = _PyPegen_expect_token(p, 703)) // token='from' ) { - D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c+ _tmp_6[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_6[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'from'")); } _res = NULL; @@ -31678,9 +33836,9 @@ _tmp_10_rule(Parser *p) return _res; } -// _tmp_11: del_kw_stmt | del_stmt +// _tmp_7: del_kw_stmt | del_stmt static void * -_tmp_11_rule(Parser *p) +_tmp_7_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31697,18 +33855,18 @@ _tmp_11_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); + D(fprintf(stderr, "%*c> _tmp_7[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); stmt_ty del_kw_stmt_var; if ( (del_kw_stmt_var = del_kw_stmt_rule(p)) // del_kw_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); + D(fprintf(stderr, "%*c+ _tmp_7[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_kw_stmt")); _res = del_kw_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_7[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_kw_stmt")); } { // del_stmt @@ -31716,18 +33874,18 @@ _tmp_11_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); + D(fprintf(stderr, "%*c> _tmp_7[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); stmt_ty del_stmt_var; if ( (del_stmt_var = del_stmt_rule(p)) // del_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); + D(fprintf(stderr, "%*c+ _tmp_7[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_stmt")); _res = del_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_7[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_stmt")); } _res = NULL; @@ -31736,9 +33894,9 @@ _tmp_11_rule(Parser *p) return _res; } -// _tmp_12: "def" | '@' | 'async' +// _tmp_8: "def" | '@' | 'async' static void * -_tmp_12_rule(Parser *p) +_tmp_8_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31755,18 +33913,18 @@ _tmp_12_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c> _tmp_8[%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_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c+ _tmp_8[%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_12[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_8[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"def\"")); } { // '@' @@ -31774,18 +33932,18 @@ _tmp_12_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c> _tmp_8[%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_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_8[%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_12[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_8[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } { // 'async' @@ -31793,18 +33951,18 @@ _tmp_12_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_8[%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' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_12[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_8[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_12[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_8[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -31813,9 +33971,9 @@ _tmp_12_rule(Parser *p) return _res; } -// _tmp_13: 'class' | '@' +// _tmp_9: 'class' | '@' static void * -_tmp_13_rule(Parser *p) +_tmp_9_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31832,18 +33990,18 @@ _tmp_13_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c> _tmp_9[%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' + (_keyword = _PyPegen_expect_token(p, 767)) // token='class' ) { - D(fprintf(stderr, "%*c+ _tmp_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c+ _tmp_9[%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_13[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); } { // '@' @@ -31851,18 +34009,18 @@ _tmp_13_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c> _tmp_9[%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_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_9[%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_13[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_9[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } _res = NULL; @@ -31871,9 +34029,9 @@ _tmp_13_rule(Parser *p) return _res; } -// _tmp_14: 'with' | 'async' +// _tmp_10: 'with' | 'async' static void * -_tmp_14_rule(Parser *p) +_tmp_10_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31890,18 +34048,18 @@ _tmp_14_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_14[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c> _tmp_10[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' ) { - D(fprintf(stderr, "%*c+ _tmp_14[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c+ _tmp_10[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_14[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with'")); } { // 'async' @@ -31909,18 +34067,18 @@ _tmp_14_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_14[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_10[%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' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_14[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_10[%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_14[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_10[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -31929,9 +34087,9 @@ _tmp_14_rule(Parser *p) return _res; } -// _tmp_15: 'for' | 'async' +// _tmp_11: 'for' | 'async' static void * -_tmp_15_rule(Parser *p) +_tmp_11_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -31948,20 +34106,270 @@ _tmp_15_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' ) { - D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c+ _tmp_11[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_15[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_11[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'for'")); } + { // 'async' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_11[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' + ) + { + D(fprintf(stderr, "%*c+ _tmp_11[%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_11[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop1_12: statement_nonewline +static asdl_seq * +_loop1_12_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; + { // statement_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_12[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "statement_nonewline")); + asdl_stmt_seq* statement_nonewline_var; + while ( + (statement_nonewline_var = statement_nonewline_rule(p)) // statement_nonewline + ) + { + _res = statement_nonewline_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_12[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "statement_nonewline")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop0_14: ';' (';'.simple_stmt+ | parenthesized_stmt_nonewline) +static asdl_seq * +_loop0_14_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // ';' (';'.simple_stmt+ | parenthesized_stmt_nonewline) + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_14[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' (';'.simple_stmt+ | parenthesized_stmt_nonewline)")); + Token * _literal; + void *elem; + while ( + (_literal = _PyPegen_expect_token(p, 13)) // token=';' + && + (elem = _tmp_339_rule(p)) // ';'.simple_stmt+ | parenthesized_stmt_nonewline + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_14[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';' (';'.simple_stmt+ | parenthesized_stmt_nonewline)")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_13: (';'.simple_stmt+ | parenthesized_stmt_nonewline) _loop0_14 +static asdl_seq * +_gather_13_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // (';'.simple_stmt+ | parenthesized_stmt_nonewline) _loop0_14 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_13[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(';'.simple_stmt+ | parenthesized_stmt_nonewline) _loop0_14")); + void *elem; + asdl_seq * seq; + if ( + (elem = _tmp_339_rule(p)) // ';'.simple_stmt+ | parenthesized_stmt_nonewline + && + (seq = _loop0_14_rule(p)) // _loop0_14 + ) + { + D(fprintf(stderr, "%*c+ _gather_13[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(';'.simple_stmt+ | parenthesized_stmt_nonewline) _loop0_14")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_13[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(';'.simple_stmt+ | parenthesized_stmt_nonewline) _loop0_14")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_15: 'with' | 'async' +static void * +_tmp_15_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; + { // 'with' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' + ) + { + D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + _res = _keyword; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_15[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with'")); + } { // 'async' if (p->error_indicator) { p->level--; @@ -31970,7 +34378,7 @@ _tmp_15_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_15[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 718)) // token='async' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_15[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); @@ -31987,9 +34395,67 @@ _tmp_15_rule(Parser *p) return _res; } -// _tmp_16: '=' annotated_rhs +// _tmp_16: 'for' | 'async' static void * _tmp_16_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; + { // 'for' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_16[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' + ) + { + D(fprintf(stderr, "%*c+ _tmp_16[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + _res = _keyword; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_16[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'for'")); + } + { // 'async' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_16[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' + ) + { + D(fprintf(stderr, "%*c+ _tmp_16[%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_16[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_17: '=' annotated_rhs +static void * +_tmp_17_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32006,7 +34472,7 @@ _tmp_16_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_16[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c> _tmp_17[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); Token * _literal; expr_ty d; if ( @@ -32015,7 +34481,7 @@ _tmp_16_rule(Parser *p) (d = annotated_rhs_rule(p)) // annotated_rhs ) { - D(fprintf(stderr, "%*c+ _tmp_16[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c+ _tmp_17[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32025,7 +34491,7 @@ _tmp_16_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_16[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_17[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); } _res = NULL; @@ -32034,9 +34500,9 @@ _tmp_16_rule(Parser *p) return _res; } -// _tmp_17: '(' single_target ')' | single_subscript_attribute_target +// _tmp_18: '(' single_target ')' | single_subscript_attribute_target static void * -_tmp_17_rule(Parser *p) +_tmp_18_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32053,7 +34519,7 @@ _tmp_17_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_17[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); + D(fprintf(stderr, "%*c> _tmp_18[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); Token * _literal; Token * _literal_1; expr_ty b; @@ -32065,7 +34531,7 @@ _tmp_17_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_17[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); + D(fprintf(stderr, "%*c+ _tmp_18[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); _res = b; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32075,7 +34541,7 @@ _tmp_17_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_17[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_18[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' single_target ')'")); } { // single_subscript_attribute_target @@ -32083,18 +34549,18 @@ _tmp_17_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_17[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); + D(fprintf(stderr, "%*c> _tmp_18[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); expr_ty single_subscript_attribute_target_var; if ( (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target ) { - D(fprintf(stderr, "%*c+ _tmp_17[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); + D(fprintf(stderr, "%*c+ _tmp_18[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); _res = single_subscript_attribute_target_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_17[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_18[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "single_subscript_attribute_target")); } _res = NULL; @@ -32103,9 +34569,9 @@ _tmp_17_rule(Parser *p) return _res; } -// _tmp_18: '=' annotated_rhs +// _tmp_19: '=' annotated_rhs static void * -_tmp_18_rule(Parser *p) +_tmp_19_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32122,7 +34588,7 @@ _tmp_18_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_18[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c> _tmp_19[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); Token * _literal; expr_ty d; if ( @@ -32131,7 +34597,7 @@ _tmp_18_rule(Parser *p) (d = annotated_rhs_rule(p)) // annotated_rhs ) { - D(fprintf(stderr, "%*c+ _tmp_18[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); + D(fprintf(stderr, "%*c+ _tmp_19[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32141,7 +34607,7 @@ _tmp_18_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_18[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_19[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'=' annotated_rhs")); } _res = NULL; @@ -32150,9 +34616,9 @@ _tmp_18_rule(Parser *p) return _res; } -// _loop1_19: (star_targets '=') +// _loop1_20: (star_targets '=') static asdl_seq * -_loop1_19_rule(Parser *p) +_loop1_20_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32178,13 +34644,13 @@ _loop1_19_rule(Parser *p) p->level--; 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_311_var; + D(fprintf(stderr, "%*c> _loop1_20[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_340_var; while ( - (_tmp_311_var = _tmp_311_rule(p)) // star_targets '=' + (_tmp_340_var = _tmp_340_rule(p)) // star_targets '=' ) { - _res = _tmp_311_var; + _res = _tmp_340_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32201,7 +34667,7 @@ _loop1_19_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_19[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_20[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(star_targets '=')")); } if (_n == 0 || p->error_indicator) { @@ -32223,9 +34689,9 @@ _loop1_19_rule(Parser *p) return _seq; } -// _tmp_20: yield_expr | star_expressions +// _tmp_21: yield_expr | star_expressions static void * -_tmp_20_rule(Parser *p) +_tmp_21_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32242,18 +34708,18 @@ _tmp_20_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_20[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_21[%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_20[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_21[%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_20[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_21[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -32261,18 +34727,18 @@ _tmp_20_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_20[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_21[%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_20[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_21[%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_20[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_21[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -32281,9 +34747,9 @@ _tmp_20_rule(Parser *p) return _res; } -// _tmp_21: '|>=' +// _tmp_22: '|>=' static void * -_tmp_21_rule(Parser *p) +_tmp_22_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32300,13 +34766,13 @@ _tmp_21_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_21[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); + D(fprintf(stderr, "%*c> _tmp_22[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); Token * t; if ( (t = _PyPegen_expect_token(p, 57)) // token='|>=' ) { - D(fprintf(stderr, "%*c+ _tmp_21[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); + D(fprintf(stderr, "%*c+ _tmp_22[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>='")); _res = ( ++ p -> subn , t ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32316,7 +34782,7 @@ _tmp_21_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_21[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_22[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|>='")); } _res = NULL; @@ -32325,9 +34791,9 @@ _tmp_21_rule(Parser *p) return _res; } -// _tmp_22: [yield_expr | star_expressions] +// _tmp_23: [yield_expr | star_expressions] static void * -_tmp_22_rule(Parser *p) +_tmp_23_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32344,13 +34810,13 @@ _tmp_22_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_22[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); + D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); void *d; if ( - (d = _tmp_312_rule(p), !p->error_indicator) // [yield_expr | star_expressions] + (d = _tmp_341_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]")); + D(fprintf(stderr, "%*c+ _tmp_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); _res = ( - - p -> subn , d ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32360,7 +34826,7 @@ _tmp_22_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_22[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_23[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "[yield_expr | star_expressions]")); } _res = NULL; @@ -32369,9 +34835,9 @@ _tmp_22_rule(Parser *p) return _res; } -// _tmp_23: ';' | NEWLINE +// _tmp_24: ';' | NEWLINE static void * -_tmp_23_rule(Parser *p) +_tmp_24_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32388,18 +34854,18 @@ _tmp_23_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 13)) // token=';' ) { - D(fprintf(stderr, "%*c+ _tmp_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c+ _tmp_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_23[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_24[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'")); } { // NEWLINE @@ -32407,18 +34873,18 @@ _tmp_23_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_23[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_24[%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_23[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_24[%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_23[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_24[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE")); } _res = NULL; @@ -32427,9 +34893,9 @@ _tmp_23_rule(Parser *p) return _res; } -// _tmp_24: yield_expr | star_expressions +// _tmp_25: yield_expr | star_expressions static void * -_tmp_24_rule(Parser *p) +_tmp_25_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32446,18 +34912,18 @@ _tmp_24_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_25[%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_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_25[%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_24[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -32465,18 +34931,18 @@ _tmp_24_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_24[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_25[%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_24[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_25[%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_24[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -32485,9 +34951,9 @@ _tmp_24_rule(Parser *p) return _res; } -// _tmp_25: '+=' | '+' '=' +// _tmp_26: '+=' | '+' '=' static void * -_tmp_25_rule(Parser *p) +_tmp_26_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32504,18 +34970,18 @@ _tmp_25_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_25[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); + D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 36)) // token='+=' ) { - D(fprintf(stderr, "%*c+ _tmp_25[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); + D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+='")); } { // '+' '=' @@ -32523,7 +34989,7 @@ _tmp_25_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_25[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); + D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); Token * _literal; Token * _literal_1; if ( @@ -32532,12 +34998,12 @@ _tmp_25_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_25[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); + D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+' '='")); _res = _PyPegen_dummy_name(p, _literal, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_25[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+' '='")); } _res = NULL; @@ -32546,9 +35012,9 @@ _tmp_25_rule(Parser *p) return _res; } -// _tmp_26: '-=' | '-' '=' +// _tmp_27: '-=' | '-' '=' static void * -_tmp_26_rule(Parser *p) +_tmp_27_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32565,18 +35031,18 @@ _tmp_26_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); + D(fprintf(stderr, "%*c> _tmp_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 37)) // token='-=' ) { - D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); + D(fprintf(stderr, "%*c+ _tmp_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_27[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-='")); } { // '-' '=' @@ -32584,7 +35050,7 @@ _tmp_26_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_26[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); + D(fprintf(stderr, "%*c> _tmp_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); Token * _literal; Token * _literal_1; if ( @@ -32593,12 +35059,12 @@ _tmp_26_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_26[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); + D(fprintf(stderr, "%*c+ _tmp_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-' '='")); _res = _PyPegen_dummy_name(p, _literal, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_26[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_27[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-' '='")); } _res = NULL; @@ -32607,9 +35073,9 @@ _tmp_26_rule(Parser *p) return _res; } -// _tmp_27: '!=' | '!' '=' +// _tmp_28: '!=' | '!' '=' static void * -_tmp_27_rule(Parser *p) +_tmp_28_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32626,18 +35092,18 @@ _tmp_27_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c> _tmp_28[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 28)) // token='!=' ) { - D(fprintf(stderr, "%*c+ _tmp_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c+ _tmp_28[%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_27[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_28[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!='")); } { // '!' '=' @@ -32645,7 +35111,7 @@ _tmp_27_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_27[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); + D(fprintf(stderr, "%*c> _tmp_28[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); Token * _literal; Token * _literal_1; if ( @@ -32654,12 +35120,12 @@ _tmp_27_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_27[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); + D(fprintf(stderr, "%*c+ _tmp_28[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' '='")); _res = _PyPegen_dummy_name(p, _literal, _literal_1); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_27[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_28[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!' '='")); } _res = NULL; @@ -32668,9 +35134,9 @@ _tmp_27_rule(Parser *p) return _res; } -// _tmp_28: 'from' expression +// _tmp_29: 'from' expression static void * -_tmp_28_rule(Parser *p) +_tmp_29_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32687,16 +35153,16 @@ _tmp_28_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_28[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); + D(fprintf(stderr, "%*c> _tmp_29[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword = _PyPegen_expect_token(p, 703)) // token='from' && (z = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_28[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); + D(fprintf(stderr, "%*c+ _tmp_29[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from' expression")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32706,7 +35172,7 @@ _tmp_28_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_28[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_29[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'from' expression")); } _res = NULL; @@ -32715,9 +35181,9 @@ _tmp_28_rule(Parser *p) return _res; } -// _loop0_30: ',' NAME +// _loop0_31: ',' NAME static asdl_seq * -_loop0_30_rule(Parser *p) +_loop0_31_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32743,7 +35209,7 @@ _loop0_30_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_30[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c> _loop0_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); Token * _literal; expr_ty elem; while ( @@ -32775,7 +35241,7 @@ _loop0_30_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_30[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_31[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32792,9 +35258,9 @@ _loop0_30_rule(Parser *p) return _seq; } -// _gather_29: NAME _loop0_30 +// _gather_30: NAME _loop0_31 static asdl_seq * -_gather_29_rule(Parser *p) +_gather_30_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32806,27 +35272,27 @@ _gather_29_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_30 + { // NAME _loop0_31 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_29[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); + D(fprintf(stderr, "%*c> _gather_30[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_31")); expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_30_rule(p)) // _loop0_30 + (seq = _loop0_31_rule(p)) // _loop0_31 ) { - D(fprintf(stderr, "%*c+ _gather_29[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); + D(fprintf(stderr, "%*c+ _gather_30[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_31")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_29[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_30")); + D(fprintf(stderr, "%*c%s _gather_30[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_31")); } _res = NULL; done: @@ -32834,9 +35300,9 @@ _gather_29_rule(Parser *p) return _res; } -// _loop0_32: ',' NAME +// _loop0_33: ',' NAME static asdl_seq * -_loop0_32_rule(Parser *p) +_loop0_33_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32862,7 +35328,7 @@ _loop0_32_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_32[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c> _loop0_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); Token * _literal; expr_ty elem; while ( @@ -32894,7 +35360,7 @@ _loop0_32_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_32[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_33[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32911,9 +35377,9 @@ _loop0_32_rule(Parser *p) return _seq; } -// _gather_31: NAME _loop0_32 +// _gather_32: NAME _loop0_33 static asdl_seq * -_gather_31_rule(Parser *p) +_gather_32_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -32925,27 +35391,27 @@ _gather_31_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_32 + { // NAME _loop0_33 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_31[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_32")); + D(fprintf(stderr, "%*c> _gather_32[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_33")); expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_32_rule(p)) // _loop0_32 + (seq = _loop0_33_rule(p)) // _loop0_33 ) { - D(fprintf(stderr, "%*c+ _gather_31[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_32")); + D(fprintf(stderr, "%*c+ _gather_32[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_33")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_31[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_32")); + D(fprintf(stderr, "%*c%s _gather_32[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_33")); } _res = NULL; done: @@ -32953,7 +35419,7 @@ _gather_31_rule(Parser *p) return _res; } -// _tmp_33: +// _tmp_34: // | 'False' // | 'None' // | 'True' @@ -32990,7 +35456,7 @@ _gather_31_rule(Parser *p) // | 'with' // | 'yield' static void * -_tmp_33_rule(Parser *p) +_tmp_34_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33007,18 +35473,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'False'")); } { // 'None' @@ -33026,18 +35492,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } { // 'True' @@ -33045,18 +35511,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'True'")); } { // 'and' @@ -33064,18 +35530,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='and' + (_keyword = _PyPegen_expect_token(p, 659)) // token='and' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'and'")); } { // 'as' @@ -33083,18 +35549,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as'")); } { // 'assert' @@ -33102,18 +35568,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 566)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 573)) // token='assert' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'assert'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'assert'")); } { // 'async' @@ -33121,18 +35587,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } { // 'await' @@ -33140,18 +35606,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 637)) // token='await' + (_keyword = _PyPegen_expect_token(p, 672)) // token='await' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'await'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'await'")); } { // 'break' @@ -33159,18 +35625,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 538)) // token='break' + (_keyword = _PyPegen_expect_token(p, 545)) // token='break' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'break'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'break'")); } { // 'class' @@ -33178,18 +35644,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 767)) // token='class' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); } { // 'continue' @@ -33197,18 +35663,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 540)) // token='continue' + (_keyword = _PyPegen_expect_token(p, 547)) // token='continue' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'continue'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'continue'")); } { // 'del' @@ -33216,18 +35682,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 663)) // token='del' + (_keyword = _PyPegen_expect_token(p, 698)) // token='del' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'del'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'del'")); } { // 'elif' @@ -33235,18 +35701,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 708)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 755)) // token='elif' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'elif'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'elif'")); } { // 'else' @@ -33254,18 +35720,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 756)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'else'")); } { // 'except' @@ -33273,18 +35739,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except'")); } { // 'finally' @@ -33292,18 +35758,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_34[%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' + (_keyword = _PyPegen_expect_token(p, 744)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_34[%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_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'finally'")); } { // 'for' @@ -33311,18 +35777,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 716)) // token='for' + (_keyword = _PyPegen_expect_token(p, 763)) // token='for' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'for'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'for'")); } { // 'from' @@ -33330,18 +35796,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 668)) // token='from' + (_keyword = _PyPegen_expect_token(p, 703)) // token='from' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'from'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'from'")); } { // 'global' @@ -33349,18 +35815,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 548)) // token='global' + (_keyword = _PyPegen_expect_token(p, 555)) // token='global' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'global'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'global'")); } { // 'goto' @@ -33368,18 +35834,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 567)) // token='goto' + (_keyword = _PyPegen_expect_token(p, 574)) // token='goto' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'goto'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'goto'")); } { // 'if' @@ -33387,18 +35853,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if'")); } { // 'import' @@ -33406,18 +35872,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 667)) // token='import' + (_keyword = _PyPegen_expect_token(p, 702)) // token='import' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'import'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'import'")); } { // 'in' @@ -33425,18 +35891,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 717)) // token='in' + (_keyword = _PyPegen_expect_token(p, 764)) // token='in' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'in'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'in'")); } { // 'is' @@ -33444,18 +35910,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 636)) // token='is' + (_keyword = _PyPegen_expect_token(p, 671)) // token='is' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'is'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'is'")); } { // 'lambda' @@ -33463,18 +35929,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 659)) // token='lambda' + (_keyword = _PyPegen_expect_token(p, 694)) // token='lambda' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'lambda'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'lambda'")); } { // 'nonlocal' @@ -33482,18 +35948,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 555)) // token='nonlocal' + (_keyword = _PyPegen_expect_token(p, 562)) // token='nonlocal' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'nonlocal'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'nonlocal'")); } { // 'not' @@ -33501,18 +35967,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 635)) // token='not' + (_keyword = _PyPegen_expect_token(p, 670)) // token='not' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'not'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'not'")); } { // 'or' @@ -33520,18 +35986,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='or' + (_keyword = _PyPegen_expect_token(p, 658)) // token='or' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'or'")); } { // 'pass' @@ -33539,18 +36005,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 558)) // token='pass' + (_keyword = _PyPegen_expect_token(p, 565)) // token='pass' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'pass'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'pass'")); } { // 'raise' @@ -33558,18 +36024,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 559)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 566)) // token='raise' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'raise'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'raise'")); } { // 'return' @@ -33577,18 +36043,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 560)) // token='return' + (_keyword = _PyPegen_expect_token(p, 567)) // token='return' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'return'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'return'")); } { // 'try' @@ -33596,18 +36062,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 688)) // token='try' + (_keyword = _PyPegen_expect_token(p, 732)) // token='try' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'try'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'try'")); } { // 'while' @@ -33615,18 +36081,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 711)) // token='while' + (_keyword = _PyPegen_expect_token(p, 758)) // token='while' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'while'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'while'")); } { // 'with' @@ -33634,18 +36100,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 679)) // token='with' + (_keyword = _PyPegen_expect_token(p, 714)) // token='with' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'with'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'with'")); } { // 'yield' @@ -33653,18 +36119,18 @@ _tmp_33_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_33[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); + D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 622)) // token='yield' + (_keyword = _PyPegen_expect_token(p, 657)) // token='yield' ) { - D(fprintf(stderr, "%*c+ _tmp_33[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); + D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'yield'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_33[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_34[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'yield'")); } _res = NULL; @@ -33673,9 +36139,9 @@ _tmp_33_rule(Parser *p) return _res; } -// _tmp_34: ';' | NEWLINE +// _tmp_35: ';' | NEWLINE static void * -_tmp_34_rule(Parser *p) +_tmp_35_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33692,18 +36158,18 @@ _tmp_34_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c> _tmp_35[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 13)) // token=';' ) { - D(fprintf(stderr, "%*c+ _tmp_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'")); + D(fprintf(stderr, "%*c+ _tmp_35[%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_34[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_35[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'")); } { // NEWLINE @@ -33711,18 +36177,18 @@ _tmp_34_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_34[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_35[%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_34[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_35[%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_34[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_35[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE")); } _res = NULL; @@ -33731,9 +36197,9 @@ _tmp_34_rule(Parser *p) return _res; } -// _tmp_35: ',' expression +// _tmp_36: ',' expression static void * -_tmp_35_rule(Parser *p) +_tmp_36_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33750,7 +36216,7 @@ _tmp_35_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_35[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _tmp_36[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty z; if ( @@ -33759,7 +36225,7 @@ _tmp_35_rule(Parser *p) (z = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_35[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c+ _tmp_36[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -33769,7 +36235,7 @@ _tmp_35_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_35[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_36[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } _res = NULL; @@ -33778,9 +36244,9 @@ _tmp_35_rule(Parser *p) return _res; } -// _loop0_37: ',' NAME +// _loop0_38: ',' NAME static asdl_seq * -_loop0_37_rule(Parser *p) +_loop0_38_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33806,7 +36272,7 @@ _loop0_37_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_37[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c> _loop0_38[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' NAME")); Token * _literal; expr_ty elem; while ( @@ -33838,8 +36304,1448 @@ _loop0_37_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_37[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); + D(fprintf(stderr, "%*c%s _loop0_38[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' NAME")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_37: NAME _loop0_38 +static asdl_seq * +_gather_37_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // NAME _loop0_38 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_37[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_38")); + expr_ty elem; + asdl_seq * seq; + if ( + (elem = _PyPegen_name_token(p)) // NAME + && + (seq = _loop0_38_rule(p)) // _loop0_38 + ) + { + D(fprintf(stderr, "%*c+ _gather_37[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_38")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_37[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_38")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_39: ('.' | '...') +static asdl_seq * +_loop0_39_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; + { // ('.' | '...') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_39[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); + void *_tmp_342_var; + while ( + (_tmp_342_var = _tmp_342_rule(p)) // '.' | '...' + ) + { + _res = _tmp_342_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_39[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('.' | '...')")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + 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_40: ('.' | '...') +static asdl_seq * +_loop1_40_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; + { // ('.' | '...') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_40[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); + void *_tmp_343_var; + while ( + (_tmp_343_var = _tmp_343_rule(p)) // '.' | '...' + ) + { + _res = _tmp_343_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_40[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('.' | '...')")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop0_42: ',' import_from_as_name +static asdl_seq * +_loop0_42_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; + { // ',' import_from_as_name + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_42[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); + Token * _literal; + alias_ty elem; + while ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = import_from_as_name_rule(p)) // import_from_as_name + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_42[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_41: import_from_as_name _loop0_42 +static asdl_seq * +_gather_41_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // import_from_as_name _loop0_42 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_41[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_42")); + alias_ty elem; + asdl_seq * seq; + if ( + (elem = import_from_as_name_rule(p)) // import_from_as_name + && + (seq = _loop0_42_rule(p)) // _loop0_42 + ) + { + D(fprintf(stderr, "%*c+ _gather_41[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_42")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_41[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_42")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_43: 'as' NAME +static void * +_tmp_43_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; + { // 'as' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_43[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty z; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (z = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ _tmp_43[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_43[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_45: ',' dotted_as_name +static asdl_seq * +_loop0_45_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; + { // ',' dotted_as_name + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_45[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); + Token * _literal; + alias_ty elem; + while ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = dotted_as_name_rule(p)) // dotted_as_name + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_45[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_44: dotted_as_name _loop0_45 +static asdl_seq * +_gather_44_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // dotted_as_name _loop0_45 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_44[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_45")); + alias_ty elem; + asdl_seq * seq; + if ( + (elem = dotted_as_name_rule(p)) // dotted_as_name + && + (seq = _loop0_45_rule(p)) // _loop0_45 + ) + { + D(fprintf(stderr, "%*c+ _gather_44[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_45")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_44[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_45")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_46: 'as' NAME +static void * +_tmp_46_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; + { // 'as' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_46[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty z; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (z = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ _tmp_46[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_46[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop1_47: ('@' named_expression NEWLINE) +static asdl_seq * +_loop1_47_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; + { // ('@' named_expression NEWLINE) + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_47[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('@' named_expression NEWLINE)")); + void *_tmp_344_var; + while ( + (_tmp_344_var = _tmp_344_rule(p)) // '@' named_expression NEWLINE + ) + { + _res = _tmp_344_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_47[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('@' named_expression NEWLINE)")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _tmp_48: '(' arguments? ')' +static void * +_tmp_48_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '(' arguments? ')' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_48[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + Token * _literal; + Token * _literal_1; + void *z; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (z = arguments_rule(p), !p->error_indicator) // arguments? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + D(fprintf(stderr, "%*c+ _tmp_48[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_48[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_49: '(' arguments? ')' +static void * +_tmp_49_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '(' arguments? ')' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_49[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + Token * _literal; + Token * _literal_1; + void *z; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (z = arguments_rule(p), !p->error_indicator) // arguments? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + D(fprintf(stderr, "%*c+ _tmp_49[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_49[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_50: '->' expression +static void * +_tmp_50_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '->' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_50[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + Token * _literal; + expr_ty z; + if ( + (_literal = _PyPegen_expect_token(p, 51)) // token='->' + && + (z = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_50[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_50[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_51: '->' expression +static void * +_tmp_51_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '->' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_51[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + Token * _literal; + expr_ty z; + if ( + (_literal = _PyPegen_expect_token(p, 51)) // token='->' + && + (z = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_51[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_51[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_52: '->' expression +static void * +_tmp_52_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '->' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_52[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + Token * _literal; + expr_ty z; + if ( + (_literal = _PyPegen_expect_token(p, 51)) // token='->' + && + (z = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_52[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_52[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_53: '->' expression +static void * +_tmp_53_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '->' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_53[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + Token * _literal; + expr_ty z; + if ( + (_literal = _PyPegen_expect_token(p, 51)) // token='->' + && + (z = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_53[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_53[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_54: param_no_default +static asdl_seq * +_loop0_54_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; + { // param_no_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_54[%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 + ) + { + _res = 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_54[%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); + 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_55: param_with_default +static asdl_seq * +_loop0_55_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; + { // param_with_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_55[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + NameDefaultPair* param_with_default_var; + while ( + (param_with_default_var = param_with_default_rule(p)) // param_with_default + ) + { + _res = param_with_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_55[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + 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_56: param_with_default +static asdl_seq * +_loop0_56_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; + { // param_with_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_56[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + NameDefaultPair* param_with_default_var; + while ( + (param_with_default_var = param_with_default_rule(p)) // param_with_default + ) + { + _res = param_with_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_56[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + 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_57: param_no_default +static asdl_seq * +_loop1_57_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; + { // param_no_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_57[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; + while ( + (param_no_default_var = param_no_default_rule(p)) // param_no_default + ) + { + _res = param_no_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop1_57[%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) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop0_58: param_with_default +static asdl_seq * +_loop0_58_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; + { // param_with_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_58[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + NameDefaultPair* param_with_default_var; + while ( + (param_with_default_var = param_with_default_rule(p)) // param_with_default + ) + { + _res = param_with_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_58[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + 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_59: param_with_default +static asdl_seq * +_loop1_59_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; + { // param_with_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_59[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + NameDefaultPair* param_with_default_var; + while ( + (param_with_default_var = param_with_default_rule(p)) // param_with_default + ) + { + _res = param_with_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop1_59[%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) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop1_60: param_no_default +static asdl_seq * +_loop1_60_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; + { // param_no_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_60[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; + while ( + (param_no_default_var = param_no_default_rule(p)) // param_no_default + ) + { + _res = param_no_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop1_60[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _loop1_61: param_no_default +static asdl_seq * +_loop1_61_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; + { // param_no_default + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_61[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; + while ( + (param_no_default_var = param_no_default_rule(p)) // param_no_default + ) + { + _res = param_no_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop1_61[%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) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -33855,51 +37761,9 @@ _loop0_37_rule(Parser *p) return _seq; } -// _gather_36: NAME _loop0_37 -static asdl_seq * -_gather_36_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // NAME _loop0_37 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_36[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_37")); - expr_ty elem; - asdl_seq * seq; - if ( - (elem = _PyPegen_name_token(p)) // NAME - && - (seq = _loop0_37_rule(p)) // _loop0_37 - ) - { - D(fprintf(stderr, "%*c+ _gather_36[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME _loop0_37")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_36[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME _loop0_37")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop0_38: ('.' | '...') +// _loop0_62: param_no_default static asdl_seq * -_loop0_38_rule(Parser *p) +_loop0_62_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33920,18 +37784,18 @@ _loop0_38_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ('.' | '...') + { // param_no_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_38[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); - void *_tmp_313_var; + D(fprintf(stderr, "%*c> _loop0_62[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; while ( - (_tmp_313_var = _tmp_313_rule(p)) // '.' | '...' + (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - _res = _tmp_313_var; + _res = param_no_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33948,8 +37812,8 @@ _loop0_38_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_38[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('.' | '...')")); + D(fprintf(stderr, "%*c%s _loop0_62[%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); if (!_seq) { @@ -33965,9 +37829,9 @@ _loop0_38_rule(Parser *p) return _seq; } -// _loop1_39: ('.' | '...') +// _loop1_63: param_with_default static asdl_seq * -_loop1_39_rule(Parser *p) +_loop1_63_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -33988,18 +37852,18 @@ _loop1_39_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ('.' | '...') + { // param_with_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_39[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('.' | '...')")); - void *_tmp_314_var; + D(fprintf(stderr, "%*c> _loop1_63[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + NameDefaultPair* param_with_default_var; while ( - (_tmp_314_var = _tmp_314_rule(p)) // '.' | '...' + (param_with_default_var = param_with_default_rule(p)) // param_with_default ) { - _res = _tmp_314_var; + _res = param_with_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34016,8 +37880,8 @@ _loop1_39_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_39[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('.' | '...')")); + D(fprintf(stderr, "%*c%s _loop1_63[%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) { PyMem_Free(_children); @@ -34038,9 +37902,9 @@ _loop1_39_rule(Parser *p) return _seq; } -// _loop0_41: ',' import_from_as_name +// _loop0_64: param_no_default static asdl_seq * -_loop0_41_rule(Parser *p) +_loop0_64_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34061,27 +37925,18 @@ _loop0_41_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' import_from_as_name + { // param_no_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_41[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); - Token * _literal; - alias_ty elem; + D(fprintf(stderr, "%*c> _loop0_64[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + arg_ty param_no_default_var; while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = import_from_as_name_rule(p)) // import_from_as_name + (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } + _res = param_no_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34098,8 +37953,8 @@ _loop0_41_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_41[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' import_from_as_name")); + D(fprintf(stderr, "%*c%s _loop0_64[%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); if (!_seq) { @@ -34115,9 +37970,9 @@ _loop0_41_rule(Parser *p) return _seq; } -// _gather_40: import_from_as_name _loop0_41 +// _loop1_65: param_with_default static asdl_seq * -_gather_40_rule(Parser *p) +_loop1_65_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34127,86 +37982,70 @@ _gather_40_rule(Parser *p) p->level--; return NULL; } - asdl_seq * _res = NULL; + void *_res = NULL; int _mark = p->mark; - { // import_from_as_name _loop0_41 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_40[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_41")); - alias_ty elem; - asdl_seq * seq; - if ( - (elem = import_from_as_name_rule(p)) // import_from_as_name - && - (seq = _loop0_41_rule(p)) // _loop0_41 - ) - { - D(fprintf(stderr, "%*c+ _gather_40[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_41")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_40[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "import_from_as_name _loop0_41")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_42: 'as' NAME -static void * -_tmp_42_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { p->error_indicator = 1; PyErr_NoMemory(); - } - if (p->error_indicator) { p->level--; return NULL; } - void * _res = NULL; - int _mark = p->mark; - { // 'as' NAME + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // param_with_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_42[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - Token * _keyword; - expr_ty z; - if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' - && - (z = _PyPegen_name_token(p)) // NAME + D(fprintf(stderr, "%*c> _loop1_65[%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 ) { - D(fprintf(stderr, "%*c+ _tmp_42[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; + _res = param_with_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; } - goto done; + _children[_n++] = _res; + _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_42[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c%s _loop1_65[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); } - _res = NULL; - done: + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); p->level--; - return _res; + return _seq; } -// _loop0_44: ',' dotted_as_name +// _loop0_66: param_maybe_default static asdl_seq * -_loop0_44_rule(Parser *p) +_loop0_66_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34227,27 +38066,18 @@ _loop0_44_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' dotted_as_name + { // param_maybe_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_44[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); - Token * _literal; - alias_ty elem; + D(fprintf(stderr, "%*c> _loop0_66[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + NameDefaultPair* param_maybe_default_var; while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = dotted_as_name_rule(p)) // dotted_as_name + (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default ) { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } + _res = param_maybe_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34264,8 +38094,8 @@ _loop0_44_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_44[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' dotted_as_name")); + D(fprintf(stderr, "%*c%s _loop0_66[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -34281,9 +38111,9 @@ _loop0_44_rule(Parser *p) return _seq; } -// _gather_43: dotted_as_name _loop0_44 +// _loop0_67: param_maybe_default static asdl_seq * -_gather_43_rule(Parser *p) +_loop0_67_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34293,86 +38123,65 @@ _gather_43_rule(Parser *p) p->level--; return NULL; } - asdl_seq * _res = NULL; + void *_res = NULL; int _mark = p->mark; - { // dotted_as_name _loop0_44 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_43[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_44")); - alias_ty elem; - asdl_seq * seq; - if ( - (elem = dotted_as_name_rule(p)) // dotted_as_name - && - (seq = _loop0_44_rule(p)) // _loop0_44 - ) - { - D(fprintf(stderr, "%*c+ _gather_43[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_44")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_43[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_as_name _loop0_44")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_45: 'as' NAME -static void * -_tmp_45_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { p->error_indicator = 1; PyErr_NoMemory(); - } - if (p->error_indicator) { p->level--; return NULL; } - void * _res = NULL; - int _mark = p->mark; - { // 'as' NAME + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // param_maybe_default if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_45[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - Token * _keyword; - expr_ty z; - if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' - && - (z = _PyPegen_name_token(p)) // NAME + D(fprintf(stderr, "%*c> _loop0_67[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + NameDefaultPair* param_maybe_default_var; + while ( + (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default ) { - D(fprintf(stderr, "%*c+ _tmp_45[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; + _res = 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; } - goto done; + _children[_n++] = _res; + _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_45[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c%s _loop0_67[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } - _res = NULL; - done: + 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 _res; + return _seq; } -// _loop1_46: ('@' named_expression NEWLINE) +// _loop1_68: param_maybe_default static asdl_seq * -_loop1_46_rule(Parser *p) +_loop1_68_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34393,18 +38202,18 @@ _loop1_46_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ('@' named_expression NEWLINE) + { // param_maybe_default if (p->error_indicator) { p->level--; 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_315_var; + D(fprintf(stderr, "%*c> _loop1_68[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + NameDefaultPair* param_maybe_default_var; while ( - (_tmp_315_var = _tmp_315_rule(p)) // '@' named_expression NEWLINE + (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default ) { - _res = _tmp_315_var; + _res = param_maybe_default_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34421,8 +38230,8 @@ _loop1_46_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_46[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('@' named_expression NEWLINE)")); + D(fprintf(stderr, "%*c%s _loop1_68[%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) { PyMem_Free(_children); @@ -34443,59 +38252,9 @@ _loop1_46_rule(Parser *p) return _seq; } -// _tmp_47: '(' arguments? ')' -static void * -_tmp_47_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void * _res = NULL; - int _mark = p->mark; - { // '(' arguments? ')' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_47[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); - Token * _literal; - Token * _literal_1; - void *z; - if ( - (_literal = _PyPegen_expect_token(p, 7)) // token='(' - && - (z = arguments_rule(p), !p->error_indicator) // arguments? - && - (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' - ) - { - D(fprintf(stderr, "%*c+ _tmp_47[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_47[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_48: '(' arguments? ')' -static void * -_tmp_48_rule(Parser *p) +// _loop0_70: ',' with_item +static asdl_seq * +_loop0_70_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34505,188 +38264,74 @@ _tmp_48_rule(Parser *p) p->level--; return NULL; } - void * _res = NULL; + void *_res = NULL; int _mark = p->mark; - { // '(' arguments? ')' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_48[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); - Token * _literal; - Token * _literal_1; - void *z; - if ( - (_literal = _PyPegen_expect_token(p, 7)) // token='(' - && - (z = arguments_rule(p), !p->error_indicator) // arguments? - && - (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' - ) - { - D(fprintf(stderr, "%*c+ _tmp_48[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_48[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_49: '->' expression -static void * -_tmp_49_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { p->error_indicator = 1; PyErr_NoMemory(); - } - if (p->error_indicator) { p->level--; return NULL; } - void * _res = NULL; - int _mark = p->mark; - { // '->' expression + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_49[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c> _loop0_70[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); Token * _literal; - expr_ty z; - if ( - (_literal = _PyPegen_expect_token(p, 51)) // token='->' + withitem_ty elem; + while ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (z = expression_rule(p)) // expression + (elem = with_item_rule(p)) // with_item ) { - D(fprintf(stderr, "%*c+ _tmp_49[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - _res = z; + _res = elem; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; + PyMem_Free(_children); p->level--; return NULL; } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_49[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_50: '->' expression -static void * -_tmp_50_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void * _res = NULL; - int _mark = p->mark; - { // '->' expression - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_50[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - Token * _literal; - expr_ty z; - if ( - (_literal = _PyPegen_expect_token(p, 51)) // token='->' - && - (z = expression_rule(p)) // expression - ) - { - D(fprintf(stderr, "%*c+ _tmp_50[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; } - goto done; + _children[_n++] = _res; + _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_50[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c%s _loop0_70[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_51: '->' expression -static void * -_tmp_51_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); p->error_indicator = 1; PyErr_NoMemory(); - } - if (p->error_indicator) { p->level--; return NULL; } - void * _res = NULL; - int _mark = p->mark; - { // '->' expression - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_51[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - Token * _literal; - expr_ty z; - if ( - (_literal = _PyPegen_expect_token(p, 51)) // token='->' - && - (z = expression_rule(p)) // expression - ) - { - D(fprintf(stderr, "%*c+ _tmp_51[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_51[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); - } - _res = NULL; - done: + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); p->level--; - return _res; + return _seq; } -// _tmp_52: '->' expression -static void * -_tmp_52_rule(Parser *p) +// _gather_69: with_item _loop0_70 +static asdl_seq * +_gather_69_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34696,34 +38341,29 @@ _tmp_52_rule(Parser *p) p->level--; return NULL; } - void * _res = NULL; + asdl_seq * _res = NULL; int _mark = p->mark; - { // '->' expression + { // with_item _loop0_70 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_52[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - Token * _literal; - expr_ty z; + D(fprintf(stderr, "%*c> _gather_69[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_70")); + withitem_ty elem; + asdl_seq * seq; if ( - (_literal = _PyPegen_expect_token(p, 51)) // token='->' + (elem = with_item_rule(p)) // with_item && - (z = expression_rule(p)) // expression + (seq = _loop0_70_rule(p)) // _loop0_70 ) { - D(fprintf(stderr, "%*c+ _tmp_52[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } + D(fprintf(stderr, "%*c+ _gather_69[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_70")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_52[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c%s _gather_69[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_70")); } _res = NULL; done: @@ -34731,9 +38371,9 @@ _tmp_52_rule(Parser *p) return _res; } -// _loop0_53: param_no_default +// _loop0_72: ',' with_item static asdl_seq * -_loop0_53_rule(Parser *p) +_loop0_72_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34754,18 +38394,27 @@ _loop0_53_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_no_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_53[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); - arg_ty param_no_default_var; + D(fprintf(stderr, "%*c> _loop0_72[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_no_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34782,8 +38431,8 @@ _loop0_53_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_53[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c%s _loop0_72[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -34799,9 +38448,9 @@ _loop0_53_rule(Parser *p) return _seq; } -// _loop0_54: param_with_default +// _gather_71: with_item _loop0_72 static asdl_seq * -_loop0_54_rule(Parser *p) +_gather_71_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34811,65 +38460,39 @@ _loop0_54_rule(Parser *p) p->level--; return NULL; } - void *_res = NULL; + asdl_seq * _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; - { // param_with_default + { // with_item _loop0_72 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_54[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); - NameDefaultPair* param_with_default_var; - while ( - (param_with_default_var = param_with_default_rule(p)) // param_with_default + D(fprintf(stderr, "%*c> _gather_71[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_72")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_72_rule(p)) // _loop0_72 ) { - _res = param_with_default_var; - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; + D(fprintf(stderr, "%*c+ _gather_71[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_72")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_54[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _gather_71[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_72")); } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); + _res = NULL; + done: p->level--; - return _seq; + return _res; } -// _loop0_55: param_with_default +// _loop0_74: ',' with_item static asdl_seq * -_loop0_55_rule(Parser *p) +_loop0_74_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34890,18 +38513,27 @@ _loop0_55_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_with_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_55[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); - NameDefaultPair* param_with_default_var; + D(fprintf(stderr, "%*c> _loop0_74[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_with_default_var = param_with_default_rule(p)) // param_with_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_with_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34918,8 +38550,8 @@ _loop0_55_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_55[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c%s _loop0_74[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -34935,9 +38567,51 @@ _loop0_55_rule(Parser *p) return _seq; } -// _loop1_56: param_no_default +// _gather_73: with_item _loop0_74 +static asdl_seq * +_gather_73_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // with_item _loop0_74 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_73[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_74")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_74_rule(p)) // _loop0_74 + ) + { + D(fprintf(stderr, "%*c+ _gather_73[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_74")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_73[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_74")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_76: ',' with_item static asdl_seq * -_loop1_56_rule(Parser *p) +_loop0_76_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -34958,18 +38632,27 @@ _loop1_56_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_no_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_56[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); - arg_ty param_no_default_var; + D(fprintf(stderr, "%*c> _loop0_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_no_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34986,13 +38669,8 @@ _loop1_56_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_56[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_76[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35008,9 +38686,51 @@ _loop1_56_rule(Parser *p) return _seq; } -// _loop0_57: param_with_default +// _gather_75: with_item _loop0_76 +static asdl_seq * +_gather_75_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // with_item _loop0_76 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_75[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_76")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_76_rule(p)) // _loop0_76 + ) + { + D(fprintf(stderr, "%*c+ _gather_75[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_76")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_75[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_76")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_78: ',' with_item static asdl_seq * -_loop0_57_rule(Parser *p) +_loop0_78_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35031,18 +38751,27 @@ _loop0_57_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_with_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_57[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); - NameDefaultPair* param_with_default_var; + D(fprintf(stderr, "%*c> _loop0_78[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_with_default_var = param_with_default_rule(p)) // param_with_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_with_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35059,8 +38788,8 @@ _loop0_57_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_57[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c%s _loop0_78[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35076,9 +38805,51 @@ _loop0_57_rule(Parser *p) return _seq; } -// _loop1_58: param_with_default +// _gather_77: with_item _loop0_78 +static asdl_seq * +_gather_77_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // with_item _loop0_78 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_77[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_78")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_78_rule(p)) // _loop0_78 + ) + { + D(fprintf(stderr, "%*c+ _gather_77[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_78")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_77[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_78")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_80: ',' with_item static asdl_seq * -_loop1_58_rule(Parser *p) +_loop0_80_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35099,18 +38870,27 @@ _loop1_58_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_with_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_58[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); - NameDefaultPair* param_with_default_var; + D(fprintf(stderr, "%*c> _loop0_80[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_with_default_var = param_with_default_rule(p)) // param_with_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_with_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35127,13 +38907,8 @@ _loop1_58_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_58[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_80[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35149,9 +38924,51 @@ _loop1_58_rule(Parser *p) return _seq; } -// _loop1_59: param_no_default +// _gather_79: with_item _loop0_80 static asdl_seq * -_loop1_59_rule(Parser *p) +_gather_79_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // with_item _loop0_80 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_79[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_80")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_80_rule(p)) // _loop0_80 + ) + { + D(fprintf(stderr, "%*c+ _gather_79[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_80")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_79[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_80")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_82: ',' with_item +static asdl_seq * +_loop0_82_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35172,18 +38989,27 @@ _loop1_59_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_no_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_59[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); - arg_ty param_no_default_var; + D(fprintf(stderr, "%*c> _loop0_82[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_no_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35200,13 +39026,8 @@ _loop1_59_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_59[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_82[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35222,9 +39043,51 @@ _loop1_59_rule(Parser *p) return _seq; } -// _loop1_60: param_no_default +// _gather_81: with_item _loop0_82 static asdl_seq * -_loop1_60_rule(Parser *p) +_gather_81_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // with_item _loop0_82 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_81[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_82")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_82_rule(p)) // _loop0_82 + ) + { + D(fprintf(stderr, "%*c+ _gather_81[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_82")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_81[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_82")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_84: ',' with_item +static asdl_seq * +_loop0_84_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35245,18 +39108,27 @@ _loop1_60_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_no_default + { // ',' with_item if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_60[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); - arg_ty param_no_default_var; + D(fprintf(stderr, "%*c> _loop0_84[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + Token * _literal; + withitem_ty elem; while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = with_item_rule(p)) // with_item ) { - _res = param_no_default_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35273,13 +39145,8 @@ _loop1_60_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_60[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_84[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35295,9 +39162,9 @@ _loop1_60_rule(Parser *p) return _seq; } -// _loop0_61: param_no_default +// _gather_83: with_item _loop0_84 static asdl_seq * -_loop0_61_rule(Parser *p) +_gather_83_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35307,65 +39174,116 @@ _loop0_61_rule(Parser *p) p->level--; return NULL; } - void *_res = NULL; + asdl_seq * _res = NULL; int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { + { // with_item _loop0_84 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_83[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_84")); + withitem_ty elem; + asdl_seq * seq; + if ( + (elem = with_item_rule(p)) // with_item + && + (seq = _loop0_84_rule(p)) // _loop0_84 + ) + { + D(fprintf(stderr, "%*c+ _gather_83[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_84")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_83[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_84")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_85: ',' | ')' | ':' +static void * +_tmp_85_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { p->error_indicator = 1; PyErr_NoMemory(); + } + if (p->error_indicator) { p->level--; return NULL; } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // param_no_default + void * _res = NULL; + int _mark = p->mark; + { // ',' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_61[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); - arg_ty param_no_default_var; - while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + D(fprintf(stderr, "%*c> _tmp_85[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - _res = param_no_default_var; - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; + D(fprintf(stderr, "%*c+ _tmp_85[%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 _loop0_61[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c%s _tmp_85[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; + { // ')' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_85[%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_85[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_85[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); + { // ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_85[%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_85[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_85[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); + } + _res = NULL; + done: p->level--; - return _seq; + return _res; } -// _loop1_62: param_with_default +// _loop1_86: except_block static asdl_seq * -_loop1_62_rule(Parser *p) +_loop1_86_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35386,18 +39304,18 @@ _loop1_62_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_with_default + { // except_block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_62[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); - NameDefaultPair* param_with_default_var; + D(fprintf(stderr, "%*c> _loop1_86[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); + excepthandler_ty except_block_var; while ( - (param_with_default_var = param_with_default_rule(p)) // param_with_default + (except_block_var = except_block_rule(p)) // except_block ) { - _res = param_with_default_var; + _res = except_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35414,8 +39332,8 @@ _loop1_62_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_62[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c%s _loop1_86[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_block")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -35436,9 +39354,9 @@ _loop1_62_rule(Parser *p) return _seq; } -// _loop0_63: param_no_default +// _loop1_87: except_star_block static asdl_seq * -_loop0_63_rule(Parser *p) +_loop1_87_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35459,18 +39377,18 @@ _loop0_63_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_no_default + { // except_star_block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_63[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); - arg_ty param_no_default_var; + D(fprintf(stderr, "%*c> _loop1_87[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); + excepthandler_ty except_star_block_var; while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + (except_star_block_var = except_star_block_rule(p)) // except_star_block ) { - _res = param_no_default_var; + _res = except_star_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35487,8 +39405,13 @@ _loop0_63_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_63[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c%s _loop1_87[%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) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35504,9 +39427,9 @@ _loop0_63_rule(Parser *p) return _seq; } -// _loop1_64: param_with_default +// _loop1_88: except_block_nonewline static asdl_seq * -_loop1_64_rule(Parser *p) +_loop1_88_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35527,18 +39450,18 @@ _loop1_64_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_with_default + { // except_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_64[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); - NameDefaultPair* param_with_default_var; + D(fprintf(stderr, "%*c> _loop1_88[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block_nonewline")); + excepthandler_ty except_block_nonewline_var; while ( - (param_with_default_var = param_with_default_rule(p)) // param_with_default + (except_block_nonewline_var = except_block_nonewline_rule(p)) // except_block_nonewline ) { - _res = param_with_default_var; + _res = except_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35555,8 +39478,8 @@ _loop1_64_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_64[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c%s _loop1_88[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_block_nonewline")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -35577,9 +39500,9 @@ _loop1_64_rule(Parser *p) return _seq; } -// _loop0_65: param_maybe_default +// _loop1_89: except_star_block_nonewline static asdl_seq * -_loop0_65_rule(Parser *p) +_loop1_89_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35600,18 +39523,18 @@ _loop0_65_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // param_maybe_default + { // except_star_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_65[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); - NameDefaultPair* param_maybe_default_var; + D(fprintf(stderr, "%*c> _loop1_89[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block_nonewline")); + excepthandler_ty except_star_block_nonewline_var; while ( - (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default + (except_star_block_nonewline_var = except_star_block_nonewline_rule(p)) // except_star_block_nonewline ) { - _res = param_maybe_default_var; + _res = except_star_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35628,8 +39551,13 @@ _loop0_65_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_65[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c%s _loop1_89[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_star_block_nonewline")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35645,9 +39573,9 @@ _loop0_65_rule(Parser *p) return _seq; } -// _loop0_66: param_maybe_default -static asdl_seq * -_loop0_66_rule(Parser *p) +// _tmp_90: 'as' NAME +static void * +_tmp_90_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35657,65 +39585,44 @@ _loop0_66_rule(Parser *p) p->level--; return NULL; } - void *_res = NULL; + void * _res = NULL; int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // param_maybe_default + { // 'as' NAME if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_66[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); - NameDefaultPair* param_maybe_default_var; - while ( - (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default + D(fprintf(stderr, "%*c> _tmp_90[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty z; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (z = _PyPegen_name_token(p)) // NAME ) { - _res = 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; + D(fprintf(stderr, "%*c+ _tmp_90[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; } - _children[_n++] = _res; - _mark = p->mark; + goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_66[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _tmp_90[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); + _res = NULL; + done: p->level--; - return _seq; + return _res; } -// _loop1_67: param_maybe_default -static asdl_seq * -_loop1_67_rule(Parser *p) +// _tmp_91: 'as' NAME +static void * +_tmp_91_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35725,70 +39632,44 @@ _loop1_67_rule(Parser *p) p->level--; return NULL; } - void *_res = NULL; + void * _res = NULL; int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // param_maybe_default + { // 'as' NAME if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_67[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); - NameDefaultPair* param_maybe_default_var; - while ( - (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default + D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty z; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (z = _PyPegen_name_token(p)) // NAME ) { - _res = 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; + D(fprintf(stderr, "%*c+ _tmp_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; } - _children[_n++] = _res; - _mark = p->mark; + goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_67[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _tmp_91[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); + _res = NULL; + done: p->level--; - return _seq; + return _res; } -// _loop0_69: ',' with_item -static asdl_seq * -_loop0_69_rule(Parser *p) +// _tmp_92: 'as' NAME +static void * +_tmp_92_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35798,74 +39679,44 @@ _loop0_69_rule(Parser *p) p->level--; return NULL; } - void *_res = NULL; + void * _res = NULL; int _mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - Py_ssize_t _children_capacity = 1; - Py_ssize_t _n = 0; - { // ',' with_item + { // 'as' NAME if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_69[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); - Token * _literal; - withitem_ty elem; - while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' + D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty z; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && - (elem = with_item_rule(p)) // with_item + (z = _PyPegen_name_token(p)) // NAME ) { - _res = elem; + D(fprintf(stderr, "%*c+ _tmp_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; - PyMem_Free(_children); p->level--; return NULL; } - if (_n == _children_capacity) { - _children_capacity *= 2; - void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_new_children) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - _children = _new_children; - } - _children[_n++] = _res; - _mark = p->mark; + goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_69[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _tmp_92[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); + _res = NULL; + done: p->level--; - return _seq; + return _res; } -// _gather_68: with_item _loop0_69 -static asdl_seq * -_gather_68_rule(Parser *p) +// _tmp_93: 'as' NAME +static void * +_tmp_93_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35875,29 +39726,34 @@ _gather_68_rule(Parser *p) p->level--; return NULL; } - asdl_seq * _res = NULL; + void * _res = NULL; int _mark = p->mark; - { // with_item _loop0_69 + { // 'as' NAME if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_68[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_69")); - withitem_ty elem; - asdl_seq * seq; + D(fprintf(stderr, "%*c> _tmp_93[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty z; if ( - (elem = with_item_rule(p)) // with_item + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && - (seq = _loop0_69_rule(p)) // _loop0_69 + (z = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _gather_68[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_69")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); + D(fprintf(stderr, "%*c+ _tmp_93[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + _res = z; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_68[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_69")); + D(fprintf(stderr, "%*c%s _tmp_93[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; done: @@ -35905,9 +39761,9 @@ _gather_68_rule(Parser *p) return _res; } -// _loop0_71: ',' with_item +// _loop1_94: switchcase_block static asdl_seq * -_loop0_71_rule(Parser *p) +_loop1_94_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -35928,27 +39784,18 @@ _loop0_71_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' with_item + { // switchcase_block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_71[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); - Token * _literal; - withitem_ty elem; + D(fprintf(stderr, "%*c> _loop1_94[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); + switch_case_ty switchcase_block_var; while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = with_item_rule(p)) // with_item + (switchcase_block_var = switchcase_block_rule(p)) // switchcase_block ) { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } + _res = switchcase_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35965,8 +39812,13 @@ _loop0_71_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_71[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c%s _loop1_94[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -35982,51 +39834,9 @@ _loop0_71_rule(Parser *p) return _seq; } -// _gather_70: with_item _loop0_71 -static asdl_seq * -_gather_70_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // with_item _loop0_71 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_70[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_71")); - withitem_ty elem; - asdl_seq * seq; - if ( - (elem = with_item_rule(p)) // with_item - && - (seq = _loop0_71_rule(p)) // _loop0_71 - ) - { - D(fprintf(stderr, "%*c+ _gather_70[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_71")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_70[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_71")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop0_73: ',' with_item +// _loop1_95: switchcase_block static asdl_seq * -_loop0_73_rule(Parser *p) +_loop1_95_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36047,27 +39857,18 @@ _loop0_73_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' with_item + { // switchcase_block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_73[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); - Token * _literal; - withitem_ty elem; + D(fprintf(stderr, "%*c> _loop1_95[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); + switch_case_ty switchcase_block_var; while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = with_item_rule(p)) // with_item + (switchcase_block_var = switchcase_block_rule(p)) // switchcase_block ) { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } + _res = switchcase_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36084,8 +39885,13 @@ _loop0_73_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_73[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c%s _loop1_95[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -36101,51 +39907,9 @@ _loop0_73_rule(Parser *p) return _seq; } -// _gather_72: with_item _loop0_73 -static asdl_seq * -_gather_72_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // with_item _loop0_73 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_72[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_73")); - withitem_ty elem; - asdl_seq * seq; - if ( - (elem = with_item_rule(p)) // with_item - && - (seq = _loop0_73_rule(p)) // _loop0_73 - ) - { - D(fprintf(stderr, "%*c+ _gather_72[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_73")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_72[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_73")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop0_75: ',' with_item +// _loop0_97: ',' (bitwiseor_pattern | 'None') static asdl_seq * -_loop0_75_rule(Parser *p) +_loop0_97_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36166,18 +39930,18 @@ _loop0_75_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' with_item + { // ',' (bitwiseor_pattern | 'None') if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_75[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c> _loop0_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); Token * _literal; - withitem_ty elem; + void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = with_item_rule(p)) // with_item + (elem = _tmp_345_rule(p)) // bitwiseor_pattern | 'None' ) { _res = elem; @@ -36203,8 +39967,8 @@ _loop0_75_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_75[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' with_item")); + D(fprintf(stderr, "%*c%s _loop0_97[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -36220,9 +39984,9 @@ _loop0_75_rule(Parser *p) return _seq; } -// _gather_74: with_item _loop0_75 +// _gather_96: (bitwiseor_pattern | 'None') _loop0_97 static asdl_seq * -_gather_74_rule(Parser *p) +_gather_96_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36234,104 +39998,27 @@ _gather_74_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_75 + { // (bitwiseor_pattern | 'None') _loop0_97 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_74[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_75")); - withitem_ty elem; + D(fprintf(stderr, "%*c> _gather_96[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_97")); + void *elem; asdl_seq * seq; if ( - (elem = with_item_rule(p)) // with_item + (elem = _tmp_345_rule(p)) // bitwiseor_pattern | 'None' && - (seq = _loop0_75_rule(p)) // _loop0_75 + (seq = _loop0_97_rule(p)) // _loop0_97 ) { - D(fprintf(stderr, "%*c+ _gather_74[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "with_item _loop0_75")); + D(fprintf(stderr, "%*c+ _gather_96[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_97")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_74[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "with_item _loop0_75")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_76: ',' | ')' | ':' -static void * -_tmp_76_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_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - ) - { - D(fprintf(stderr, "%*c+ _tmp_76[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_76[%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_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 8)) // token=')' - ) - { - D(fprintf(stderr, "%*c+ _tmp_76[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_76[%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_76[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 11)) // token=':' - ) - { - D(fprintf(stderr, "%*c+ _tmp_76[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_76[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c%s _gather_96[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_97")); } _res = NULL; done: @@ -36339,82 +40026,9 @@ _tmp_76_rule(Parser *p) return _res; } -// _loop1_77: except_block -static asdl_seq * -_loop1_77_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; - { // except_block - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _loop1_77[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block")); - excepthandler_ty except_block_var; - while ( - (except_block_var = except_block_rule(p)) // except_block - ) - { - _res = except_block_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_77[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_block")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; - } - asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); - if (!_seq) { - PyMem_Free(_children); - p->error_indicator = 1; - PyErr_NoMemory(); - p->level--; - return NULL; - } - for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); - PyMem_Free(_children); - p->level--; - return _seq; -} - -// _loop1_78: except_star_block +// _loop1_98: switchcase_block_nonewline static asdl_seq * -_loop1_78_rule(Parser *p) +_loop1_98_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36435,18 +40049,18 @@ _loop1_78_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // except_star_block + { // switchcase_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_78[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); - excepthandler_ty except_star_block_var; + D(fprintf(stderr, "%*c> _loop1_98[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block_nonewline")); + switch_case_ty switchcase_block_nonewline_var; while ( - (except_star_block_var = except_star_block_rule(p)) // except_star_block + (switchcase_block_nonewline_var = switchcase_block_nonewline_rule(p)) // switchcase_block_nonewline ) { - _res = except_star_block_var; + _res = switchcase_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36463,8 +40077,8 @@ _loop1_78_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_78[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_star_block")); + D(fprintf(stderr, "%*c%s _loop1_98[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block_nonewline")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -36485,9 +40099,9 @@ _loop1_78_rule(Parser *p) return _seq; } -// _tmp_79: 'as' NAME -static void * -_tmp_79_rule(Parser *p) +// _loop1_99: switchcase_block_nonewline +static asdl_seq * +_loop1_99_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36497,91 +40111,70 @@ _tmp_79_rule(Parser *p) p->level--; return NULL; } - void * _res = NULL; + void *_res = NULL; int _mark = p->mark; - { // 'as' NAME - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_79[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - Token * _keyword; - expr_ty z; - if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' - && - (z = _PyPegen_name_token(p)) // NAME - ) - { - D(fprintf(stderr, "%*c+ _tmp_79[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_79[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_80: 'as' NAME -static void * -_tmp_80_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { p->error_indicator = 1; PyErr_NoMemory(); - } - if (p->error_indicator) { p->level--; return NULL; } - void * _res = NULL; - int _mark = p->mark; - { // 'as' NAME + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // switchcase_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_80[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - Token * _keyword; - expr_ty z; - if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' - && - (z = _PyPegen_name_token(p)) // NAME + D(fprintf(stderr, "%*c> _loop1_99[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block_nonewline")); + switch_case_ty switchcase_block_nonewline_var; + while ( + (switchcase_block_nonewline_var = switchcase_block_nonewline_rule(p)) // switchcase_block_nonewline ) { - D(fprintf(stderr, "%*c+ _tmp_80[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); - _res = z; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; + _res = switchcase_block_nonewline_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; } - goto done; + _children[_n++] = _res; + _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_80[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c%s _loop1_99[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block_nonewline")); } - _res = NULL; - done: + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); p->level--; - return _res; + return _seq; } -// _loop1_81: switchcase_block +// _loop0_101: ',' (bitwiseor_pattern | 'None') static asdl_seq * -_loop1_81_rule(Parser *p) +_loop0_101_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36602,18 +40195,27 @@ _loop1_81_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // switchcase_block + { // ',' (bitwiseor_pattern | 'None') if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_81[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); - switch_case_ty switchcase_block_var; + D(fprintf(stderr, "%*c> _loop0_101[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); + Token * _literal; + void *elem; while ( - (switchcase_block_var = switchcase_block_rule(p)) // switchcase_block + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = _tmp_346_rule(p)) // bitwiseor_pattern | 'None' ) { - _res = switchcase_block_var; + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36630,13 +40232,8 @@ _loop1_81_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_81[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block")); - } - if (_n == 0 || p->error_indicator) { - PyMem_Free(_children); - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _loop0_101[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -36652,9 +40249,51 @@ _loop1_81_rule(Parser *p) return _seq; } -// _loop1_82: switchcase_block +// _gather_100: (bitwiseor_pattern | 'None') _loop0_101 +static asdl_seq * +_gather_100_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // (bitwiseor_pattern | 'None') _loop0_101 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_100[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_101")); + void *elem; + asdl_seq * seq; + if ( + (elem = _tmp_346_rule(p)) // bitwiseor_pattern | 'None' + && + (seq = _loop0_101_rule(p)) // _loop0_101 + ) + { + D(fprintf(stderr, "%*c+ _gather_100[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_101")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_100[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_101")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop1_102: case_block static asdl_seq * -_loop1_82_rule(Parser *p) +_loop1_102_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36675,18 +40314,18 @@ _loop1_82_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // switchcase_block + { // case_block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_82[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "switchcase_block")); - switch_case_ty switchcase_block_var; + D(fprintf(stderr, "%*c> _loop1_102[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); + match_case_ty case_block_var; while ( - (switchcase_block_var = switchcase_block_rule(p)) // switchcase_block + (case_block_var = case_block_rule(p)) // case_block ) { - _res = switchcase_block_var; + _res = case_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36703,8 +40342,8 @@ _loop1_82_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_82[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "switchcase_block")); + D(fprintf(stderr, "%*c%s _loop1_102[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -36725,9 +40364,9 @@ _loop1_82_rule(Parser *p) return _seq; } -// _loop0_84: ',' (bitwiseor_pattern | 'None') +// _loop1_103: case_block static asdl_seq * -_loop0_84_rule(Parser *p) +_loop1_103_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36748,27 +40387,18 @@ _loop0_84_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' (bitwiseor_pattern | 'None') + { // case_block if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_84[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); - Token * _literal; - void *elem; + D(fprintf(stderr, "%*c> _loop1_103[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); + match_case_ty case_block_var; while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = _tmp_316_rule(p)) // bitwiseor_pattern | 'None' + (case_block_var = case_block_rule(p)) // case_block ) { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } + _res = case_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36785,8 +40415,13 @@ _loop0_84_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_84[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (bitwiseor_pattern | 'None')")); + D(fprintf(stderr, "%*c%s _loop1_103[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block")); + } + if (_n == 0 || p->error_indicator) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -36802,51 +40437,9 @@ _loop0_84_rule(Parser *p) return _seq; } -// _gather_83: (bitwiseor_pattern | 'None') _loop0_84 +// _loop1_104: case_block_nonewline static asdl_seq * -_gather_83_rule(Parser *p) -{ - if (p->level++ == MAXSTACK) { - p->error_indicator = 1; - PyErr_NoMemory(); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - asdl_seq * _res = NULL; - int _mark = p->mark; - { // (bitwiseor_pattern | 'None') _loop0_84 - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _gather_83[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_84")); - void *elem; - asdl_seq * seq; - if ( - (elem = _tmp_316_rule(p)) // bitwiseor_pattern | 'None' - && - (seq = _loop0_84_rule(p)) // _loop0_84 - ) - { - D(fprintf(stderr, "%*c+ _gather_83[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_84")); - _res = _PyPegen_seq_insert_in_front(p, elem, seq); - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_83[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(bitwiseor_pattern | 'None') _loop0_84")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _loop1_85: case_block -static asdl_seq * -_loop1_85_rule(Parser *p) +_loop1_104_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36867,18 +40460,18 @@ _loop1_85_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // case_block + { // case_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_85[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); - match_case_ty case_block_var; + D(fprintf(stderr, "%*c> _loop1_104[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block_nonewline")); + match_case_ty case_block_nonewline_var; while ( - (case_block_var = case_block_rule(p)) // case_block + (case_block_nonewline_var = case_block_nonewline_rule(p)) // case_block_nonewline ) { - _res = case_block_var; + _res = case_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36895,8 +40488,8 @@ _loop1_85_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_85[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block")); + D(fprintf(stderr, "%*c%s _loop1_104[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block_nonewline")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -36917,9 +40510,9 @@ _loop1_85_rule(Parser *p) return _seq; } -// _loop1_86: case_block +// _loop1_105: case_block_nonewline static asdl_seq * -_loop1_86_rule(Parser *p) +_loop1_105_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -36940,18 +40533,18 @@ _loop1_86_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // case_block + { // case_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_86[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block")); - match_case_ty case_block_var; + D(fprintf(stderr, "%*c> _loop1_105[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "case_block_nonewline")); + match_case_ty case_block_nonewline_var; while ( - (case_block_var = case_block_rule(p)) // case_block + (case_block_nonewline_var = case_block_nonewline_rule(p)) // case_block_nonewline ) { - _res = case_block_var; + _res = case_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -36968,8 +40561,8 @@ _loop1_86_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_86[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block")); + D(fprintf(stderr, "%*c%s _loop1_105[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "case_block_nonewline")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -36990,9 +40583,9 @@ _loop1_86_rule(Parser *p) return _seq; } -// _loop0_88: '|' closed_pattern +// _loop0_107: '|' closed_pattern static asdl_seq * -_loop0_88_rule(Parser *p) +_loop0_107_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37018,7 +40611,7 @@ _loop0_88_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_88[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|' closed_pattern")); + D(fprintf(stderr, "%*c> _loop0_107[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|' closed_pattern")); Token * _literal; pattern_ty elem; while ( @@ -37050,7 +40643,7 @@ _loop0_88_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_88[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_107[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|' closed_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37067,9 +40660,9 @@ _loop0_88_rule(Parser *p) return _seq; } -// _gather_87: closed_pattern _loop0_88 +// _gather_106: closed_pattern _loop0_107 static asdl_seq * -_gather_87_rule(Parser *p) +_gather_106_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37081,27 +40674,27 @@ _gather_87_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // closed_pattern _loop0_88 + { // closed_pattern _loop0_107 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_87[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_88")); + D(fprintf(stderr, "%*c> _gather_106[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_107")); pattern_ty elem; asdl_seq * seq; if ( (elem = closed_pattern_rule(p)) // closed_pattern && - (seq = _loop0_88_rule(p)) // _loop0_88 + (seq = _loop0_107_rule(p)) // _loop0_107 ) { - D(fprintf(stderr, "%*c+ _gather_87[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_88")); + D(fprintf(stderr, "%*c+ _gather_106[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_107")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_87[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_88")); + D(fprintf(stderr, "%*c%s _gather_106[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "closed_pattern _loop0_107")); } _res = NULL; done: @@ -37109,9 +40702,9 @@ _gather_87_rule(Parser *p) return _res; } -// _tmp_89: '+' | '-' +// _tmp_108: '+' | '-' static void * -_tmp_89_rule(Parser *p) +_tmp_108_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37128,18 +40721,18 @@ _tmp_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_89[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_108[%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_89[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_108[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+'")); } { // '-' @@ -37147,18 +40740,18 @@ _tmp_89_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_89[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c> _tmp_108[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_89[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_108[%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_89[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_108[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-'")); } _res = NULL; @@ -37167,9 +40760,9 @@ _tmp_89_rule(Parser *p) return _res; } -// _tmp_90: '+' | '-' +// _tmp_109: '+' | '-' static void * -_tmp_90_rule(Parser *p) +_tmp_109_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37186,18 +40779,18 @@ _tmp_90_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_90[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_90[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_109[%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_90[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'+'")); } { // '-' @@ -37205,18 +40798,18 @@ _tmp_90_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_90[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c> _tmp_109[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_90[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_109[%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_90[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_109[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'-'")); } _res = NULL; @@ -37225,9 +40818,9 @@ _tmp_90_rule(Parser *p) return _res; } -// _tmp_91: '.' | '(' | '=' +// _tmp_110: '.' | '(' | '=' static void * -_tmp_91_rule(Parser *p) +_tmp_110_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37244,18 +40837,18 @@ _tmp_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_110[%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_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_110[%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_91[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'.'")); } { // '(' @@ -37263,18 +40856,18 @@ _tmp_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c> _tmp_110[%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_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c+ _tmp_110[%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_91[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'('")); } { // '=' @@ -37282,18 +40875,18 @@ _tmp_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_91[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_110[%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_91[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_110[%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_91[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } _res = NULL; @@ -37302,9 +40895,9 @@ _tmp_91_rule(Parser *p) return _res; } -// _tmp_92: '.' | '(' | '=' +// _tmp_111: '.' | '(' | '=' static void * -_tmp_92_rule(Parser *p) +_tmp_111_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37321,18 +40914,18 @@ _tmp_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c> _tmp_111[%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_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_92[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_111[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'.'")); } { // '(' @@ -37340,18 +40933,18 @@ _tmp_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c> _tmp_111[%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_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_92[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_111[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'('")); } { // '=' @@ -37359,18 +40952,18 @@ _tmp_92_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_92[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_111[%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_92[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_111[%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_92[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_111[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } _res = NULL; @@ -37379,9 +40972,9 @@ _tmp_92_rule(Parser *p) return _res; } -// _loop0_94: ',' maybe_star_pattern +// _loop0_113: ',' maybe_star_pattern static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_113_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37407,7 +41000,7 @@ _loop0_94_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_94[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' maybe_star_pattern")); + D(fprintf(stderr, "%*c> _loop0_113[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' maybe_star_pattern")); Token * _literal; pattern_ty elem; while ( @@ -37439,7 +41032,7 @@ _loop0_94_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_94[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_113[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' maybe_star_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37456,9 +41049,9 @@ _loop0_94_rule(Parser *p) return _seq; } -// _gather_93: maybe_star_pattern _loop0_94 +// _gather_112: maybe_star_pattern _loop0_113 static asdl_seq * -_gather_93_rule(Parser *p) +_gather_112_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37470,27 +41063,27 @@ _gather_93_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // maybe_star_pattern _loop0_94 + { // maybe_star_pattern _loop0_113 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_93[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_94")); + D(fprintf(stderr, "%*c> _gather_112[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_113")); pattern_ty elem; asdl_seq * seq; if ( (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern && - (seq = _loop0_94_rule(p)) // _loop0_94 + (seq = _loop0_113_rule(p)) // _loop0_113 ) { - D(fprintf(stderr, "%*c+ _gather_93[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_94")); + D(fprintf(stderr, "%*c+ _gather_112[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_113")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_93[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_94")); + D(fprintf(stderr, "%*c%s _gather_112[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "maybe_star_pattern _loop0_113")); } _res = NULL; done: @@ -37498,9 +41091,9 @@ _gather_93_rule(Parser *p) return _res; } -// _loop0_96: ',' key_value_pattern +// _loop0_115: ',' key_value_pattern static asdl_seq * -_loop0_96_rule(Parser *p) +_loop0_115_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37526,7 +41119,7 @@ _loop0_96_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_96[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' key_value_pattern")); + D(fprintf(stderr, "%*c> _loop0_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' key_value_pattern")); Token * _literal; KeyPatternPair* elem; while ( @@ -37558,7 +41151,7 @@ _loop0_96_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_96[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_115[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' key_value_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37575,9 +41168,9 @@ _loop0_96_rule(Parser *p) return _seq; } -// _gather_95: key_value_pattern _loop0_96 +// _gather_114: key_value_pattern _loop0_115 static asdl_seq * -_gather_95_rule(Parser *p) +_gather_114_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37589,27 +41182,27 @@ _gather_95_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // key_value_pattern _loop0_96 + { // key_value_pattern _loop0_115 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_95[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_96")); + D(fprintf(stderr, "%*c> _gather_114[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_115")); KeyPatternPair* elem; asdl_seq * seq; if ( (elem = key_value_pattern_rule(p)) // key_value_pattern && - (seq = _loop0_96_rule(p)) // _loop0_96 + (seq = _loop0_115_rule(p)) // _loop0_115 ) { - D(fprintf(stderr, "%*c+ _gather_95[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_96")); + D(fprintf(stderr, "%*c+ _gather_114[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_115")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_95[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_96")); + D(fprintf(stderr, "%*c%s _gather_114[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "key_value_pattern _loop0_115")); } _res = NULL; done: @@ -37617,9 +41210,9 @@ _gather_95_rule(Parser *p) return _res; } -// _tmp_97: literal_expr | attr +// _tmp_116: literal_expr | attr static void * -_tmp_97_rule(Parser *p) +_tmp_116_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37636,18 +41229,18 @@ _tmp_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); + D(fprintf(stderr, "%*c> _tmp_116[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); expr_ty literal_expr_var; if ( (literal_expr_var = literal_expr_rule(p)) // literal_expr ) { - D(fprintf(stderr, "%*c+ _tmp_97[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); + D(fprintf(stderr, "%*c+ _tmp_116[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "literal_expr")); _res = literal_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_97[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "literal_expr")); } { // attr @@ -37655,18 +41248,18 @@ _tmp_97_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_97[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); + D(fprintf(stderr, "%*c> _tmp_116[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); expr_ty attr_var; if ( (attr_var = attr_rule(p)) // attr ) { - D(fprintf(stderr, "%*c+ _tmp_97[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); + D(fprintf(stderr, "%*c+ _tmp_116[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "attr")); _res = attr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_97[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "attr")); } _res = NULL; @@ -37675,9 +41268,9 @@ _tmp_97_rule(Parser *p) return _res; } -// _loop0_99: ',' pattern +// _loop0_118: ',' pattern static asdl_seq * -_loop0_99_rule(Parser *p) +_loop0_118_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37703,7 +41296,7 @@ _loop0_99_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_99[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' pattern")); + D(fprintf(stderr, "%*c> _loop0_118[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' pattern")); Token * _literal; pattern_ty elem; while ( @@ -37735,7 +41328,7 @@ _loop0_99_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_99[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_118[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37752,9 +41345,9 @@ _loop0_99_rule(Parser *p) return _seq; } -// _gather_98: pattern _loop0_99 +// _gather_117: pattern _loop0_118 static asdl_seq * -_gather_98_rule(Parser *p) +_gather_117_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37766,27 +41359,27 @@ _gather_98_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // pattern _loop0_99 + { // pattern _loop0_118 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_98[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_99")); + D(fprintf(stderr, "%*c> _gather_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_118")); pattern_ty elem; asdl_seq * seq; if ( (elem = pattern_rule(p)) // pattern && - (seq = _loop0_99_rule(p)) // _loop0_99 + (seq = _loop0_118_rule(p)) // _loop0_118 ) { - D(fprintf(stderr, "%*c+ _gather_98[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_99")); + D(fprintf(stderr, "%*c+ _gather_117[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "pattern _loop0_118")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_98[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "pattern _loop0_99")); + D(fprintf(stderr, "%*c%s _gather_117[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "pattern _loop0_118")); } _res = NULL; done: @@ -37794,9 +41387,9 @@ _gather_98_rule(Parser *p) return _res; } -// _loop0_101: ',' keyword_pattern +// _loop0_120: ',' keyword_pattern static asdl_seq * -_loop0_101_rule(Parser *p) +_loop0_120_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37822,7 +41415,7 @@ _loop0_101_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_101[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' keyword_pattern")); + D(fprintf(stderr, "%*c> _loop0_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' keyword_pattern")); Token * _literal; KeyPatternPair* elem; while ( @@ -37854,7 +41447,7 @@ _loop0_101_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_101[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_120[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' keyword_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -37871,9 +41464,9 @@ _loop0_101_rule(Parser *p) return _seq; } -// _gather_100: keyword_pattern _loop0_101 +// _gather_119: keyword_pattern _loop0_120 static asdl_seq * -_gather_100_rule(Parser *p) +_gather_119_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37885,27 +41478,27 @@ _gather_100_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // keyword_pattern _loop0_101 + { // keyword_pattern _loop0_120 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_100[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_101")); + D(fprintf(stderr, "%*c> _gather_119[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_120")); KeyPatternPair* elem; asdl_seq * seq; if ( (elem = keyword_pattern_rule(p)) // keyword_pattern && - (seq = _loop0_101_rule(p)) // _loop0_101 + (seq = _loop0_120_rule(p)) // _loop0_120 ) { - D(fprintf(stderr, "%*c+ _gather_100[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_101")); + D(fprintf(stderr, "%*c+ _gather_119[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_120")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_100[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_101")); + D(fprintf(stderr, "%*c%s _gather_119[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "keyword_pattern _loop0_120")); } _res = NULL; done: @@ -37913,9 +41506,9 @@ _gather_100_rule(Parser *p) return _res; } -// _tmp_102: ';'.simple_stmt+ ';'? | block +// _tmp_121: ';'.simple_stmt+ ';'? | block static void * -_tmp_102_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -37932,17 +41525,17 @@ _tmp_102_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_102[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings asdl_stmt_seq* s; if ( - (s = (asdl_stmt_seq*)_gather_317_rule(p)) // ';'.simple_stmt+ + (s = (asdl_stmt_seq*)_gather_347_rule(p)) // ';'.simple_stmt+ && (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'? ) { - D(fprintf(stderr, "%*c+ _tmp_102[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); _res = s; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37952,7 +41545,7 @@ _tmp_102_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_102[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';'.simple_stmt+ ';'?")); } { // block @@ -37960,18 +41553,18 @@ _tmp_102_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_102[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c> _tmp_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); asdl_stmt_seq* block_var; if ( (block_var = block_rule(p)) // block ) { - D(fprintf(stderr, "%*c+ _tmp_102[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); + D(fprintf(stderr, "%*c+ _tmp_121[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block")); _res = block_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_102[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_121[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block")); } _res = NULL; @@ -37980,9 +41573,67 @@ _tmp_102_rule(Parser *p) return _res; } -// _loop0_104: ',' type_param +// _tmp_122: simple_stmts_nonewline | block_nonewline +static void * +_tmp_122_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; + { // simple_stmts_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + asdl_stmt_seq* simple_stmts_nonewline_var; + if ( + (simple_stmts_nonewline_var = simple_stmts_nonewline_rule(p)) // simple_stmts_nonewline + ) + { + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + _res = simple_stmts_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmts_nonewline")); + } + { // block_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block_nonewline")); + asdl_stmt_seq* block_nonewline_var; + if ( + (block_nonewline_var = block_nonewline_rule(p)) // block_nonewline + ) + { + D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block_nonewline")); + _res = block_nonewline_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_124: ',' type_param static asdl_seq * -_loop0_104_rule(Parser *p) +_loop0_124_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38008,7 +41659,7 @@ _loop0_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_104[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' type_param")); + D(fprintf(stderr, "%*c> _loop0_124[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' type_param")); Token * _literal; type_param_ty elem; while ( @@ -38040,7 +41691,7 @@ _loop0_104_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_104[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_124[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' type_param")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38057,9 +41708,9 @@ _loop0_104_rule(Parser *p) return _seq; } -// _gather_103: type_param _loop0_104 +// _gather_123: type_param _loop0_124 static asdl_seq * -_gather_103_rule(Parser *p) +_gather_123_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38071,27 +41722,27 @@ _gather_103_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // type_param _loop0_104 + { // type_param _loop0_124 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_103[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_104")); + D(fprintf(stderr, "%*c> _gather_123[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_124")); type_param_ty elem; asdl_seq * seq; if ( (elem = type_param_rule(p)) // type_param && - (seq = _loop0_104_rule(p)) // _loop0_104 + (seq = _loop0_124_rule(p)) // _loop0_124 ) { - D(fprintf(stderr, "%*c+ _gather_103[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_104")); + D(fprintf(stderr, "%*c+ _gather_123[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "type_param _loop0_124")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_103[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "type_param _loop0_104")); + D(fprintf(stderr, "%*c%s _gather_123[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "type_param _loop0_124")); } _res = NULL; done: @@ -38099,9 +41750,9 @@ _gather_103_rule(Parser *p) return _res; } -// _loop1_105: (',' expression) +// _loop1_125: (',' expression) static asdl_seq * -_loop1_105_rule(Parser *p) +_loop1_125_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38127,13 +41778,13 @@ _loop1_105_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_105[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' expression)")); - void *_tmp_319_var; + D(fprintf(stderr, "%*c> _loop1_125[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' expression)")); + void *_tmp_349_var; while ( - (_tmp_319_var = _tmp_319_rule(p)) // ',' expression + (_tmp_349_var = _tmp_349_rule(p)) // ',' expression ) { - _res = _tmp_319_var; + _res = _tmp_349_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38150,7 +41801,7 @@ _loop1_105_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_105[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_125[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(',' expression)")); } if (_n == 0 || p->error_indicator) { @@ -38172,9 +41823,9 @@ _loop1_105_rule(Parser *p) return _seq; } -// _loop1_106: (',' star_expression) +// _loop1_126: (',' star_expression) static asdl_seq * -_loop1_106_rule(Parser *p) +_loop1_126_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38200,13 +41851,13 @@ _loop1_106_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_106[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_expression)")); - void *_tmp_320_var; + D(fprintf(stderr, "%*c> _loop1_126[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_expression)")); + void *_tmp_350_var; while ( - (_tmp_320_var = _tmp_320_rule(p)) // ',' star_expression + (_tmp_350_var = _tmp_350_rule(p)) // ',' star_expression ) { - _res = _tmp_320_var; + _res = _tmp_350_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38223,7 +41874,7 @@ _loop1_106_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_106[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_126[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(',' star_expression)")); } if (_n == 0 || p->error_indicator) { @@ -38245,9 +41896,9 @@ _loop1_106_rule(Parser *p) return _seq; } -// _loop0_108: ',' star_named_expression +// _loop0_128: ',' star_named_expression static asdl_seq * -_loop0_108_rule(Parser *p) +_loop0_128_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38273,7 +41924,7 @@ _loop0_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_108[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_named_expression")); + D(fprintf(stderr, "%*c> _loop0_128[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_named_expression")); Token * _literal; expr_ty elem; while ( @@ -38305,7 +41956,7 @@ _loop0_108_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_108[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_128[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_named_expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38322,9 +41973,9 @@ _loop0_108_rule(Parser *p) return _seq; } -// _gather_107: star_named_expression _loop0_108 +// _gather_127: star_named_expression _loop0_128 static asdl_seq * -_gather_107_rule(Parser *p) +_gather_127_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38336,27 +41987,27 @@ _gather_107_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_named_expression _loop0_108 + { // star_named_expression _loop0_128 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_107[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_108")); + D(fprintf(stderr, "%*c> _gather_127[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_128")); expr_ty elem; asdl_seq * seq; if ( (elem = star_named_expression_rule(p)) // star_named_expression && - (seq = _loop0_108_rule(p)) // _loop0_108 + (seq = _loop0_128_rule(p)) // _loop0_128 ) { - D(fprintf(stderr, "%*c+ _gather_107[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_108")); + D(fprintf(stderr, "%*c+ _gather_127[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_128")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_107[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_108")); + D(fprintf(stderr, "%*c%s _gather_127[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_named_expression _loop0_128")); } _res = NULL; done: @@ -38364,9 +42015,9 @@ _gather_107_rule(Parser *p) return _res; } -// _loop1_109: ('or' conjunction) +// _loop1_129: ('or' conjunction) static asdl_seq * -_loop1_109_rule(Parser *p) +_loop1_129_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38392,13 +42043,13 @@ _loop1_109_rule(Parser *p) p->level--; 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_321_var; + D(fprintf(stderr, "%*c> _loop1_129[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('or' conjunction)")); + void *_tmp_351_var; while ( - (_tmp_321_var = _tmp_321_rule(p)) // 'or' conjunction + (_tmp_351_var = _tmp_351_rule(p)) // 'or' conjunction ) { - _res = _tmp_321_var; + _res = _tmp_351_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38415,7 +42066,7 @@ _loop1_109_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_109[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_129[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('or' conjunction)")); } if (_n == 0 || p->error_indicator) { @@ -38437,9 +42088,9 @@ _loop1_109_rule(Parser *p) return _seq; } -// _loop1_110: ('and' inversion) +// _loop1_130: ('and' inversion) static asdl_seq * -_loop1_110_rule(Parser *p) +_loop1_130_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38465,13 +42116,13 @@ _loop1_110_rule(Parser *p) p->level--; 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_322_var; + D(fprintf(stderr, "%*c> _loop1_130[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('and' inversion)")); + void *_tmp_352_var; while ( - (_tmp_322_var = _tmp_322_rule(p)) // 'and' inversion + (_tmp_352_var = _tmp_352_rule(p)) // 'and' inversion ) { - _res = _tmp_322_var; + _res = _tmp_352_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38488,7 +42139,7 @@ _loop1_110_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_110[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_130[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "('and' inversion)")); } if (_n == 0 || p->error_indicator) { @@ -38510,9 +42161,9 @@ _loop1_110_rule(Parser *p) return _seq; } -// _loop1_111: compare_op_composition_pair +// _loop1_131: compare_op_composition_pair static asdl_seq * -_loop1_111_rule(Parser *p) +_loop1_131_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38538,7 +42189,7 @@ _loop1_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_111[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "compare_op_composition_pair")); + D(fprintf(stderr, "%*c> _loop1_131[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "compare_op_composition_pair")); CmpopExprPair* compare_op_composition_pair_var; while ( (compare_op_composition_pair_var = compare_op_composition_pair_rule(p)) // compare_op_composition_pair @@ -38561,7 +42212,7 @@ _loop1_111_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_111[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_131[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "compare_op_composition_pair")); } if (_n == 0 || p->error_indicator) { @@ -38583,9 +42234,9 @@ _loop1_111_rule(Parser *p) return _seq; } -// _tmp_112: '!=' +// _tmp_132: '!=' static void * -_tmp_112_rule(Parser *p) +_tmp_132_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38602,13 +42253,13 @@ _tmp_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_112[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c> _tmp_132[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); Token * tok; if ( (tok = _PyPegen_expect_token(p, 28)) // token='!=' ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); + D(fprintf(stderr, "%*c+ _tmp_132[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!='")); _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -38618,7 +42269,7 @@ _tmp_112_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_112[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_132[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!='")); } _res = NULL; @@ -38627,9 +42278,9 @@ _tmp_112_rule(Parser *p) return _res; } -// _tmp_113: '|>' +// _tmp_133: '|>' static void * -_tmp_113_rule(Parser *p) +_tmp_133_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38646,13 +42297,13 @@ _tmp_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_113[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); + D(fprintf(stderr, "%*c> _tmp_133[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); Token * t; if ( (t = _PyPegen_expect_token(p, 55)) // token='|>' ) { - D(fprintf(stderr, "%*c+ _tmp_113[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); + D(fprintf(stderr, "%*c+ _tmp_133[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|>'")); _res = ( ++ p -> subn , t ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -38662,7 +42313,7 @@ _tmp_113_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_113[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_133[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|>'")); } _res = NULL; @@ -38671,9 +42322,9 @@ _tmp_113_rule(Parser *p) return _res; } -// _tmp_114: bitwise_or? +// _tmp_134: bitwise_or? static void * -_tmp_114_rule(Parser *p) +_tmp_134_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38690,13 +42341,13 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); + D(fprintf(stderr, "%*c> _tmp_134[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); void *c; if ( (c = bitwise_or_rule(p), !p->error_indicator) // bitwise_or? ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); + D(fprintf(stderr, "%*c+ _tmp_134[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwise_or?")); _res = ( - - p -> subn , c ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -38706,7 +42357,7 @@ _tmp_114_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_114[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_134[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwise_or?")); } _res = NULL; @@ -38715,9 +42366,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _tmp_115: class_or_func_expr | tuplecomp | genexp +// _tmp_135: class_or_func_expr | tuplecomp | genexp static void * -_tmp_115_rule(Parser *p) +_tmp_135_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38734,18 +42385,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + D(fprintf(stderr, "%*c> _tmp_135[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); expr_ty class_or_func_expr_var; if ( (class_or_func_expr_var = class_or_func_expr_rule(p)) // class_or_func_expr ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); _res = class_or_func_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "class_or_func_expr")); } { // tuplecomp @@ -38753,18 +42404,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c> _tmp_135[%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_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); _res = tuplecomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuplecomp")); } { // genexp @@ -38772,18 +42423,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c> _tmp_135[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); expr_ty genexp_var; if ( (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } _res = NULL; @@ -38792,9 +42443,9 @@ _tmp_115_rule(Parser *p) return _res; } -// _loop0_117: ',' (slice | starred_expression) +// _loop0_137: ',' (slice | starred_expression) static asdl_seq * -_loop0_117_rule(Parser *p) +_loop0_137_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38820,13 +42471,13 @@ _loop0_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_117[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (slice | starred_expression)")); + D(fprintf(stderr, "%*c> _loop0_137[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (slice | starred_expression)")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_323_rule(p)) // slice | starred_expression + (elem = _tmp_353_rule(p)) // slice | starred_expression ) { _res = elem; @@ -38852,7 +42503,7 @@ _loop0_117_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_117[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_137[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (slice | starred_expression)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38869,9 +42520,9 @@ _loop0_117_rule(Parser *p) return _seq; } -// _gather_116: (slice | starred_expression) _loop0_117 +// _gather_136: (slice | starred_expression) _loop0_137 static asdl_seq * -_gather_116_rule(Parser *p) +_gather_136_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38883,27 +42534,27 @@ _gather_116_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (slice | starred_expression) _loop0_117 + { // (slice | starred_expression) _loop0_137 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_116[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_117")); + D(fprintf(stderr, "%*c> _gather_136[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_137")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_323_rule(p)) // slice | starred_expression + (elem = _tmp_353_rule(p)) // slice | starred_expression && - (seq = _loop0_117_rule(p)) // _loop0_117 + (seq = _loop0_137_rule(p)) // _loop0_137 ) { - D(fprintf(stderr, "%*c+ _gather_116[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_117")); + D(fprintf(stderr, "%*c+ _gather_136[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_137")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_116[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_117")); + D(fprintf(stderr, "%*c%s _gather_136[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(slice | starred_expression) _loop0_137")); } _res = NULL; done: @@ -38911,9 +42562,9 @@ _gather_116_rule(Parser *p) return _res; } -// _tmp_118: ':' expression? +// _tmp_138: ':' expression? static void * -_tmp_118_rule(Parser *p) +_tmp_138_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38930,7 +42581,7 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); + D(fprintf(stderr, "%*c> _tmp_138[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); Token * _literal; void *d; if ( @@ -38939,7 +42590,7 @@ _tmp_118_rule(Parser *p) (d = expression_rule(p), !p->error_indicator) // expression? ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); + D(fprintf(stderr, "%*c+ _tmp_138[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':' expression?")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -38949,7 +42600,7 @@ _tmp_118_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_138[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':' expression?")); } _res = NULL; @@ -38958,9 +42609,9 @@ _tmp_118_rule(Parser *p) return _res; } -// _tmp_119: STRING | FSTRING_START +// _tmp_139: STRING | FSTRING_START static void * -_tmp_119_rule(Parser *p) +_tmp_139_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -38977,18 +42628,18 @@ _tmp_119_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_119[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); expr_ty string_var; if ( (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_119[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "STRING")); + D(fprintf(stderr, "%*c+ _tmp_139[%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_119[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "STRING")); } { // FSTRING_START @@ -38996,18 +42647,18 @@ _tmp_119_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_119[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); + D(fprintf(stderr, "%*c> _tmp_139[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); Token * fstring_start_var; if ( (fstring_start_var = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START' ) { - D(fprintf(stderr, "%*c+ _tmp_119[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_START")); _res = fstring_start_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_119[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "FSTRING_START")); } _res = NULL; @@ -39016,9 +42667,9 @@ _tmp_119_rule(Parser *p) return _res; } -// _tmp_120: class_or_func_expr | tuple | group | tuplecomp | genexp +// _tmp_140: class_or_func_expr | tuple | group | tuplecomp | genexp static void * -_tmp_120_rule(Parser *p) +_tmp_140_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39035,18 +42686,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + D(fprintf(stderr, "%*c> _tmp_140[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); expr_ty class_or_func_expr_var; if ( (class_or_func_expr_var = class_or_func_expr_rule(p)) // class_or_func_expr ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); + D(fprintf(stderr, "%*c+ _tmp_140[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "class_or_func_expr")); _res = class_or_func_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_140[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "class_or_func_expr")); } { // tuple @@ -39054,18 +42705,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c> _tmp_140[%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_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_140[%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_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_140[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuple")); } { // group @@ -39073,18 +42724,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); + D(fprintf(stderr, "%*c> _tmp_140[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); expr_ty group_var; if ( (group_var = group_rule(p)) // group ) { - D(fprintf(stderr, "%*c+ _tmp_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); + D(fprintf(stderr, "%*c+ _tmp_140[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "group")); _res = group_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_140[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "group")); } { // tuplecomp @@ -39092,18 +42743,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c> _tmp_140[%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_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c+ _tmp_140[%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_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_140[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "tuplecomp")); } { // genexp @@ -39111,18 +42762,18 @@ _tmp_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_120[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c> _tmp_140[%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_120[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_140[%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_120[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_140[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } _res = NULL; @@ -39131,9 +42782,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _tmp_121: list | listcomp +// _tmp_141: list | listcomp static void * -_tmp_121_rule(Parser *p) +_tmp_141_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39150,18 +42801,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c> _tmp_141[%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_121[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c+ _tmp_141[%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_121[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_141[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "list")); } { // listcomp @@ -39169,18 +42820,18 @@ _tmp_121_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); + D(fprintf(stderr, "%*c> _tmp_141[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); expr_ty listcomp_var; if ( (listcomp_var = listcomp_rule(p)) // listcomp ) { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); + D(fprintf(stderr, "%*c+ _tmp_141[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "listcomp")); _res = listcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_141[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "listcomp")); } _res = NULL; @@ -39189,9 +42840,9 @@ _tmp_121_rule(Parser *p) return _res; } -// _tmp_122: dict | set | dictcomp | setcomp +// _tmp_142: dict | set | dictcomp | setcomp static void * -_tmp_122_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39208,18 +42859,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); expr_ty dict_var; if ( (dict_var = dict_rule(p)) // dict ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dict")); _res = dict_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dict")); } { // set @@ -39227,18 +42878,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); expr_ty set_var; if ( (set_var = set_rule(p)) // set ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "set")); _res = set_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "set")); } { // dictcomp @@ -39246,18 +42897,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); expr_ty dictcomp_var; if ( (dictcomp_var = dictcomp_rule(p)) // dictcomp ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dictcomp")); _res = dictcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dictcomp")); } { // setcomp @@ -39265,18 +42916,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); + D(fprintf(stderr, "%*c> _tmp_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); expr_ty setcomp_var; if ( (setcomp_var = setcomp_rule(p)) // setcomp ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); + D(fprintf(stderr, "%*c+ _tmp_142[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "setcomp")); _res = setcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_142[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "setcomp")); } _res = NULL; @@ -39285,9 +42936,9 @@ _tmp_122_rule(Parser *p) return _res; } -// _tmp_123: yield_expr | slice +// _tmp_143: yield_expr | slice static void * -_tmp_123_rule(Parser *p) +_tmp_143_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39304,18 +42955,18 @@ _tmp_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_123[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_143[%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_123[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_143[%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_123[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_143[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // slice @@ -39323,18 +42974,18 @@ _tmp_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_123[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c> _tmp_143[%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_123[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c+ _tmp_143[%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_123[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_143[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slice")); } _res = NULL; @@ -39343,11 +42994,11 @@ _tmp_123_rule(Parser *p) return _res; } -// _tmp_124: +// _tmp_144: // | &("def" | '@' | 'async') function_def_nonewline // | &('class' | '@') class_def_nonewline static void * -_tmp_124_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39364,20 +43015,20 @@ _tmp_124_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _tmp_144[%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_324_rule, p) + _PyPegen_lookahead(1, _tmp_354_rule, p) && (function_def_nonewline_var = function_def_nonewline_rule(p)) // function_def_nonewline ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def_nonewline")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def_nonewline")); _res = function_def_nonewline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_124[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&(\"def\" | '@' | 'async') function_def_nonewline")); } { // &('class' | '@') class_def_nonewline @@ -39385,20 +43036,20 @@ _tmp_124_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_124[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); + D(fprintf(stderr, "%*c> _tmp_144[%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_325_rule, p) + _PyPegen_lookahead(1, _tmp_355_rule, p) && (class_def_nonewline_var = class_def_nonewline_rule(p)) // class_def_nonewline ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); _res = class_def_nonewline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_124[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "&('class' | '@') class_def_nonewline")); } _res = NULL; @@ -39407,9 +43058,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _loop0_125: lambda_param_no_default +// _loop0_145: lambda_param_no_default static asdl_seq * -_loop0_125_rule(Parser *p) +_loop0_145_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39435,7 +43086,7 @@ _loop0_125_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_125[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_145[%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 @@ -39458,7 +43109,7 @@ _loop0_125_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_125[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_145[%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); @@ -39475,9 +43126,9 @@ _loop0_125_rule(Parser *p) return _seq; } -// _loop0_126: lambda_param_with_default +// _loop0_146: lambda_param_with_default static asdl_seq * -_loop0_126_rule(Parser *p) +_loop0_146_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39503,7 +43154,7 @@ _loop0_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_126[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_146[%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 @@ -39526,7 +43177,7 @@ _loop0_126_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_126[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_146[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39543,9 +43194,9 @@ _loop0_126_rule(Parser *p) return _seq; } -// _loop0_127: lambda_param_with_default +// _loop0_147: lambda_param_with_default static asdl_seq * -_loop0_127_rule(Parser *p) +_loop0_147_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39571,7 +43222,7 @@ _loop0_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_127[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_147[%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 @@ -39594,7 +43245,7 @@ _loop0_127_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_127[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_147[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39611,9 +43262,9 @@ _loop0_127_rule(Parser *p) return _seq; } -// _loop1_128: lambda_param_no_default +// _loop1_148: lambda_param_no_default static asdl_seq * -_loop1_128_rule(Parser *p) +_loop1_148_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39639,7 +43290,7 @@ _loop1_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_128[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_148[%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 @@ -39662,7 +43313,7 @@ _loop1_128_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_128[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_148[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -39684,9 +43335,9 @@ _loop1_128_rule(Parser *p) return _seq; } -// _loop0_129: lambda_param_with_default +// _loop0_149: lambda_param_with_default static asdl_seq * -_loop0_129_rule(Parser *p) +_loop0_149_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39712,7 +43363,7 @@ _loop0_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_129[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_149[%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 @@ -39735,7 +43386,7 @@ _loop0_129_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_129[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_149[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -39752,9 +43403,9 @@ _loop0_129_rule(Parser *p) return _seq; } -// _loop1_130: lambda_param_with_default +// _loop1_150: lambda_param_with_default static asdl_seq * -_loop1_130_rule(Parser *p) +_loop1_150_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39780,7 +43431,7 @@ _loop1_130_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_130[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_150[%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 @@ -39803,7 +43454,7 @@ _loop1_130_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_130[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_150[%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) { @@ -39825,9 +43476,9 @@ _loop1_130_rule(Parser *p) return _seq; } -// _loop1_131: lambda_param_no_default +// _loop1_151: lambda_param_no_default static asdl_seq * -_loop1_131_rule(Parser *p) +_loop1_151_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39853,7 +43504,7 @@ _loop1_131_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_131[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_151[%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 @@ -39876,7 +43527,7 @@ _loop1_131_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_131[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_151[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -39898,9 +43549,9 @@ _loop1_131_rule(Parser *p) return _seq; } -// _loop1_132: lambda_param_no_default +// _loop1_152: lambda_param_no_default static asdl_seq * -_loop1_132_rule(Parser *p) +_loop1_152_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39926,7 +43577,7 @@ _loop1_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_132[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_152[%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 @@ -39949,7 +43600,7 @@ _loop1_132_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_132[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_152[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -39971,9 +43622,9 @@ _loop1_132_rule(Parser *p) return _seq; } -// _loop0_133: lambda_param_no_default +// _loop0_153: lambda_param_no_default static asdl_seq * -_loop0_133_rule(Parser *p) +_loop0_153_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -39999,7 +43650,7 @@ _loop0_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_133[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_153[%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 @@ -40022,7 +43673,7 @@ _loop0_133_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_133[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_153[%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); @@ -40039,9 +43690,9 @@ _loop0_133_rule(Parser *p) return _seq; } -// _loop1_134: lambda_param_with_default +// _loop1_154: lambda_param_with_default static asdl_seq * -_loop1_134_rule(Parser *p) +_loop1_154_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40067,7 +43718,7 @@ _loop1_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_134[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_154[%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 @@ -40090,7 +43741,7 @@ _loop1_134_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_134[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_154[%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) { @@ -40112,9 +43763,9 @@ _loop1_134_rule(Parser *p) return _seq; } -// _loop0_135: lambda_param_no_default +// _loop0_155: lambda_param_no_default static asdl_seq * -_loop0_135_rule(Parser *p) +_loop0_155_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40140,7 +43791,7 @@ _loop0_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_135[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_155[%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 @@ -40163,7 +43814,7 @@ _loop0_135_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_135[%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, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40180,9 +43831,9 @@ _loop0_135_rule(Parser *p) return _seq; } -// _loop1_136: lambda_param_with_default +// _loop1_156: lambda_param_with_default static asdl_seq * -_loop1_136_rule(Parser *p) +_loop1_156_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40208,7 +43859,7 @@ _loop1_136_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_136[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_156[%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 @@ -40231,7 +43882,7 @@ _loop1_136_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_136[%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, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -40253,9 +43904,9 @@ _loop1_136_rule(Parser *p) return _seq; } -// _loop0_137: lambda_param_maybe_default +// _loop0_157: lambda_param_maybe_default static asdl_seq * -_loop0_137_rule(Parser *p) +_loop0_157_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40281,7 +43932,7 @@ _loop0_137_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_137[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_157[%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 @@ -40304,7 +43955,7 @@ _loop0_137_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_137[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_157[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40321,9 +43972,9 @@ _loop0_137_rule(Parser *p) return _seq; } -// _loop1_138: lambda_param_maybe_default +// _loop1_158: lambda_param_maybe_default static asdl_seq * -_loop1_138_rule(Parser *p) +_loop1_158_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40349,7 +44000,7 @@ _loop1_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_138[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_158[%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 @@ -40372,7 +44023,7 @@ _loop1_138_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_138[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_158[%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) { @@ -40394,9 +44045,9 @@ _loop1_138_rule(Parser *p) return _seq; } -// _loop0_139: lambda_sum_param_no_default +// _loop0_159: lambda_sum_param_no_default static asdl_seq * -_loop0_139_rule(Parser *p) +_loop0_159_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40422,7 +44073,7 @@ _loop0_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_139[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_159[%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 @@ -40445,7 +44096,7 @@ _loop0_139_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_139[%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, "lambda_sum_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40462,9 +44113,9 @@ _loop0_139_rule(Parser *p) return _seq; } -// _loop0_140: lambda_sum_param_with_default +// _loop0_160: lambda_sum_param_with_default static asdl_seq * -_loop0_140_rule(Parser *p) +_loop0_160_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40490,7 +44141,7 @@ _loop0_140_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_140[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_160[%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 @@ -40513,7 +44164,7 @@ _loop0_140_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_140[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_160[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40530,9 +44181,9 @@ _loop0_140_rule(Parser *p) return _seq; } -// _loop0_141: lambda_sum_param_with_default +// _loop0_161: lambda_sum_param_with_default static asdl_seq * -_loop0_141_rule(Parser *p) +_loop0_161_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40558,7 +44209,7 @@ _loop0_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_141[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_161[%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 @@ -40581,7 +44232,7 @@ _loop0_141_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_141[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_161[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40598,9 +44249,9 @@ _loop0_141_rule(Parser *p) return _seq; } -// _loop1_142: lambda_sum_param_no_default +// _loop1_162: lambda_sum_param_no_default static asdl_seq * -_loop1_142_rule(Parser *p) +_loop1_162_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40626,7 +44277,7 @@ _loop1_142_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_142[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_162[%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 @@ -40649,7 +44300,7 @@ _loop1_142_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_142[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_162[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -40671,9 +44322,9 @@ _loop1_142_rule(Parser *p) return _seq; } -// _loop0_143: lambda_sum_param_with_default +// _loop0_163: lambda_sum_param_with_default static asdl_seq * -_loop0_143_rule(Parser *p) +_loop0_163_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40699,7 +44350,7 @@ _loop0_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_143[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_163[%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 @@ -40722,7 +44373,7 @@ _loop0_143_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_143[%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, "lambda_sum_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -40739,9 +44390,9 @@ _loop0_143_rule(Parser *p) return _seq; } -// _loop1_144: lambda_sum_param_with_default +// _loop1_164: lambda_sum_param_with_default static asdl_seq * -_loop1_144_rule(Parser *p) +_loop1_164_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40767,7 +44418,7 @@ _loop1_144_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_144[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_164[%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 @@ -40790,7 +44441,7 @@ _loop1_144_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_144[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_164[%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) { @@ -40812,9 +44463,9 @@ _loop1_144_rule(Parser *p) return _seq; } -// _loop1_145: param_no_default +// _loop1_165: param_no_default static asdl_seq * -_loop1_145_rule(Parser *p) +_loop1_165_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40840,7 +44491,7 @@ _loop1_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_145[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_165[%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 @@ -40863,7 +44514,7 @@ _loop1_145_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_145[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_165[%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) { @@ -40885,9 +44536,9 @@ _loop1_145_rule(Parser *p) return _seq; } -// _loop1_146: param_no_default +// _loop1_166: param_no_default static asdl_seq * -_loop1_146_rule(Parser *p) +_loop1_166_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40913,7 +44564,7 @@ _loop1_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_146[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_166[%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 @@ -40936,7 +44587,7 @@ _loop1_146_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_146[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_166[%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) { @@ -40958,9 +44609,9 @@ _loop1_146_rule(Parser *p) return _seq; } -// _loop0_147: lambda_sum_param_no_default +// _loop0_167: lambda_sum_param_no_default static asdl_seq * -_loop0_147_rule(Parser *p) +_loop0_167_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -40986,7 +44637,7 @@ _loop0_147_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_147[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_167[%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 @@ -41009,7 +44660,7 @@ _loop0_147_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_147[%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, "lambda_sum_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41026,9 +44677,9 @@ _loop0_147_rule(Parser *p) return _seq; } -// _loop1_148: lambda_sum_param_with_default +// _loop1_168: lambda_sum_param_with_default static asdl_seq * -_loop1_148_rule(Parser *p) +_loop1_168_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41054,7 +44705,7 @@ _loop1_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_148[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_168[%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 @@ -41077,7 +44728,7 @@ _loop1_148_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_148[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_168[%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) { @@ -41099,9 +44750,9 @@ _loop1_148_rule(Parser *p) return _seq; } -// _loop0_149: lambda_sum_param_no_default +// _loop0_169: lambda_sum_param_no_default static asdl_seq * -_loop0_149_rule(Parser *p) +_loop0_169_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41127,7 +44778,7 @@ _loop0_149_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_149[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_169[%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 @@ -41150,7 +44801,7 @@ _loop0_149_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_149[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_169[%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); @@ -41167,9 +44818,9 @@ _loop0_149_rule(Parser *p) return _seq; } -// _loop1_150: lambda_sum_param_with_default +// _loop1_170: lambda_sum_param_with_default static asdl_seq * -_loop1_150_rule(Parser *p) +_loop1_170_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41195,7 +44846,7 @@ _loop1_150_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_150[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_170[%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 @@ -41218,7 +44869,7 @@ _loop1_150_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_150[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_170[%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) { @@ -41240,9 +44891,9 @@ _loop1_150_rule(Parser *p) return _seq; } -// _loop0_151: lambda_sum_param_maybe_default +// _loop0_171: lambda_sum_param_maybe_default static asdl_seq * -_loop0_151_rule(Parser *p) +_loop0_171_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41268,7 +44919,7 @@ _loop0_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_151[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_171[%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 @@ -41291,7 +44942,7 @@ _loop0_151_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_151[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_171[%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); @@ -41308,9 +44959,9 @@ _loop0_151_rule(Parser *p) return _seq; } -// _loop0_152: lambda_sum_param_maybe_default +// _loop0_172: lambda_sum_param_maybe_default static asdl_seq * -_loop0_152_rule(Parser *p) +_loop0_172_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41336,7 +44987,7 @@ _loop0_152_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _loop0_172[%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 @@ -41359,7 +45010,7 @@ _loop0_152_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_152[%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, "lambda_sum_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41376,9 +45027,9 @@ _loop0_152_rule(Parser *p) return _seq; } -// _loop1_153: lambda_sum_param_maybe_default +// _loop1_173: lambda_sum_param_maybe_default static asdl_seq * -_loop1_153_rule(Parser *p) +_loop1_173_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41404,7 +45055,7 @@ _loop1_153_rule(Parser *p) 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")); + D(fprintf(stderr, "%*c> _loop1_173[%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 @@ -41427,7 +45078,7 @@ _loop1_153_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_153[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_173[%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) { @@ -41449,9 +45100,9 @@ _loop1_153_rule(Parser *p) return _seq; } -// _tmp_154: yield_expr | star_expressions +// _tmp_174: yield_expr | star_expressions static void * -_tmp_154_rule(Parser *p) +_tmp_174_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41468,18 +45119,18 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_174[%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_154[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_174[%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_154[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_174[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -41487,18 +45138,18 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_174[%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_154[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_174[%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_154[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_174[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -41507,9 +45158,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _loop0_155: fstring_format_spec +// _loop0_175: fstring_format_spec static asdl_seq * -_loop0_155_rule(Parser *p) +_loop0_175_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41535,7 +45186,7 @@ _loop0_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_155[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_175[%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 @@ -41558,7 +45209,7 @@ _loop0_155_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_155[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_175[%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); @@ -41575,9 +45226,9 @@ _loop0_155_rule(Parser *p) return _seq; } -// _loop1_156: (fstring | string) +// _loop1_176: (fstring | string) static asdl_seq * -_loop1_156_rule(Parser *p) +_loop1_176_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41603,13 +45254,13 @@ _loop1_156_rule(Parser *p) p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop1_176[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(fstring | string)")); + void *_tmp_356_var; while ( - (_tmp_326_var = _tmp_326_rule(p)) // fstring | string + (_tmp_356_var = _tmp_356_rule(p)) // fstring | string ) { - _res = _tmp_326_var; + _res = _tmp_356_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -41626,7 +45277,7 @@ _loop1_156_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_156[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_176[%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) { @@ -41648,9 +45299,9 @@ _loop1_156_rule(Parser *p) return _seq; } -// _tmp_157: star_named_expression ',' star_named_expressions? +// _tmp_177: star_named_expression ',' star_named_expressions? static void * -_tmp_157_rule(Parser *p) +_tmp_177_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41667,7 +45318,7 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_177[%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; @@ -41679,7 +45330,7 @@ _tmp_157_rule(Parser *p) (z = star_named_expressions_rule(p), !p->error_indicator) // 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?")); + D(fprintf(stderr, "%*c+ _tmp_177[%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; @@ -41689,7 +45340,7 @@ _tmp_157_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_177[%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; @@ -41698,9 +45349,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _loop0_159: ',' double_starred_kvpair +// _loop0_179: ',' double_starred_kvpair static asdl_seq * -_loop0_159_rule(Parser *p) +_loop0_179_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41726,7 +45377,7 @@ _loop0_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_159[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_179[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -41758,7 +45409,7 @@ _loop0_159_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_159[%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, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -41775,9 +45426,9 @@ _loop0_159_rule(Parser *p) return _seq; } -// _gather_158: double_starred_kvpair _loop0_159 +// _gather_178: double_starred_kvpair _loop0_179 static asdl_seq * -_gather_158_rule(Parser *p) +_gather_178_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41789,27 +45440,27 @@ _gather_158_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_159 + { // double_starred_kvpair _loop0_179 if (p->error_indicator) { p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _gather_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_179")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_159_rule(p)) // _loop0_159 + (seq = _loop0_179_rule(p)) // _loop0_179 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_179")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_178[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_179")); } _res = NULL; done: @@ -41817,9 +45468,9 @@ _gather_158_rule(Parser *p) return _res; } -// _loop1_160: for_if_clause +// _loop1_180: for_if_clause static asdl_seq * -_loop1_160_rule(Parser *p) +_loop1_180_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41845,7 +45496,7 @@ _loop1_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_160[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "for_if_clause")); + D(fprintf(stderr, "%*c> _loop1_180[%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 @@ -41868,7 +45519,7 @@ _loop1_160_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_160[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_180[%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) { @@ -41890,9 +45541,9 @@ _loop1_160_rule(Parser *p) return _seq; } -// _loop0_161: ('if' disjunction) +// _loop0_181: ('if' disjunction) static asdl_seq * -_loop0_161_rule(Parser *p) +_loop0_181_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41918,13 +45569,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_327_var; + D(fprintf(stderr, "%*c> _loop0_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_357_var; while ( - (_tmp_327_var = _tmp_327_rule(p)) // 'if' disjunction + (_tmp_357_var = _tmp_357_rule(p)) // 'if' disjunction ) { - _res = _tmp_327_var; + _res = _tmp_357_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -41941,7 +45592,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_181[%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); @@ -41958,9 +45609,9 @@ _loop0_161_rule(Parser *p) return _seq; } -// _loop0_162: ('if' disjunction) +// _loop0_182: ('if' disjunction) static asdl_seq * -_loop0_162_rule(Parser *p) +_loop0_182_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -41986,13 +45637,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_328_var; + D(fprintf(stderr, "%*c> _loop0_182[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_358_var; while ( - (_tmp_328_var = _tmp_328_rule(p)) // 'if' disjunction + (_tmp_358_var = _tmp_358_rule(p)) // 'if' disjunction ) { - _res = _tmp_328_var; + _res = _tmp_358_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -42009,7 +45660,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_182[%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); @@ -42026,9 +45677,9 @@ _loop0_162_rule(Parser *p) return _seq; } -// _loop0_163: ('if' disjunction) +// _loop0_183: ('if' disjunction) static asdl_seq * -_loop0_163_rule(Parser *p) +_loop0_183_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42054,13 +45705,13 @@ _loop0_163_rule(Parser *p) p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop0_183[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "('if' disjunction)")); + void *_tmp_359_var; while ( - (_tmp_329_var = _tmp_329_rule(p)) // 'if' disjunction + (_tmp_359_var = _tmp_359_rule(p)) // 'if' disjunction ) { - _res = _tmp_329_var; + _res = _tmp_359_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -42077,7 +45728,7 @@ _loop0_163_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_163[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_183[%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); @@ -42094,9 +45745,9 @@ _loop0_163_rule(Parser *p) return _seq; } -// _tmp_164: assignment_expression | expression !':=' +// _tmp_184: assignment_expression | expression !':=' static void * -_tmp_164_rule(Parser *p) +_tmp_184_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42113,18 +45764,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_184[%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_184[%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_184[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -42132,7 +45783,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_184[%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 @@ -42140,12 +45791,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_184[%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_184[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -42154,9 +45805,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _tmp_165: assignment_expression | expression !':=' +// _tmp_185: assignment_expression | expression !':=' static void * -_tmp_165_rule(Parser *p) +_tmp_185_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42173,18 +45824,18 @@ _tmp_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_165[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_185[%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_165[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_185[%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_165[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_185[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -42192,7 +45843,7 @@ _tmp_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_165[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_185[%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 @@ -42200,12 +45851,12 @@ _tmp_165_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_185[%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_165[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_185[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -42214,10 +45865,10 @@ _tmp_165_rule(Parser *p) return _res; } -// _loop0_167: +// _loop0_187: // | ',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_167_rule(Parser *p) +_loop0_187_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42243,13 +45894,13 @@ _loop0_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_167[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_187[%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_330_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' + (elem = _tmp_360_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -42275,7 +45926,7 @@ _loop0_167_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_167[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_187[%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); @@ -42292,10 +45943,10 @@ _loop0_167_rule(Parser *p) return _seq; } -// _gather_166: -// | (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167 +// _gather_186: +// | (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_187 static asdl_seq * -_gather_166_rule(Parser *p) +_gather_186_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42307,27 +45958,27 @@ _gather_166_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167 + { // (starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_187 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_166[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167")); + D(fprintf(stderr, "%*c> _gather_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_187")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_330_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' + (elem = _tmp_360_rule(p)) // starred_expression | simple_slice | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_167_rule(p)) // _loop0_167 + (seq = _loop0_187_rule(p)) // _loop0_187 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_186[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_187")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_166[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_167")); + 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, "(starred_expression | simple_slice | (assignment_expression | expression !':=') !'=') _loop0_187")); } _res = NULL; done: @@ -42335,9 +45986,9 @@ _gather_166_rule(Parser *p) return _res; } -// _tmp_168: ',' kwargs +// _tmp_188: ',' kwargs static void * -_tmp_168_rule(Parser *p) +_tmp_188_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42354,7 +46005,7 @@ _tmp_168_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_168[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -42363,7 +46014,7 @@ _tmp_168_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_188[%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; @@ -42373,7 +46024,7 @@ _tmp_168_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_168[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_188[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' kwargs")); } _res = NULL; @@ -42382,9 +46033,9 @@ _tmp_168_rule(Parser *p) return _res; } -// _loop0_170: ',' kwarg_or_starred +// _loop0_190: ',' kwarg_or_starred static asdl_seq * -_loop0_170_rule(Parser *p) +_loop0_190_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42410,7 +46061,7 @@ _loop0_170_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_170[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -42442,7 +46093,7 @@ _loop0_170_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_170[%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, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42459,9 +46110,9 @@ _loop0_170_rule(Parser *p) return _seq; } -// _gather_169: kwarg_or_starred _loop0_170 +// _gather_189: kwarg_or_starred _loop0_190 static asdl_seq * -_gather_169_rule(Parser *p) +_gather_189_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42473,27 +46124,27 @@ _gather_169_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_170 + { // kwarg_or_starred _loop0_190 if (p->error_indicator) { p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _gather_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_190")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_170_rule(p)) // _loop0_170 + (seq = _loop0_190_rule(p)) // _loop0_190 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_190")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + 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, "kwarg_or_starred _loop0_190")); } _res = NULL; done: @@ -42501,9 +46152,9 @@ _gather_169_rule(Parser *p) return _res; } -// _loop0_172: ',' kwarg_or_double_starred +// _loop0_192: ',' kwarg_or_double_starred static asdl_seq * -_loop0_172_rule(Parser *p) +_loop0_192_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42529,7 +46180,7 @@ _loop0_172_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_172[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -42561,7 +46212,7 @@ _loop0_172_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_172[%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, "',' kwarg_or_double_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42578,9 +46229,9 @@ _loop0_172_rule(Parser *p) return _seq; } -// _gather_171: kwarg_or_double_starred _loop0_172 +// _gather_191: kwarg_or_double_starred _loop0_192 static asdl_seq * -_gather_171_rule(Parser *p) +_gather_191_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42592,27 +46243,27 @@ _gather_171_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_172 + { // kwarg_or_double_starred _loop0_192 if (p->error_indicator) { p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _gather_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_192")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_172_rule(p)) // _loop0_172 + (seq = _loop0_192_rule(p)) // _loop0_192 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_192")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + 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, "kwarg_or_double_starred _loop0_192")); } _res = NULL; done: @@ -42620,9 +46271,9 @@ _gather_171_rule(Parser *p) return _res; } -// _loop0_174: ',' kwarg_or_starred +// _loop0_194: ',' kwarg_or_starred static asdl_seq * -_loop0_174_rule(Parser *p) +_loop0_194_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42648,7 +46299,7 @@ _loop0_174_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_174[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_194[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -42680,7 +46331,7 @@ _loop0_174_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_174[%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, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -42697,9 +46348,9 @@ _loop0_174_rule(Parser *p) return _seq; } -// _gather_173: kwarg_or_starred _loop0_174 +// _gather_193: kwarg_or_starred _loop0_194 static asdl_seq * -_gather_173_rule(Parser *p) +_gather_193_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42711,27 +46362,27 @@ _gather_173_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_174 + { // kwarg_or_starred _loop0_194 if (p->error_indicator) { p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _gather_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_194")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_174_rule(p)) // _loop0_174 + (seq = _loop0_194_rule(p)) // _loop0_194 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_193[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_starred _loop0_194")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + 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, "kwarg_or_starred _loop0_194")); } _res = NULL; done: @@ -42739,9 +46390,9 @@ _gather_173_rule(Parser *p) return _res; } -// _loop0_176: ',' kwarg_or_double_starred +// _loop0_196: ',' kwarg_or_double_starred static asdl_seq * -_loop0_176_rule(Parser *p) +_loop0_196_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42767,7 +46418,7 @@ _loop0_176_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_176[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_196[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -42799,7 +46450,7 @@ _loop0_176_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_176[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_196[%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); @@ -42816,9 +46467,9 @@ _loop0_176_rule(Parser *p) return _seq; } -// _gather_175: kwarg_or_double_starred _loop0_176 +// _gather_195: kwarg_or_double_starred _loop0_196 static asdl_seq * -_gather_175_rule(Parser *p) +_gather_195_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42830,27 +46481,27 @@ _gather_175_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_176 + { // kwarg_or_double_starred _loop0_196 if (p->error_indicator) { p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _gather_195[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_196")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_176_rule(p)) // _loop0_176 + (seq = _loop0_196_rule(p)) // _loop0_196 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_195[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_196")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_195[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "kwarg_or_double_starred _loop0_196")); } _res = NULL; done: @@ -42858,9 +46509,9 @@ _gather_175_rule(Parser *p) return _res; } -// _tmp_177: simple_slice | expression +// _tmp_197: simple_slice | expression static void * -_tmp_177_rule(Parser *p) +_tmp_197_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42877,18 +46528,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_197[%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_197[%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_197[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // expression @@ -42896,18 +46547,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_197[%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_197[%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_197[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression")); } _res = NULL; @@ -42916,9 +46567,9 @@ _tmp_177_rule(Parser *p) return _res; } -// _tmp_178: simple_slice | expression +// _tmp_198: simple_slice | expression static void * -_tmp_178_rule(Parser *p) +_tmp_198_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -42935,18 +46586,18 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_198[%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_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_198[%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_178[%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, "simple_slice")); } { // expression @@ -42954,18 +46605,18 @@ _tmp_178_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_178[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c> _tmp_198[%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_178[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression")); + D(fprintf(stderr, "%*c+ _tmp_198[%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_178[%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, "expression")); } _res = NULL; @@ -42974,9 +46625,9 @@ _tmp_178_rule(Parser *p) return _res; } -// _loop0_179: (',' star_target) +// _loop0_199: (',' star_target) static asdl_seq * -_loop0_179_rule(Parser *p) +_loop0_199_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43002,13 +46653,13 @@ _loop0_179_rule(Parser *p) p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop0_199[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); + void *_tmp_361_var; while ( - (_tmp_331_var = _tmp_331_rule(p)) // ',' star_target + (_tmp_361_var = _tmp_361_rule(p)) // ',' star_target ) { - _res = _tmp_331_var; + _res = _tmp_361_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -43025,7 +46676,7 @@ _loop0_179_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_179[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_199[%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); @@ -43042,9 +46693,9 @@ _loop0_179_rule(Parser *p) return _seq; } -// _loop0_181: ',' star_target +// _loop0_201: ',' star_target static asdl_seq * -_loop0_181_rule(Parser *p) +_loop0_201_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43070,7 +46721,7 @@ _loop0_181_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_181[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_201[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -43102,7 +46753,7 @@ _loop0_181_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_181[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_201[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43119,9 +46770,9 @@ _loop0_181_rule(Parser *p) return _seq; } -// _gather_180: star_target _loop0_181 +// _gather_200: star_target _loop0_201 static asdl_seq * -_gather_180_rule(Parser *p) +_gather_200_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43133,27 +46784,27 @@ _gather_180_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_181 + { // star_target _loop0_201 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_180[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_181")); + D(fprintf(stderr, "%*c> _gather_200[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_201")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_181_rule(p)) // _loop0_181 + (seq = _loop0_201_rule(p)) // _loop0_201 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_200[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_target _loop0_201")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_200[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_target _loop0_201")); } _res = NULL; done: @@ -43161,9 +46812,9 @@ _gather_180_rule(Parser *p) return _res; } -// _loop1_182: (',' star_target) +// _loop1_202: (',' star_target) static asdl_seq * -_loop1_182_rule(Parser *p) +_loop1_202_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43189,13 +46840,13 @@ _loop1_182_rule(Parser *p) p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop1_202[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(',' star_target)")); + void *_tmp_362_var; while ( - (_tmp_332_var = _tmp_332_rule(p)) // ',' star_target + (_tmp_362_var = _tmp_362_rule(p)) // ',' star_target ) { - _res = _tmp_332_var; + _res = _tmp_362_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -43212,7 +46863,7 @@ _loop1_182_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_182[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_202[%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) { @@ -43234,9 +46885,9 @@ _loop1_182_rule(Parser *p) return _seq; } -// _tmp_183: !'*' star_target +// _tmp_203: !'*' star_target static void * -_tmp_183_rule(Parser *p) +_tmp_203_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43253,7 +46904,7 @@ _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, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_203[%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='*' @@ -43261,12 +46912,12 @@ _tmp_183_rule(Parser *p) (star_target_var = star_target_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_203[%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_183[%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, "!'*' star_target")); } _res = NULL; @@ -43275,9 +46926,9 @@ _tmp_183_rule(Parser *p) return _res; } -// _tmp_184: genexp | tuplecomp +// _tmp_204: genexp | tuplecomp static void * -_tmp_184_rule(Parser *p) +_tmp_204_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43294,18 +46945,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); expr_ty genexp_var; if ( (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_204[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_184[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_204[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "genexp")); } { // tuplecomp @@ -43313,18 +46964,18 @@ _tmp_184_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_184[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c> _tmp_204[%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_184[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuplecomp")); + D(fprintf(stderr, "%*c+ _tmp_204[%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_184[%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, "tuplecomp")); } _res = NULL; @@ -43333,9 +46984,9 @@ _tmp_184_rule(Parser *p) return _res; } -// _loop0_186: ',' del_target +// _loop0_206: ',' del_target static asdl_seq * -_loop0_186_rule(Parser *p) +_loop0_206_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43361,7 +47012,7 @@ _loop0_186_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_186[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_206[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -43393,7 +47044,7 @@ _loop0_186_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_186[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_206[%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); @@ -43410,9 +47061,9 @@ _loop0_186_rule(Parser *p) return _seq; } -// _gather_185: del_target _loop0_186 +// _gather_205: del_target _loop0_206 static asdl_seq * -_gather_185_rule(Parser *p) +_gather_205_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43424,27 +47075,27 @@ _gather_185_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_186 + { // del_target _loop0_206 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_185[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_186")); + D(fprintf(stderr, "%*c> _gather_205[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_206")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_186_rule(p)) // _loop0_186 + (seq = _loop0_206_rule(p)) // _loop0_206 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "del_target _loop0_206")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "del_target _loop0_206")); } _res = NULL; done: @@ -43452,9 +47103,9 @@ _gather_185_rule(Parser *p) return _res; } -// _loop0_188: ',' expression +// _loop0_208: ',' expression static asdl_seq * -_loop0_188_rule(Parser *p) +_loop0_208_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43480,7 +47131,7 @@ _loop0_188_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_188[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_208[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -43512,7 +47163,7 @@ _loop0_188_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_188[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_208[%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); @@ -43529,9 +47180,9 @@ _loop0_188_rule(Parser *p) return _seq; } -// _gather_187: expression _loop0_188 +// _gather_207: expression _loop0_208 static asdl_seq * -_gather_187_rule(Parser *p) +_gather_207_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43543,27 +47194,27 @@ _gather_187_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_188 + { // expression _loop0_208 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_187[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_188")); + D(fprintf(stderr, "%*c> _gather_207[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_208")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_188_rule(p)) // _loop0_188 + (seq = _loop0_208_rule(p)) // _loop0_208 ) { - D(fprintf(stderr, "%*c+ _gather_187[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_188")); + D(fprintf(stderr, "%*c+ _gather_207[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_208")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_207[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_208")); } _res = NULL; done: @@ -43571,9 +47222,9 @@ _gather_187_rule(Parser *p) return _res; } -// _loop0_190: ',' expression +// _loop0_210: ',' expression static asdl_seq * -_loop0_190_rule(Parser *p) +_loop0_210_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43599,7 +47250,7 @@ _loop0_190_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_190[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_210[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -43631,7 +47282,7 @@ _loop0_190_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_190[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_210[%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); @@ -43648,9 +47299,9 @@ _loop0_190_rule(Parser *p) return _seq; } -// _gather_189: expression _loop0_190 +// _gather_209: expression _loop0_210 static asdl_seq * -_gather_189_rule(Parser *p) +_gather_209_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43662,27 +47313,27 @@ _gather_189_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_190 + { // expression _loop0_210 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_189[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_190")); + D(fprintf(stderr, "%*c> _gather_209[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_210")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_190_rule(p)) // _loop0_190 + (seq = _loop0_210_rule(p)) // _loop0_210 ) { - D(fprintf(stderr, "%*c+ _gather_189[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_190")); + D(fprintf(stderr, "%*c+ _gather_209[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_210")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_209[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_210")); } _res = NULL; done: @@ -43690,9 +47341,9 @@ _gather_189_rule(Parser *p) return _res; } -// _loop0_192: ',' expression +// _loop0_212: ',' expression static asdl_seq * -_loop0_192_rule(Parser *p) +_loop0_212_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43718,7 +47369,7 @@ _loop0_192_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_192[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_212[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -43750,7 +47401,7 @@ _loop0_192_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_192[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_212[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -43767,9 +47418,9 @@ _loop0_192_rule(Parser *p) return _seq; } -// _gather_191: expression _loop0_192 +// _gather_211: expression _loop0_212 static asdl_seq * -_gather_191_rule(Parser *p) +_gather_211_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43781,27 +47432,27 @@ _gather_191_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_192 + { // expression _loop0_212 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_191[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_192")); + D(fprintf(stderr, "%*c> _gather_211[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_212")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_192_rule(p)) // _loop0_192 + (seq = _loop0_212_rule(p)) // _loop0_212 ) { - D(fprintf(stderr, "%*c+ _gather_191[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_192")); + D(fprintf(stderr, "%*c+ _gather_211[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_212")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_212")); } _res = NULL; done: @@ -43809,9 +47460,9 @@ _gather_191_rule(Parser *p) return _res; } -// _loop0_194: ',' expression +// _loop0_214: ',' expression static asdl_seq * -_loop0_194_rule(Parser *p) +_loop0_214_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43837,7 +47488,7 @@ _loop0_194_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_194[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -43869,7 +47520,7 @@ _loop0_194_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_194[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_214[%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); @@ -43886,9 +47537,9 @@ _loop0_194_rule(Parser *p) return _seq; } -// _gather_193: expression _loop0_194 +// _gather_213: expression _loop0_214 static asdl_seq * -_gather_193_rule(Parser *p) +_gather_213_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43900,27 +47551,27 @@ _gather_193_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_194 + { // expression _loop0_214 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_193[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_194")); + D(fprintf(stderr, "%*c> _gather_213[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_214")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_194_rule(p)) // _loop0_194 + (seq = _loop0_214_rule(p)) // _loop0_214 ) { - D(fprintf(stderr, "%*c+ _gather_193[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_194")); + D(fprintf(stderr, "%*c+ _gather_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression _loop0_214")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_213[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression _loop0_214")); } _res = NULL; done: @@ -43928,9 +47579,9 @@ _gather_193_rule(Parser *p) return _res; } -// _tmp_195: NEWLINE INDENT +// _tmp_215: NEWLINE INDENT static void * -_tmp_195_rule(Parser *p) +_tmp_215_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43947,7 +47598,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, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_215[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -43956,12 +47607,12 @@ _tmp_195_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_195[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_215[%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_195[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_215[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NEWLINE INDENT")); } _res = NULL; @@ -43970,9 +47621,9 @@ _tmp_195_rule(Parser *p) return _res; } -// _tmp_196: args | expression for_if_clauses +// _tmp_216: args | expression for_if_clauses static void * -_tmp_196_rule(Parser *p) +_tmp_216_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -43989,18 +47640,18 @@ _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_216[%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_196[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args")); + D(fprintf(stderr, "%*c+ _tmp_216[%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_196[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_216[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "args")); } { // expression for_if_clauses @@ -44008,7 +47659,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, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_216[%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 ( @@ -44017,12 +47668,12 @@ _tmp_196_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_216[%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_196[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_216[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression for_if_clauses")); } _res = NULL; @@ -44031,9 +47682,9 @@ _tmp_196_rule(Parser *p) return _res; } -// _tmp_197: args ',' +// _tmp_217: args ',' static void * -_tmp_197_rule(Parser *p) +_tmp_217_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44050,7 +47701,7 @@ _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, "args ','")); + D(fprintf(stderr, "%*c> _tmp_217[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -44059,12 +47710,12 @@ _tmp_197_rule(Parser *p) (_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, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_217[%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_197[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_217[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "args ','")); } _res = NULL; @@ -44073,9 +47724,9 @@ _tmp_197_rule(Parser *p) return _res; } -// _tmp_198: ',' | ')' +// _tmp_218: ',' | ')' static void * -_tmp_198_rule(Parser *p) +_tmp_218_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44092,18 +47743,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, "','")); + D(fprintf(stderr, "%*c> _tmp_218[%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_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_218[%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_198[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_218[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // ')' @@ -44111,18 +47762,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, "')'")); + D(fprintf(stderr, "%*c> _tmp_218[%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_198[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_218[%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_198[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_218[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } _res = NULL; @@ -44131,9 +47782,9 @@ _tmp_198_rule(Parser *p) return _res; } -// _tmp_199: 'True' | 'False' | 'None' +// _tmp_219: 'True' | 'False' | 'None' static void * -_tmp_199_rule(Parser *p) +_tmp_219_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44150,18 +47801,18 @@ _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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_219[%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' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_199[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_219[%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_199[%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, "'True'")); } { // 'False' @@ -44169,18 +47820,18 @@ _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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_219[%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' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_199[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_219[%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_199[%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, "'False'")); } { // 'None' @@ -44188,18 +47839,18 @@ _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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_219[%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' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_199[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_219[%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_199[%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, "'None'")); } _res = NULL; @@ -44208,9 +47859,9 @@ _tmp_199_rule(Parser *p) return _res; } -// _tmp_200: NAME '=' +// _tmp_220: NAME '=' static void * -_tmp_200_rule(Parser *p) +_tmp_220_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44227,7 +47878,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 '='")); + D(fprintf(stderr, "%*c> _tmp_220[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -44236,12 +47887,12 @@ _tmp_200_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_200[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_220[%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_200[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_220[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "NAME '='")); } _res = NULL; @@ -44250,9 +47901,9 @@ _tmp_200_rule(Parser *p) return _res; } -// _tmp_201: NAME STRING | SOFT_KEYWORD +// _tmp_221: NAME STRING | SOFT_KEYWORD static void * -_tmp_201_rule(Parser *p) +_tmp_221_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44269,7 +47920,7 @@ _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, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_221[%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 ( @@ -44278,12 +47929,12 @@ _tmp_201_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_201[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_221[%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_201[%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, "NAME STRING")); } { // SOFT_KEYWORD @@ -44291,18 +47942,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, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_221[%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_201[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_221[%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_201[%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, "SOFT_KEYWORD")); } _res = NULL; @@ -44311,9 +47962,9 @@ _tmp_201_rule(Parser *p) return _res; } -// _tmp_202: 'else' | ':' +// _tmp_222: 'else' | ':' static void * -_tmp_202_rule(Parser *p) +_tmp_222_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44330,18 +47981,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, "'else'")); + D(fprintf(stderr, "%*c> _tmp_222[%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' + (_keyword = _PyPegen_expect_token(p, 756)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_202[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_222[%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_202[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_222[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'else'")); } { // ':' @@ -44349,18 +48000,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_222[%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_202[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_222[%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_202[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_222[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } _res = NULL; @@ -44369,9 +48020,9 @@ _tmp_202_rule(Parser *p) return _res; } -// _tmp_203: FSTRING_MIDDLE | fstring_replacement_field +// _tmp_223: FSTRING_MIDDLE | fstring_replacement_field static void * -_tmp_203_rule(Parser *p) +_tmp_223_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44388,18 +48039,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, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c> _tmp_223[%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_203[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); + D(fprintf(stderr, "%*c+ _tmp_223[%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_203[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_223[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "FSTRING_MIDDLE")); } { // fstring_replacement_field @@ -44407,18 +48058,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, "fstring_replacement_field")); + D(fprintf(stderr, "%*c> _tmp_223[%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_203[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); + D(fprintf(stderr, "%*c+ _tmp_223[%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_203[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_223[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring_replacement_field")); } _res = NULL; @@ -44427,9 +48078,9 @@ _tmp_203_rule(Parser *p) return _res; } -// _tmp_204: '=' | ':=' +// _tmp_224: '=' | ':=' static void * -_tmp_204_rule(Parser *p) +_tmp_224_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44446,18 +48097,18 @@ _tmp_204_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c> _tmp_224[%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_204[%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_204[%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, "'='")); } { // ':=' @@ -44465,18 +48116,18 @@ _tmp_204_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_204[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':='")); + D(fprintf(stderr, "%*c> _tmp_224[%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_204[%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_204[%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; @@ -44485,9 +48136,9 @@ _tmp_204_rule(Parser *p) return _res; } -// _tmp_205: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_225: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_205_rule(Parser *p) +_tmp_225_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44504,18 +48155,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, "list")); + D(fprintf(stderr, "%*c> _tmp_225[%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_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "list")); + D(fprintf(stderr, "%*c+ _tmp_225[%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_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + 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, "list")); } { // tuple @@ -44523,18 +48174,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, "tuple")); + D(fprintf(stderr, "%*c> _tmp_225[%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_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_225[%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_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + 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, "tuple")); } { // genexp @@ -44542,18 +48193,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, "genexp")); + D(fprintf(stderr, "%*c> _tmp_225[%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_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_225[%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_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + 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, "genexp")); } { // 'True' @@ -44561,18 +48212,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, "'True'")); + D(fprintf(stderr, "%*c> _tmp_225[%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' + (_keyword = _PyPegen_expect_token(p, 695)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_225[%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_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + 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, "'True'")); } { // 'None' @@ -44580,18 +48231,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, "'None'")); + D(fprintf(stderr, "%*c> _tmp_225[%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' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_225[%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_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + 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, "'None'")); } { // 'False' @@ -44599,18 +48250,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, "'False'")); + D(fprintf(stderr, "%*c> _tmp_225[%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' + (_keyword = _PyPegen_expect_token(p, 697)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_205[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_225[%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_205[%d-%d L%d]: %s failed!\n", p->level, ' ', + 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, "'False'")); } _res = NULL; @@ -44619,9 +48270,9 @@ _tmp_205_rule(Parser *p) return _res; } -// _tmp_206: '=' | ':=' +// _tmp_226: '=' | ':=' static void * -_tmp_206_rule(Parser *p) +_tmp_226_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44638,18 +48289,18 @@ _tmp_206_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_206[%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, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_206[%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_206[%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, "'='")); } { // ':=' @@ -44657,18 +48308,18 @@ _tmp_206_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_206[%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, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_206[%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_206[%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; @@ -44677,9 +48328,9 @@ _tmp_206_rule(Parser *p) return _res; } -// _loop0_207: star_named_expressions +// _loop0_227: star_named_expressions static asdl_seq * -_loop0_207_rule(Parser *p) +_loop0_227_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44705,7 +48356,7 @@ _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_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_227[%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 @@ -44728,7 +48379,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_227[%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); @@ -44745,9 +48396,9 @@ _loop0_207_rule(Parser *p) return _seq; } -// _loop0_208: (star_targets '=') +// _loop0_228: (star_targets '=') static asdl_seq * -_loop0_208_rule(Parser *p) +_loop0_228_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44773,13 +48424,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_333_var; + D(fprintf(stderr, "%*c> _loop0_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_363_var; while ( - (_tmp_333_var = _tmp_333_rule(p)) // star_targets '=' + (_tmp_363_var = _tmp_363_rule(p)) // star_targets '=' ) { - _res = _tmp_333_var; + _res = _tmp_363_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -44796,7 +48447,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_228[%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); @@ -44813,9 +48464,9 @@ _loop0_208_rule(Parser *p) return _seq; } -// _loop0_209: (star_targets '=') +// _loop0_229: (star_targets '=') static asdl_seq * -_loop0_209_rule(Parser *p) +_loop0_229_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44841,13 +48492,13 @@ _loop0_209_rule(Parser *p) p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop0_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(star_targets '=')")); + void *_tmp_364_var; while ( - (_tmp_334_var = _tmp_334_rule(p)) // star_targets '=' + (_tmp_364_var = _tmp_364_rule(p)) // star_targets '=' ) { - _res = _tmp_334_var; + _res = _tmp_364_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -44864,7 +48515,7 @@ _loop0_209_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_209[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_229[%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); @@ -44881,9 +48532,9 @@ _loop0_209_rule(Parser *p) return _seq; } -// _tmp_210: yield_expr | star_expressions +// _tmp_230: yield_expr | star_expressions static void * -_tmp_210_rule(Parser *p) +_tmp_230_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44900,18 +48551,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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_230[%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_210[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_230[%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_210[%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, "yield_expr")); } { // star_expressions @@ -44919,18 +48570,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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_230[%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_210[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_230[%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_210[%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, "star_expressions")); } _res = NULL; @@ -44939,9 +48590,9 @@ _tmp_210_rule(Parser *p) return _res; } -// _tmp_211: '[' | '(' | '{' +// _tmp_231: '[' | '(' | '{' static void * -_tmp_211_rule(Parser *p) +_tmp_231_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -44958,18 +48609,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_231[%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_231[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_231[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'['")); } { // '(' @@ -44977,18 +48628,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_231[%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_211[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); + D(fprintf(stderr, "%*c+ _tmp_231[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_231[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'('")); } { // '{' @@ -44996,18 +48647,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_231[%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_231[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_211[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_231[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -45016,9 +48667,9 @@ _tmp_211_rule(Parser *p) return _res; } -// _tmp_212: '[' | '{' +// _tmp_232: '[' | '{' static void * -_tmp_212_rule(Parser *p) +_tmp_232_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45035,18 +48686,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_232[%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_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_212[%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, "'['")); } { // '{' @@ -45054,18 +48705,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_232[%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_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_212[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_232[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -45074,9 +48725,9 @@ _tmp_212_rule(Parser *p) return _res; } -// _tmp_213: '[' | '{' +// _tmp_233: '[' | '{' static void * -_tmp_213_rule(Parser *p) +_tmp_233_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45093,18 +48744,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, "'['")); + D(fprintf(stderr, "%*c> _tmp_233[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); + D(fprintf(stderr, "%*c+ _tmp_233[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_213[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_233[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'['")); } { // '{' @@ -45112,18 +48763,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, "'{'")); + D(fprintf(stderr, "%*c> _tmp_233[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_213[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_233[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_213[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_233[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'{'")); } _res = NULL; @@ -45132,9 +48783,9 @@ _tmp_213_rule(Parser *p) return _res; } -// _tmp_214: slash_no_default | slash_with_default +// _tmp_234: slash_no_default | slash_with_default static void * -_tmp_214_rule(Parser *p) +_tmp_234_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45151,18 +48802,18 @@ _tmp_214_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_234[%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_214[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_234[%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_214[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_234[%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 @@ -45170,18 +48821,18 @@ _tmp_214_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_214[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_234[%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_214[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_234[%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_214[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_234[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_with_default")); } _res = NULL; @@ -45190,9 +48841,9 @@ _tmp_214_rule(Parser *p) return _res; } -// _loop0_215: param_maybe_default +// _loop0_235: param_maybe_default static asdl_seq * -_loop0_215_rule(Parser *p) +_loop0_235_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45218,7 +48869,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_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_235[%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 @@ -45241,7 +48892,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_235[%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); @@ -45258,9 +48909,9 @@ _loop0_215_rule(Parser *p) return _seq; } -// _loop0_216: param_no_default +// _loop0_236: param_no_default static asdl_seq * -_loop0_216_rule(Parser *p) +_loop0_236_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45286,7 +48937,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_236[%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 @@ -45309,7 +48960,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_236[%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); @@ -45326,9 +48977,9 @@ _loop0_216_rule(Parser *p) return _seq; } -// _loop0_217: param_no_default +// _loop0_237: param_no_default static asdl_seq * -_loop0_217_rule(Parser *p) +_loop0_237_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45354,7 +49005,7 @@ _loop0_217_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_217[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop0_237[%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 @@ -45377,7 +49028,7 @@ _loop0_217_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_217[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_237[%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); @@ -45394,9 +49045,9 @@ _loop0_217_rule(Parser *p) return _seq; } -// _loop1_218: param_no_default +// _loop1_238: param_no_default static asdl_seq * -_loop1_218_rule(Parser *p) +_loop1_238_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45422,7 +49073,7 @@ _loop1_218_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_218[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _loop1_238[%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 @@ -45445,7 +49096,7 @@ _loop1_218_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_218[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_238[%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) { @@ -45467,9 +49118,9 @@ _loop1_218_rule(Parser *p) return _seq; } -// _tmp_219: slash_no_default | slash_with_default +// _tmp_239: slash_no_default | slash_with_default static void * -_tmp_219_rule(Parser *p) +_tmp_239_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45486,18 +49137,18 @@ _tmp_219_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_219[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_239[%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_219[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_239[%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_219[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_239[%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 @@ -45505,18 +49156,18 @@ _tmp_219_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_219[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_239[%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_219[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_239[%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_219[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_239[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slash_with_default")); } _res = NULL; @@ -45525,9 +49176,9 @@ _tmp_219_rule(Parser *p) return _res; } -// _loop0_220: param_maybe_default +// _loop0_240: param_maybe_default static asdl_seq * -_loop0_220_rule(Parser *p) +_loop0_240_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45553,7 +49204,7 @@ _loop0_220_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_220[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_240[%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 @@ -45576,7 +49227,7 @@ _loop0_220_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_220[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_240[%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); @@ -45593,9 +49244,9 @@ _loop0_220_rule(Parser *p) return _seq; } -// _tmp_221: ',' | param_no_default +// _tmp_241: ',' | param_no_default static void * -_tmp_221_rule(Parser *p) +_tmp_241_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45612,18 +49263,18 @@ _tmp_221_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_221[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_241[%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_221[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_241[%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_221[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_241[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // param_no_default @@ -45631,18 +49282,18 @@ _tmp_221_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_221[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_241[%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_221[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_241[%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_221[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_241[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } _res = NULL; @@ -45651,9 +49302,9 @@ _tmp_221_rule(Parser *p) return _res; } -// _loop0_222: param_maybe_default +// _loop0_242: param_maybe_default static asdl_seq * -_loop0_222_rule(Parser *p) +_loop0_242_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45679,7 +49330,7 @@ _loop0_222_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_222[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_242[%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 @@ -45702,7 +49353,7 @@ _loop0_222_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_222[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_242[%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); @@ -45719,9 +49370,9 @@ _loop0_222_rule(Parser *p) return _seq; } -// _loop1_223: param_maybe_default +// _loop1_243: param_maybe_default static asdl_seq * -_loop1_223_rule(Parser *p) +_loop1_243_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45747,7 +49398,7 @@ _loop1_223_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_223[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_243[%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 @@ -45770,7 +49421,7 @@ _loop1_223_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_223[%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, "param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -45792,9 +49443,9 @@ _loop1_223_rule(Parser *p) return _seq; } -// _tmp_224: ')' | ',' +// _tmp_244: ')' | ',' static void * -_tmp_224_rule(Parser *p) +_tmp_244_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45811,18 +49462,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_244[%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_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_224[%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, "')'")); } { // ',' @@ -45830,18 +49481,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_244[%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_224[%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_224[%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; @@ -45850,9 +49501,9 @@ _tmp_224_rule(Parser *p) return _res; } -// _tmp_225: '|' | ',' +// _tmp_245: '|' | ',' static void * -_tmp_225_rule(Parser *p) +_tmp_245_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45869,18 +49520,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_245[%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, "'|'")); + 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_225[%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, "'|'")); } { // ',' @@ -45888,18 +49539,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_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_225[%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_225[%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; @@ -45908,9 +49559,9 @@ _tmp_225_rule(Parser *p) return _res; } -// _tmp_226: ')' | ',' (')' | '**') +// _tmp_246: ')' | ',' (')' | '**') static void * -_tmp_226_rule(Parser *p) +_tmp_246_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45927,18 +49578,18 @@ _tmp_226_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c> _tmp_246[%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_226[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_246[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_246[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // ',' (')' | '**') @@ -45946,21 +49597,21 @@ _tmp_226_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_226[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_246[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); Token * _literal; - void *_tmp_335_var; + void *_tmp_365_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_335_var = _tmp_335_rule(p)) // ')' | '**' + (_tmp_365_var = _tmp_365_rule(p)) // ')' | '**' ) { - 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); + D(fprintf(stderr, "%*c+ _tmp_246[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_365_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_226[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_246[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (')' | '**')")); } _res = NULL; @@ -45969,9 +49620,9 @@ _tmp_226_rule(Parser *p) return _res; } -// _tmp_227: param_no_default | ',' +// _tmp_247: param_no_default | ',' static void * -_tmp_227_rule(Parser *p) +_tmp_247_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -45988,18 +49639,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_247[%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_247[%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_247[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_no_default")); } { // ',' @@ -46007,18 +49658,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_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_227[%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_227[%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; @@ -46027,9 +49678,9 @@ _tmp_227_rule(Parser *p) return _res; } -// _loop0_228: param_maybe_default +// _loop0_248: param_maybe_default static asdl_seq * -_loop0_228_rule(Parser *p) +_loop0_248_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46055,7 +49706,7 @@ _loop0_228_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_228[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_248[%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 @@ -46078,7 +49729,7 @@ _loop0_228_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_228[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_248[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46095,9 +49746,9 @@ _loop0_228_rule(Parser *p) return _seq; } -// _tmp_229: param_no_default | ',' +// _tmp_249: param_no_default | ',' static void * -_tmp_229_rule(Parser *p) +_tmp_249_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46114,18 +49765,18 @@ _tmp_229_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_249[%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_229[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_249[%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_229[%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, "param_no_default")); } { // ',' @@ -46133,18 +49784,18 @@ _tmp_229_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_229[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_249[%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_229[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_249[%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_229[%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, "','")); } _res = NULL; @@ -46153,9 +49804,9 @@ _tmp_229_rule(Parser *p) return _res; } -// _tmp_230: '*' | '**' | '/' +// _tmp_250: '*' | '**' | '/' static void * -_tmp_230_rule(Parser *p) +_tmp_250_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46172,18 +49823,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, "'*'")); + D(fprintf(stderr, "%*c> _tmp_250[%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_230[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_250[%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_230[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_250[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*'")); } { // '**' @@ -46191,18 +49842,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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_250[%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_230[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_250[%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_230[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_250[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } { // '/' @@ -46210,18 +49861,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, "'/'")); + D(fprintf(stderr, "%*c> _tmp_250[%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_230[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_250[%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_230[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_250[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'/'")); } _res = NULL; @@ -46230,9 +49881,9 @@ _tmp_230_rule(Parser *p) return _res; } -// _loop1_231: param_with_default +// _loop1_251: param_with_default static asdl_seq * -_loop1_231_rule(Parser *p) +_loop1_251_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46258,7 +49909,7 @@ _loop1_231_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_231[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "param_with_default")); + D(fprintf(stderr, "%*c> _loop1_251[%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 @@ -46281,7 +49932,7 @@ _loop1_231_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_231[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_251[%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) { @@ -46303,9 +49954,9 @@ _loop1_231_rule(Parser *p) return _seq; } -// _tmp_232: lambda_slash_no_default | lambda_slash_with_default +// _tmp_252: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_232_rule(Parser *p) +_tmp_252_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46322,18 +49973,18 @@ _tmp_232_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_232[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_252[%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_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_252[%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_232[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_252[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -46341,18 +49992,18 @@ _tmp_232_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_232[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_252[%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_232[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_252[%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_232[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_252[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); } _res = NULL; @@ -46361,9 +50012,9 @@ _tmp_232_rule(Parser *p) return _res; } -// _loop0_233: lambda_param_maybe_default +// _loop0_253: lambda_param_maybe_default static asdl_seq * -_loop0_233_rule(Parser *p) +_loop0_253_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46389,7 +50040,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_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_253[%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 @@ -46412,7 +50063,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_253[%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); @@ -46429,9 +50080,9 @@ _loop0_233_rule(Parser *p) return _seq; } -// _loop0_234: lambda_param_no_default +// _loop0_254: lambda_param_no_default static asdl_seq * -_loop0_234_rule(Parser *p) +_loop0_254_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46457,7 +50108,7 @@ _loop0_234_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_234[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_254[%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 @@ -46480,7 +50131,7 @@ _loop0_234_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_234[%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_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46497,9 +50148,9 @@ _loop0_234_rule(Parser *p) return _seq; } -// _loop0_235: lambda_param_no_default +// _loop0_255: lambda_param_no_default static asdl_seq * -_loop0_235_rule(Parser *p) +_loop0_255_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46525,7 +50176,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_no_default")); + D(fprintf(stderr, "%*c> _loop0_255[%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 @@ -46548,7 +50199,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_255[%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); @@ -46565,9 +50216,9 @@ _loop0_235_rule(Parser *p) return _seq; } -// _loop0_237: ',' lambda_param +// _loop0_257: ',' lambda_param static asdl_seq * -_loop0_237_rule(Parser *p) +_loop0_257_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46593,7 +50244,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")); + D(fprintf(stderr, "%*c> _loop0_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -46625,7 +50276,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_257[%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); @@ -46642,9 +50293,9 @@ _loop0_237_rule(Parser *p) return _seq; } -// _gather_236: lambda_param _loop0_237 +// _gather_256: lambda_param _loop0_257 static asdl_seq * -_gather_236_rule(Parser *p) +_gather_256_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46656,27 +50307,27 @@ _gather_236_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_237 + { // lambda_param _loop0_257 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_236[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_237")); + D(fprintf(stderr, "%*c> _gather_256[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_257")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_237_rule(p)) // _loop0_237 + (seq = _loop0_257_rule(p)) // _loop0_257 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_256[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_257")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_236[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_237")); + D(fprintf(stderr, "%*c%s _gather_256[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_257")); } _res = NULL; done: @@ -46684,9 +50335,9 @@ _gather_236_rule(Parser *p) return _res; } -// _tmp_238: lambda_slash_no_default | lambda_slash_with_default +// _tmp_258: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_238_rule(Parser *p) +_tmp_258_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46703,18 +50354,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_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_258[%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_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_258[%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_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_258[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -46722,18 +50373,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_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_258[%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_238[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_258[%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_238[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_258[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_slash_with_default")); } _res = NULL; @@ -46742,9 +50393,9 @@ _tmp_238_rule(Parser *p) return _res; } -// _loop0_239: lambda_param_maybe_default +// _loop0_259: lambda_param_maybe_default static asdl_seq * -_loop0_239_rule(Parser *p) +_loop0_259_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46770,7 +50421,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_259[%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 @@ -46793,7 +50444,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_259[%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); @@ -46810,9 +50461,9 @@ _loop0_239_rule(Parser *p) return _seq; } -// _tmp_240: ',' | lambda_param_no_default +// _tmp_260: ',' | lambda_param_no_default static void * -_tmp_240_rule(Parser *p) +_tmp_260_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46829,18 +50480,18 @@ _tmp_240_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_240[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_260[%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_240[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_260[%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_240[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_260[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // lambda_param_no_default @@ -46848,18 +50499,18 @@ _tmp_240_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_240[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_260[%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_240[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_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_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_240[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_260[%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; @@ -46868,9 +50519,9 @@ _tmp_240_rule(Parser *p) return _res; } -// _loop0_241: lambda_param_maybe_default +// _loop0_261: lambda_param_maybe_default static asdl_seq * -_loop0_241_rule(Parser *p) +_loop0_261_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46896,7 +50547,7 @@ _loop0_241_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_241[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_261[%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 @@ -46919,7 +50570,7 @@ _loop0_241_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_241[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_261[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -46936,9 +50587,9 @@ _loop0_241_rule(Parser *p) return _seq; } -// _loop1_242: lambda_param_maybe_default +// _loop1_262: lambda_param_maybe_default static asdl_seq * -_loop1_242_rule(Parser *p) +_loop1_262_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -46964,7 +50615,7 @@ _loop1_242_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_242[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_262[%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 @@ -46987,7 +50638,7 @@ _loop1_242_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_242[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_262[%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) { @@ -47009,9 +50660,9 @@ _loop1_242_rule(Parser *p) return _seq; } -// _loop1_243: lambda_param_with_default +// _loop1_263: lambda_param_with_default static asdl_seq * -_loop1_243_rule(Parser *p) +_loop1_263_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47037,7 +50688,7 @@ _loop1_243_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_243[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_263[%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 @@ -47060,7 +50711,7 @@ _loop1_243_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_243[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_263[%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) { @@ -47082,9 +50733,9 @@ _loop1_243_rule(Parser *p) return _seq; } -// _tmp_244: ':' | ',' (':' | '**') +// _tmp_264: ':' | ',' (':' | '**') static void * -_tmp_244_rule(Parser *p) +_tmp_264_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47101,18 +50752,18 @@ _tmp_244_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + 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, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_244[%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_244[%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, "':'")); } { // ',' (':' | '**') @@ -47120,21 +50771,21 @@ _tmp_244_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_244[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); + D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); Token * _literal; - void *_tmp_336_var; + void *_tmp_366_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_336_var = _tmp_336_rule(p)) // ':' | '**' + (_tmp_366_var = _tmp_366_rule(p)) // ':' | '**' ) { - 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); + D(fprintf(stderr, "%*c+ _tmp_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_366_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_244[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_264[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (':' | '**')")); } _res = NULL; @@ -47143,9 +50794,9 @@ _tmp_244_rule(Parser *p) return _res; } -// _tmp_245: lambda_param_no_default | ',' +// _tmp_265: lambda_param_no_default | ',' static void * -_tmp_245_rule(Parser *p) +_tmp_265_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47162,18 +50813,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_265[%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_265[%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_265[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } { // ',' @@ -47181,18 +50832,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_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_245[%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_245[%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; @@ -47201,9 +50852,9 @@ _tmp_245_rule(Parser *p) return _res; } -// _loop0_246: lambda_param_maybe_default +// _loop0_266: lambda_param_maybe_default static asdl_seq * -_loop0_246_rule(Parser *p) +_loop0_266_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47229,7 +50880,7 @@ _loop0_246_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_246[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_266[%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 @@ -47252,7 +50903,7 @@ _loop0_246_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_246[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_266[%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); @@ -47269,9 +50920,9 @@ _loop0_246_rule(Parser *p) return _seq; } -// _tmp_247: lambda_param_no_default | ',' +// _tmp_267: lambda_param_no_default | ',' static void * -_tmp_247_rule(Parser *p) +_tmp_267_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47288,18 +50939,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_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_267[%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_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_267[%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_247[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_267[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param_no_default")); } { // ',' @@ -47307,18 +50958,18 @@ _tmp_247_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_247[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_267[%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_247[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_267[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_247[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_267[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -47327,9 +50978,9 @@ _tmp_247_rule(Parser *p) return _res; } -// _tmp_248: '*' | '**' | '/' +// _tmp_268: '*' | '**' | '/' static void * -_tmp_248_rule(Parser *p) +_tmp_268_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47346,18 +50997,18 @@ _tmp_248_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_248[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_248[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'*'")); } { // '**' @@ -47365,18 +51016,18 @@ _tmp_248_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_248[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_248[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } { // '/' @@ -47384,18 +51035,18 @@ _tmp_248_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_248[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c> _tmp_268[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_248[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_268[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_248[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_268[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'/'")); } _res = NULL; @@ -47404,9 +51055,9 @@ _tmp_248_rule(Parser *p) return _res; } -// _tmp_249: lambda_sum_slash_no_default | lambda_sum_slash_with_default +// _tmp_269: lambda_sum_slash_no_default | lambda_sum_slash_with_default static void * -_tmp_249_rule(Parser *p) +_tmp_269_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47423,18 +51074,18 @@ _tmp_249_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_269[%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_249[%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_269[%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_249[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_269[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_no_default")); } { // lambda_sum_slash_with_default @@ -47442,18 +51093,18 @@ _tmp_249_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_249[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_269[%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_249[%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_269[%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_249[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_269[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_slash_with_default")); } _res = NULL; @@ -47462,9 +51113,9 @@ _tmp_249_rule(Parser *p) return _res; } -// _loop0_250: lambda_sum_param_maybe_default +// _loop0_270: lambda_sum_param_maybe_default static asdl_seq * -_loop0_250_rule(Parser *p) +_loop0_270_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47490,7 +51141,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_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_270[%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 @@ -47513,7 +51164,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_270[%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); @@ -47530,9 +51181,9 @@ _loop0_250_rule(Parser *p) return _seq; } -// _loop0_251: lambda_sum_param_no_default +// _loop0_271: lambda_sum_param_no_default static asdl_seq * -_loop0_251_rule(Parser *p) +_loop0_271_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47558,7 +51209,7 @@ _loop0_251_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _loop0_271[%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 @@ -47581,7 +51232,7 @@ _loop0_251_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_251[%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, "lambda_sum_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -47598,9 +51249,9 @@ _loop0_251_rule(Parser *p) return _seq; } -// _loop0_252: lambda_sum_param_no_default +// _loop0_272: lambda_sum_param_no_default static asdl_seq * -_loop0_252_rule(Parser *p) +_loop0_272_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47626,7 +51277,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_sum_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_272[%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 @@ -47649,7 +51300,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_272[%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); @@ -47666,9 +51317,9 @@ _loop0_252_rule(Parser *p) return _seq; } -// _loop0_254: ',' lambda_param +// _loop0_274: ',' lambda_param static asdl_seq * -_loop0_254_rule(Parser *p) +_loop0_274_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47694,7 +51345,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_param")); + D(fprintf(stderr, "%*c> _loop0_274[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -47726,7 +51377,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_274[%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); @@ -47743,9 +51394,9 @@ _loop0_254_rule(Parser *p) return _seq; } -// _gather_253: lambda_param _loop0_254 +// _gather_273: lambda_param _loop0_274 static asdl_seq * -_gather_253_rule(Parser *p) +_gather_273_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47757,27 +51408,27 @@ _gather_253_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_254 + { // lambda_param _loop0_274 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_253[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_254")); + D(fprintf(stderr, "%*c> _gather_273[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_274")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_254_rule(p)) // _loop0_254 + (seq = _loop0_274_rule(p)) // _loop0_274 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_273[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_param _loop0_274")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_273[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_param _loop0_274")); } _res = NULL; done: @@ -47785,9 +51436,9 @@ _gather_253_rule(Parser *p) return _res; } -// _tmp_255: lambda_sum_slash_no_default | lambda_sum_slash_with_default +// _tmp_275: lambda_sum_slash_no_default | lambda_sum_slash_with_default static void * -_tmp_255_rule(Parser *p) +_tmp_275_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47804,18 +51455,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_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_275[%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_255[%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_275[%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_255[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_275[%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 @@ -47823,18 +51474,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_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_275[%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_255[%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_275[%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_255[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_275[%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; @@ -47843,9 +51494,9 @@ _tmp_255_rule(Parser *p) return _res; } -// _loop0_256: lambda_sum_param_maybe_default +// _loop0_276: lambda_sum_param_maybe_default static asdl_seq * -_loop0_256_rule(Parser *p) +_loop0_276_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47871,7 +51522,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_276[%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 @@ -47894,7 +51545,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_276[%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); @@ -47911,9 +51562,9 @@ _loop0_256_rule(Parser *p) return _seq; } -// _tmp_257: ',' | lambda_sum_param_no_default +// _tmp_277: ',' | lambda_sum_param_no_default static void * -_tmp_257_rule(Parser *p) +_tmp_277_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47930,18 +51581,18 @@ _tmp_257_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_277[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_257[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_277[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_257[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_277[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } { // lambda_sum_param_no_default @@ -47949,18 +51600,18 @@ _tmp_257_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_257[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_277[%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_257[%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_277[%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_257[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_277[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } _res = NULL; @@ -47969,9 +51620,9 @@ _tmp_257_rule(Parser *p) return _res; } -// _loop0_258: lambda_sum_param_maybe_default +// _loop0_278: lambda_sum_param_maybe_default static asdl_seq * -_loop0_258_rule(Parser *p) +_loop0_278_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -47997,7 +51648,7 @@ _loop0_258_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _loop0_278[%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 @@ -48020,7 +51671,7 @@ _loop0_258_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_258[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_278[%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); @@ -48037,9 +51688,9 @@ _loop0_258_rule(Parser *p) return _seq; } -// _loop1_259: lambda_sum_param_maybe_default +// _loop1_279: lambda_sum_param_maybe_default static asdl_seq * -_loop1_259_rule(Parser *p) +_loop1_279_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48065,7 +51716,7 @@ _loop1_259_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _loop1_279[%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 @@ -48088,7 +51739,7 @@ _loop1_259_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_259[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_279[%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) { @@ -48110,9 +51761,9 @@ _loop1_259_rule(Parser *p) return _seq; } -// _loop1_260: lambda_sum_param_with_default +// _loop1_280: lambda_sum_param_with_default static asdl_seq * -_loop1_260_rule(Parser *p) +_loop1_280_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48138,7 +51789,7 @@ _loop1_260_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _loop1_280[%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 @@ -48161,7 +51812,7 @@ _loop1_260_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_260[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_280[%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) { @@ -48183,9 +51834,9 @@ _loop1_260_rule(Parser *p) return _seq; } -// _tmp_261: '|' | ',' ('|' | '**') +// _tmp_281: '|' | ',' ('|' | '**') static void * -_tmp_261_rule(Parser *p) +_tmp_281_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48202,18 +51853,18 @@ _tmp_261_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + D(fprintf(stderr, "%*c> _tmp_281[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 18)) // token='|' ) { - D(fprintf(stderr, "%*c+ _tmp_261[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + D(fprintf(stderr, "%*c+ _tmp_281[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_261[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_281[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|'")); } { // ',' ('|' | '**') @@ -48221,21 +51872,21 @@ _tmp_261_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_261[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); + D(fprintf(stderr, "%*c> _tmp_281[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); Token * _literal; - void *_tmp_337_var; + void *_tmp_367_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_337_var = _tmp_337_rule(p)) // '|' | '**' + (_tmp_367_var = _tmp_367_rule(p)) // '|' | '**' ) { - 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); + D(fprintf(stderr, "%*c+ _tmp_281[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_367_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_261[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_281[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' ('|' | '**')")); } _res = NULL; @@ -48244,9 +51895,9 @@ _tmp_261_rule(Parser *p) return _res; } -// _tmp_262: lambda_sum_param_no_default | ',' +// _tmp_282: lambda_sum_param_no_default | ',' static void * -_tmp_262_rule(Parser *p) +_tmp_282_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48263,18 +51914,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_282[%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_282[%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_282[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); } { // ',' @@ -48282,18 +51933,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_282[%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_282[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_262[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_282[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -48302,9 +51953,9 @@ _tmp_262_rule(Parser *p) return _res; } -// _loop0_263: lambda_sum_param_maybe_default +// _loop0_283: lambda_sum_param_maybe_default static asdl_seq * -_loop0_263_rule(Parser *p) +_loop0_283_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48330,7 +51981,7 @@ _loop0_263_rule(Parser *p) p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _loop0_283[%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 @@ -48353,7 +52004,7 @@ _loop0_263_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_263[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_283[%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); @@ -48370,9 +52021,9 @@ _loop0_263_rule(Parser *p) return _seq; } -// _tmp_264: lambda_sum_param_no_default | ',' +// _tmp_284: lambda_sum_param_no_default | ',' static void * -_tmp_264_rule(Parser *p) +_tmp_284_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48389,18 +52040,18 @@ _tmp_264_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "lambda_sum_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_284[%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_264[%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_284[%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_264[%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, "lambda_sum_param_no_default")); } { // ',' @@ -48408,18 +52059,18 @@ _tmp_264_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_264[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_284[%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_264[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_284[%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_264[%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, "','")); } _res = NULL; @@ -48428,9 +52079,9 @@ _tmp_264_rule(Parser *p) return _res; } -// _tmp_265: ',' | ')' | ':' +// _tmp_285: ',' | ')' | ':' static void * -_tmp_265_rule(Parser *p) +_tmp_285_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48447,18 +52098,18 @@ _tmp_265_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + 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, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_265[%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_265[%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, "','")); } { // ')' @@ -48466,18 +52117,18 @@ _tmp_265_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + 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, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_265[%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_265[%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, "')'")); } { // ':' @@ -48485,18 +52136,18 @@ _tmp_265_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_265[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + 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_265[%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_265[%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; @@ -48505,9 +52156,9 @@ _tmp_265_rule(Parser *p) return _res; } -// _loop0_267: ',' dotted_name +// _loop0_287: ',' dotted_name static asdl_seq * -_loop0_267_rule(Parser *p) +_loop0_287_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48533,7 +52184,7 @@ _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, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_287[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -48565,7 +52216,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_287[%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); @@ -48582,9 +52233,9 @@ _loop0_267_rule(Parser *p) return _seq; } -// _gather_266: dotted_name _loop0_267 +// _gather_286: dotted_name _loop0_287 static asdl_seq * -_gather_266_rule(Parser *p) +_gather_286_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48596,27 +52247,27 @@ _gather_266_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_267 + { // dotted_name _loop0_287 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, "dotted_name _loop0_267")); + D(fprintf(stderr, "%*c> _gather_286[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_287")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_267_rule(p)) // _loop0_267 + (seq = _loop0_287_rule(p)) // _loop0_287 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_286[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "dotted_name _loop0_287")); _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, "dotted_name _loop0_267")); + D(fprintf(stderr, "%*c%s _gather_286[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "dotted_name _loop0_287")); } _res = NULL; done: @@ -48624,9 +52275,9 @@ _gather_266_rule(Parser *p) return _res; } -// _loop0_269: ',' (expression ['as' star_target]) +// _loop0_289: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_269_rule(Parser *p) +_loop0_289_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48652,13 +52303,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, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_289[%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_368_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -48684,7 +52335,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_289[%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); @@ -48701,9 +52352,9 @@ _loop0_269_rule(Parser *p) return _seq; } -// _gather_268: (expression ['as' star_target]) _loop0_269 +// _gather_288: (expression ['as' star_target]) _loop0_289 static asdl_seq * -_gather_268_rule(Parser *p) +_gather_288_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48715,27 +52366,27 @@ _gather_268_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_269 + { // (expression ['as' star_target]) _loop0_289 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, "(expression ['as' star_target]) _loop0_269")); + D(fprintf(stderr, "%*c> _gather_288[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_289")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_338_rule(p)) // expression ['as' star_target] + (elem = _tmp_368_rule(p)) // expression ['as' star_target] && - (seq = _loop0_269_rule(p)) // _loop0_269 + (seq = _loop0_289_rule(p)) // _loop0_289 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_288[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_289")); _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, "(expression ['as' star_target]) _loop0_269")); + D(fprintf(stderr, "%*c%s _gather_288[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_289")); } _res = NULL; done: @@ -48743,9 +52394,9 @@ _gather_268_rule(Parser *p) return _res; } -// _loop0_271: ',' (expressions ['as' star_target]) +// _loop0_291: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_271_rule(Parser *p) +_loop0_291_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48771,13 +52422,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, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_291[%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_369_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -48803,7 +52454,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_291[%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); @@ -48820,9 +52471,9 @@ _loop0_271_rule(Parser *p) return _seq; } -// _gather_270: (expressions ['as' star_target]) _loop0_271 +// _gather_290: (expressions ['as' star_target]) _loop0_291 static asdl_seq * -_gather_270_rule(Parser *p) +_gather_290_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48834,27 +52485,27 @@ _gather_270_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_271 + { // (expressions ['as' star_target]) _loop0_291 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, "(expressions ['as' star_target]) _loop0_271")); + D(fprintf(stderr, "%*c> _gather_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_291")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_339_rule(p)) // expressions ['as' star_target] + (elem = _tmp_369_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_271_rule(p)) // _loop0_271 + (seq = _loop0_291_rule(p)) // _loop0_291 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_291")); _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, "(expressions ['as' star_target]) _loop0_271")); + 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, "(expressions ['as' star_target]) _loop0_291")); } _res = NULL; done: @@ -48862,9 +52513,9 @@ _gather_270_rule(Parser *p) return _res; } -// _loop0_273: ',' (expression ['as' star_target]) +// _loop0_293: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_273_rule(Parser *p) +_loop0_293_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48890,13 +52541,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, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_293[%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_340_rule(p)) // expression ['as' star_target] + (elem = _tmp_370_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -48922,7 +52573,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_293[%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); @@ -48939,9 +52590,128 @@ _loop0_273_rule(Parser *p) return _seq; } -// _gather_272: (expression ['as' star_target]) _loop0_273 +// _gather_292: (expression ['as' star_target]) _loop0_293 +static asdl_seq * +_gather_292_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // (expression ['as' star_target]) _loop0_293 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_292[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_293")); + void *elem; + asdl_seq * seq; + if ( + (elem = _tmp_370_rule(p)) // expression ['as' star_target] + && + (seq = _loop0_293_rule(p)) // _loop0_293 + ) + { + D(fprintf(stderr, "%*c+ _gather_292[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expression ['as' star_target]) _loop0_293")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + 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, "(expression ['as' star_target]) _loop0_293")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_295: ',' (expressions ['as' star_target]) +static asdl_seq * +_loop0_295_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; + { // ',' (expressions ['as' star_target]) + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_295[%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_371_rule(p)) // expressions ['as' star_target] + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_295[%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); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_294: (expressions ['as' star_target]) _loop0_295 static asdl_seq * -_gather_272_rule(Parser *p) +_gather_294_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -48953,27 +52723,27 @@ _gather_272_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_273 + { // (expressions ['as' star_target]) _loop0_295 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, "(expression ['as' star_target]) _loop0_273")); + D(fprintf(stderr, "%*c> _gather_294[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_295")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_340_rule(p)) // expression ['as' star_target] + (elem = _tmp_371_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_273_rule(p)) // _loop0_273 + (seq = _loop0_295_rule(p)) // _loop0_295 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_295")); _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, "(expression ['as' star_target]) _loop0_273")); + D(fprintf(stderr, "%*c%s _gather_294[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(expressions ['as' star_target]) _loop0_295")); } _res = NULL; done: @@ -48981,9 +52751,318 @@ _gather_272_rule(Parser *p) return _res; } -// _loop0_275: ',' (expressions ['as' star_target]) +// _tmp_296: 'except' | 'finally' +static void * +_tmp_296_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; + { // 'except' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_296[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' + ) + { + D(fprintf(stderr, "%*c+ _tmp_296[%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_296[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'except'")); + } + { // 'finally' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_296[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 744)) // token='finally' + ) + { + D(fprintf(stderr, "%*c+ _tmp_296[%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_296[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'finally'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_297: block +static asdl_seq * +_loop0_297_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; + { // block + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_297[%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 + ) + { + _res = block_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_297[%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); + 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_298: except_block +static asdl_seq * +_loop1_298_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; + { // except_block + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop1_298[%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 + ) + { + _res = except_block_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_298[%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) { + PyMem_Free(_children); + p->level--; + return NULL; + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _tmp_299: 'as' NAME +static void * +_tmp_299_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; + { // 'as' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_299[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty name_var; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (name_var = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ _tmp_299[%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_299[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_300: block +static asdl_seq * +_loop0_300_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; + { // block + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_300[%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 + ) + { + _res = block_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_300[%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); + 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_301: except_star_block static asdl_seq * -_loop0_275_rule(Parser *p) +_loop1_301_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49004,27 +53083,18 @@ _loop0_275_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // ',' (expressions ['as' star_target]) + { // except_star_block if (p->error_indicator) { p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop1_301[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block")); + excepthandler_ty except_star_block_var; while ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (elem = _tmp_341_rule(p)) // expressions ['as' star_target] + (except_star_block_var = except_star_block_rule(p)) // except_star_block ) { - _res = elem; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - PyMem_Free(_children); - p->level--; - return NULL; - } + _res = except_star_block_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -49041,8 +53111,13 @@ _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, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c%s _loop1_301[%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) { + PyMem_Free(_children); + p->level--; + return NULL; } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -49058,9 +53133,9 @@ _loop0_275_rule(Parser *p) return _seq; } -// _gather_274: (expressions ['as' star_target]) _loop0_275 -static asdl_seq * -_gather_274_rule(Parser *p) +// _tmp_302: expression ['as' NAME] +static void * +_tmp_302_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49070,29 +53145,30 @@ _gather_274_rule(Parser *p) p->level--; return NULL; } - asdl_seq * _res = NULL; + void * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_275 + { // expression ['as' NAME] if (p->error_indicator) { p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _tmp_302[%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 ( - (elem = _tmp_341_rule(p)) // expressions ['as' star_target] + (expression_var = expression_rule(p)) // expression && - (seq = _loop0_275_rule(p)) // _loop0_275 + (_opt_var = _tmp_372_rule(p), !p->error_indicator) // ['as' NAME] ) { - 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); + D(fprintf(stderr, "%*c+ _tmp_302[%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 _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")); + 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, "expression ['as' NAME]")); } _res = NULL; done: @@ -49100,9 +53176,9 @@ _gather_274_rule(Parser *p) return _res; } -// _tmp_276: 'except' | 'finally' +// _tmp_303: 'except' | 'finally' static void * -_tmp_276_rule(Parser *p) +_tmp_303_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49119,18 +53195,18 @@ _tmp_276_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c> _tmp_303[%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' + (_keyword = _PyPegen_expect_token(p, 748)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_276[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_303[%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_276[%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, "'except'")); } { // 'finally' @@ -49138,18 +53214,18 @@ _tmp_276_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_276[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_303[%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' + (_keyword = _PyPegen_expect_token(p, 744)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_276[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_303[%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_276[%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, "'finally'")); } _res = NULL; @@ -49158,9 +53234,9 @@ _tmp_276_rule(Parser *p) return _res; } -// _loop0_277: block +// _loop0_304: block_nonewline static asdl_seq * -_loop0_277_rule(Parser *p) +_loop0_304_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49181,18 +53257,18 @@ _loop0_277_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // block + { // block_nonewline if (p->error_indicator) { p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop0_304[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block_nonewline")); + asdl_stmt_seq* block_nonewline_var; while ( - (block_var = block_rule(p)) // block + (block_nonewline_var = block_nonewline_rule(p)) // block_nonewline ) { - _res = block_var; + _res = block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -49209,8 +53285,8 @@ _loop0_277_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _loop0_304[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block_nonewline")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -49226,9 +53302,9 @@ _loop0_277_rule(Parser *p) return _seq; } -// _loop1_278: except_block +// _loop1_305: except_block_nonewline static asdl_seq * -_loop1_278_rule(Parser *p) +_loop1_305_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49249,18 +53325,18 @@ _loop1_278_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // except_block + { // except_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop1_305[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_block_nonewline")); + excepthandler_ty except_block_nonewline_var; while ( - (except_block_var = except_block_rule(p)) // except_block + (except_block_nonewline_var = except_block_nonewline_rule(p)) // except_block_nonewline ) { - _res = except_block_var; + _res = except_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -49277,8 +53353,8 @@ _loop1_278_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _loop1_305[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_block_nonewline")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -49299,9 +53375,9 @@ _loop1_278_rule(Parser *p) return _seq; } -// _tmp_279: 'as' NAME +// _tmp_306: 'as' NAME static void * -_tmp_279_rule(Parser *p) +_tmp_306_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49318,21 +53394,21 @@ _tmp_279_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_279[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_306[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_279[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_306[%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_279[%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, "'as' NAME")); } _res = NULL; @@ -49341,9 +53417,9 @@ _tmp_279_rule(Parser *p) return _res; } -// _loop0_280: block +// _loop0_307: block_nonewline static asdl_seq * -_loop0_280_rule(Parser *p) +_loop0_307_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49364,18 +53440,18 @@ _loop0_280_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // block + { // block_nonewline if (p->error_indicator) { p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop0_307[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "block_nonewline")); + asdl_stmt_seq* block_nonewline_var; while ( - (block_var = block_rule(p)) // block + (block_nonewline_var = block_nonewline_rule(p)) // block_nonewline ) { - _res = block_var; + _res = block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -49392,8 +53468,8 @@ _loop0_280_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_280[%d-%d L%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "block")); + 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, "block_nonewline")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); if (!_seq) { @@ -49409,9 +53485,9 @@ _loop0_280_rule(Parser *p) return _seq; } -// _loop1_281: except_star_block +// _loop1_308: except_star_block_nonewline static asdl_seq * -_loop1_281_rule(Parser *p) +_loop1_308_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49432,18 +53508,18 @@ _loop1_281_rule(Parser *p) } Py_ssize_t _children_capacity = 1; Py_ssize_t _n = 0; - { // except_star_block + { // except_star_block_nonewline if (p->error_indicator) { p->level--; return NULL; } - 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; + D(fprintf(stderr, "%*c> _loop1_308[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "except_star_block_nonewline")); + excepthandler_ty except_star_block_nonewline_var; while ( - (except_star_block_var = except_star_block_rule(p)) // except_star_block + (except_star_block_nonewline_var = except_star_block_nonewline_rule(p)) // except_star_block_nonewline ) { - _res = except_star_block_var; + _res = except_star_block_nonewline_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -49460,8 +53536,8 @@ _loop1_281_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _loop1_308[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "except_star_block_nonewline")); } if (_n == 0 || p->error_indicator) { PyMem_Free(_children); @@ -49482,9 +53558,9 @@ _loop1_281_rule(Parser *p) return _seq; } -// _tmp_282: expression ['as' NAME] +// _tmp_309: expression ['as' NAME] static void * -_tmp_282_rule(Parser *p) +_tmp_309_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49501,22 +53577,22 @@ _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, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_309[%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_342_rule(p), !p->error_indicator) // ['as' NAME] + (_opt_var = _tmp_373_rule(p), !p->error_indicator) // ['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]")); + D(fprintf(stderr, "%*c+ _tmp_309[%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_282[%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, "expression ['as' NAME]")); } _res = NULL; @@ -49525,9 +53601,9 @@ _tmp_282_rule(Parser *p) return _res; } -// _tmp_283: 'as' NAME +// _tmp_310: 'as' NAME static void * -_tmp_283_rule(Parser *p) +_tmp_310_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49544,21 +53620,21 @@ _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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_310[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_283[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_310[%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_283[%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, "'as' NAME")); } _res = NULL; @@ -49567,9 +53643,9 @@ _tmp_283_rule(Parser *p) return _res; } -// _tmp_284: 'as' NAME +// _tmp_311: 'as' NAME static void * -_tmp_284_rule(Parser *p) +_tmp_311_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49586,21 +53662,21 @@ _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_311[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (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_311[%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_311[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -49609,9 +53685,9 @@ _tmp_284_rule(Parser *p) return _res; } -// _tmp_285: NEWLINE | ':' +// _tmp_312: NEWLINE | ':' static void * -_tmp_285_rule(Parser *p) +_tmp_312_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49628,18 +53704,18 @@ _tmp_285_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_285[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_312[%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_285[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_312[%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_285[%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, "NEWLINE")); } { // ':' @@ -49647,18 +53723,18 @@ _tmp_285_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_285[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c> _tmp_312[%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_285[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_312[%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_285[%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, "':'")); } _res = NULL; @@ -49667,9 +53743,9 @@ _tmp_285_rule(Parser *p) return _res; } -// _tmp_286: 'as' NAME +// _tmp_313: 'as' NAME static void * -_tmp_286_rule(Parser *p) +_tmp_313_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49686,21 +53762,21 @@ _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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_313[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_286[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_313[%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_286[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_313[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -49709,9 +53785,9 @@ _tmp_286_rule(Parser *p) return _res; } -// _tmp_287: 'as' NAME +// _tmp_314: 'as' NAME static void * -_tmp_287_rule(Parser *p) +_tmp_314_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49728,21 +53804,21 @@ _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, "'as' NAME")); + D(fprintf(stderr, "%*c> _tmp_314[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_287[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_314[%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_287[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_314[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -49751,9 +53827,51 @@ _tmp_287_rule(Parser *p) return _res; } -// _tmp_288: positional_patterns ',' +// _tmp_315: 'as' NAME static void * -_tmp_288_rule(Parser *p) +_tmp_315_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; + { // 'as' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_315[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty name_var; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (name_var = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ _tmp_315[%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_315[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_316: positional_patterns ',' +static void * +_tmp_316_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49770,7 +53888,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, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_316[%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 ( @@ -49779,12 +53897,12 @@ _tmp_288_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_288[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_316[%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_288[%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, "positional_patterns ','")); } _res = NULL; @@ -49793,9 +53911,9 @@ _tmp_288_rule(Parser *p) return _res; } -// _tmp_289: '->' expression +// _tmp_317: '->' expression static void * -_tmp_289_rule(Parser *p) +_tmp_317_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49812,7 +53930,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, "'->' expression")); + D(fprintf(stderr, "%*c> _tmp_317[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); Token * _literal; expr_ty expression_var; if ( @@ -49821,12 +53939,12 @@ _tmp_289_rule(Parser *p) (expression_var = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_289[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'->' expression")); + D(fprintf(stderr, "%*c+ _tmp_317[%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_289[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_317[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'->' expression")); } _res = NULL; @@ -49835,9 +53953,9 @@ _tmp_289_rule(Parser *p) return _res; } -// _tmp_290: '(' arguments? ')' +// _tmp_318: '(' arguments? ')' static void * -_tmp_290_rule(Parser *p) +_tmp_318_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49854,7 +53972,7 @@ _tmp_290_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_290[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_318[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *_opt_var; @@ -49867,12 +53985,12 @@ _tmp_290_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_290[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_318[%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_290[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_318[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); } _res = NULL; @@ -49881,9 +53999,9 @@ _tmp_290_rule(Parser *p) return _res; } -// _tmp_291: '(' arguments? ')' +// _tmp_319: '(' arguments? ')' static void * -_tmp_291_rule(Parser *p) +_tmp_319_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49900,7 +54018,7 @@ _tmp_291_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_291[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c> _tmp_319[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); Token * _literal; Token * _literal_1; void *_opt_var; @@ -49913,12 +54031,12 @@ _tmp_291_rule(Parser *p) (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_291[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'(' arguments? ')'")); + D(fprintf(stderr, "%*c+ _tmp_319[%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_291[%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, "'(' arguments? ')'")); } _res = NULL; @@ -49927,9 +54045,9 @@ _tmp_291_rule(Parser *p) return _res; } -// _loop0_293: ',' double_starred_kvpair +// _loop0_321: ',' double_starred_kvpair static asdl_seq * -_loop0_293_rule(Parser *p) +_loop0_321_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -49955,7 +54073,7 @@ _loop0_293_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_293[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_321[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -49987,7 +54105,7 @@ _loop0_293_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_293[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_321[%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); @@ -50004,9 +54122,9 @@ _loop0_293_rule(Parser *p) return _seq; } -// _gather_292: double_starred_kvpair _loop0_293 +// _gather_320: double_starred_kvpair _loop0_321 static asdl_seq * -_gather_292_rule(Parser *p) +_gather_320_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50018,27 +54136,27 @@ _gather_292_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_293 + { // double_starred_kvpair _loop0_321 if (p->error_indicator) { p->level--; return NULL; } - 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")); + D(fprintf(stderr, "%*c> _gather_320[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_321")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_293_rule(p)) // _loop0_293 + (seq = _loop0_321_rule(p)) // _loop0_321 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_320[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_321")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_320[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "double_starred_kvpair _loop0_321")); } _res = NULL; done: @@ -50046,9 +54164,9 @@ _gather_292_rule(Parser *p) return _res; } -// _tmp_294: '}' | ',' +// _tmp_322: '}' | ',' static void * -_tmp_294_rule(Parser *p) +_tmp_322_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50065,18 +54183,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_322[%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_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_322[%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_294[%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, "'}'")); } { // ',' @@ -50084,18 +54202,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, "','")); + D(fprintf(stderr, "%*c> _tmp_322[%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_294[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_322[%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_294[%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, "','")); } _res = NULL; @@ -50104,9 +54222,9 @@ _tmp_294_rule(Parser *p) return _res; } -// _tmp_295: '}' | ',' +// _tmp_323: '}' | ',' static void * -_tmp_295_rule(Parser *p) +_tmp_323_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50123,18 +54241,18 @@ _tmp_295_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_295[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c> _tmp_323[%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_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_323[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_295[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_323[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } { // ',' @@ -50142,18 +54260,18 @@ _tmp_295_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_295[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c> _tmp_323[%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_295[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); + D(fprintf(stderr, "%*c+ _tmp_323[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_295[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_323[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "','")); } _res = NULL; @@ -50162,9 +54280,9 @@ _tmp_295_rule(Parser *p) return _res; } -// _tmp_296: yield_expr | star_expressions +// _tmp_324: yield_expr | star_expressions static void * -_tmp_296_rule(Parser *p) +_tmp_324_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50181,18 +54299,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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_324[%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_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_324[%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_296[%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, "yield_expr")); } { // star_expressions @@ -50200,18 +54318,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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_324[%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_296[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_324[%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_296[%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, "star_expressions")); } _res = NULL; @@ -50220,9 +54338,9 @@ _tmp_296_rule(Parser *p) return _res; } -// _tmp_297: yield_expr | star_expressions +// _tmp_325: yield_expr | star_expressions static void * -_tmp_297_rule(Parser *p) +_tmp_325_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50239,18 +54357,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_325[%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_325[%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_325[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -50258,18 +54376,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_325[%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_325[%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_325[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -50278,9 +54396,9 @@ _tmp_297_rule(Parser *p) return _res; } -// _tmp_298: '=' | '!' | ':' | '}' +// _tmp_326: '=' | '!' | ':' | '}' static void * -_tmp_298_rule(Parser *p) +_tmp_326_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50297,18 +54415,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_326[%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_298[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'='")); + D(fprintf(stderr, "%*c+ _tmp_326[%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_326[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'='")); } { // '!' @@ -50316,18 +54434,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_326[%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_326[%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_326[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'!'")); } { // ':' @@ -50335,18 +54453,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_326[%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_326[%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_326[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '}' @@ -50354,18 +54472,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_326[%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_326[%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_326[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'}'")); } _res = NULL; @@ -50374,9 +54492,9 @@ _tmp_298_rule(Parser *p) return _res; } -// _tmp_299: yield_expr | star_expressions +// _tmp_327: yield_expr | star_expressions static void * -_tmp_299_rule(Parser *p) +_tmp_327_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50393,18 +54511,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_327[%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_327[%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_327[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "yield_expr")); } { // star_expressions @@ -50412,18 +54530,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_327[%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_327[%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_327[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_expressions")); } _res = NULL; @@ -50432,9 +54550,9 @@ _tmp_299_rule(Parser *p) return _res; } -// _tmp_300: '!' | ':' | '}' +// _tmp_328: '!' | ':' | '}' static void * -_tmp_300_rule(Parser *p) +_tmp_328_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50451,18 +54569,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, "'!'")); + D(fprintf(stderr, "%*c> _tmp_328[%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_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_328[%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_300[%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, "'!'")); } { // ':' @@ -50470,18 +54588,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_328[%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_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_328[%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_300[%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, "':'")); } { // '}' @@ -50489,18 +54607,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_328[%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_300[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_328[%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_300[%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, "'}'")); } _res = NULL; @@ -50509,9 +54627,9 @@ _tmp_300_rule(Parser *p) return _res; } -// _tmp_301: yield_expr | star_expressions +// _tmp_329: yield_expr | star_expressions static void * -_tmp_301_rule(Parser *p) +_tmp_329_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50528,18 +54646,18 @@ _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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_329[%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_301[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_329[%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_301[%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, "yield_expr")); } { // star_expressions @@ -50547,18 +54665,18 @@ _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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_329[%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_301[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_329[%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_301[%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, "star_expressions")); } _res = NULL; @@ -50567,9 +54685,9 @@ _tmp_301_rule(Parser *p) return _res; } -// _tmp_302: yield_expr | star_expressions +// _tmp_330: yield_expr | star_expressions static void * -_tmp_302_rule(Parser *p) +_tmp_330_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50586,18 +54704,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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_330[%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_302[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_330[%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_302[%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, "yield_expr")); } { // star_expressions @@ -50605,18 +54723,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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_330[%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_302[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_330[%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_302[%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, "star_expressions")); } _res = NULL; @@ -50625,9 +54743,9 @@ _tmp_302_rule(Parser *p) return _res; } -// _tmp_303: '!' NAME +// _tmp_331: '!' NAME static void * -_tmp_303_rule(Parser *p) +_tmp_331_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50644,7 +54762,7 @@ _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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_331[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -50653,12 +54771,12 @@ _tmp_303_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_303[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_331[%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_303[%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, "'!' NAME")); } _res = NULL; @@ -50667,9 +54785,9 @@ _tmp_303_rule(Parser *p) return _res; } -// _tmp_304: ':' | '}' +// _tmp_332: ':' | '}' static void * -_tmp_304_rule(Parser *p) +_tmp_332_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50686,18 +54804,18 @@ _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, "':'")); + D(fprintf(stderr, "%*c> _tmp_332[%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_304[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_332[%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_304[%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, "':'")); } { // '}' @@ -50705,18 +54823,18 @@ _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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_332[%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_304[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_332[%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_304[%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, "'}'")); } _res = NULL; @@ -50725,9 +54843,9 @@ _tmp_304_rule(Parser *p) return _res; } -// _tmp_305: yield_expr | star_expressions +// _tmp_333: yield_expr | star_expressions static void * -_tmp_305_rule(Parser *p) +_tmp_333_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50744,18 +54862,18 @@ _tmp_305_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_305[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_333[%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_305[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_333[%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_305[%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, "yield_expr")); } { // star_expressions @@ -50763,18 +54881,18 @@ _tmp_305_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_305[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_333[%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_305[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_333[%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_305[%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_expressions")); } _res = NULL; @@ -50783,9 +54901,9 @@ _tmp_305_rule(Parser *p) return _res; } -// _tmp_306: '!' NAME +// _tmp_334: '!' NAME static void * -_tmp_306_rule(Parser *p) +_tmp_334_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50802,7 +54920,7 @@ _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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_334[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -50811,12 +54929,12 @@ _tmp_306_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_306[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_334[%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_306[%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, "'!' NAME")); } _res = NULL; @@ -50825,9 +54943,9 @@ _tmp_306_rule(Parser *p) return _res; } -// _loop0_307: fstring_format_spec +// _loop0_335: fstring_format_spec static asdl_seq * -_loop0_307_rule(Parser *p) +_loop0_335_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50853,7 +54971,7 @@ _loop0_307_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_307[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_335[%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 @@ -50876,7 +54994,7 @@ _loop0_307_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_307[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_335[%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); @@ -50893,9 +55011,9 @@ _loop0_307_rule(Parser *p) return _seq; } -// _tmp_308: yield_expr | star_expressions +// _tmp_336: yield_expr | star_expressions static void * -_tmp_308_rule(Parser *p) +_tmp_336_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50912,18 +55030,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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_336[%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_308[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_336[%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_308[%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, "yield_expr")); } { // star_expressions @@ -50931,18 +55049,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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_336[%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_308[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_336[%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_308[%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, "star_expressions")); } _res = NULL; @@ -50951,9 +55069,9 @@ _tmp_308_rule(Parser *p) return _res; } -// _tmp_309: '!' NAME +// _tmp_337: '!' NAME static void * -_tmp_309_rule(Parser *p) +_tmp_337_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -50970,7 +55088,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, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_337[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); Token * _literal; expr_ty name_var; if ( @@ -50979,12 +55097,12 @@ _tmp_309_rule(Parser *p) (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_309[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'!' NAME")); + D(fprintf(stderr, "%*c+ _tmp_337[%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_309[%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, "'!' NAME")); } _res = NULL; @@ -50993,9 +55111,9 @@ _tmp_309_rule(Parser *p) return _res; } -// _tmp_310: ':' | '}' +// _tmp_338: ':' | '}' static void * -_tmp_310_rule(Parser *p) +_tmp_338_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51012,18 +55130,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, "':'")); + D(fprintf(stderr, "%*c> _tmp_338[%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_310[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_338[%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_310[%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, "':'")); } { // '}' @@ -51031,18 +55149,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, "'}'")); + D(fprintf(stderr, "%*c> _tmp_338[%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_310[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_338[%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_310[%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, "'}'")); } _res = NULL; @@ -51051,9 +55169,72 @@ _tmp_310_rule(Parser *p) return _res; } -// _tmp_311: star_targets '=' +// _tmp_339: ';'.simple_stmt+ | parenthesized_stmt_nonewline static void * -_tmp_311_rule(Parser *p) +_tmp_339_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; + { // ';'.simple_stmt+ + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_339[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+")); + asdl_stmt_seq* b; + if ( + (b = (asdl_stmt_seq*)_gather_374_rule(p)) // ';'.simple_stmt+ + ) + { + D(fprintf(stderr, "%*c+ _tmp_339[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';'.simple_stmt+")); + _res = b; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + 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, "';'.simple_stmt+")); + } + { // parenthesized_stmt_nonewline + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_339[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "parenthesized_stmt_nonewline")); + asdl_stmt_seq* parenthesized_stmt_nonewline_var; + if ( + (parenthesized_stmt_nonewline_var = parenthesized_stmt_nonewline_rule(p)) // parenthesized_stmt_nonewline + ) + { + D(fprintf(stderr, "%*c+ _tmp_339[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "parenthesized_stmt_nonewline")); + _res = parenthesized_stmt_nonewline_var; + goto done; + } + p->mark = _mark; + 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, "parenthesized_stmt_nonewline")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_340: star_targets '=' +static void * +_tmp_340_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51070,7 +55251,7 @@ _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, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_340[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -51079,7 +55260,7 @@ _tmp_311_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_311[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_340[%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; @@ -51089,7 +55270,7 @@ _tmp_311_rule(Parser *p) 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_340[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -51098,9 +55279,9 @@ _tmp_311_rule(Parser *p) return _res; } -// _tmp_312: yield_expr | star_expressions +// _tmp_341: yield_expr | star_expressions static void * -_tmp_312_rule(Parser *p) +_tmp_341_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51117,18 +55298,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, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_341[%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_312[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_341[%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_312[%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, "yield_expr")); } { // star_expressions @@ -51136,18 +55317,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, "star_expressions")); + D(fprintf(stderr, "%*c> _tmp_341[%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_312[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_expressions")); + D(fprintf(stderr, "%*c+ _tmp_341[%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_312[%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, "star_expressions")); } _res = NULL; @@ -51156,9 +55337,9 @@ _tmp_312_rule(Parser *p) return _res; } -// _tmp_313: '.' | '...' +// _tmp_342: '.' | '...' static void * -_tmp_313_rule(Parser *p) +_tmp_342_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51175,18 +55356,18 @@ _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, "'.'")); + D(fprintf(stderr, "%*c> _tmp_342[%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_313[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_342[%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_313[%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, "'.'")); } { // '...' @@ -51194,18 +55375,18 @@ _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, "'...'")); + D(fprintf(stderr, "%*c> _tmp_342[%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_313[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_342[%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_313[%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, "'...'")); } _res = NULL; @@ -51214,9 +55395,9 @@ _tmp_313_rule(Parser *p) return _res; } -// _tmp_314: '.' | '...' +// _tmp_343: '.' | '...' static void * -_tmp_314_rule(Parser *p) +_tmp_343_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51233,18 +55414,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, "'.'")); + D(fprintf(stderr, "%*c> _tmp_343[%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_314[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_343[%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_314[%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, "'.'")); } { // '...' @@ -51252,18 +55433,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, "'...'")); + D(fprintf(stderr, "%*c> _tmp_343[%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_314[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_343[%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_314[%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, "'...'")); } _res = NULL; @@ -51272,9 +55453,9 @@ _tmp_314_rule(Parser *p) return _res; } -// _tmp_315: '@' named_expression NEWLINE +// _tmp_344: '@' named_expression NEWLINE static void * -_tmp_315_rule(Parser *p) +_tmp_344_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51291,7 +55472,7 @@ _tmp_315_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_315[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_344[%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; @@ -51303,7 +55484,7 @@ _tmp_315_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='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")); + D(fprintf(stderr, "%*c+ _tmp_344[%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; @@ -51313,7 +55494,7 @@ _tmp_315_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_315[%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, "'@' named_expression NEWLINE")); } _res = NULL; @@ -51322,9 +55503,9 @@ _tmp_315_rule(Parser *p) return _res; } -// _tmp_316: bitwiseor_pattern | 'None' +// _tmp_345: bitwiseor_pattern | 'None' static void * -_tmp_316_rule(Parser *p) +_tmp_345_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51350,18 +55531,18 @@ _tmp_316_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_316[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + D(fprintf(stderr, "%*c> _tmp_345[%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_316[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + D(fprintf(stderr, "%*c+ _tmp_345[%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_316[%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, "bitwiseor_pattern")); } { // 'None' @@ -51369,13 +55550,13 @@ _tmp_316_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_316[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c> _tmp_345[%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' + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_316[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_345[%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--; @@ -51394,7 +55575,88 @@ _tmp_316_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_316[%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, "'None'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_346: bitwiseor_pattern | 'None' +static void * +_tmp_346_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->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 + { // bitwiseor_pattern + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_346[%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_346[%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_346[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "bitwiseor_pattern")); + } + { // 'None' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_346[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'None'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 696)) // token='None' + ) + { + D(fprintf(stderr, "%*c+ _tmp_346[%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--; + 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_Constant ( Py_None , 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 _tmp_346[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'None'")); } _res = NULL; @@ -51403,9 +55665,9 @@ _tmp_316_rule(Parser *p) return _res; } -// _loop0_318: ';' simple_stmt +// _loop0_348: ';' simple_stmt static asdl_seq * -_loop0_318_rule(Parser *p) +_loop0_348_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51431,7 +55693,7 @@ _loop0_318_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_318[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + D(fprintf(stderr, "%*c> _loop0_348[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); Token * _literal; stmt_ty elem; while ( @@ -51463,7 +55725,7 @@ _loop0_318_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_318[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_348[%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); @@ -51480,9 +55742,9 @@ _loop0_318_rule(Parser *p) return _seq; } -// _gather_317: simple_stmt _loop0_318 +// _gather_347: simple_stmt _loop0_348 static asdl_seq * -_gather_317_rule(Parser *p) +_gather_347_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51494,27 +55756,27 @@ _gather_317_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // simple_stmt _loop0_318 + { // simple_stmt _loop0_348 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_317[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_318")); + D(fprintf(stderr, "%*c> _gather_347[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_348")); stmt_ty elem; asdl_seq * seq; if ( (elem = simple_stmt_rule(p)) // simple_stmt && - (seq = _loop0_318_rule(p)) // _loop0_318 + (seq = _loop0_348_rule(p)) // _loop0_348 ) { - 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")); + D(fprintf(stderr, "%*c+ _gather_347[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_348")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - 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")); + D(fprintf(stderr, "%*c%s _gather_347[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_348")); } _res = NULL; done: @@ -51522,9 +55784,9 @@ _gather_317_rule(Parser *p) return _res; } -// _tmp_319: ',' expression +// _tmp_349: ',' expression static void * -_tmp_319_rule(Parser *p) +_tmp_349_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51541,7 +55803,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, "',' expression")); + D(fprintf(stderr, "%*c> _tmp_349[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); Token * _literal; expr_ty c; if ( @@ -51550,7 +55812,7 @@ _tmp_319_rule(Parser *p) (c = expression_rule(p)) // expression ) { - D(fprintf(stderr, "%*c+ _tmp_319[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' expression")); + D(fprintf(stderr, "%*c+ _tmp_349[%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; @@ -51560,7 +55822,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_349[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' expression")); } _res = NULL; @@ -51569,9 +55831,9 @@ _tmp_319_rule(Parser *p) return _res; } -// _tmp_320: ',' star_expression +// _tmp_350: ',' star_expression static void * -_tmp_320_rule(Parser *p) +_tmp_350_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51588,7 +55850,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, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_350[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -51597,7 +55859,7 @@ _tmp_320_rule(Parser *p) (c = star_expression_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_350[%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; @@ -51607,7 +55869,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_350[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_expression")); } _res = NULL; @@ -51616,9 +55878,9 @@ _tmp_320_rule(Parser *p) return _res; } -// _tmp_321: 'or' conjunction +// _tmp_351: 'or' conjunction static void * -_tmp_321_rule(Parser *p) +_tmp_351_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51635,16 +55897,16 @@ _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, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_351[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); Token * _keyword; expr_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='or' + (_keyword = _PyPegen_expect_token(p, 658)) // token='or' && (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_321[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_351[%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; @@ -51654,7 +55916,7 @@ _tmp_321_rule(Parser *p) 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_351[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'or' conjunction")); } _res = NULL; @@ -51663,9 +55925,9 @@ _tmp_321_rule(Parser *p) return _res; } -// _tmp_322: 'and' inversion +// _tmp_352: 'and' inversion static void * -_tmp_322_rule(Parser *p) +_tmp_352_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51682,16 +55944,16 @@ _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, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_352[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); Token * _keyword; expr_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='and' + (_keyword = _PyPegen_expect_token(p, 659)) // token='and' && (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_322[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_352[%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; @@ -51701,7 +55963,7 @@ _tmp_322_rule(Parser *p) 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_352[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'and' inversion")); } _res = NULL; @@ -51710,9 +55972,9 @@ _tmp_322_rule(Parser *p) return _res; } -// _tmp_323: slice | starred_expression +// _tmp_353: slice | starred_expression static void * -_tmp_323_rule(Parser *p) +_tmp_353_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51729,18 +55991,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, "slice")); + D(fprintf(stderr, "%*c> _tmp_353[%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_323[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "slice")); + D(fprintf(stderr, "%*c+ _tmp_353[%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_323[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_353[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "slice")); } { // starred_expression @@ -51748,18 +56010,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, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_353[%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_323[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_353[%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_323[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_353[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "starred_expression")); } _res = NULL; @@ -51768,9 +56030,9 @@ _tmp_323_rule(Parser *p) return _res; } -// _tmp_324: "def" | '@' | 'async' +// _tmp_354: "def" | '@' | 'async' static void * -_tmp_324_rule(Parser *p) +_tmp_354_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51787,18 +56049,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, "\"def\"")); + D(fprintf(stderr, "%*c> _tmp_354[%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_324[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "\"def\"")); + D(fprintf(stderr, "%*c+ _tmp_354[%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_324[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_354[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "\"def\"")); } { // '@' @@ -51806,18 +56068,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, "'@'")); + D(fprintf(stderr, "%*c> _tmp_354[%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_324[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_354[%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_324[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_354[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } { // 'async' @@ -51825,18 +56087,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, "'async'")); + D(fprintf(stderr, "%*c> _tmp_354[%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' + (_keyword = _PyPegen_expect_token(p, 765)) // token='async' ) { - D(fprintf(stderr, "%*c+ _tmp_324[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'async'")); + D(fprintf(stderr, "%*c+ _tmp_354[%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_324[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_354[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'async'")); } _res = NULL; @@ -51845,9 +56107,9 @@ _tmp_324_rule(Parser *p) return _res; } -// _tmp_325: 'class' | '@' +// _tmp_355: 'class' | '@' static void * -_tmp_325_rule(Parser *p) +_tmp_355_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51864,18 +56126,18 @@ _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, "'class'")); + D(fprintf(stderr, "%*c> _tmp_355[%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' + (_keyword = _PyPegen_expect_token(p, 767)) // token='class' ) { - D(fprintf(stderr, "%*c+ _tmp_325[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'class'")); + D(fprintf(stderr, "%*c+ _tmp_355[%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_325[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_355[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'class'")); } { // '@' @@ -51883,18 +56145,18 @@ _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, "'@'")); + D(fprintf(stderr, "%*c> _tmp_355[%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_325[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_355[%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_325[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_355[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'@'")); } _res = NULL; @@ -51903,9 +56165,9 @@ _tmp_325_rule(Parser *p) return _res; } -// _tmp_326: fstring | string +// _tmp_356: fstring | string static void * -_tmp_326_rule(Parser *p) +_tmp_356_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51922,18 +56184,18 @@ _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, "fstring")); + D(fprintf(stderr, "%*c> _tmp_356[%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_326[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_356[%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_326[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_356[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "fstring")); } { // string @@ -51941,18 +56203,18 @@ _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, "string")); + D(fprintf(stderr, "%*c> _tmp_356[%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_326[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "string")); + D(fprintf(stderr, "%*c+ _tmp_356[%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_326[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_356[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "string")); } _res = NULL; @@ -51961,9 +56223,9 @@ _tmp_326_rule(Parser *p) return _res; } -// _tmp_327: 'if' disjunction +// _tmp_357: 'if' disjunction static void * -_tmp_327_rule(Parser *p) +_tmp_357_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -51980,16 +56242,16 @@ _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_357[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (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_357[%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; @@ -51999,7 +56261,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_357[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -52008,9 +56270,9 @@ _tmp_327_rule(Parser *p) return _res; } -// _tmp_328: 'if' disjunction +// _tmp_358: 'if' disjunction static void * -_tmp_328_rule(Parser *p) +_tmp_358_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52027,16 +56289,16 @@ _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, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_358[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_328[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_358[%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; @@ -52046,7 +56308,7 @@ _tmp_328_rule(Parser *p) 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_358[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -52055,9 +56317,9 @@ _tmp_328_rule(Parser *p) return _res; } -// _tmp_329: 'if' disjunction +// _tmp_359: 'if' disjunction static void * -_tmp_329_rule(Parser *p) +_tmp_359_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52074,16 +56336,16 @@ _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, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_359[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 706)) // token='if' + (_keyword = _PyPegen_expect_token(p, 753)) // token='if' && (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_329[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_359[%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; @@ -52093,7 +56355,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_359[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'if' disjunction")); } _res = NULL; @@ -52102,12 +56364,12 @@ _tmp_329_rule(Parser *p) return _res; } -// _tmp_330: +// _tmp_360: // | starred_expression // | simple_slice // | (assignment_expression | expression !':=') !'=' static void * -_tmp_330_rule(Parser *p) +_tmp_360_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52124,18 +56386,18 @@ _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, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_360[%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_330[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_360[%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_330[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_360[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "starred_expression")); } { // simple_slice @@ -52143,18 +56405,18 @@ _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, "simple_slice")); + D(fprintf(stderr, "%*c> _tmp_360[%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_330[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_slice")); + D(fprintf(stderr, "%*c+ _tmp_360[%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_330[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_360[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_slice")); } { // (assignment_expression | expression !':=') !'=' @@ -52162,20 +56424,20 @@ _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, "(assignment_expression | expression !':=') !'='")); - void *_tmp_343_var; + D(fprintf(stderr, "%*c> _tmp_360[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); + void *_tmp_376_var; if ( - (_tmp_343_var = _tmp_343_rule(p)) // assignment_expression | expression !':=' + (_tmp_376_var = _tmp_376_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - 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; + D(fprintf(stderr, "%*c+ _tmp_360[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_376_var; 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_360[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -52184,9 +56446,9 @@ _tmp_330_rule(Parser *p) return _res; } -// _tmp_331: ',' star_target +// _tmp_361: ',' star_target static void * -_tmp_331_rule(Parser *p) +_tmp_361_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52203,7 +56465,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_target")); + D(fprintf(stderr, "%*c> _tmp_361[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -52212,7 +56474,7 @@ _tmp_331_rule(Parser *p) (c = star_target_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_361[%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; @@ -52222,7 +56484,7 @@ _tmp_331_rule(Parser *p) 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_361[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } _res = NULL; @@ -52231,9 +56493,9 @@ _tmp_331_rule(Parser *p) return _res; } -// _tmp_332: ',' star_target +// _tmp_362: ',' star_target static void * -_tmp_332_rule(Parser *p) +_tmp_362_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52250,7 +56512,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_target")); + D(fprintf(stderr, "%*c> _tmp_362[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -52259,7 +56521,7 @@ _tmp_332_rule(Parser *p) (c = star_target_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_362[%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; @@ -52269,7 +56531,7 @@ _tmp_332_rule(Parser *p) 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_362[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "',' star_target")); } _res = NULL; @@ -52278,9 +56540,9 @@ _tmp_332_rule(Parser *p) return _res; } -// _tmp_333: star_targets '=' +// _tmp_363: star_targets '=' static void * -_tmp_333_rule(Parser *p) +_tmp_363_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52297,7 +56559,7 @@ _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, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_363[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty star_targets_var; if ( @@ -52306,12 +56568,12 @@ _tmp_333_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_333[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_363[%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_333[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_363[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -52320,9 +56582,9 @@ _tmp_333_rule(Parser *p) return _res; } -// _tmp_334: star_targets '=' +// _tmp_364: star_targets '=' static void * -_tmp_334_rule(Parser *p) +_tmp_364_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52339,7 +56601,7 @@ _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, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_364[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); Token * _literal; expr_ty star_targets_var; if ( @@ -52348,12 +56610,12 @@ _tmp_334_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_334[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_364[%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_334[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_364[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "star_targets '='")); } _res = NULL; @@ -52362,9 +56624,9 @@ _tmp_334_rule(Parser *p) return _res; } -// _tmp_335: ')' | '**' +// _tmp_365: ')' | '**' static void * -_tmp_335_rule(Parser *p) +_tmp_365_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52381,18 +56643,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_365[%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_335[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "')'")); + D(fprintf(stderr, "%*c+ _tmp_365[%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_365[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "')'")); } { // '**' @@ -52400,18 +56662,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_365[%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_365[%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_365[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -52420,9 +56682,9 @@ _tmp_335_rule(Parser *p) return _res; } -// _tmp_336: ':' | '**' +// _tmp_366: ':' | '**' static void * -_tmp_336_rule(Parser *p) +_tmp_366_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52439,18 +56701,18 @@ _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, "':'")); + D(fprintf(stderr, "%*c> _tmp_366[%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_336[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "':'")); + D(fprintf(stderr, "%*c+ _tmp_366[%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_336[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_366[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "':'")); } { // '**' @@ -52458,18 +56720,18 @@ _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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_366[%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_336[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_366[%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_336[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_366[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -52478,9 +56740,9 @@ _tmp_336_rule(Parser *p) return _res; } -// _tmp_337: '|' | '**' +// _tmp_367: '|' | '**' static void * -_tmp_337_rule(Parser *p) +_tmp_367_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52497,18 +56759,18 @@ _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, "'|'")); + D(fprintf(stderr, "%*c> _tmp_367[%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_337[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'|'")); + D(fprintf(stderr, "%*c+ _tmp_367[%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_337[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_367[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'|'")); } { // '**' @@ -52516,18 +56778,18 @@ _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, "'**'")); + D(fprintf(stderr, "%*c> _tmp_367[%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_337[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_367[%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_337[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_367[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'**'")); } _res = NULL; @@ -52536,9 +56798,9 @@ _tmp_337_rule(Parser *p) return _res; } -// _tmp_338: expression ['as' star_target] +// _tmp_368: expression ['as' star_target] static void * -_tmp_338_rule(Parser *p) +_tmp_368_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52555,22 +56817,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_368[%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_377_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_368[%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_368[%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; @@ -52579,9 +56841,9 @@ _tmp_338_rule(Parser *p) return _res; } -// _tmp_339: expressions ['as' star_target] +// _tmp_369: expressions ['as' star_target] static void * -_tmp_339_rule(Parser *p) +_tmp_369_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52598,22 +56860,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_369[%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_378_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_369[%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_369[%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; @@ -52622,9 +56884,9 @@ _tmp_339_rule(Parser *p) return _res; } -// _tmp_340: expression ['as' star_target] +// _tmp_370: expression ['as' star_target] static void * -_tmp_340_rule(Parser *p) +_tmp_370_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52641,22 +56903,22 @@ _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, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_370[%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_346_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_379_rule(p), !p->error_indicator) // ['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]")); + D(fprintf(stderr, "%*c+ _tmp_370[%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_340[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_370[%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; @@ -52665,9 +56927,9 @@ _tmp_340_rule(Parser *p) return _res; } -// _tmp_341: expressions ['as' star_target] +// _tmp_371: expressions ['as' star_target] static void * -_tmp_341_rule(Parser *p) +_tmp_371_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52684,22 +56946,22 @@ _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, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_371[%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_347_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_380_rule(p), !p->error_indicator) // ['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]")); + D(fprintf(stderr, "%*c+ _tmp_371[%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_341[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_371[%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; @@ -52708,9 +56970,9 @@ _tmp_341_rule(Parser *p) return _res; } -// _tmp_342: 'as' NAME +// _tmp_372: 'as' NAME static void * -_tmp_342_rule(Parser *p) +_tmp_372_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52727,21 +56989,21 @@ _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' NAME")); + D(fprintf(stderr, "%*c> _tmp_372[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); Token * _keyword; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_342[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + D(fprintf(stderr, "%*c+ _tmp_372[%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_342[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_372[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); } _res = NULL; @@ -52750,9 +57012,170 @@ _tmp_342_rule(Parser *p) return _res; } -// _tmp_343: assignment_expression | expression !':=' +// _tmp_373: 'as' NAME static void * -_tmp_343_rule(Parser *p) +_tmp_373_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; + { // 'as' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_373[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' NAME")); + Token * _keyword; + expr_ty name_var; + if ( + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' + && + (name_var = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ _tmp_373[%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_373[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop0_375: ';' simple_stmt +static asdl_seq * +_loop0_375_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // ';' simple_stmt + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_375[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + Token * _literal; + stmt_ty elem; + while ( + (_literal = _PyPegen_expect_token(p, 13)) // token=';' + && + (elem = simple_stmt_rule(p)) // simple_stmt + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_375[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "';' simple_stmt")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_374: simple_stmt _loop0_375 +static asdl_seq * +_gather_374_rule(Parser *p) +{ + if (p->level++ == MAXSTACK) { + p->error_indicator = 1; + PyErr_NoMemory(); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // simple_stmt _loop0_375 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_374[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_375")); + stmt_ty elem; + asdl_seq * seq; + if ( + (elem = simple_stmt_rule(p)) // simple_stmt + && + (seq = _loop0_375_rule(p)) // _loop0_375 + ) + { + D(fprintf(stderr, "%*c+ _gather_374[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_375")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_374[%d-%d L%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "simple_stmt _loop0_375")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_376: assignment_expression | expression !':=' +static void * +_tmp_376_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52769,18 +57192,18 @@ _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, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_376[%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_343[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_376[%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_343[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_376[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "assignment_expression")); } { // expression !':=' @@ -52788,7 +57211,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, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_376[%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 @@ -52796,12 +57219,12 @@ _tmp_343_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_343[%d-%d L%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_376[%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_343[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_376[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "expression !':='")); } _res = NULL; @@ -52810,9 +57233,9 @@ _tmp_343_rule(Parser *p) return _res; } -// _tmp_344: 'as' star_target +// _tmp_377: 'as' star_target static void * -_tmp_344_rule(Parser *p) +_tmp_377_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52829,21 +57252,21 @@ _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_377[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (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_377[%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_377[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -52852,9 +57275,9 @@ _tmp_344_rule(Parser *p) return _res; } -// _tmp_345: 'as' star_target +// _tmp_378: 'as' star_target static void * -_tmp_345_rule(Parser *p) +_tmp_378_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52871,21 +57294,21 @@ _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_378[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (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_378[%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_378[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -52894,9 +57317,9 @@ _tmp_345_rule(Parser *p) return _res; } -// _tmp_346: 'as' star_target +// _tmp_379: 'as' star_target static void * -_tmp_346_rule(Parser *p) +_tmp_379_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52913,21 +57336,21 @@ _tmp_346_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_346[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_379[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (star_target_var = star_target_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_379[%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_346[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_379[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL; @@ -52936,9 +57359,9 @@ _tmp_346_rule(Parser *p) return _res; } -// _tmp_347: 'as' star_target +// _tmp_380: 'as' star_target static void * -_tmp_347_rule(Parser *p) +_tmp_380_rule(Parser *p) { if (p->level++ == MAXSTACK) { p->error_indicator = 1; @@ -52955,21 +57378,21 @@ _tmp_347_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_347[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_380[%d-%d L%d]: %s\n", p->level, ' ', _mark, p->mark, p->tok->lineno, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='as' + (_keyword = _PyPegen_expect_token(p, 751)) // token='as' && (star_target_var = star_target_rule(p)) // 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")); + D(fprintf(stderr, "%*c+ _tmp_380[%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_347[%d-%d L%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_380[%d-%d L%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, p->tok->lineno, "'as' star_target")); } _res = NULL;