bpo-40334: PEP 617 implementation: New PEG parser for CPython (GH-19503)
Co-authored-by: Guido van Rossum <guido@python.org>
Co-authored-by: Lysandros Nikolaou <lisandrosnik@gmail.com>
diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c
new file mode 100644
index 0000000..25607ea
--- /dev/null
+++ b/Parser/pegen/parse.c
@@ -0,0 +1,15391 @@
+// @generated by pegen.py from ./Grammar/python.gram
+#include "pegen.h"
+static const int n_keyword_lists = 15;
+static KeywordToken *reserved_keywords[] = {
+ NULL,
+ NULL,
+ (KeywordToken[]) {
+ {"if", 510},
+ {"in", 518},
+ {"is", 526},
+ {"as", 531},
+ {"or", 532},
+ {NULL, -1},
+ },
+ (KeywordToken[]) {
+ {"del", 503},
+ {"try", 511},
+ {"for", 517},
+ {"def", 522},
+ {"not", 525},
+ {"and", 533},
+ {NULL, -1},
+ },
+ (KeywordToken[]) {
+ {"pass", 502},
+ {"from", 514},
+ {"elif", 515},
+ {"else", 516},
+ {"with", 519},
+ {"True", 527},
+ {"None", 529},
+ {NULL, -1},
+ },
+ (KeywordToken[]) {
+ {"raise", 501},
+ {"yield", 504},
+ {"break", 506},
+ {"while", 512},
+ {"class", 523},
+ {"False", 528},
+ {NULL, -1},
+ },
+ (KeywordToken[]) {
+ {"return", 500},
+ {"assert", 505},
+ {"global", 508},
+ {"import", 513},
+ {"except", 520},
+ {"lambda", 524},
+ {NULL, -1},
+ },
+ (KeywordToken[]) {
+ {"finally", 521},
+ {NULL, -1},
+ },
+ (KeywordToken[]) {
+ {"continue", 507},
+ {"nonlocal", 509},
+ {NULL, -1},
+ },
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (KeywordToken[]) {
+ {"__new_parser__", 530},
+ {NULL, -1},
+ },
+};
+#define file_type 1000
+#define interactive_type 1001
+#define eval_type 1002
+#define fstring_type 1003
+#define statements_type 1004
+#define statement_type 1005
+#define statement_newline_type 1006
+#define simple_stmt_type 1007
+#define small_stmt_type 1008
+#define compound_stmt_type 1009
+#define assignment_type 1010
+#define augassign_type 1011
+#define global_stmt_type 1012
+#define nonlocal_stmt_type 1013
+#define yield_stmt_type 1014
+#define assert_stmt_type 1015
+#define del_stmt_type 1016
+#define import_stmt_type 1017
+#define import_name_type 1018
+#define import_from_type 1019
+#define import_from_targets_type 1020
+#define import_from_as_names_type 1021
+#define import_from_as_name_type 1022
+#define dotted_as_names_type 1023
+#define dotted_as_name_type 1024
+#define dotted_name_type 1025 // Left-recursive
+#define if_stmt_type 1026
+#define elif_stmt_type 1027
+#define else_block_type 1028
+#define while_stmt_type 1029
+#define for_stmt_type 1030
+#define with_stmt_type 1031
+#define with_item_type 1032
+#define try_stmt_type 1033
+#define except_block_type 1034
+#define finally_block_type 1035
+#define return_stmt_type 1036
+#define raise_stmt_type 1037
+#define function_def_type 1038
+#define function_def_raw_type 1039
+#define params_type 1040
+#define parameters_type 1041
+#define slash_without_default_type 1042
+#define slash_with_default_type 1043
+#define star_etc_type 1044
+#define name_with_optional_default_type 1045
+#define names_with_default_type 1046
+#define name_with_default_type 1047
+#define plain_names_type 1048
+#define plain_name_type 1049
+#define kwds_type 1050
+#define annotation_type 1051
+#define decorators_type 1052
+#define class_def_type 1053
+#define class_def_raw_type 1054
+#define block_type 1055
+#define expressions_list_type 1056
+#define star_expressions_type 1057
+#define star_expression_type 1058
+#define star_named_expressions_type 1059
+#define star_named_expression_type 1060
+#define named_expression_type 1061
+#define annotated_rhs_type 1062
+#define expressions_type 1063
+#define expression_type 1064
+#define lambdef_type 1065
+#define lambda_parameters_type 1066
+#define lambda_slash_without_default_type 1067
+#define lambda_slash_with_default_type 1068
+#define lambda_star_etc_type 1069
+#define lambda_name_with_optional_default_type 1070
+#define lambda_names_with_default_type 1071
+#define lambda_name_with_default_type 1072
+#define lambda_plain_names_type 1073
+#define lambda_plain_name_type 1074
+#define lambda_kwds_type 1075
+#define disjunction_type 1076
+#define conjunction_type 1077
+#define inversion_type 1078
+#define comparison_type 1079
+#define compare_op_bitwise_or_pair_type 1080
+#define eq_bitwise_or_type 1081
+#define noteq_bitwise_or_type 1082
+#define lte_bitwise_or_type 1083
+#define lt_bitwise_or_type 1084
+#define gte_bitwise_or_type 1085
+#define gt_bitwise_or_type 1086
+#define notin_bitwise_or_type 1087
+#define in_bitwise_or_type 1088
+#define isnot_bitwise_or_type 1089
+#define is_bitwise_or_type 1090
+#define bitwise_or_type 1091 // Left-recursive
+#define bitwise_xor_type 1092 // Left-recursive
+#define bitwise_and_type 1093 // Left-recursive
+#define shift_expr_type 1094 // Left-recursive
+#define sum_type 1095 // Left-recursive
+#define term_type 1096 // Left-recursive
+#define factor_type 1097
+#define power_type 1098
+#define await_primary_type 1099
+#define primary_type 1100 // Left-recursive
+#define slices_type 1101
+#define slice_type 1102
+#define atom_type 1103
+#define strings_type 1104
+#define list_type 1105
+#define listcomp_type 1106
+#define tuple_type 1107
+#define group_type 1108
+#define genexp_type 1109
+#define set_type 1110
+#define setcomp_type 1111
+#define dict_type 1112
+#define dictcomp_type 1113
+#define kvpairs_type 1114
+#define kvpair_type 1115
+#define for_if_clauses_type 1116
+#define yield_expr_type 1117
+#define arguments_type 1118
+#define args_type 1119
+#define kwargs_type 1120
+#define starred_expression_type 1121
+#define kwarg_or_starred_type 1122
+#define kwarg_or_double_starred_type 1123
+#define star_targets_type 1124
+#define star_targets_seq_type 1125
+#define star_target_type 1126
+#define star_atom_type 1127
+#define inside_paren_ann_assign_target_type 1128
+#define ann_assign_subscript_attribute_target_type 1129
+#define del_targets_type 1130
+#define del_target_type 1131
+#define del_t_atom_type 1132
+#define targets_type 1133
+#define target_type 1134
+#define t_primary_type 1135 // Left-recursive
+#define t_lookahead_type 1136
+#define t_atom_type 1137
+#define incorrect_arguments_type 1138
+#define invalid_named_expression_type 1139
+#define invalid_assignment_type 1140
+#define invalid_block_type 1141
+#define invalid_comprehension_type 1142
+#define invalid_parameters_type 1143
+#define _loop0_1_type 1144
+#define _loop1_2_type 1145
+#define _loop0_4_type 1146
+#define _gather_3_type 1147
+#define _tmp_5_type 1148
+#define _tmp_6_type 1149
+#define _tmp_7_type 1150
+#define _tmp_8_type 1151
+#define _tmp_9_type 1152
+#define _tmp_10_type 1153
+#define _tmp_11_type 1154
+#define _tmp_12_type 1155
+#define _loop1_13_type 1156
+#define _tmp_14_type 1157
+#define _tmp_15_type 1158
+#define _loop0_17_type 1159
+#define _gather_16_type 1160
+#define _loop0_19_type 1161
+#define _gather_18_type 1162
+#define _tmp_20_type 1163
+#define _loop0_21_type 1164
+#define _loop1_22_type 1165
+#define _loop0_24_type 1166
+#define _gather_23_type 1167
+#define _tmp_25_type 1168
+#define _loop0_27_type 1169
+#define _gather_26_type 1170
+#define _tmp_28_type 1171
+#define _loop0_30_type 1172
+#define _gather_29_type 1173
+#define _loop0_32_type 1174
+#define _gather_31_type 1175
+#define _tmp_33_type 1176
+#define _loop1_34_type 1177
+#define _tmp_35_type 1178
+#define _tmp_36_type 1179
+#define _tmp_37_type 1180
+#define _tmp_38_type 1181
+#define _tmp_39_type 1182
+#define _tmp_40_type 1183
+#define _tmp_41_type 1184
+#define _tmp_42_type 1185
+#define _tmp_43_type 1186
+#define _tmp_44_type 1187
+#define _tmp_45_type 1188
+#define _tmp_46_type 1189
+#define _loop0_47_type 1190
+#define _tmp_48_type 1191
+#define _loop1_49_type 1192
+#define _tmp_50_type 1193
+#define _tmp_51_type 1194
+#define _loop0_53_type 1195
+#define _gather_52_type 1196
+#define _loop0_55_type 1197
+#define _gather_54_type 1198
+#define _tmp_56_type 1199
+#define _loop1_57_type 1200
+#define _tmp_58_type 1201
+#define _loop0_60_type 1202
+#define _gather_59_type 1203
+#define _loop1_61_type 1204
+#define _loop0_63_type 1205
+#define _gather_62_type 1206
+#define _loop1_64_type 1207
+#define _tmp_65_type 1208
+#define _tmp_66_type 1209
+#define _tmp_67_type 1210
+#define _tmp_68_type 1211
+#define _tmp_69_type 1212
+#define _tmp_70_type 1213
+#define _tmp_71_type 1214
+#define _tmp_72_type 1215
+#define _tmp_73_type 1216
+#define _loop0_74_type 1217
+#define _tmp_75_type 1218
+#define _loop1_76_type 1219
+#define _tmp_77_type 1220
+#define _tmp_78_type 1221
+#define _loop0_80_type 1222
+#define _gather_79_type 1223
+#define _loop0_82_type 1224
+#define _gather_81_type 1225
+#define _loop1_83_type 1226
+#define _loop1_84_type 1227
+#define _loop1_85_type 1228
+#define _loop0_87_type 1229
+#define _gather_86_type 1230
+#define _tmp_88_type 1231
+#define _tmp_89_type 1232
+#define _tmp_90_type 1233
+#define _tmp_91_type 1234
+#define _loop1_92_type 1235
+#define _tmp_93_type 1236
+#define _tmp_94_type 1237
+#define _loop0_96_type 1238
+#define _gather_95_type 1239
+#define _loop1_97_type 1240
+#define _tmp_98_type 1241
+#define _tmp_99_type 1242
+#define _loop0_101_type 1243
+#define _gather_100_type 1244
+#define _loop0_103_type 1245
+#define _gather_102_type 1246
+#define _loop0_105_type 1247
+#define _gather_104_type 1248
+#define _loop0_107_type 1249
+#define _gather_106_type 1250
+#define _loop0_108_type 1251
+#define _loop0_110_type 1252
+#define _gather_109_type 1253
+#define _tmp_111_type 1254
+#define _loop0_113_type 1255
+#define _gather_112_type 1256
+#define _loop0_115_type 1257
+#define _gather_114_type 1258
+#define _tmp_116_type 1259
+#define _tmp_117_type 1260
+#define _tmp_118_type 1261
+#define _tmp_119_type 1262
+#define _tmp_120_type 1263
+#define _tmp_121_type 1264
+#define _tmp_122_type 1265
+#define _tmp_123_type 1266
+#define _tmp_124_type 1267
+#define _tmp_125_type 1268
+#define _tmp_126_type 1269
+#define _tmp_127_type 1270
+#define _tmp_128_type 1271
+#define _tmp_129_type 1272
+#define _tmp_130_type 1273
+#define _tmp_131_type 1274
+#define _tmp_132_type 1275
+#define _tmp_133_type 1276
+#define _tmp_134_type 1277
+#define _loop0_135_type 1278
+#define _tmp_136_type 1279
+
+static mod_ty file_rule(Parser *p);
+static mod_ty interactive_rule(Parser *p);
+static mod_ty eval_rule(Parser *p);
+static expr_ty fstring_rule(Parser *p);
+static asdl_seq* statements_rule(Parser *p);
+static asdl_seq* statement_rule(Parser *p);
+static asdl_seq* statement_newline_rule(Parser *p);
+static asdl_seq* simple_stmt_rule(Parser *p);
+static stmt_ty small_stmt_rule(Parser *p);
+static stmt_ty compound_stmt_rule(Parser *p);
+static void *assignment_rule(Parser *p);
+static AugOperator* augassign_rule(Parser *p);
+static stmt_ty global_stmt_rule(Parser *p);
+static stmt_ty nonlocal_stmt_rule(Parser *p);
+static stmt_ty yield_stmt_rule(Parser *p);
+static stmt_ty assert_stmt_rule(Parser *p);
+static stmt_ty del_stmt_rule(Parser *p);
+static stmt_ty import_stmt_rule(Parser *p);
+static stmt_ty import_name_rule(Parser *p);
+static stmt_ty import_from_rule(Parser *p);
+static asdl_seq* import_from_targets_rule(Parser *p);
+static asdl_seq* import_from_as_names_rule(Parser *p);
+static alias_ty import_from_as_name_rule(Parser *p);
+static asdl_seq* dotted_as_names_rule(Parser *p);
+static alias_ty dotted_as_name_rule(Parser *p);
+static expr_ty dotted_name_rule(Parser *p);
+static stmt_ty if_stmt_rule(Parser *p);
+static stmt_ty elif_stmt_rule(Parser *p);
+static asdl_seq* else_block_rule(Parser *p);
+static stmt_ty while_stmt_rule(Parser *p);
+static stmt_ty for_stmt_rule(Parser *p);
+static stmt_ty with_stmt_rule(Parser *p);
+static withitem_ty with_item_rule(Parser *p);
+static stmt_ty try_stmt_rule(Parser *p);
+static excepthandler_ty except_block_rule(Parser *p);
+static asdl_seq* finally_block_rule(Parser *p);
+static stmt_ty return_stmt_rule(Parser *p);
+static stmt_ty raise_stmt_rule(Parser *p);
+static stmt_ty function_def_rule(Parser *p);
+static stmt_ty function_def_raw_rule(Parser *p);
+static arguments_ty params_rule(Parser *p);
+static arguments_ty parameters_rule(Parser *p);
+static asdl_seq* slash_without_default_rule(Parser *p);
+static SlashWithDefault* slash_with_default_rule(Parser *p);
+static StarEtc* star_etc_rule(Parser *p);
+static NameDefaultPair* name_with_optional_default_rule(Parser *p);
+static asdl_seq* names_with_default_rule(Parser *p);
+static NameDefaultPair* name_with_default_rule(Parser *p);
+static asdl_seq* plain_names_rule(Parser *p);
+static arg_ty plain_name_rule(Parser *p);
+static arg_ty kwds_rule(Parser *p);
+static expr_ty annotation_rule(Parser *p);
+static asdl_seq* decorators_rule(Parser *p);
+static stmt_ty class_def_rule(Parser *p);
+static stmt_ty class_def_raw_rule(Parser *p);
+static asdl_seq* block_rule(Parser *p);
+static asdl_seq* expressions_list_rule(Parser *p);
+static expr_ty star_expressions_rule(Parser *p);
+static expr_ty star_expression_rule(Parser *p);
+static asdl_seq* star_named_expressions_rule(Parser *p);
+static expr_ty star_named_expression_rule(Parser *p);
+static expr_ty named_expression_rule(Parser *p);
+static expr_ty annotated_rhs_rule(Parser *p);
+static expr_ty expressions_rule(Parser *p);
+static expr_ty expression_rule(Parser *p);
+static expr_ty lambdef_rule(Parser *p);
+static arguments_ty lambda_parameters_rule(Parser *p);
+static asdl_seq* lambda_slash_without_default_rule(Parser *p);
+static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
+static StarEtc* lambda_star_etc_rule(Parser *p);
+static NameDefaultPair* lambda_name_with_optional_default_rule(Parser *p);
+static asdl_seq* lambda_names_with_default_rule(Parser *p);
+static NameDefaultPair* lambda_name_with_default_rule(Parser *p);
+static asdl_seq* lambda_plain_names_rule(Parser *p);
+static arg_ty lambda_plain_name_rule(Parser *p);
+static arg_ty lambda_kwds_rule(Parser *p);
+static expr_ty disjunction_rule(Parser *p);
+static expr_ty conjunction_rule(Parser *p);
+static expr_ty inversion_rule(Parser *p);
+static expr_ty comparison_rule(Parser *p);
+static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
+static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
+static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
+static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
+static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
+static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
+static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
+static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
+static CmpopExprPair* in_bitwise_or_rule(Parser *p);
+static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
+static CmpopExprPair* is_bitwise_or_rule(Parser *p);
+static expr_ty bitwise_or_rule(Parser *p);
+static expr_ty bitwise_xor_rule(Parser *p);
+static expr_ty bitwise_and_rule(Parser *p);
+static expr_ty shift_expr_rule(Parser *p);
+static expr_ty sum_rule(Parser *p);
+static expr_ty term_rule(Parser *p);
+static expr_ty factor_rule(Parser *p);
+static expr_ty power_rule(Parser *p);
+static expr_ty await_primary_rule(Parser *p);
+static expr_ty primary_rule(Parser *p);
+static expr_ty slices_rule(Parser *p);
+static expr_ty slice_rule(Parser *p);
+static expr_ty atom_rule(Parser *p);
+static expr_ty strings_rule(Parser *p);
+static expr_ty list_rule(Parser *p);
+static expr_ty listcomp_rule(Parser *p);
+static expr_ty tuple_rule(Parser *p);
+static expr_ty group_rule(Parser *p);
+static expr_ty genexp_rule(Parser *p);
+static expr_ty set_rule(Parser *p);
+static expr_ty setcomp_rule(Parser *p);
+static expr_ty dict_rule(Parser *p);
+static expr_ty dictcomp_rule(Parser *p);
+static asdl_seq* kvpairs_rule(Parser *p);
+static KeyValuePair* kvpair_rule(Parser *p);
+static asdl_seq* for_if_clauses_rule(Parser *p);
+static expr_ty yield_expr_rule(Parser *p);
+static expr_ty arguments_rule(Parser *p);
+static expr_ty args_rule(Parser *p);
+static asdl_seq* kwargs_rule(Parser *p);
+static expr_ty starred_expression_rule(Parser *p);
+static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
+static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
+static expr_ty star_targets_rule(Parser *p);
+static asdl_seq* star_targets_seq_rule(Parser *p);
+static expr_ty star_target_rule(Parser *p);
+static expr_ty star_atom_rule(Parser *p);
+static expr_ty inside_paren_ann_assign_target_rule(Parser *p);
+static expr_ty ann_assign_subscript_attribute_target_rule(Parser *p);
+static asdl_seq* del_targets_rule(Parser *p);
+static expr_ty del_target_rule(Parser *p);
+static expr_ty del_t_atom_rule(Parser *p);
+static asdl_seq* targets_rule(Parser *p);
+static expr_ty target_rule(Parser *p);
+static expr_ty t_primary_rule(Parser *p);
+static void *t_lookahead_rule(Parser *p);
+static expr_ty t_atom_rule(Parser *p);
+static void *incorrect_arguments_rule(Parser *p);
+static void *invalid_named_expression_rule(Parser *p);
+static void *invalid_assignment_rule(Parser *p);
+static void *invalid_block_rule(Parser *p);
+static void *invalid_comprehension_rule(Parser *p);
+static void *invalid_parameters_rule(Parser *p);
+static asdl_seq *_loop0_1_rule(Parser *p);
+static asdl_seq *_loop1_2_rule(Parser *p);
+static asdl_seq *_loop0_4_rule(Parser *p);
+static asdl_seq *_gather_3_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 asdl_seq *_loop1_13_rule(Parser *p);
+static void *_tmp_14_rule(Parser *p);
+static void *_tmp_15_rule(Parser *p);
+static asdl_seq *_loop0_17_rule(Parser *p);
+static asdl_seq *_gather_16_rule(Parser *p);
+static asdl_seq *_loop0_19_rule(Parser *p);
+static asdl_seq *_gather_18_rule(Parser *p);
+static void *_tmp_20_rule(Parser *p);
+static asdl_seq *_loop0_21_rule(Parser *p);
+static asdl_seq *_loop1_22_rule(Parser *p);
+static asdl_seq *_loop0_24_rule(Parser *p);
+static asdl_seq *_gather_23_rule(Parser *p);
+static void *_tmp_25_rule(Parser *p);
+static asdl_seq *_loop0_27_rule(Parser *p);
+static asdl_seq *_gather_26_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 asdl_seq *_loop1_34_rule(Parser *p);
+static void *_tmp_35_rule(Parser *p);
+static void *_tmp_36_rule(Parser *p);
+static void *_tmp_37_rule(Parser *p);
+static void *_tmp_38_rule(Parser *p);
+static void *_tmp_39_rule(Parser *p);
+static void *_tmp_40_rule(Parser *p);
+static void *_tmp_41_rule(Parser *p);
+static void *_tmp_42_rule(Parser *p);
+static void *_tmp_43_rule(Parser *p);
+static void *_tmp_44_rule(Parser *p);
+static void *_tmp_45_rule(Parser *p);
+static void *_tmp_46_rule(Parser *p);
+static asdl_seq *_loop0_47_rule(Parser *p);
+static void *_tmp_48_rule(Parser *p);
+static asdl_seq *_loop1_49_rule(Parser *p);
+static void *_tmp_50_rule(Parser *p);
+static void *_tmp_51_rule(Parser *p);
+static asdl_seq *_loop0_53_rule(Parser *p);
+static asdl_seq *_gather_52_rule(Parser *p);
+static asdl_seq *_loop0_55_rule(Parser *p);
+static asdl_seq *_gather_54_rule(Parser *p);
+static void *_tmp_56_rule(Parser *p);
+static asdl_seq *_loop1_57_rule(Parser *p);
+static void *_tmp_58_rule(Parser *p);
+static asdl_seq *_loop0_60_rule(Parser *p);
+static asdl_seq *_gather_59_rule(Parser *p);
+static asdl_seq *_loop1_61_rule(Parser *p);
+static asdl_seq *_loop0_63_rule(Parser *p);
+static asdl_seq *_gather_62_rule(Parser *p);
+static asdl_seq *_loop1_64_rule(Parser *p);
+static void *_tmp_65_rule(Parser *p);
+static void *_tmp_66_rule(Parser *p);
+static void *_tmp_67_rule(Parser *p);
+static void *_tmp_68_rule(Parser *p);
+static void *_tmp_69_rule(Parser *p);
+static void *_tmp_70_rule(Parser *p);
+static void *_tmp_71_rule(Parser *p);
+static void *_tmp_72_rule(Parser *p);
+static void *_tmp_73_rule(Parser *p);
+static asdl_seq *_loop0_74_rule(Parser *p);
+static void *_tmp_75_rule(Parser *p);
+static asdl_seq *_loop1_76_rule(Parser *p);
+static void *_tmp_77_rule(Parser *p);
+static void *_tmp_78_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 *_loop1_83_rule(Parser *p);
+static asdl_seq *_loop1_84_rule(Parser *p);
+static asdl_seq *_loop1_85_rule(Parser *p);
+static asdl_seq *_loop0_87_rule(Parser *p);
+static asdl_seq *_gather_86_rule(Parser *p);
+static void *_tmp_88_rule(Parser *p);
+static void *_tmp_89_rule(Parser *p);
+static void *_tmp_90_rule(Parser *p);
+static void *_tmp_91_rule(Parser *p);
+static asdl_seq *_loop1_92_rule(Parser *p);
+static void *_tmp_93_rule(Parser *p);
+static void *_tmp_94_rule(Parser *p);
+static asdl_seq *_loop0_96_rule(Parser *p);
+static asdl_seq *_gather_95_rule(Parser *p);
+static asdl_seq *_loop1_97_rule(Parser *p);
+static void *_tmp_98_rule(Parser *p);
+static void *_tmp_99_rule(Parser *p);
+static asdl_seq *_loop0_101_rule(Parser *p);
+static asdl_seq *_gather_100_rule(Parser *p);
+static asdl_seq *_loop0_103_rule(Parser *p);
+static asdl_seq *_gather_102_rule(Parser *p);
+static asdl_seq *_loop0_105_rule(Parser *p);
+static asdl_seq *_gather_104_rule(Parser *p);
+static asdl_seq *_loop0_107_rule(Parser *p);
+static asdl_seq *_gather_106_rule(Parser *p);
+static asdl_seq *_loop0_108_rule(Parser *p);
+static asdl_seq *_loop0_110_rule(Parser *p);
+static asdl_seq *_gather_109_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 void *_tmp_117_rule(Parser *p);
+static void *_tmp_118_rule(Parser *p);
+static void *_tmp_119_rule(Parser *p);
+static void *_tmp_120_rule(Parser *p);
+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 void *_tmp_125_rule(Parser *p);
+static void *_tmp_126_rule(Parser *p);
+static void *_tmp_127_rule(Parser *p);
+static void *_tmp_128_rule(Parser *p);
+static void *_tmp_129_rule(Parser *p);
+static void *_tmp_130_rule(Parser *p);
+static void *_tmp_131_rule(Parser *p);
+static void *_tmp_132_rule(Parser *p);
+static void *_tmp_133_rule(Parser *p);
+static void *_tmp_134_rule(Parser *p);
+static asdl_seq *_loop0_135_rule(Parser *p);
+static void *_tmp_136_rule(Parser *p);
+
+
+// file: statements? $
+static mod_ty
+file_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ mod_ty res = NULL;
+ int mark = p->mark;
+ { // statements? $
+ void *a;
+ void *endmarker_var;
+ if (
+ (a = statements_rule(p), 1)
+ &&
+ (endmarker_var = _PyPegen_endmarker_token(p))
+ )
+ {
+ res = Module ( a , NULL , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// interactive: statement_newline
+static mod_ty
+interactive_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ mod_ty res = NULL;
+ int mark = p->mark;
+ { // statement_newline
+ asdl_seq* a;
+ if (
+ (a = statement_newline_rule(p))
+ )
+ {
+ res = Interactive ( a , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// eval: expressions NEWLINE* $
+static mod_ty
+eval_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ mod_ty res = NULL;
+ int mark = p->mark;
+ { // expressions NEWLINE* $
+ asdl_seq * _loop0_1_var;
+ expr_ty a;
+ void *endmarker_var;
+ if (
+ (a = expressions_rule(p))
+ &&
+ (_loop0_1_var = _loop0_1_rule(p))
+ &&
+ (endmarker_var = _PyPegen_endmarker_token(p))
+ )
+ {
+ res = Expression ( a , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// fstring: star_expressions
+static expr_ty
+fstring_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ { // star_expressions
+ expr_ty star_expressions_var;
+ if (
+ (star_expressions_var = star_expressions_rule(p))
+ )
+ {
+ res = star_expressions_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// statements: statement+
+static asdl_seq*
+statements_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // statement+
+ asdl_seq * a;
+ if (
+ (a = _loop1_2_rule(p))
+ )
+ {
+ res = _PyPegen_seq_flatten ( p , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// statement: compound_stmt | simple_stmt
+static asdl_seq*
+statement_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // compound_stmt
+ stmt_ty a;
+ if (
+ (a = compound_stmt_rule(p))
+ )
+ {
+ res = _PyPegen_singleton_seq ( p , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // simple_stmt
+ asdl_seq* simple_stmt_var;
+ if (
+ (simple_stmt_var = simple_stmt_rule(p))
+ )
+ {
+ res = simple_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// statement_newline: compound_stmt NEWLINE | simple_stmt | NEWLINE | $
+static asdl_seq*
+statement_newline_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // compound_stmt NEWLINE
+ stmt_ty a;
+ void *newline_var;
+ if (
+ (a = compound_stmt_rule(p))
+ &&
+ (newline_var = _PyPegen_newline_token(p))
+ )
+ {
+ res = _PyPegen_singleton_seq ( p , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // simple_stmt
+ asdl_seq* simple_stmt_var;
+ if (
+ (simple_stmt_var = simple_stmt_rule(p))
+ )
+ {
+ res = simple_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // NEWLINE
+ void *newline_var;
+ if (
+ (newline_var = _PyPegen_newline_token(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ return NULL;
+ }
+ int end_lineno = token->end_lineno;
+ UNUSED(end_lineno); // Only used by EXTRA macro
+ int end_col_offset = token->end_col_offset;
+ UNUSED(end_col_offset); // Only used by EXTRA macro
+ res = _PyPegen_singleton_seq ( p , CHECK ( _Py_Pass ( EXTRA ) ) );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // $
+ void *endmarker_var;
+ if (
+ (endmarker_var = _PyPegen_endmarker_token(p))
+ )
+ {
+ res = _PyPegen_interactive_exit ( p );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// simple_stmt: small_stmt !';' NEWLINE | ';'.small_stmt+ ';'? NEWLINE
+static asdl_seq*
+simple_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // small_stmt !';' NEWLINE
+ stmt_ty a;
+ void *newline_var;
+ if (
+ (a = small_stmt_rule(p))
+ &&
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13)
+ &&
+ (newline_var = _PyPegen_newline_token(p))
+ )
+ {
+ res = _PyPegen_singleton_seq ( p , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ';'.small_stmt+ ';'? NEWLINE
+ asdl_seq * a;
+ void *newline_var;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_3_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 13), 1)
+ &&
+ (newline_var = _PyPegen_newline_token(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// small_stmt:
+// | assignment
+// | star_expressions
+// | &'return' return_stmt
+// | &('import' | 'from') import_stmt
+// | &'raise' raise_stmt
+// | 'pass'
+// | &'del' del_stmt
+// | &'yield' yield_stmt
+// | &'assert' assert_stmt
+// | 'break'
+// | 'continue'
+// | &'global' global_stmt
+// | &'nonlocal' nonlocal_stmt
+static stmt_ty
+small_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ if (_PyPegen_is_memoized(p, small_stmt_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // assignment
+ void *assignment_var;
+ if (
+ (assignment_var = assignment_rule(p))
+ )
+ {
+ res = assignment_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expressions
+ expr_ty e;
+ if (
+ (e = star_expressions_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Expr ( e , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'return' return_stmt
+ stmt_ty return_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 500)
+ &&
+ (return_stmt_var = return_stmt_rule(p))
+ )
+ {
+ res = return_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &('import' | 'from') import_stmt
+ stmt_ty import_stmt_var;
+ if (
+ _PyPegen_lookahead(1, _tmp_5_rule, p)
+ &&
+ (import_stmt_var = import_stmt_rule(p))
+ )
+ {
+ res = import_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'raise' raise_stmt
+ stmt_ty raise_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 501)
+ &&
+ (raise_stmt_var = raise_stmt_rule(p))
+ )
+ {
+ res = raise_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'pass'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 502))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Pass ( EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'del' del_stmt
+ stmt_ty del_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 503)
+ &&
+ (del_stmt_var = del_stmt_rule(p))
+ )
+ {
+ res = del_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'yield' yield_stmt
+ stmt_ty yield_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 504)
+ &&
+ (yield_stmt_var = yield_stmt_rule(p))
+ )
+ {
+ res = yield_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'assert' assert_stmt
+ stmt_ty assert_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 505)
+ &&
+ (assert_stmt_var = assert_stmt_rule(p))
+ )
+ {
+ res = assert_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'break'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 506))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Break ( EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'continue'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 507))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Continue ( EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'global' global_stmt
+ stmt_ty global_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 508)
+ &&
+ (global_stmt_var = global_stmt_rule(p))
+ )
+ {
+ res = global_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'nonlocal' nonlocal_stmt
+ stmt_ty nonlocal_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 509)
+ &&
+ (nonlocal_stmt_var = nonlocal_stmt_rule(p))
+ )
+ {
+ res = nonlocal_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, small_stmt_type, res);
+ return res;
+}
+
+// compound_stmt:
+// | &('def' | '@' | ASYNC) function_def
+// | &'if' if_stmt
+// | &('class' | '@') class_def
+// | &('with' | ASYNC) with_stmt
+// | &('for' | ASYNC) for_stmt
+// | &'try' try_stmt
+// | &'while' while_stmt
+static stmt_ty
+compound_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ { // &('def' | '@' | ASYNC) function_def
+ stmt_ty function_def_var;
+ if (
+ _PyPegen_lookahead(1, _tmp_6_rule, p)
+ &&
+ (function_def_var = function_def_rule(p))
+ )
+ {
+ res = function_def_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'if' if_stmt
+ stmt_ty if_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 510)
+ &&
+ (if_stmt_var = if_stmt_rule(p))
+ )
+ {
+ res = if_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &('class' | '@') class_def
+ stmt_ty class_def_var;
+ if (
+ _PyPegen_lookahead(1, _tmp_7_rule, p)
+ &&
+ (class_def_var = class_def_rule(p))
+ )
+ {
+ res = class_def_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &('with' | ASYNC) with_stmt
+ stmt_ty with_stmt_var;
+ if (
+ _PyPegen_lookahead(1, _tmp_8_rule, p)
+ &&
+ (with_stmt_var = with_stmt_rule(p))
+ )
+ {
+ res = with_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &('for' | ASYNC) for_stmt
+ stmt_ty for_stmt_var;
+ if (
+ _PyPegen_lookahead(1, _tmp_9_rule, p)
+ &&
+ (for_stmt_var = for_stmt_rule(p))
+ )
+ {
+ res = for_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'try' try_stmt
+ stmt_ty try_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 511)
+ &&
+ (try_stmt_var = try_stmt_rule(p))
+ )
+ {
+ res = try_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'while' while_stmt
+ stmt_ty while_stmt_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 512)
+ &&
+ (while_stmt_var = while_stmt_rule(p))
+ )
+ {
+ res = while_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// assignment:
+// | NAME ':' expression ['=' annotated_rhs]
+// | ('(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target) ':' expression ['=' annotated_rhs]
+// | ((star_targets '='))+ (yield_expr | star_expressions)
+// | target augassign (yield_expr | star_expressions)
+// | invalid_assignment
+static void *
+assignment_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME ':' expression ['=' annotated_rhs]
+ expr_ty a;
+ expr_ty b;
+ void *c;
+ void *literal;
+ if (
+ (a = _PyPegen_name_token(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = expression_rule(p))
+ &&
+ (c = _tmp_10_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_AnnAssign ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ('(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target) ':' expression ['=' annotated_rhs]
+ void *a;
+ expr_ty b;
+ void *c;
+ void *literal;
+ if (
+ (a = _tmp_11_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = expression_rule(p))
+ &&
+ (c = _tmp_12_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_AnnAssign ( a , b , c , 0 , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ((star_targets '='))+ (yield_expr | star_expressions)
+ asdl_seq * a;
+ void *b;
+ if (
+ (a = _loop1_13_rule(p))
+ &&
+ (b = _tmp_14_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Assign ( a , b , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // target augassign (yield_expr | star_expressions)
+ expr_ty a;
+ AugOperator* b;
+ void *c;
+ if (
+ (a = target_rule(p))
+ &&
+ (b = augassign_rule(p))
+ &&
+ (c = _tmp_15_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_AugAssign ( a , b -> kind , c , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // invalid_assignment
+ void *invalid_assignment_var;
+ if (
+ (invalid_assignment_var = invalid_assignment_rule(p))
+ )
+ {
+ res = invalid_assignment_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// augassign:
+// | '+='
+// | '-='
+// | '*='
+// | '@='
+// | '/='
+// | '%='
+// | '&='
+// | '|='
+// | '^='
+// | '<<='
+// | '>>='
+// | '**='
+// | '//='
+static AugOperator*
+augassign_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ AugOperator* res = NULL;
+ int mark = p->mark;
+ { // '+='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 36))
+ )
+ {
+ res = _PyPegen_augoperator ( p , Add );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '-='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 37))
+ )
+ {
+ res = _PyPegen_augoperator ( p , Sub );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '*='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 38))
+ )
+ {
+ res = _PyPegen_augoperator ( p , Mult );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '@='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 50))
+ )
+ {
+ res = _PyPegen_augoperator ( p , MatMult );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '/='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 39))
+ )
+ {
+ res = _PyPegen_augoperator ( p , Div );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '%='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 40))
+ )
+ {
+ res = _PyPegen_augoperator ( p , Mod );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '&='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 41))
+ )
+ {
+ res = _PyPegen_augoperator ( p , BitAnd );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '|='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 42))
+ )
+ {
+ res = _PyPegen_augoperator ( p , BitOr );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '^='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 43))
+ )
+ {
+ res = _PyPegen_augoperator ( p , BitXor );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '<<='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 44))
+ )
+ {
+ res = _PyPegen_augoperator ( p , LShift );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '>>='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 45))
+ )
+ {
+ res = _PyPegen_augoperator ( p , RShift );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '**='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 46))
+ )
+ {
+ res = _PyPegen_augoperator ( p , Pow );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '//='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 48))
+ )
+ {
+ res = _PyPegen_augoperator ( p , FloorDiv );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// global_stmt: 'global' ','.NAME+
+static stmt_ty
+global_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'global' ','.NAME+
+ asdl_seq * a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 508))
+ &&
+ (a = _gather_16_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Global ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// nonlocal_stmt: 'nonlocal' ','.NAME+
+static stmt_ty
+nonlocal_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'nonlocal' ','.NAME+
+ asdl_seq * a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 509))
+ &&
+ (a = _gather_18_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Nonlocal ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// yield_stmt: yield_expr
+static stmt_ty
+yield_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // yield_expr
+ expr_ty y;
+ if (
+ (y = yield_expr_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Expr ( y , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// assert_stmt: 'assert' expression [',' expression]
+static stmt_ty
+assert_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'assert' expression [',' expression]
+ expr_ty a;
+ void *b;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 505))
+ &&
+ (a = expression_rule(p))
+ &&
+ (b = _tmp_20_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Assert ( a , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// del_stmt: 'del' del_targets
+static stmt_ty
+del_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'del' del_targets
+ asdl_seq* a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 503))
+ &&
+ (a = del_targets_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Delete ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// import_stmt: import_name | import_from
+static stmt_ty
+import_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ { // import_name
+ stmt_ty import_name_var;
+ if (
+ (import_name_var = import_name_rule(p))
+ )
+ {
+ res = import_name_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // import_from
+ stmt_ty import_from_var;
+ if (
+ (import_from_var = import_from_rule(p))
+ )
+ {
+ res = import_from_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// import_name: 'import' dotted_as_names
+static stmt_ty
+import_name_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'import' dotted_as_names
+ asdl_seq* a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 513))
+ &&
+ (a = dotted_as_names_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Import ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// import_from:
+// | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
+// | 'from' (('.' | '...'))+ 'import' import_from_targets
+static stmt_ty
+import_from_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
+ asdl_seq * a;
+ expr_ty b;
+ asdl_seq* c;
+ void *keyword;
+ void *keyword_1;
+ if (
+ (keyword = _PyPegen_expect_token(p, 514))
+ &&
+ (a = _loop0_21_rule(p))
+ &&
+ (b = dotted_name_rule(p))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 513))
+ &&
+ (c = import_from_targets_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'from' (('.' | '...'))+ 'import' import_from_targets
+ asdl_seq * a;
+ asdl_seq* b;
+ void *keyword;
+ void *keyword_1;
+ if (
+ (keyword = _PyPegen_expect_token(p, 514))
+ &&
+ (a = _loop1_22_rule(p))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 513))
+ &&
+ (b = import_from_targets_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// import_from_targets: '(' import_from_as_names ','? ')' | import_from_as_names | '*'
+static asdl_seq*
+import_from_targets_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // '(' import_from_as_names ','? ')'
+ asdl_seq* a;
+ void *literal;
+ void *literal_1;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = import_from_as_names_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // import_from_as_names
+ asdl_seq* import_from_as_names_var;
+ if (
+ (import_from_as_names_var = import_from_as_names_rule(p))
+ )
+ {
+ res = import_from_as_names_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '*'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ )
+ {
+ res = _PyPegen_singleton_seq ( p , CHECK ( _PyPegen_alias_for_star ( p ) ) );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// import_from_as_names: ','.import_from_as_name+
+static asdl_seq*
+import_from_as_names_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.import_from_as_name+
+ asdl_seq * a;
+ if (
+ (a = _gather_23_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// import_from_as_name: NAME ['as' NAME]
+static alias_ty
+import_from_as_name_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ alias_ty res = NULL;
+ int mark = p->mark;
+ { // NAME ['as' NAME]
+ expr_ty a;
+ void *b;
+ if (
+ (a = _PyPegen_name_token(p))
+ &&
+ (b = _tmp_25_rule(p), 1)
+ )
+ {
+ res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// dotted_as_names: ','.dotted_as_name+
+static asdl_seq*
+dotted_as_names_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.dotted_as_name+
+ asdl_seq * a;
+ if (
+ (a = _gather_26_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// dotted_as_name: dotted_name ['as' NAME]
+static alias_ty
+dotted_as_name_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ alias_ty res = NULL;
+ int mark = p->mark;
+ { // dotted_name ['as' NAME]
+ expr_ty a;
+ void *b;
+ if (
+ (a = dotted_name_rule(p))
+ &&
+ (b = _tmp_28_rule(p), 1)
+ )
+ {
+ res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// dotted_name: dotted_name '.' NAME | NAME
+static expr_ty dotted_name_raw(Parser *);
+static expr_ty
+dotted_name_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, dotted_name_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_0 = _PyPegen_update_memo(p, mark, dotted_name_type, res);
+ if (tmpvar_0) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = dotted_name_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+dotted_name_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ { // dotted_name '.' NAME
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = dotted_name_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ )
+ {
+ res = _PyPegen_join_names_with_dot ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // NAME
+ expr_ty name_var;
+ if (
+ (name_var = _PyPegen_name_token(p))
+ )
+ {
+ res = name_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// if_stmt:
+// | 'if' named_expression ':' block elif_stmt
+// | 'if' named_expression ':' block else_block?
+static stmt_ty
+if_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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 elif_stmt
+ expr_ty a;
+ asdl_seq* b;
+ stmt_ty c;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 510))
+ &&
+ (a = named_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (c = elif_stmt_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'if' named_expression ':' block else_block?
+ expr_ty a;
+ asdl_seq* b;
+ void *c;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 510))
+ &&
+ (a = named_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (c = else_block_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_If ( a , b , c , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// elif_stmt:
+// | 'elif' named_expression ':' block elif_stmt
+// | 'elif' named_expression ':' block else_block?
+static stmt_ty
+elif_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ expr_ty a;
+ asdl_seq* b;
+ stmt_ty c;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 515))
+ &&
+ (a = named_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (c = elif_stmt_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'elif' named_expression ':' block else_block?
+ expr_ty a;
+ asdl_seq* b;
+ void *c;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 515))
+ &&
+ (a = named_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (c = else_block_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_If ( a , b , c , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// else_block: 'else' ':' block
+static asdl_seq*
+else_block_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // 'else' ':' block
+ asdl_seq* b;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 516))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ )
+ {
+ res = b;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// while_stmt: 'while' named_expression ':' block else_block?
+static stmt_ty
+while_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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 else_block?
+ expr_ty a;
+ asdl_seq* b;
+ void *c;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 512))
+ &&
+ (a = named_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (c = else_block_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_While ( a , b , c , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// for_stmt: ASYNC? 'for' star_targets 'in' star_expressions ':' block else_block?
+static stmt_ty
+for_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // ASYNC? 'for' star_targets 'in' star_expressions ':' block else_block?
+ asdl_seq* b;
+ void *el;
+ expr_ty ex;
+ void *is_async;
+ void *keyword;
+ void *keyword_1;
+ void *literal;
+ expr_ty t;
+ if (
+ (is_async = _PyPegen_async_token(p), 1)
+ &&
+ (keyword = _PyPegen_expect_token(p, 517))
+ &&
+ (t = star_targets_rule(p))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 518))
+ &&
+ (ex = star_expressions_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (el = else_block_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = ( is_async ? _Py_AsyncFor : _Py_For ) ( t , ex , b , el , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// with_stmt:
+// | ASYNC? 'with' '(' ','.with_item+ ')' ':' block
+// | ASYNC? 'with' ','.with_item+ ':' block
+static stmt_ty
+with_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // ASYNC? 'with' '(' ','.with_item+ ')' ':' block
+ asdl_seq * a;
+ asdl_seq* b;
+ void *is_async;
+ void *keyword;
+ void *literal;
+ void *literal_1;
+ void *literal_2;
+ if (
+ (is_async = _PyPegen_async_token(p), 1)
+ &&
+ (keyword = _PyPegen_expect_token(p, 519))
+ &&
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = _gather_29_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ &&
+ (literal_2 = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = ( is_async ? _Py_AsyncWith : _Py_With ) ( a , b , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ASYNC? 'with' ','.with_item+ ':' block
+ asdl_seq * a;
+ asdl_seq* b;
+ void *is_async;
+ void *keyword;
+ void *literal;
+ if (
+ (is_async = _PyPegen_async_token(p), 1)
+ &&
+ (keyword = _PyPegen_expect_token(p, 519))
+ &&
+ (a = _gather_31_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = ( is_async ? _Py_AsyncWith : _Py_With ) ( a , b , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// with_item: expression ['as' target]
+static withitem_ty
+with_item_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ withitem_ty res = NULL;
+ int mark = p->mark;
+ { // expression ['as' target]
+ expr_ty e;
+ void *o;
+ if (
+ (e = expression_rule(p))
+ &&
+ (o = _tmp_33_rule(p), 1)
+ )
+ {
+ res = _Py_withitem ( e , o , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// try_stmt:
+// | 'try' ':' block finally_block
+// | 'try' ':' block except_block+ else_block? finally_block?
+static stmt_ty
+try_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'try' ':' block finally_block
+ asdl_seq* b;
+ asdl_seq* f;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 511))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (f = finally_block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Try ( b , NULL , NULL , f , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'try' ':' block except_block+ else_block? finally_block?
+ asdl_seq* b;
+ void *el;
+ asdl_seq * ex;
+ void *f;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 511))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ &&
+ (ex = _loop1_34_rule(p))
+ &&
+ (el = else_block_rule(p), 1)
+ &&
+ (f = finally_block_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Try ( b , ex , el , f , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// except_block: 'except' expression ['as' target] ':' block | 'except' ':' block
+static excepthandler_ty
+except_block_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ excepthandler_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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' target] ':' block
+ asdl_seq* b;
+ expr_ty e;
+ void *keyword;
+ void *literal;
+ void *t;
+ if (
+ (keyword = _PyPegen_expect_token(p, 520))
+ &&
+ (e = expression_rule(p))
+ &&
+ (t = _tmp_35_rule(p), 1)
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'except' ':' block
+ asdl_seq* b;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 520))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_ExceptHandler ( NULL , NULL , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// finally_block: 'finally' ':' block
+static asdl_seq*
+finally_block_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // 'finally' ':' block
+ asdl_seq* a;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 521))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (a = block_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// return_stmt: 'return' star_expressions?
+static stmt_ty
+return_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'return' star_expressions?
+ void *a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 500))
+ &&
+ (a = star_expressions_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Return ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// raise_stmt: 'raise' expression ['from' expression] | 'raise'
+static stmt_ty
+raise_stmt_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'raise' expression ['from' expression]
+ expr_ty a;
+ void *b;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 501))
+ &&
+ (a = expression_rule(p))
+ &&
+ (b = _tmp_36_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Raise ( a , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'raise'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 501))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Raise ( NULL , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// function_def: decorators function_def_raw | function_def_raw
+static stmt_ty
+function_def_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ { // decorators function_def_raw
+ asdl_seq* d;
+ stmt_ty f;
+ if (
+ (d = decorators_rule(p))
+ &&
+ (f = function_def_raw_rule(p))
+ )
+ {
+ res = _PyPegen_function_def_decorators ( p , d , f );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // function_def_raw
+ stmt_ty function_def_raw_var;
+ if (
+ (function_def_raw_var = function_def_raw_rule(p))
+ )
+ {
+ res = function_def_raw_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// function_def_raw: ASYNC? 'def' NAME '(' params? ')' ['->' annotation] ':' block
+static stmt_ty
+function_def_raw_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // ASYNC? 'def' NAME '(' params? ')' ['->' annotation] ':' block
+ void *a;
+ asdl_seq* b;
+ void *is_async;
+ void *keyword;
+ void *literal;
+ void *literal_1;
+ void *literal_2;
+ expr_ty n;
+ void *params;
+ if (
+ (is_async = _PyPegen_async_token(p), 1)
+ &&
+ (keyword = _PyPegen_expect_token(p, 522))
+ &&
+ (n = _PyPegen_name_token(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (params = params_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ &&
+ (a = _tmp_37_rule(p), 1)
+ &&
+ (literal_2 = _PyPegen_expect_token(p, 11))
+ &&
+ (b = block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = ( is_async ? _Py_AsyncFunctionDef : _Py_FunctionDef ) ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// params: invalid_parameters | parameters
+static arguments_ty
+params_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arguments_ty res = NULL;
+ int mark = p->mark;
+ { // invalid_parameters
+ void *invalid_parameters_var;
+ if (
+ (invalid_parameters_var = invalid_parameters_rule(p))
+ )
+ {
+ res = invalid_parameters_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // parameters
+ arguments_ty parameters_var;
+ if (
+ (parameters_var = parameters_rule(p))
+ )
+ {
+ res = parameters_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// parameters:
+// | slash_without_default [',' plain_names] [',' names_with_default] [',' star_etc?]
+// | slash_with_default [',' names_with_default] [',' star_etc?]
+// | plain_names [',' names_with_default] [',' star_etc?]
+// | names_with_default [',' star_etc?]
+// | star_etc
+static arguments_ty
+parameters_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arguments_ty res = NULL;
+ int mark = p->mark;
+ { // slash_without_default [',' plain_names] [',' names_with_default] [',' star_etc?]
+ asdl_seq* a;
+ void *b;
+ void *c;
+ void *d;
+ if (
+ (a = slash_without_default_rule(p))
+ &&
+ (b = _tmp_38_rule(p), 1)
+ &&
+ (c = _tmp_39_rule(p), 1)
+ &&
+ (d = _tmp_40_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // slash_with_default [',' names_with_default] [',' star_etc?]
+ SlashWithDefault* a;
+ void *b;
+ void *c;
+ if (
+ (a = slash_with_default_rule(p))
+ &&
+ (b = _tmp_41_rule(p), 1)
+ &&
+ (c = _tmp_42_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // plain_names [',' names_with_default] [',' star_etc?]
+ asdl_seq* a;
+ void *b;
+ void *c;
+ if (
+ (a = plain_names_rule(p))
+ &&
+ (b = _tmp_43_rule(p), 1)
+ &&
+ (c = _tmp_44_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // names_with_default [',' star_etc?]
+ asdl_seq* a;
+ void *b;
+ if (
+ (a = names_with_default_rule(p))
+ &&
+ (b = _tmp_45_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_etc
+ StarEtc* a;
+ if (
+ (a = star_etc_rule(p))
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// slash_without_default: plain_names ',' '/'
+static asdl_seq*
+slash_without_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // plain_names ',' '/'
+ asdl_seq* a;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = plain_names_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 17))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// slash_with_default: [plain_names ','] names_with_default ',' '/'
+static SlashWithDefault*
+slash_with_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ SlashWithDefault* res = NULL;
+ int mark = p->mark;
+ { // [plain_names ','] names_with_default ',' '/'
+ void *a;
+ asdl_seq* b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = _tmp_46_rule(p), 1)
+ &&
+ (b = names_with_default_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 17))
+ )
+ {
+ res = _PyPegen_slash_with_default ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_etc:
+// | '*' plain_name name_with_optional_default* [',' kwds] ','?
+// | '*' name_with_optional_default+ [',' kwds] ','?
+// | kwds ','?
+static StarEtc*
+star_etc_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ StarEtc* res = NULL;
+ int mark = p->mark;
+ { // '*' plain_name name_with_optional_default* [',' kwds] ','?
+ arg_ty a;
+ asdl_seq * b;
+ void *c;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (a = plain_name_rule(p))
+ &&
+ (b = _loop0_47_rule(p))
+ &&
+ (c = _tmp_48_rule(p), 1)
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = _PyPegen_star_etc ( p , a , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '*' name_with_optional_default+ [',' kwds] ','?
+ asdl_seq * b;
+ void *c;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (b = _loop1_49_rule(p))
+ &&
+ (c = _tmp_50_rule(p), 1)
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = _PyPegen_star_etc ( p , NULL , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // kwds ','?
+ arg_ty a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = kwds_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = _PyPegen_star_etc ( p , NULL , NULL , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// name_with_optional_default: ',' plain_name ['=' expression]
+static NameDefaultPair*
+name_with_optional_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ NameDefaultPair* res = NULL;
+ int mark = p->mark;
+ { // ',' plain_name ['=' expression]
+ arg_ty a;
+ void *b;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (a = plain_name_rule(p))
+ &&
+ (b = _tmp_51_rule(p), 1)
+ )
+ {
+ res = _PyPegen_name_default_pair ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// names_with_default: ','.name_with_default+
+static asdl_seq*
+names_with_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.name_with_default+
+ asdl_seq * a;
+ if (
+ (a = _gather_52_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// name_with_default: plain_name '=' expression
+static NameDefaultPair*
+name_with_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ NameDefaultPair* res = NULL;
+ int mark = p->mark;
+ { // plain_name '=' expression
+ expr_ty e;
+ void *literal;
+ arg_ty n;
+ if (
+ (n = plain_name_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (e = expression_rule(p))
+ )
+ {
+ res = _PyPegen_name_default_pair ( p , n , e );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// plain_names: ','.(plain_name !'=')+
+static asdl_seq*
+plain_names_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ if (_PyPegen_is_memoized(p, plain_names_type, &res))
+ return res;
+ int mark = p->mark;
+ { // ','.(plain_name !'=')+
+ asdl_seq * a;
+ if (
+ (a = _gather_54_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, plain_names_type, res);
+ return res;
+}
+
+// plain_name: NAME [':' annotation]
+static arg_ty
+plain_name_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arg_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME [':' annotation]
+ expr_ty a;
+ void *b;
+ if (
+ (a = _PyPegen_name_token(p))
+ &&
+ (b = _tmp_56_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_arg ( a -> v . Name . id , b , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// kwds: '**' plain_name
+static arg_ty
+kwds_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arg_ty res = NULL;
+ int mark = p->mark;
+ { // '**' plain_name
+ arg_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 35))
+ &&
+ (a = plain_name_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// annotation: expression
+static expr_ty
+annotation_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ { // expression
+ expr_ty expression_var;
+ if (
+ (expression_var = expression_rule(p))
+ )
+ {
+ res = expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// decorators: (('@' named_expression NEWLINE))+
+static asdl_seq*
+decorators_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // (('@' named_expression NEWLINE))+
+ asdl_seq * a;
+ if (
+ (a = _loop1_57_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// class_def: decorators class_def_raw | class_def_raw
+static stmt_ty
+class_def_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ { // decorators class_def_raw
+ asdl_seq* a;
+ stmt_ty b;
+ if (
+ (a = decorators_rule(p))
+ &&
+ (b = class_def_raw_rule(p))
+ )
+ {
+ res = _PyPegen_class_def_decorators ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // class_def_raw
+ stmt_ty class_def_raw_var;
+ if (
+ (class_def_raw_var = class_def_raw_rule(p))
+ )
+ {
+ res = class_def_raw_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// class_def_raw: 'class' NAME ['(' arguments? ')'] ':' block
+static stmt_ty
+class_def_raw_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ stmt_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'class' NAME ['(' arguments? ')'] ':' block
+ expr_ty a;
+ void *b;
+ asdl_seq* c;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 523))
+ &&
+ (a = _PyPegen_name_token(p))
+ &&
+ (b = _tmp_58_rule(p), 1)
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (c = block_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// block: NEWLINE INDENT statements DEDENT | simple_stmt | invalid_block
+static asdl_seq*
+block_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ if (_PyPegen_is_memoized(p, block_type, &res))
+ return res;
+ int mark = p->mark;
+ { // NEWLINE INDENT statements DEDENT
+ asdl_seq* a;
+ void *dedent_var;
+ void *indent_var;
+ void *newline_var;
+ if (
+ (newline_var = _PyPegen_newline_token(p))
+ &&
+ (indent_var = _PyPegen_indent_token(p))
+ &&
+ (a = statements_rule(p))
+ &&
+ (dedent_var = _PyPegen_dedent_token(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // simple_stmt
+ asdl_seq* simple_stmt_var;
+ if (
+ (simple_stmt_var = simple_stmt_rule(p))
+ )
+ {
+ res = simple_stmt_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // invalid_block
+ void *invalid_block_var;
+ if (
+ (invalid_block_var = invalid_block_rule(p))
+ )
+ {
+ res = invalid_block_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, block_type, res);
+ return res;
+}
+
+// expressions_list: ','.star_expression+ ','?
+static asdl_seq*
+expressions_list_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.star_expression+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_59_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_expressions:
+// | star_expression ((',' star_expression))+ ','?
+// | star_expression ','
+// | star_expression
+static expr_ty
+star_expressions_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // star_expression ((',' star_expression))+ ','?
+ expr_ty a;
+ asdl_seq * b;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = star_expression_rule(p))
+ &&
+ (b = _loop1_61_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expression ','
+ expr_ty a;
+ void *literal;
+ if (
+ (a = star_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expression
+ expr_ty star_expression_var;
+ if (
+ (star_expression_var = star_expression_rule(p))
+ )
+ {
+ res = star_expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_expression: '*' bitwise_or | expression
+static expr_ty
+star_expression_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, star_expression_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '*' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Starred ( a , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression
+ expr_ty expression_var;
+ if (
+ (expression_var = expression_rule(p))
+ )
+ {
+ res = expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, star_expression_type, res);
+ return res;
+}
+
+// star_named_expressions: ','.star_named_expression+ ','?
+static asdl_seq*
+star_named_expressions_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.star_named_expression+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_62_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_named_expression: '*' bitwise_or | named_expression
+static expr_ty
+star_named_expression_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '*' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Starred ( a , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // named_expression
+ expr_ty named_expression_var;
+ if (
+ (named_expression_var = named_expression_rule(p))
+ )
+ {
+ res = named_expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// named_expression: NAME ':=' expression | expression !':=' | invalid_named_expression
+static expr_ty
+named_expression_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME ':=' expression
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = _PyPegen_name_token(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 53))
+ &&
+ (b = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_NamedExpr ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression !':='
+ expr_ty expression_var;
+ if (
+ (expression_var = expression_rule(p))
+ &&
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)
+ )
+ {
+ res = expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // invalid_named_expression
+ void *invalid_named_expression_var;
+ if (
+ (invalid_named_expression_var = invalid_named_expression_rule(p))
+ )
+ {
+ res = invalid_named_expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// annotated_rhs: yield_expr | star_expressions
+static expr_ty
+annotated_rhs_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ { // yield_expr
+ expr_ty yield_expr_var;
+ if (
+ (yield_expr_var = yield_expr_rule(p))
+ )
+ {
+ res = yield_expr_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expressions
+ expr_ty star_expressions_var;
+ if (
+ (star_expressions_var = star_expressions_rule(p))
+ )
+ {
+ res = star_expressions_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// expressions: expression ((',' expression))+ ','? | expression ',' | expression
+static expr_ty
+expressions_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // expression ((',' expression))+ ','?
+ expr_ty a;
+ asdl_seq * b;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = expression_rule(p))
+ &&
+ (b = _loop1_64_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression ','
+ expr_ty a;
+ void *literal;
+ if (
+ (a = expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression
+ expr_ty expression_var;
+ if (
+ (expression_var = expression_rule(p))
+ )
+ {
+ res = expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// expression: disjunction 'if' disjunction 'else' expression | disjunction | lambdef
+static expr_ty
+expression_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, expression_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // disjunction 'if' disjunction 'else' expression
+ expr_ty a;
+ expr_ty b;
+ expr_ty c;
+ void *keyword;
+ void *keyword_1;
+ if (
+ (a = disjunction_rule(p))
+ &&
+ (keyword = _PyPegen_expect_token(p, 510))
+ &&
+ (b = disjunction_rule(p))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 516))
+ &&
+ (c = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_IfExp ( b , a , c , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // disjunction
+ expr_ty disjunction_var;
+ if (
+ (disjunction_var = disjunction_rule(p))
+ )
+ {
+ res = disjunction_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lambdef
+ expr_ty lambdef_var;
+ if (
+ (lambdef_var = lambdef_rule(p))
+ )
+ {
+ res = lambdef_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, expression_type, res);
+ return res;
+}
+
+// lambdef: 'lambda' lambda_parameters? ':' expression
+static expr_ty
+lambdef_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'lambda' lambda_parameters? ':' expression
+ void *a;
+ expr_ty b;
+ void *keyword;
+ void *literal;
+ if (
+ (keyword = _PyPegen_expect_token(p, 524))
+ &&
+ (a = lambda_parameters_rule(p), 1)
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Lambda ( ( a ) ? a : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_parameters:
+// | lambda_slash_without_default [',' lambda_plain_names] [',' lambda_names_with_default] [',' lambda_star_etc?]
+// | lambda_slash_with_default [',' lambda_names_with_default] [',' lambda_star_etc?]
+// | lambda_plain_names [',' lambda_names_with_default] [',' lambda_star_etc?]
+// | lambda_names_with_default [',' lambda_star_etc?]
+// | lambda_star_etc
+static arguments_ty
+lambda_parameters_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arguments_ty res = NULL;
+ int mark = p->mark;
+ { // lambda_slash_without_default [',' lambda_plain_names] [',' lambda_names_with_default] [',' lambda_star_etc?]
+ asdl_seq* a;
+ void *b;
+ void *c;
+ void *d;
+ if (
+ (a = lambda_slash_without_default_rule(p))
+ &&
+ (b = _tmp_65_rule(p), 1)
+ &&
+ (c = _tmp_66_rule(p), 1)
+ &&
+ (d = _tmp_67_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lambda_slash_with_default [',' lambda_names_with_default] [',' lambda_star_etc?]
+ SlashWithDefault* a;
+ void *b;
+ void *c;
+ if (
+ (a = lambda_slash_with_default_rule(p))
+ &&
+ (b = _tmp_68_rule(p), 1)
+ &&
+ (c = _tmp_69_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lambda_plain_names [',' lambda_names_with_default] [',' lambda_star_etc?]
+ asdl_seq* a;
+ void *b;
+ void *c;
+ if (
+ (a = lambda_plain_names_rule(p))
+ &&
+ (b = _tmp_70_rule(p), 1)
+ &&
+ (c = _tmp_71_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lambda_names_with_default [',' lambda_star_etc?]
+ asdl_seq* a;
+ void *b;
+ if (
+ (a = lambda_names_with_default_rule(p))
+ &&
+ (b = _tmp_72_rule(p), 1)
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lambda_star_etc
+ StarEtc* a;
+ if (
+ (a = lambda_star_etc_rule(p))
+ )
+ {
+ res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_slash_without_default: lambda_plain_names ',' '/'
+static asdl_seq*
+lambda_slash_without_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // lambda_plain_names ',' '/'
+ asdl_seq* a;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = lambda_plain_names_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 17))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_slash_with_default: [lambda_plain_names ','] lambda_names_with_default ',' '/'
+static SlashWithDefault*
+lambda_slash_with_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ SlashWithDefault* res = NULL;
+ int mark = p->mark;
+ { // [lambda_plain_names ','] lambda_names_with_default ',' '/'
+ void *a;
+ asdl_seq* b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = _tmp_73_rule(p), 1)
+ &&
+ (b = lambda_names_with_default_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 17))
+ )
+ {
+ res = _PyPegen_slash_with_default ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_star_etc:
+// | '*' lambda_plain_name lambda_name_with_optional_default* [',' lambda_kwds] ','?
+// | '*' lambda_name_with_optional_default+ [',' lambda_kwds] ','?
+// | lambda_kwds ','?
+static StarEtc*
+lambda_star_etc_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ StarEtc* res = NULL;
+ int mark = p->mark;
+ { // '*' lambda_plain_name lambda_name_with_optional_default* [',' lambda_kwds] ','?
+ arg_ty a;
+ asdl_seq * b;
+ void *c;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (a = lambda_plain_name_rule(p))
+ &&
+ (b = _loop0_74_rule(p))
+ &&
+ (c = _tmp_75_rule(p), 1)
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = _PyPegen_star_etc ( p , a , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '*' lambda_name_with_optional_default+ [',' lambda_kwds] ','?
+ asdl_seq * b;
+ void *c;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (b = _loop1_76_rule(p))
+ &&
+ (c = _tmp_77_rule(p), 1)
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = _PyPegen_star_etc ( p , NULL , b , c );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lambda_kwds ','?
+ arg_ty a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = lambda_kwds_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = _PyPegen_star_etc ( p , NULL , NULL , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_name_with_optional_default: ',' lambda_plain_name ['=' expression]
+static NameDefaultPair*
+lambda_name_with_optional_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ NameDefaultPair* res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_plain_name ['=' expression]
+ arg_ty a;
+ void *b;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (a = lambda_plain_name_rule(p))
+ &&
+ (b = _tmp_78_rule(p), 1)
+ )
+ {
+ res = _PyPegen_name_default_pair ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_names_with_default: ','.lambda_name_with_default+
+static asdl_seq*
+lambda_names_with_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.lambda_name_with_default+
+ asdl_seq * a;
+ if (
+ (a = _gather_79_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_name_with_default: lambda_plain_name '=' expression
+static NameDefaultPair*
+lambda_name_with_default_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ NameDefaultPair* res = NULL;
+ int mark = p->mark;
+ { // lambda_plain_name '=' expression
+ expr_ty e;
+ void *literal;
+ arg_ty n;
+ if (
+ (n = lambda_plain_name_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (e = expression_rule(p))
+ )
+ {
+ res = _PyPegen_name_default_pair ( p , n , e );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_plain_names: ','.(lambda_plain_name !'=')+
+static asdl_seq*
+lambda_plain_names_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.(lambda_plain_name !'=')+
+ asdl_seq * a;
+ if (
+ (a = _gather_81_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_plain_name: NAME
+static arg_ty
+lambda_plain_name_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arg_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME
+ expr_ty a;
+ if (
+ (a = _PyPegen_name_token(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lambda_kwds: '**' lambda_plain_name
+static arg_ty
+lambda_kwds_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ arg_ty res = NULL;
+ int mark = p->mark;
+ { // '**' lambda_plain_name
+ arg_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 35))
+ &&
+ (a = lambda_plain_name_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// disjunction: conjunction (('or' conjunction))+ | conjunction
+static expr_ty
+disjunction_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, disjunction_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // conjunction (('or' conjunction))+
+ expr_ty a;
+ asdl_seq * b;
+ if (
+ (a = conjunction_rule(p))
+ &&
+ (b = _loop1_83_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BoolOp ( Or , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // conjunction
+ expr_ty conjunction_var;
+ if (
+ (conjunction_var = conjunction_rule(p))
+ )
+ {
+ res = conjunction_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, disjunction_type, res);
+ return res;
+}
+
+// conjunction: inversion (('and' inversion))+ | inversion
+static expr_ty
+conjunction_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, conjunction_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // inversion (('and' inversion))+
+ expr_ty a;
+ asdl_seq * b;
+ if (
+ (a = inversion_rule(p))
+ &&
+ (b = _loop1_84_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BoolOp ( And , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // inversion
+ expr_ty inversion_var;
+ if (
+ (inversion_var = inversion_rule(p))
+ )
+ {
+ res = inversion_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, conjunction_type, res);
+ return res;
+}
+
+// inversion: 'not' inversion | comparison
+static expr_ty
+inversion_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, inversion_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'not' inversion
+ expr_ty a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 525))
+ &&
+ (a = inversion_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_UnaryOp ( Not , a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // comparison
+ expr_ty comparison_var;
+ if (
+ (comparison_var = comparison_rule(p))
+ )
+ {
+ res = comparison_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, inversion_type, res);
+ return res;
+}
+
+// comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
+static expr_ty
+comparison_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // bitwise_or compare_op_bitwise_or_pair+
+ expr_ty a;
+ asdl_seq * b;
+ if (
+ (a = bitwise_or_rule(p))
+ &&
+ (b = _loop1_85_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Compare ( a , CHECK ( _PyPegen_get_cmpops ( p , b ) ) , CHECK ( _PyPegen_get_exprs ( p , b ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // bitwise_or
+ expr_ty bitwise_or_var;
+ if (
+ (bitwise_or_var = bitwise_or_rule(p))
+ )
+ {
+ res = bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// compare_op_bitwise_or_pair:
+// | eq_bitwise_or
+// | noteq_bitwise_or
+// | lte_bitwise_or
+// | lt_bitwise_or
+// | gte_bitwise_or
+// | gt_bitwise_or
+// | notin_bitwise_or
+// | in_bitwise_or
+// | isnot_bitwise_or
+// | is_bitwise_or
+static CmpopExprPair*
+compare_op_bitwise_or_pair_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // eq_bitwise_or
+ CmpopExprPair* eq_bitwise_or_var;
+ if (
+ (eq_bitwise_or_var = eq_bitwise_or_rule(p))
+ )
+ {
+ res = eq_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // noteq_bitwise_or
+ CmpopExprPair* noteq_bitwise_or_var;
+ if (
+ (noteq_bitwise_or_var = noteq_bitwise_or_rule(p))
+ )
+ {
+ res = noteq_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lte_bitwise_or
+ CmpopExprPair* lte_bitwise_or_var;
+ if (
+ (lte_bitwise_or_var = lte_bitwise_or_rule(p))
+ )
+ {
+ res = lte_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // lt_bitwise_or
+ CmpopExprPair* lt_bitwise_or_var;
+ if (
+ (lt_bitwise_or_var = lt_bitwise_or_rule(p))
+ )
+ {
+ res = lt_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // gte_bitwise_or
+ CmpopExprPair* gte_bitwise_or_var;
+ if (
+ (gte_bitwise_or_var = gte_bitwise_or_rule(p))
+ )
+ {
+ res = gte_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // gt_bitwise_or
+ CmpopExprPair* gt_bitwise_or_var;
+ if (
+ (gt_bitwise_or_var = gt_bitwise_or_rule(p))
+ )
+ {
+ res = gt_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // notin_bitwise_or
+ CmpopExprPair* notin_bitwise_or_var;
+ if (
+ (notin_bitwise_or_var = notin_bitwise_or_rule(p))
+ )
+ {
+ res = notin_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // in_bitwise_or
+ CmpopExprPair* in_bitwise_or_var;
+ if (
+ (in_bitwise_or_var = in_bitwise_or_rule(p))
+ )
+ {
+ res = in_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // isnot_bitwise_or
+ CmpopExprPair* isnot_bitwise_or_var;
+ if (
+ (isnot_bitwise_or_var = isnot_bitwise_or_rule(p))
+ )
+ {
+ res = isnot_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // is_bitwise_or
+ CmpopExprPair* is_bitwise_or_var;
+ if (
+ (is_bitwise_or_var = is_bitwise_or_rule(p))
+ )
+ {
+ res = is_bitwise_or_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// eq_bitwise_or: '==' bitwise_or
+static CmpopExprPair*
+eq_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // '==' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 27))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// noteq_bitwise_or: '!=' bitwise_or
+static CmpopExprPair*
+noteq_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // '!=' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 28))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lte_bitwise_or: '<=' bitwise_or
+static CmpopExprPair*
+lte_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // '<=' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 29))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// lt_bitwise_or: '<' bitwise_or
+static CmpopExprPair*
+lt_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // '<' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 20))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// gte_bitwise_or: '>=' bitwise_or
+static CmpopExprPair*
+gte_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // '>=' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 30))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// gt_bitwise_or: '>' bitwise_or
+static CmpopExprPair*
+gt_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // '>' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 21))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// notin_bitwise_or: 'not' 'in' bitwise_or
+static CmpopExprPair*
+notin_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // 'not' 'in' bitwise_or
+ expr_ty a;
+ void *keyword;
+ void *keyword_1;
+ if (
+ (keyword = _PyPegen_expect_token(p, 525))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 518))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// in_bitwise_or: 'in' bitwise_or
+static CmpopExprPair*
+in_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // 'in' bitwise_or
+ expr_ty a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 518))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , In , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// isnot_bitwise_or: 'is' 'not' bitwise_or
+static CmpopExprPair*
+isnot_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // 'is' 'not' bitwise_or
+ expr_ty a;
+ void *keyword;
+ void *keyword_1;
+ if (
+ (keyword = _PyPegen_expect_token(p, 526))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 525))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// is_bitwise_or: 'is' bitwise_or
+static CmpopExprPair*
+is_bitwise_or_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ CmpopExprPair* res = NULL;
+ int mark = p->mark;
+ { // 'is' bitwise_or
+ expr_ty a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 526))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_cmpop_expr_pair ( p , Is , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor
+static expr_ty bitwise_or_raw(Parser *);
+static expr_ty
+bitwise_or_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, bitwise_or_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_1 = _PyPegen_update_memo(p, mark, bitwise_or_type, res);
+ if (tmpvar_1) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = bitwise_or_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+bitwise_or_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // bitwise_or '|' bitwise_xor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = bitwise_or_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 18))
+ &&
+ (b = bitwise_xor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , BitOr , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // bitwise_xor
+ expr_ty bitwise_xor_var;
+ if (
+ (bitwise_xor_var = bitwise_xor_rule(p))
+ )
+ {
+ res = bitwise_xor_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and
+static expr_ty bitwise_xor_raw(Parser *);
+static expr_ty
+bitwise_xor_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, bitwise_xor_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_2 = _PyPegen_update_memo(p, mark, bitwise_xor_type, res);
+ if (tmpvar_2) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = bitwise_xor_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+bitwise_xor_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // bitwise_xor '^' bitwise_and
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = bitwise_xor_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 32))
+ &&
+ (b = bitwise_and_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , BitXor , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // bitwise_and
+ expr_ty bitwise_and_var;
+ if (
+ (bitwise_and_var = bitwise_and_rule(p))
+ )
+ {
+ res = bitwise_and_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// bitwise_and: bitwise_and '&' shift_expr | shift_expr
+static expr_ty bitwise_and_raw(Parser *);
+static expr_ty
+bitwise_and_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, bitwise_and_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_3 = _PyPegen_update_memo(p, mark, bitwise_and_type, res);
+ if (tmpvar_3) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = bitwise_and_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+bitwise_and_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // bitwise_and '&' shift_expr
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = bitwise_and_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 19))
+ &&
+ (b = shift_expr_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , BitAnd , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // shift_expr
+ expr_ty shift_expr_var;
+ if (
+ (shift_expr_var = shift_expr_rule(p))
+ )
+ {
+ res = shift_expr_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | sum
+static expr_ty shift_expr_raw(Parser *);
+static expr_ty
+shift_expr_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, shift_expr_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_4 = _PyPegen_update_memo(p, mark, shift_expr_type, res);
+ if (tmpvar_4) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = shift_expr_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+shift_expr_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // shift_expr '<<' sum
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = shift_expr_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 33))
+ &&
+ (b = sum_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , LShift , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // shift_expr '>>' sum
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = shift_expr_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 34))
+ &&
+ (b = sum_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , RShift , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // sum
+ expr_ty sum_var;
+ if (
+ (sum_var = sum_rule(p))
+ )
+ {
+ res = sum_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// sum: sum '+' term | sum '-' term | term
+static expr_ty sum_raw(Parser *);
+static expr_ty
+sum_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, sum_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_5 = _PyPegen_update_memo(p, mark, sum_type, res);
+ if (tmpvar_5) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = sum_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+sum_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // sum '+' term
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = sum_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 14))
+ &&
+ (b = term_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , Add , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // sum '-' term
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = sum_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 15))
+ &&
+ (b = term_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , Sub , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // term
+ expr_ty term_var;
+ if (
+ (term_var = term_rule(p))
+ )
+ {
+ res = term_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// Left-recursive
+// term:
+// | term '*' factor
+// | term '/' factor
+// | term '//' factor
+// | term '%' factor
+// | term '@' factor
+// | factor
+static expr_ty term_raw(Parser *);
+static expr_ty
+term_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, term_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_6 = _PyPegen_update_memo(p, mark, term_type, res);
+ if (tmpvar_6) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = term_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+term_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // term '*' factor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = term_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (b = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , Mult , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // term '/' factor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = term_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 17))
+ &&
+ (b = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , Div , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // term '//' factor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = term_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 47))
+ &&
+ (b = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , FloorDiv , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // term '%' factor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = term_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 24))
+ &&
+ (b = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , Mod , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // term '@' factor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = term_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 49))
+ &&
+ (b = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , MatMult , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // factor
+ expr_ty factor_var;
+ if (
+ (factor_var = factor_rule(p))
+ )
+ {
+ res = factor_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// factor: '+' factor | '-' factor | '~' factor | power
+static expr_ty
+factor_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, factor_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '+' factor
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 14))
+ &&
+ (a = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_UnaryOp ( UAdd , a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '-' factor
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 15))
+ &&
+ (a = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_UnaryOp ( USub , a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '~' factor
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 31))
+ &&
+ (a = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_UnaryOp ( Invert , a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // power
+ expr_ty power_var;
+ if (
+ (power_var = power_rule(p))
+ )
+ {
+ res = power_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, factor_type, res);
+ return res;
+}
+
+// power: await_primary '**' factor | await_primary
+static expr_ty
+power_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // await_primary '**' factor
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = await_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 35))
+ &&
+ (b = factor_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_BinOp ( a , Pow , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // await_primary
+ expr_ty await_primary_var;
+ if (
+ (await_primary_var = await_primary_rule(p))
+ )
+ {
+ res = await_primary_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// await_primary: AWAIT primary | primary
+static expr_ty
+await_primary_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, await_primary_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // AWAIT primary
+ expr_ty a;
+ void *await_var;
+ if (
+ (await_var = _PyPegen_await_token(p))
+ &&
+ (a = primary_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Await ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // primary
+ expr_ty primary_var;
+ if (
+ (primary_var = primary_rule(p))
+ )
+ {
+ res = primary_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, await_primary_type, res);
+ return res;
+}
+
+// Left-recursive
+// primary:
+// | primary '.' NAME
+// | primary genexp
+// | primary '(' arguments? ')'
+// | primary '[' slices ']'
+// | atom
+static expr_ty primary_raw(Parser *);
+static expr_ty
+primary_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, primary_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_7 = _PyPegen_update_memo(p, mark, primary_type, res);
+ if (tmpvar_7) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = primary_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+primary_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // primary '.' NAME
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // primary genexp
+ expr_ty a;
+ expr_ty b;
+ if (
+ (a = primary_rule(p))
+ &&
+ (b = genexp_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // primary '(' arguments? ')'
+ expr_ty a;
+ void *b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (b = arguments_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // primary '[' slices ']'
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = slices_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Subscript ( a , b , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // atom
+ expr_ty atom_var;
+ if (
+ (atom_var = atom_rule(p))
+ )
+ {
+ res = atom_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// slices: slice !',' | ','.slice+ ','?
+static expr_ty
+slices_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // slice !','
+ expr_ty a;
+ if (
+ (a = slice_rule(p))
+ &&
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ','.slice+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_86_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( a , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// slice: expression? ':' expression? [':' expression?] | expression
+static expr_ty
+slice_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // expression? ':' expression? [':' expression?]
+ void *a;
+ void *b;
+ void *c;
+ void *literal;
+ if (
+ (a = expression_rule(p), 1)
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = expression_rule(p), 1)
+ &&
+ (c = _tmp_88_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Slice ( a , b , c , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression
+ expr_ty a;
+ if (
+ (a = expression_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// atom:
+// | NAME
+// | 'True'
+// | 'False'
+// | 'None'
+// | '__new_parser__'
+// | &STRING strings
+// | NUMBER
+// | &'(' (tuple | group | genexp)
+// | &'[' (list | listcomp)
+// | &'{' (dict | set | dictcomp | setcomp)
+// | '...'
+static expr_ty
+atom_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME
+ expr_ty name_var;
+ if (
+ (name_var = _PyPegen_name_token(p))
+ )
+ {
+ res = name_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'True'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 527))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Constant ( Py_True , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'False'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 528))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Constant ( Py_False , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'None'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 529))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Constant ( Py_None , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '__new_parser__'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 530))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "You found it!" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &STRING strings
+ expr_ty strings_var;
+ if (
+ _PyPegen_lookahead(1, _PyPegen_string_token, p)
+ &&
+ (strings_var = strings_rule(p))
+ )
+ {
+ res = strings_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // NUMBER
+ expr_ty number_var;
+ if (
+ (number_var = _PyPegen_number_token(p))
+ )
+ {
+ res = number_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'(' (tuple | group | genexp)
+ void *_tmp_89_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7)
+ &&
+ (_tmp_89_var = _tmp_89_rule(p))
+ )
+ {
+ res = _tmp_89_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'[' (list | listcomp)
+ void *_tmp_90_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9)
+ &&
+ (_tmp_90_var = _tmp_90_rule(p))
+ )
+ {
+ res = _tmp_90_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // &'{' (dict | set | dictcomp | setcomp)
+ void *_tmp_91_var;
+ if (
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25)
+ &&
+ (_tmp_91_var = _tmp_91_rule(p))
+ )
+ {
+ res = _tmp_91_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '...'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 52))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Constant ( Py_Ellipsis , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// strings: STRING+
+static expr_ty
+strings_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, strings_type, &res))
+ return res;
+ int mark = p->mark;
+ { // STRING+
+ asdl_seq * a;
+ if (
+ (a = _loop1_92_rule(p))
+ )
+ {
+ res = _PyPegen_concatenate_strings ( p , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, strings_type, res);
+ return res;
+}
+
+// list: '[' star_named_expressions? ']'
+static expr_ty
+list_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '[' star_named_expressions? ']'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (a = star_named_expressions_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_List ( a , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
+static expr_ty
+listcomp_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '[' named_expression for_if_clauses ']'
+ expr_ty a;
+ asdl_seq* b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (a = named_expression_rule(p))
+ &&
+ (b = for_if_clauses_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_ListComp ( a , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // invalid_comprehension
+ void *invalid_comprehension_var;
+ if (
+ (invalid_comprehension_var = invalid_comprehension_rule(p))
+ )
+ {
+ res = invalid_comprehension_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
+static expr_ty
+tuple_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '(' [star_named_expression ',' star_named_expressions?] ')'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = _tmp_93_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( a , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// group: '(' (yield_expr | named_expression) ')'
+static expr_ty
+group_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ { // '(' (yield_expr | named_expression) ')'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = _tmp_94_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// genexp: '(' expression for_if_clauses ')' | invalid_comprehension
+static expr_ty
+genexp_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '(' expression for_if_clauses ')'
+ expr_ty a;
+ asdl_seq* b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = expression_rule(p))
+ &&
+ (b = for_if_clauses_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_GeneratorExp ( a , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // invalid_comprehension
+ void *invalid_comprehension_var;
+ if (
+ (invalid_comprehension_var = invalid_comprehension_rule(p))
+ )
+ {
+ res = invalid_comprehension_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// set: '{' expressions_list '}'
+static expr_ty
+set_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '{' expressions_list '}'
+ asdl_seq* a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 25))
+ &&
+ (a = expressions_list_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 26))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Set ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// setcomp: '{' expression for_if_clauses '}' | invalid_comprehension
+static expr_ty
+setcomp_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '{' expression for_if_clauses '}'
+ expr_ty a;
+ asdl_seq* b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 25))
+ &&
+ (a = expression_rule(p))
+ &&
+ (b = for_if_clauses_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 26))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_SetComp ( a , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // invalid_comprehension
+ void *invalid_comprehension_var;
+ if (
+ (invalid_comprehension_var = invalid_comprehension_rule(p))
+ )
+ {
+ res = invalid_comprehension_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// dict: '{' kvpairs? '}'
+static expr_ty
+dict_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '{' kvpairs? '}'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 25))
+ &&
+ (a = kvpairs_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 26))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Dict ( CHECK ( _PyPegen_get_keys ( p , a ) ) , CHECK ( _PyPegen_get_values ( p , a ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// dictcomp: '{' kvpair for_if_clauses '}'
+static expr_ty
+dictcomp_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '{' kvpair for_if_clauses '}'
+ KeyValuePair* a;
+ asdl_seq* b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 25))
+ &&
+ (a = kvpair_rule(p))
+ &&
+ (b = for_if_clauses_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 26))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_DictComp ( a -> key , a -> value , b , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// kvpairs: ','.kvpair+ ','?
+static asdl_seq*
+kvpairs_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.kvpair+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_95_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// kvpair: '**' bitwise_or | expression ':' expression
+static KeyValuePair*
+kvpair_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ KeyValuePair* res = NULL;
+ int mark = p->mark;
+ { // '**' bitwise_or
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 35))
+ &&
+ (a = bitwise_or_rule(p))
+ )
+ {
+ res = _PyPegen_key_value_pair ( p , NULL , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression ':' expression
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (b = expression_rule(p))
+ )
+ {
+ res = _PyPegen_key_value_pair ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// for_if_clauses: ((ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*))+
+static asdl_seq*
+for_if_clauses_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ((ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*))+
+ asdl_seq * a;
+ if (
+ (a = _loop1_97_rule(p))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
+static expr_ty
+yield_expr_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // 'yield' 'from' expression
+ expr_ty a;
+ void *keyword;
+ void *keyword_1;
+ if (
+ (keyword = _PyPegen_expect_token(p, 504))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 514))
+ &&
+ (a = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_YieldFrom ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'yield' star_expressions?
+ void *a;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 504))
+ &&
+ (a = star_expressions_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Yield ( a , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// arguments: args ','? &')' | incorrect_arguments
+static expr_ty
+arguments_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, arguments_type, &res))
+ return res;
+ int mark = p->mark;
+ { // args ','? &')'
+ expr_ty a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = args_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ &&
+ _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // incorrect_arguments
+ void *incorrect_arguments_var;
+ if (
+ (incorrect_arguments_var = incorrect_arguments_rule(p))
+ )
+ {
+ res = incorrect_arguments_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, arguments_type, res);
+ return res;
+}
+
+// args: starred_expression [',' args] | kwargs | named_expression [',' args]
+static expr_ty
+args_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // starred_expression [',' args]
+ expr_ty a;
+ void *b;
+ if (
+ (a = starred_expression_rule(p))
+ &&
+ (b = _tmp_98_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( _PyPegen_dummy_name ( p ) , ( b ) ? CHECK ( _PyPegen_seq_insert_in_front ( p , a , ( ( expr_ty ) b ) -> v . Call . args ) ) : CHECK ( _PyPegen_singleton_seq ( p , a ) ) , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // kwargs
+ asdl_seq* a;
+ if (
+ (a = kwargs_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // named_expression [',' args]
+ expr_ty a;
+ void *b;
+ if (
+ (a = named_expression_rule(p))
+ &&
+ (b = _tmp_99_rule(p), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( _PyPegen_dummy_name ( p ) , ( b ) ? CHECK ( _PyPegen_seq_insert_in_front ( p , a , ( ( expr_ty ) b ) -> v . Call . args ) ) : CHECK ( _PyPegen_singleton_seq ( p , a ) ) , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// kwargs:
+// | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
+// | ','.kwarg_or_starred+
+// | ','.kwarg_or_double_starred+
+static asdl_seq*
+kwargs_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
+ asdl_seq * a;
+ asdl_seq * b;
+ void *literal;
+ if (
+ (a = _gather_100_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (b = _gather_102_rule(p))
+ )
+ {
+ res = _PyPegen_join_sequences ( p , a , b );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ','.kwarg_or_starred+
+ asdl_seq * _gather_104_var;
+ if (
+ (_gather_104_var = _gather_104_rule(p))
+ )
+ {
+ res = _gather_104_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ','.kwarg_or_double_starred+
+ asdl_seq * _gather_106_var;
+ if (
+ (_gather_106_var = _gather_106_rule(p))
+ )
+ {
+ res = _gather_106_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// starred_expression: '*' expression
+static expr_ty
+starred_expression_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '*' expression
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (a = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Starred ( a , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// kwarg_or_starred: NAME '=' expression | starred_expression
+static KeywordOrStarred*
+kwarg_or_starred_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ KeywordOrStarred* res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME '=' expression
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = _PyPegen_name_token(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (b = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ return NULL;
+ }
+ int end_lineno = token->end_lineno;
+ UNUSED(end_lineno); // Only used by EXTRA macro
+ int end_col_offset = token->end_col_offset;
+ UNUSED(end_col_offset); // Only used by EXTRA macro
+ res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // starred_expression
+ expr_ty a;
+ if (
+ (a = starred_expression_rule(p))
+ )
+ {
+ res = _PyPegen_keyword_or_starred ( p , a , 0 );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// kwarg_or_double_starred: NAME '=' expression | '**' expression
+static KeywordOrStarred*
+kwarg_or_double_starred_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ KeywordOrStarred* res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME '=' expression
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = _PyPegen_name_token(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (b = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ return NULL;
+ }
+ int end_lineno = token->end_lineno;
+ UNUSED(end_lineno); // Only used by EXTRA macro
+ int end_col_offset = token->end_col_offset;
+ UNUSED(end_col_offset); // Only used by EXTRA macro
+ res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '**' expression
+ expr_ty a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 35))
+ &&
+ (a = expression_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ return NULL;
+ }
+ int end_lineno = token->end_lineno;
+ UNUSED(end_lineno); // Only used by EXTRA macro
+ int end_col_offset = token->end_col_offset;
+ UNUSED(end_col_offset); // Only used by EXTRA macro
+ res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( NULL , a , EXTRA ) ) , 1 );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_targets: star_target !',' | star_target ((',' star_target))* ','?
+static expr_ty
+star_targets_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // star_target !','
+ expr_ty a;
+ if (
+ (a = star_target_rule(p))
+ &&
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_target ((',' star_target))* ','?
+ expr_ty a;
+ asdl_seq * b;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = star_target_rule(p))
+ &&
+ (b = _loop0_108_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_targets_seq: ','.star_target+ ','?
+static asdl_seq*
+star_targets_seq_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.star_target+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_109_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// star_target:
+// | '*' (!'*' star_target)
+// | t_primary '.' NAME !t_lookahead
+// | t_primary '[' slices ']' !t_lookahead
+// | star_atom
+static expr_ty
+star_target_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, star_target_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // '*' (!'*' star_target)
+ void *a;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (a = _tmp_111_rule(p))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Starred ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '.' NAME !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '[' slices ']' !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = slices_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Subscript ( a , b , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_atom
+ expr_ty star_atom_var;
+ if (
+ (star_atom_var = star_atom_rule(p))
+ )
+ {
+ res = star_atom_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, star_target_type, res);
+ return res;
+}
+
+// star_atom:
+// | NAME
+// | '(' star_target ')'
+// | '(' star_targets_seq? ')'
+// | '[' star_targets_seq? ']'
+static expr_ty
+star_atom_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME
+ expr_ty a;
+ if (
+ (a = _PyPegen_name_token(p))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Store );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' star_target ')'
+ expr_ty a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = star_target_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Store );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' star_targets_seq? ')'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = star_targets_seq_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( a , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '[' star_targets_seq? ']'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (a = star_targets_seq_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_List ( a , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// inside_paren_ann_assign_target:
+// | ann_assign_subscript_attribute_target
+// | NAME
+// | '(' inside_paren_ann_assign_target ')'
+static expr_ty
+inside_paren_ann_assign_target_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ { // ann_assign_subscript_attribute_target
+ expr_ty ann_assign_subscript_attribute_target_var;
+ if (
+ (ann_assign_subscript_attribute_target_var = ann_assign_subscript_attribute_target_rule(p))
+ )
+ {
+ res = ann_assign_subscript_attribute_target_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // NAME
+ expr_ty a;
+ if (
+ (a = _PyPegen_name_token(p))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Store );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' inside_paren_ann_assign_target ')'
+ expr_ty a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = inside_paren_ann_assign_target_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// ann_assign_subscript_attribute_target:
+// | t_primary '.' NAME !t_lookahead
+// | t_primary '[' slices ']' !t_lookahead
+static expr_ty
+ann_assign_subscript_attribute_target_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // t_primary '.' NAME !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '[' slices ']' !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = slices_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Subscript ( a , b , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// del_targets: ','.del_target+ ','?
+static asdl_seq*
+del_targets_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.del_target+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_112_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// del_target:
+// | t_primary '.' NAME !t_lookahead
+// | t_primary '[' slices ']' !t_lookahead
+// | del_t_atom
+static expr_ty
+del_target_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, del_target_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // t_primary '.' NAME !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Attribute ( a , b -> v . Name . id , Del , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '[' slices ']' !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = slices_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Subscript ( a , b , Del , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // del_t_atom
+ expr_ty del_t_atom_var;
+ if (
+ (del_t_atom_var = del_t_atom_rule(p))
+ )
+ {
+ res = del_t_atom_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, del_target_type, res);
+ return res;
+}
+
+// del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
+static expr_ty
+del_t_atom_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME
+ expr_ty a;
+ if (
+ (a = _PyPegen_name_token(p))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Del );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' del_target ')'
+ expr_ty a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = del_target_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Del );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' del_targets? ')'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = del_targets_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( a , Del , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '[' del_targets? ']'
+ void *a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (a = del_targets_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_List ( a , Del , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// targets: ','.target+ ','?
+static asdl_seq*
+targets_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq* res = NULL;
+ int mark = p->mark;
+ { // ','.target+ ','?
+ asdl_seq * a;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (a = _gather_114_rule(p))
+ &&
+ (opt_var = _PyPegen_expect_token(p, 12), 1)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// target:
+// | t_primary '.' NAME !t_lookahead
+// | t_primary '[' slices ']' !t_lookahead
+// | t_atom
+static expr_ty
+target_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, target_type, &res))
+ return res;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // t_primary '.' NAME !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '[' slices ']' !t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = slices_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ &&
+ _PyPegen_lookahead(0, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Subscript ( a , b , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_atom
+ expr_ty t_atom_var;
+ if (
+ (t_atom_var = t_atom_rule(p))
+ )
+ {
+ res = t_atom_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ _PyPegen_insert_memo(p, mark, target_type, res);
+ return res;
+}
+
+// Left-recursive
+// t_primary:
+// | t_primary '.' NAME &t_lookahead
+// | t_primary '[' slices ']' &t_lookahead
+// | t_primary genexp &t_lookahead
+// | t_primary '(' arguments? ')' &t_lookahead
+// | atom &t_lookahead
+static expr_ty t_primary_raw(Parser *);
+static expr_ty
+t_primary_rule(Parser *p)
+{
+ expr_ty res = NULL;
+ if (_PyPegen_is_memoized(p, t_primary_type, &res))
+ return res;
+ int mark = p->mark;
+ int resmark = p->mark;
+ while (1) {
+ int tmpvar_8 = _PyPegen_update_memo(p, mark, t_primary_type, res);
+ if (tmpvar_8) {
+ return res;
+ }
+ p->mark = mark;
+ void *raw = t_primary_raw(p);
+ if (raw == NULL || p->mark <= resmark)
+ break;
+ resmark = p->mark;
+ res = raw;
+ }
+ p->mark = resmark;
+ return res;
+}
+static expr_ty
+t_primary_raw(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ 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
+ { // t_primary '.' NAME &t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 23))
+ &&
+ (b = _PyPegen_name_token(p))
+ &&
+ _PyPegen_lookahead(1, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '[' slices ']' &t_lookahead
+ expr_ty a;
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = slices_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ &&
+ _PyPegen_lookahead(1, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Subscript ( a , b , Load , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary genexp &t_lookahead
+ expr_ty a;
+ expr_ty b;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (b = genexp_rule(p))
+ &&
+ _PyPegen_lookahead(1, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // t_primary '(' arguments? ')' &t_lookahead
+ expr_ty a;
+ void *b;
+ void *literal;
+ void *literal_1;
+ if (
+ (a = t_primary_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (b = arguments_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ &&
+ _PyPegen_lookahead(1, t_lookahead_rule, p)
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // atom &t_lookahead
+ expr_ty a;
+ if (
+ (a = atom_rule(p))
+ &&
+ _PyPegen_lookahead(1, t_lookahead_rule, p)
+ )
+ {
+ res = a;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// t_lookahead: '(' | '[' | '.'
+static void *
+t_lookahead_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '('
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '['
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '.'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 23))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// t_atom: NAME | '(' target ')' | '(' targets? ')' | '[' targets? ']'
+static expr_ty
+t_atom_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ expr_ty res = NULL;
+ int mark = p->mark;
+ if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ int start_lineno = p->tokens[mark]->lineno;
+ UNUSED(start_lineno); // Only used by EXTRA macro
+ int start_col_offset = p->tokens[mark]->col_offset;
+ UNUSED(start_col_offset); // Only used by EXTRA macro
+ { // NAME
+ expr_ty a;
+ if (
+ (a = _PyPegen_name_token(p))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Store );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' target ')'
+ expr_ty a;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (a = target_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = _PyPegen_set_expr_context ( p , a , Store );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '(' targets? ')'
+ void *b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (b = targets_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_Tuple ( b , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '[' targets? ']'
+ void *b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ &&
+ (b = targets_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 10))
+ )
+ {
+ Token *token = _PyPegen_get_last_nonnwhitespace_token(p);
+ if (token == NULL) {
+ 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 = _Py_List ( b , Store , EXTRA );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// incorrect_arguments:
+// | args ',' '*'
+// | expression for_if_clauses ',' [args | expression for_if_clauses]
+// | args ',' args
+static void *
+incorrect_arguments_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // args ',' '*'
+ expr_ty args_var;
+ void *literal;
+ void *literal_1;
+ if (
+ (args_var = args_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 16))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "iterable argument unpacking follows keyword argument unpacking" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression for_if_clauses ',' [args | expression for_if_clauses]
+ expr_ty expression_var;
+ asdl_seq* for_if_clauses_var;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (expression_var = expression_rule(p))
+ &&
+ (for_if_clauses_var = for_if_clauses_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (opt_var = _tmp_116_rule(p), 1)
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "Generator expression must be parenthesized" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // args ',' args
+ expr_ty a;
+ expr_ty args_var;
+ void *literal;
+ if (
+ (a = args_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (args_var = args_rule(p))
+ )
+ {
+ res = _PyPegen_arguments_parsing_error ( p , a );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// invalid_named_expression: expression ':=' expression
+static void *
+invalid_named_expression_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // expression ':=' expression
+ expr_ty a;
+ expr_ty expression_var;
+ void *literal;
+ if (
+ (a = expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 53))
+ &&
+ (expression_var = expression_rule(p))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// invalid_assignment:
+// | list ':'
+// | tuple ':'
+// | expression ':' expression ['=' annotated_rhs]
+// | expression ('=' | augassign) (yield_expr | star_expressions)
+static void *
+invalid_assignment_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // list ':'
+ expr_ty list_var;
+ void *literal;
+ if (
+ (list_var = list_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "only single target (not list) can be annotated" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // tuple ':'
+ void *literal;
+ expr_ty tuple_var;
+ if (
+ (tuple_var = tuple_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "only single target (not tuple) can be annotated" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression ':' expression ['=' annotated_rhs]
+ expr_ty expression_var;
+ expr_ty expression_var_1;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ if (
+ (expression_var = expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (expression_var_1 = expression_rule(p))
+ &&
+ (opt_var = _tmp_117_rule(p), 1)
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "illegal target for annotation" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression ('=' | augassign) (yield_expr | star_expressions)
+ void *_tmp_118_var;
+ void *_tmp_119_var;
+ expr_ty a;
+ if (
+ (a = expression_rule(p))
+ &&
+ (_tmp_118_var = _tmp_118_rule(p))
+ &&
+ (_tmp_119_var = _tmp_119_rule(p))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "cannot assign to %s" , _PyPegen_get_expr_name ( a ) );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// invalid_block: NEWLINE !INDENT
+static void *
+invalid_block_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // NEWLINE !INDENT
+ void *newline_var;
+ if (
+ (newline_var = _PyPegen_newline_token(p))
+ &&
+ _PyPegen_lookahead(0, _PyPegen_indent_token, p)
+ )
+ {
+ res = RAISE_INDENTATION_ERROR ( "expected an indented block" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// invalid_comprehension: ('[' | '(' | '{') '*' expression for_if_clauses
+static void *
+invalid_comprehension_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ('[' | '(' | '{') '*' expression for_if_clauses
+ void *_tmp_120_var;
+ expr_ty expression_var;
+ asdl_seq* for_if_clauses_var;
+ void *literal;
+ if (
+ (_tmp_120_var = _tmp_120_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 16))
+ &&
+ (expression_var = expression_rule(p))
+ &&
+ (for_if_clauses_var = for_if_clauses_rule(p))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "iterable unpacking cannot be used in comprehension" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// invalid_parameters:
+// | [plain_names ','] (slash_with_default | names_with_default) ',' plain_names
+static void *
+invalid_parameters_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // [plain_names ','] (slash_with_default | names_with_default) ',' plain_names
+ void *_tmp_122_var;
+ void *literal;
+ void *opt_var;
+ UNUSED(opt_var); // Silence compiler warnings
+ asdl_seq* plain_names_var;
+ if (
+ (opt_var = _tmp_121_rule(p), 1)
+ &&
+ (_tmp_122_var = _tmp_122_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (plain_names_var = plain_names_rule(p))
+ )
+ {
+ res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_1: NEWLINE
+static asdl_seq *
+_loop0_1_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // NEWLINE
+ void *newline_var;
+ while (
+ (newline_var = _PyPegen_newline_token(p))
+ )
+ {
+ res = newline_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_1");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_1_type, seq);
+ return seq;
+}
+
+// _loop1_2: statement
+static asdl_seq *
+_loop1_2_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // statement
+ asdl_seq* statement_var;
+ while (
+ (statement_var = statement_rule(p))
+ )
+ {
+ res = statement_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_2");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_2_type, seq);
+ return seq;
+}
+
+// _loop0_4: ';' small_stmt
+static asdl_seq *
+_loop0_4_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ';' small_stmt
+ stmt_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 13))
+ &&
+ (elem = small_stmt_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_4");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_4_type, seq);
+ return seq;
+}
+
+// _gather_3: small_stmt _loop0_4
+static asdl_seq *
+_gather_3_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // small_stmt _loop0_4
+ stmt_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = small_stmt_rule(p))
+ &&
+ (seq = _loop0_4_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_5: 'import' | 'from'
+static void *
+_tmp_5_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'import'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 513))
+ )
+ {
+ res = keyword;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // 'from'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 514))
+ )
+ {
+ res = keyword;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_6: 'def' | '@' | ASYNC
+static void *
+_tmp_6_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'def'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 522))
+ )
+ {
+ res = keyword;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '@'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 49))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ASYNC
+ void *async_var;
+ if (
+ (async_var = _PyPegen_async_token(p))
+ )
+ {
+ res = async_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_7: 'class' | '@'
+static void *
+_tmp_7_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'class'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 523))
+ )
+ {
+ res = keyword;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '@'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 49))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_8: 'with' | ASYNC
+static void *
+_tmp_8_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'with'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 519))
+ )
+ {
+ res = keyword;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ASYNC
+ void *async_var;
+ if (
+ (async_var = _PyPegen_async_token(p))
+ )
+ {
+ res = async_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_9: 'for' | ASYNC
+static void *
+_tmp_9_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'for'
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 517))
+ )
+ {
+ res = keyword;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ASYNC
+ void *async_var;
+ if (
+ (async_var = _PyPegen_async_token(p))
+ )
+ {
+ res = async_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_10: '=' annotated_rhs
+static void *
+_tmp_10_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '=' annotated_rhs
+ expr_ty d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (d = annotated_rhs_rule(p))
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_11: '(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target
+static void *
+_tmp_11_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '(' inside_paren_ann_assign_target ')'
+ expr_ty b;
+ void *literal;
+ void *literal_1;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (b = inside_paren_ann_assign_target_rule(p))
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = b;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // ann_assign_subscript_attribute_target
+ expr_ty ann_assign_subscript_attribute_target_var;
+ if (
+ (ann_assign_subscript_attribute_target_var = ann_assign_subscript_attribute_target_rule(p))
+ )
+ {
+ res = ann_assign_subscript_attribute_target_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_12: '=' annotated_rhs
+static void *
+_tmp_12_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '=' annotated_rhs
+ expr_ty d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (d = annotated_rhs_rule(p))
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_13: (star_targets '=')
+static asdl_seq *
+_loop1_13_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // (star_targets '=')
+ void *_tmp_123_var;
+ while (
+ (_tmp_123_var = _tmp_123_rule(p))
+ )
+ {
+ res = _tmp_123_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_13");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_13_type, seq);
+ return seq;
+}
+
+// _tmp_14: yield_expr | star_expressions
+static void *
+_tmp_14_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // yield_expr
+ expr_ty yield_expr_var;
+ if (
+ (yield_expr_var = yield_expr_rule(p))
+ )
+ {
+ res = yield_expr_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expressions
+ expr_ty star_expressions_var;
+ if (
+ (star_expressions_var = star_expressions_rule(p))
+ )
+ {
+ res = star_expressions_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_15: yield_expr | star_expressions
+static void *
+_tmp_15_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // yield_expr
+ expr_ty yield_expr_var;
+ if (
+ (yield_expr_var = yield_expr_rule(p))
+ )
+ {
+ res = yield_expr_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expressions
+ expr_ty star_expressions_var;
+ if (
+ (star_expressions_var = star_expressions_rule(p))
+ )
+ {
+ res = star_expressions_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_17: ',' NAME
+static asdl_seq *
+_loop0_17_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' NAME
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = _PyPegen_name_token(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_17");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_17_type, seq);
+ return seq;
+}
+
+// _gather_16: NAME _loop0_17
+static asdl_seq *
+_gather_16_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // NAME _loop0_17
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = _PyPegen_name_token(p))
+ &&
+ (seq = _loop0_17_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_19: ',' NAME
+static asdl_seq *
+_loop0_19_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' NAME
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = _PyPegen_name_token(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_19");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_19_type, seq);
+ return seq;
+}
+
+// _gather_18: NAME _loop0_19
+static asdl_seq *
+_gather_18_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // NAME _loop0_19
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = _PyPegen_name_token(p))
+ &&
+ (seq = _loop0_19_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_20: ',' expression
+static void *
+_tmp_20_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' expression
+ void *literal;
+ expr_ty z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = expression_rule(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_21: ('.' | '...')
+static asdl_seq *
+_loop0_21_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ('.' | '...')
+ void *_tmp_124_var;
+ while (
+ (_tmp_124_var = _tmp_124_rule(p))
+ )
+ {
+ res = _tmp_124_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_21");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_21_type, seq);
+ return seq;
+}
+
+// _loop1_22: ('.' | '...')
+static asdl_seq *
+_loop1_22_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ('.' | '...')
+ void *_tmp_125_var;
+ while (
+ (_tmp_125_var = _tmp_125_rule(p))
+ )
+ {
+ res = _tmp_125_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_22");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_22_type, seq);
+ return seq;
+}
+
+// _loop0_24: ',' import_from_as_name
+static asdl_seq *
+_loop0_24_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' import_from_as_name
+ alias_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = import_from_as_name_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_24");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_24_type, seq);
+ return seq;
+}
+
+// _gather_23: import_from_as_name _loop0_24
+static asdl_seq *
+_gather_23_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // import_from_as_name _loop0_24
+ alias_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = import_from_as_name_rule(p))
+ &&
+ (seq = _loop0_24_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_25: 'as' NAME
+static void *
+_tmp_25_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'as' NAME
+ void *keyword;
+ expr_ty z;
+ if (
+ (keyword = _PyPegen_expect_token(p, 531))
+ &&
+ (z = _PyPegen_name_token(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_27: ',' dotted_as_name
+static asdl_seq *
+_loop0_27_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' dotted_as_name
+ alias_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = dotted_as_name_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_27");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_27_type, seq);
+ return seq;
+}
+
+// _gather_26: dotted_as_name _loop0_27
+static asdl_seq *
+_gather_26_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // dotted_as_name _loop0_27
+ alias_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = dotted_as_name_rule(p))
+ &&
+ (seq = _loop0_27_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_28: 'as' NAME
+static void *
+_tmp_28_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'as' NAME
+ void *keyword;
+ expr_ty z;
+ if (
+ (keyword = _PyPegen_expect_token(p, 531))
+ &&
+ (z = _PyPegen_name_token(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_30: ',' with_item
+static asdl_seq *
+_loop0_30_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' with_item
+ withitem_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = with_item_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_30");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_30_type, seq);
+ return seq;
+}
+
+// _gather_29: with_item _loop0_30
+static asdl_seq *
+_gather_29_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // with_item _loop0_30
+ withitem_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = with_item_rule(p))
+ &&
+ (seq = _loop0_30_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_32: ',' with_item
+static asdl_seq *
+_loop0_32_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' with_item
+ withitem_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = with_item_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_32");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_32_type, seq);
+ return seq;
+}
+
+// _gather_31: with_item _loop0_32
+static asdl_seq *
+_gather_31_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // with_item _loop0_32
+ withitem_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = with_item_rule(p))
+ &&
+ (seq = _loop0_32_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_33: 'as' target
+static void *
+_tmp_33_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'as' target
+ void *keyword;
+ expr_ty t;
+ if (
+ (keyword = _PyPegen_expect_token(p, 531))
+ &&
+ (t = target_rule(p))
+ )
+ {
+ res = t;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_34: except_block
+static asdl_seq *
+_loop1_34_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // except_block
+ excepthandler_ty except_block_var;
+ while (
+ (except_block_var = except_block_rule(p))
+ )
+ {
+ res = except_block_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_34");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_34_type, seq);
+ return seq;
+}
+
+// _tmp_35: 'as' target
+static void *
+_tmp_35_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'as' target
+ void *keyword;
+ expr_ty z;
+ if (
+ (keyword = _PyPegen_expect_token(p, 531))
+ &&
+ (z = target_rule(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_36: 'from' expression
+static void *
+_tmp_36_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'from' expression
+ void *keyword;
+ expr_ty z;
+ if (
+ (keyword = _PyPegen_expect_token(p, 514))
+ &&
+ (z = expression_rule(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_37: '->' annotation
+static void *
+_tmp_37_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '->' annotation
+ void *literal;
+ expr_ty z;
+ if (
+ (literal = _PyPegen_expect_token(p, 51))
+ &&
+ (z = annotation_rule(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_38: ',' plain_names
+static void *
+_tmp_38_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' plain_names
+ void *literal;
+ asdl_seq* x;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (x = plain_names_rule(p))
+ )
+ {
+ res = x;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_39: ',' names_with_default
+static void *
+_tmp_39_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' names_with_default
+ void *literal;
+ asdl_seq* y;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (y = names_with_default_rule(p))
+ )
+ {
+ res = y;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_40: ',' star_etc?
+static void *
+_tmp_40_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_41: ',' names_with_default
+static void *
+_tmp_41_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' names_with_default
+ void *literal;
+ asdl_seq* y;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (y = names_with_default_rule(p))
+ )
+ {
+ res = y;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_42: ',' star_etc?
+static void *
+_tmp_42_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_43: ',' names_with_default
+static void *
+_tmp_43_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' names_with_default
+ void *literal;
+ asdl_seq* y;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (y = names_with_default_rule(p))
+ )
+ {
+ res = y;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_44: ',' star_etc?
+static void *
+_tmp_44_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_45: ',' star_etc?
+static void *
+_tmp_45_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_46: plain_names ','
+static void *
+_tmp_46_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // plain_names ','
+ void *literal;
+ asdl_seq* n;
+ if (
+ (n = plain_names_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ )
+ {
+ res = n;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_47: name_with_optional_default
+static asdl_seq *
+_loop0_47_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // name_with_optional_default
+ NameDefaultPair* name_with_optional_default_var;
+ while (
+ (name_with_optional_default_var = name_with_optional_default_rule(p))
+ )
+ {
+ res = name_with_optional_default_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_47");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_47_type, seq);
+ return seq;
+}
+
+// _tmp_48: ',' kwds
+static void *
+_tmp_48_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' kwds
+ arg_ty d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (d = kwds_rule(p))
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_49: name_with_optional_default
+static asdl_seq *
+_loop1_49_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // name_with_optional_default
+ NameDefaultPair* name_with_optional_default_var;
+ while (
+ (name_with_optional_default_var = name_with_optional_default_rule(p))
+ )
+ {
+ res = name_with_optional_default_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_49");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_49_type, seq);
+ return seq;
+}
+
+// _tmp_50: ',' kwds
+static void *
+_tmp_50_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' kwds
+ arg_ty d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (d = kwds_rule(p))
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_51: '=' expression
+static void *
+_tmp_51_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '=' expression
+ expr_ty e;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (e = expression_rule(p))
+ )
+ {
+ res = e;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_53: ',' name_with_default
+static asdl_seq *
+_loop0_53_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' name_with_default
+ NameDefaultPair* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = name_with_default_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_53");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_53_type, seq);
+ return seq;
+}
+
+// _gather_52: name_with_default _loop0_53
+static asdl_seq *
+_gather_52_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // name_with_default _loop0_53
+ NameDefaultPair* elem;
+ asdl_seq * seq;
+ if (
+ (elem = name_with_default_rule(p))
+ &&
+ (seq = _loop0_53_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_55: ',' (plain_name !'=')
+static asdl_seq *
+_loop0_55_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' (plain_name !'=')
+ void *elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = _tmp_126_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_55");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_55_type, seq);
+ return seq;
+}
+
+// _gather_54: (plain_name !'=') _loop0_55
+static asdl_seq *
+_gather_54_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // (plain_name !'=') _loop0_55
+ void *elem;
+ asdl_seq * seq;
+ if (
+ (elem = _tmp_126_rule(p))
+ &&
+ (seq = _loop0_55_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_56: ':' annotation
+static void *
+_tmp_56_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ':' annotation
+ void *literal;
+ expr_ty z;
+ if (
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (z = annotation_rule(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_57: ('@' named_expression NEWLINE)
+static asdl_seq *
+_loop1_57_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ('@' named_expression NEWLINE)
+ void *_tmp_127_var;
+ while (
+ (_tmp_127_var = _tmp_127_rule(p))
+ )
+ {
+ res = _tmp_127_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_57");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_57_type, seq);
+ return seq;
+}
+
+// _tmp_58: '(' arguments? ')'
+static void *
+_tmp_58_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '(' arguments? ')'
+ void *literal;
+ void *literal_1;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ &&
+ (z = arguments_rule(p), 1)
+ &&
+ (literal_1 = _PyPegen_expect_token(p, 8))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_60: ',' star_expression
+static asdl_seq *
+_loop0_60_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' star_expression
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = star_expression_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_60");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_60_type, seq);
+ return seq;
+}
+
+// _gather_59: star_expression _loop0_60
+static asdl_seq *
+_gather_59_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // star_expression _loop0_60
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = star_expression_rule(p))
+ &&
+ (seq = _loop0_60_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_61: (',' star_expression)
+static asdl_seq *
+_loop1_61_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // (',' star_expression)
+ void *_tmp_128_var;
+ while (
+ (_tmp_128_var = _tmp_128_rule(p))
+ )
+ {
+ res = _tmp_128_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_61");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_61_type, seq);
+ return seq;
+}
+
+// _loop0_63: ',' star_named_expression
+static asdl_seq *
+_loop0_63_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' star_named_expression
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = star_named_expression_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_63");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_63_type, seq);
+ return seq;
+}
+
+// _gather_62: star_named_expression _loop0_63
+static asdl_seq *
+_gather_62_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // star_named_expression _loop0_63
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = star_named_expression_rule(p))
+ &&
+ (seq = _loop0_63_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_64: (',' expression)
+static asdl_seq *
+_loop1_64_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // (',' expression)
+ void *_tmp_129_var;
+ while (
+ (_tmp_129_var = _tmp_129_rule(p))
+ )
+ {
+ res = _tmp_129_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_64");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_64_type, seq);
+ return seq;
+}
+
+// _tmp_65: ',' lambda_plain_names
+static void *
+_tmp_65_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_plain_names
+ void *literal;
+ asdl_seq* x;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (x = lambda_plain_names_rule(p))
+ )
+ {
+ res = x;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_66: ',' lambda_names_with_default
+static void *
+_tmp_66_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_names_with_default
+ void *literal;
+ asdl_seq* y;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (y = lambda_names_with_default_rule(p))
+ )
+ {
+ res = y;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_67: ',' lambda_star_etc?
+static void *
+_tmp_67_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = lambda_star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_68: ',' lambda_names_with_default
+static void *
+_tmp_68_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_names_with_default
+ void *literal;
+ asdl_seq* y;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (y = lambda_names_with_default_rule(p))
+ )
+ {
+ res = y;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_69: ',' lambda_star_etc?
+static void *
+_tmp_69_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = lambda_star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_70: ',' lambda_names_with_default
+static void *
+_tmp_70_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_names_with_default
+ void *literal;
+ asdl_seq* y;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (y = lambda_names_with_default_rule(p))
+ )
+ {
+ res = y;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_71: ',' lambda_star_etc?
+static void *
+_tmp_71_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = lambda_star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_72: ',' lambda_star_etc?
+static void *
+_tmp_72_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_star_etc?
+ void *literal;
+ void *z;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = lambda_star_etc_rule(p), 1)
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_73: lambda_plain_names ','
+static void *
+_tmp_73_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // lambda_plain_names ','
+ void *literal;
+ asdl_seq* n;
+ if (
+ (n = lambda_plain_names_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ )
+ {
+ res = n;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_74: lambda_name_with_optional_default
+static asdl_seq *
+_loop0_74_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // lambda_name_with_optional_default
+ NameDefaultPair* lambda_name_with_optional_default_var;
+ while (
+ (lambda_name_with_optional_default_var = lambda_name_with_optional_default_rule(p))
+ )
+ {
+ res = lambda_name_with_optional_default_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_74");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_74_type, seq);
+ return seq;
+}
+
+// _tmp_75: ',' lambda_kwds
+static void *
+_tmp_75_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_kwds
+ arg_ty d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (d = lambda_kwds_rule(p))
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_76: lambda_name_with_optional_default
+static asdl_seq *
+_loop1_76_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // lambda_name_with_optional_default
+ NameDefaultPair* lambda_name_with_optional_default_var;
+ while (
+ (lambda_name_with_optional_default_var = lambda_name_with_optional_default_rule(p))
+ )
+ {
+ res = lambda_name_with_optional_default_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_76");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_76_type, seq);
+ return seq;
+}
+
+// _tmp_77: ',' lambda_kwds
+static void *
+_tmp_77_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' lambda_kwds
+ arg_ty d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (d = lambda_kwds_rule(p))
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_78: '=' expression
+static void *
+_tmp_78_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '=' expression
+ expr_ty e;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (e = expression_rule(p))
+ )
+ {
+ res = e;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_80: ',' lambda_name_with_default
+static asdl_seq *
+_loop0_80_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' lambda_name_with_default
+ NameDefaultPair* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = lambda_name_with_default_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_80");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_80_type, seq);
+ return seq;
+}
+
+// _gather_79: lambda_name_with_default _loop0_80
+static asdl_seq *
+_gather_79_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // lambda_name_with_default _loop0_80
+ NameDefaultPair* elem;
+ asdl_seq * seq;
+ if (
+ (elem = lambda_name_with_default_rule(p))
+ &&
+ (seq = _loop0_80_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_82: ',' (lambda_plain_name !'=')
+static asdl_seq *
+_loop0_82_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' (lambda_plain_name !'=')
+ void *elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = _tmp_130_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_82");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_82_type, seq);
+ return seq;
+}
+
+// _gather_81: (lambda_plain_name !'=') _loop0_82
+static asdl_seq *
+_gather_81_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // (lambda_plain_name !'=') _loop0_82
+ void *elem;
+ asdl_seq * seq;
+ if (
+ (elem = _tmp_130_rule(p))
+ &&
+ (seq = _loop0_82_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_83: ('or' conjunction)
+static asdl_seq *
+_loop1_83_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ('or' conjunction)
+ void *_tmp_131_var;
+ while (
+ (_tmp_131_var = _tmp_131_rule(p))
+ )
+ {
+ res = _tmp_131_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_83");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_83_type, seq);
+ return seq;
+}
+
+// _loop1_84: ('and' inversion)
+static asdl_seq *
+_loop1_84_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ('and' inversion)
+ void *_tmp_132_var;
+ while (
+ (_tmp_132_var = _tmp_132_rule(p))
+ )
+ {
+ res = _tmp_132_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_84");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_84_type, seq);
+ return seq;
+}
+
+// _loop1_85: compare_op_bitwise_or_pair
+static asdl_seq *
+_loop1_85_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // compare_op_bitwise_or_pair
+ CmpopExprPair* compare_op_bitwise_or_pair_var;
+ while (
+ (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p))
+ )
+ {
+ res = compare_op_bitwise_or_pair_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_85");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_85_type, seq);
+ return seq;
+}
+
+// _loop0_87: ',' slice
+static asdl_seq *
+_loop0_87_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' slice
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = slice_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_87");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_87_type, seq);
+ return seq;
+}
+
+// _gather_86: slice _loop0_87
+static asdl_seq *
+_gather_86_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // slice _loop0_87
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = slice_rule(p))
+ &&
+ (seq = _loop0_87_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_88: ':' expression?
+static void *
+_tmp_88_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ':' expression?
+ void *d;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 11))
+ &&
+ (d = expression_rule(p), 1)
+ )
+ {
+ res = d;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_89: tuple | group | genexp
+static void *
+_tmp_89_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // tuple
+ expr_ty tuple_var;
+ if (
+ (tuple_var = tuple_rule(p))
+ )
+ {
+ res = tuple_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // group
+ expr_ty group_var;
+ if (
+ (group_var = group_rule(p))
+ )
+ {
+ res = group_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // genexp
+ expr_ty genexp_var;
+ if (
+ (genexp_var = genexp_rule(p))
+ )
+ {
+ res = genexp_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_90: list | listcomp
+static void *
+_tmp_90_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // list
+ expr_ty list_var;
+ if (
+ (list_var = list_rule(p))
+ )
+ {
+ res = list_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // listcomp
+ expr_ty listcomp_var;
+ if (
+ (listcomp_var = listcomp_rule(p))
+ )
+ {
+ res = listcomp_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_91: dict | set | dictcomp | setcomp
+static void *
+_tmp_91_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // dict
+ expr_ty dict_var;
+ if (
+ (dict_var = dict_rule(p))
+ )
+ {
+ res = dict_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // set
+ expr_ty set_var;
+ if (
+ (set_var = set_rule(p))
+ )
+ {
+ res = set_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // dictcomp
+ expr_ty dictcomp_var;
+ if (
+ (dictcomp_var = dictcomp_rule(p))
+ )
+ {
+ res = dictcomp_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // setcomp
+ expr_ty setcomp_var;
+ if (
+ (setcomp_var = setcomp_rule(p))
+ )
+ {
+ res = setcomp_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_92: STRING
+static asdl_seq *
+_loop1_92_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // STRING
+ expr_ty string_var;
+ while (
+ (string_var = _PyPegen_string_token(p))
+ )
+ {
+ res = string_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_92");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_92_type, seq);
+ return seq;
+}
+
+// _tmp_93: star_named_expression ',' star_named_expressions?
+static void *
+_tmp_93_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // star_named_expression ',' star_named_expressions?
+ void *literal;
+ expr_ty y;
+ void *z;
+ if (
+ (y = star_named_expression_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (z = star_named_expressions_rule(p), 1)
+ )
+ {
+ res = _PyPegen_seq_insert_in_front ( p , y , z );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_94: yield_expr | named_expression
+static void *
+_tmp_94_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // yield_expr
+ expr_ty yield_expr_var;
+ if (
+ (yield_expr_var = yield_expr_rule(p))
+ )
+ {
+ res = yield_expr_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // named_expression
+ expr_ty named_expression_var;
+ if (
+ (named_expression_var = named_expression_rule(p))
+ )
+ {
+ res = named_expression_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_96: ',' kvpair
+static asdl_seq *
+_loop0_96_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' kvpair
+ KeyValuePair* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = kvpair_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_96");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_96_type, seq);
+ return seq;
+}
+
+// _gather_95: kvpair _loop0_96
+static asdl_seq *
+_gather_95_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // kvpair _loop0_96
+ KeyValuePair* elem;
+ asdl_seq * seq;
+ if (
+ (elem = kvpair_rule(p))
+ &&
+ (seq = _loop0_96_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop1_97: (ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*)
+static asdl_seq *
+_loop1_97_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // (ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*)
+ void *_tmp_133_var;
+ while (
+ (_tmp_133_var = _tmp_133_rule(p))
+ )
+ {
+ res = _tmp_133_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ if (n == 0) {
+ PyMem_Free(children);
+ return NULL;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_97");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop1_97_type, seq);
+ return seq;
+}
+
+// _tmp_98: ',' args
+static void *
+_tmp_98_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' args
+ expr_ty c;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (c = args_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_99: ',' args
+static void *
+_tmp_99_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' args
+ expr_ty c;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (c = args_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_101: ',' kwarg_or_starred
+static asdl_seq *
+_loop0_101_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' kwarg_or_starred
+ KeywordOrStarred* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = kwarg_or_starred_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_101");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_101_type, seq);
+ return seq;
+}
+
+// _gather_100: kwarg_or_starred _loop0_101
+static asdl_seq *
+_gather_100_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // kwarg_or_starred _loop0_101
+ KeywordOrStarred* elem;
+ asdl_seq * seq;
+ if (
+ (elem = kwarg_or_starred_rule(p))
+ &&
+ (seq = _loop0_101_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_103: ',' kwarg_or_double_starred
+static asdl_seq *
+_loop0_103_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' kwarg_or_double_starred
+ KeywordOrStarred* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = kwarg_or_double_starred_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_103");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_103_type, seq);
+ return seq;
+}
+
+// _gather_102: kwarg_or_double_starred _loop0_103
+static asdl_seq *
+_gather_102_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // kwarg_or_double_starred _loop0_103
+ KeywordOrStarred* elem;
+ asdl_seq * seq;
+ if (
+ (elem = kwarg_or_double_starred_rule(p))
+ &&
+ (seq = _loop0_103_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_105: ',' kwarg_or_starred
+static asdl_seq *
+_loop0_105_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' kwarg_or_starred
+ KeywordOrStarred* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = kwarg_or_starred_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_105");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_105_type, seq);
+ return seq;
+}
+
+// _gather_104: kwarg_or_starred _loop0_105
+static asdl_seq *
+_gather_104_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // kwarg_or_starred _loop0_105
+ KeywordOrStarred* elem;
+ asdl_seq * seq;
+ if (
+ (elem = kwarg_or_starred_rule(p))
+ &&
+ (seq = _loop0_105_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_107: ',' kwarg_or_double_starred
+static asdl_seq *
+_loop0_107_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' kwarg_or_double_starred
+ KeywordOrStarred* elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = kwarg_or_double_starred_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_107");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_107_type, seq);
+ return seq;
+}
+
+// _gather_106: kwarg_or_double_starred _loop0_107
+static asdl_seq *
+_gather_106_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // kwarg_or_double_starred _loop0_107
+ KeywordOrStarred* elem;
+ asdl_seq * seq;
+ if (
+ (elem = kwarg_or_double_starred_rule(p))
+ &&
+ (seq = _loop0_107_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_108: (',' star_target)
+static asdl_seq *
+_loop0_108_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // (',' star_target)
+ void *_tmp_134_var;
+ while (
+ (_tmp_134_var = _tmp_134_rule(p))
+ )
+ {
+ res = _tmp_134_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_108");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_108_type, seq);
+ return seq;
+}
+
+// _loop0_110: ',' star_target
+static asdl_seq *
+_loop0_110_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' star_target
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = star_target_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_110");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_110_type, seq);
+ return seq;
+}
+
+// _gather_109: star_target _loop0_110
+static asdl_seq *
+_gather_109_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // star_target _loop0_110
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = star_target_rule(p))
+ &&
+ (seq = _loop0_110_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_111: !'*' star_target
+static void *
+_tmp_111_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // !'*' star_target
+ expr_ty star_target_var;
+ if (
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16)
+ &&
+ (star_target_var = star_target_rule(p))
+ )
+ {
+ res = star_target_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_113: ',' del_target
+static asdl_seq *
+_loop0_113_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' del_target
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = del_target_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_113");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_113_type, seq);
+ return seq;
+}
+
+// _gather_112: del_target _loop0_113
+static asdl_seq *
+_gather_112_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // del_target _loop0_113
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = del_target_rule(p))
+ &&
+ (seq = _loop0_113_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_115: ',' target
+static asdl_seq *
+_loop0_115_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ',' target
+ expr_ty elem;
+ void *literal;
+ while (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (elem = target_rule(p))
+ )
+ {
+ res = elem;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ PyMem_Free(children);
+ return NULL;
+ }
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_115");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_115_type, seq);
+ return seq;
+}
+
+// _gather_114: target _loop0_115
+static asdl_seq *
+_gather_114_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ asdl_seq * res = NULL;
+ int mark = p->mark;
+ { // target _loop0_115
+ expr_ty elem;
+ asdl_seq * seq;
+ if (
+ (elem = target_rule(p))
+ &&
+ (seq = _loop0_115_rule(p))
+ )
+ {
+ res = _PyPegen_seq_insert_in_front(p, elem, seq);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_116: args | expression for_if_clauses
+static void *
+_tmp_116_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // args
+ expr_ty args_var;
+ if (
+ (args_var = args_rule(p))
+ )
+ {
+ res = args_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // expression for_if_clauses
+ expr_ty expression_var;
+ asdl_seq* for_if_clauses_var;
+ if (
+ (expression_var = expression_rule(p))
+ &&
+ (for_if_clauses_var = for_if_clauses_rule(p))
+ )
+ {
+ res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_117: '=' annotated_rhs
+static void *
+_tmp_117_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '=' annotated_rhs
+ expr_ty annotated_rhs_var;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 22))
+ &&
+ (annotated_rhs_var = annotated_rhs_rule(p))
+ )
+ {
+ res = _PyPegen_dummy_name(p, literal, annotated_rhs_var);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_118: '=' | augassign
+static void *
+_tmp_118_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '='
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 22))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // augassign
+ AugOperator* augassign_var;
+ if (
+ (augassign_var = augassign_rule(p))
+ )
+ {
+ res = augassign_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_119: yield_expr | star_expressions
+static void *
+_tmp_119_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // yield_expr
+ expr_ty yield_expr_var;
+ if (
+ (yield_expr_var = yield_expr_rule(p))
+ )
+ {
+ res = yield_expr_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // star_expressions
+ expr_ty star_expressions_var;
+ if (
+ (star_expressions_var = star_expressions_rule(p))
+ )
+ {
+ res = star_expressions_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_120: '[' | '(' | '{'
+static void *
+_tmp_120_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '['
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 9))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '('
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 7))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '{'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 25))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_121: plain_names ','
+static void *
+_tmp_121_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // plain_names ','
+ void *literal;
+ asdl_seq* plain_names_var;
+ if (
+ (plain_names_var = plain_names_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 12))
+ )
+ {
+ res = _PyPegen_dummy_name(p, plain_names_var, literal);
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_122: slash_with_default | names_with_default
+static void *
+_tmp_122_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // slash_with_default
+ SlashWithDefault* slash_with_default_var;
+ if (
+ (slash_with_default_var = slash_with_default_rule(p))
+ )
+ {
+ res = slash_with_default_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // names_with_default
+ asdl_seq* names_with_default_var;
+ if (
+ (names_with_default_var = names_with_default_rule(p))
+ )
+ {
+ res = names_with_default_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_123: star_targets '='
+static void *
+_tmp_123_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // star_targets '='
+ void *literal;
+ expr_ty z;
+ if (
+ (z = star_targets_rule(p))
+ &&
+ (literal = _PyPegen_expect_token(p, 22))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_124: '.' | '...'
+static void *
+_tmp_124_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '.'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 23))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '...'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 52))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_125: '.' | '...'
+static void *
+_tmp_125_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '.'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 23))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ { // '...'
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 52))
+ )
+ {
+ res = literal;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_126: plain_name !'='
+static void *
+_tmp_126_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // plain_name !'='
+ arg_ty plain_name_var;
+ if (
+ (plain_name_var = plain_name_rule(p))
+ &&
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)
+ )
+ {
+ res = plain_name_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_127: '@' named_expression NEWLINE
+static void *
+_tmp_127_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // '@' named_expression NEWLINE
+ expr_ty f;
+ void *literal;
+ void *newline_var;
+ if (
+ (literal = _PyPegen_expect_token(p, 49))
+ &&
+ (f = named_expression_rule(p))
+ &&
+ (newline_var = _PyPegen_newline_token(p))
+ )
+ {
+ res = f;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_128: ',' star_expression
+static void *
+_tmp_128_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' star_expression
+ expr_ty c;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (c = star_expression_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_129: ',' expression
+static void *
+_tmp_129_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' expression
+ expr_ty c;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (c = expression_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_130: lambda_plain_name !'='
+static void *
+_tmp_130_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // lambda_plain_name !'='
+ arg_ty lambda_plain_name_var;
+ if (
+ (lambda_plain_name_var = lambda_plain_name_rule(p))
+ &&
+ _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)
+ )
+ {
+ res = lambda_plain_name_var;
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_131: 'or' conjunction
+static void *
+_tmp_131_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'or' conjunction
+ expr_ty c;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 532))
+ &&
+ (c = conjunction_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_132: 'and' inversion
+static void *
+_tmp_132_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'and' inversion
+ expr_ty c;
+ void *keyword;
+ if (
+ (keyword = _PyPegen_expect_token(p, 533))
+ &&
+ (c = inversion_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_133: ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*
+static void *
+_tmp_133_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ASYNC? 'for' star_targets 'in' disjunction (('if' disjunction))*
+ expr_ty a;
+ expr_ty b;
+ asdl_seq * c;
+ void *keyword;
+ void *keyword_1;
+ void *y;
+ if (
+ (y = _PyPegen_async_token(p), 1)
+ &&
+ (keyword = _PyPegen_expect_token(p, 517))
+ &&
+ (a = star_targets_rule(p))
+ &&
+ (keyword_1 = _PyPegen_expect_token(p, 518))
+ &&
+ (b = disjunction_rule(p))
+ &&
+ (c = _loop0_135_rule(p))
+ )
+ {
+ res = _Py_comprehension ( a , b , c , y != NULL , p -> arena );
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _tmp_134: ',' star_target
+static void *
+_tmp_134_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // ',' star_target
+ expr_ty c;
+ void *literal;
+ if (
+ (literal = _PyPegen_expect_token(p, 12))
+ &&
+ (c = star_target_rule(p))
+ )
+ {
+ res = c;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+// _loop0_135: ('if' disjunction)
+static asdl_seq *
+_loop0_135_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void *res = NULL;
+ int mark = p->mark;
+ int start_mark = p->mark;
+ void **children = PyMem_Malloc(sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "Parser out of memory");
+ return NULL;
+ }
+ ssize_t children_capacity = 1;
+ ssize_t n = 0;
+ { // ('if' disjunction)
+ void *_tmp_136_var;
+ while (
+ (_tmp_136_var = _tmp_136_rule(p))
+ )
+ {
+ res = _tmp_136_var;
+ if (n == children_capacity) {
+ children_capacity *= 2;
+ children = PyMem_Realloc(children, children_capacity*sizeof(void *));
+ if (!children) {
+ PyErr_Format(PyExc_MemoryError, "realloc None");
+ return NULL;
+ }
+ }
+ children[n++] = res;
+ mark = p->mark;
+ }
+ p->mark = mark;
+ }
+ asdl_seq *seq = _Py_asdl_seq_new(n, p->arena);
+ if (!seq) {
+ PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_135");
+ PyMem_Free(children);
+ return NULL;
+ }
+ for (int i = 0; i < n; i++) asdl_seq_SET(seq, i, children[i]);
+ PyMem_Free(children);
+ _PyPegen_insert_memo(p, start_mark, _loop0_135_type, seq);
+ return seq;
+}
+
+// _tmp_136: 'if' disjunction
+static void *
+_tmp_136_rule(Parser *p)
+{
+ if (p->error_indicator) {
+ return NULL;
+ }
+ void * res = NULL;
+ int mark = p->mark;
+ { // 'if' disjunction
+ void *keyword;
+ expr_ty z;
+ if (
+ (keyword = _PyPegen_expect_token(p, 510))
+ &&
+ (z = disjunction_rule(p))
+ )
+ {
+ res = z;
+ if (res == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ return NULL;
+ }
+ goto done;
+ }
+ p->mark = mark;
+ }
+ res = NULL;
+ done:
+ return res;
+}
+
+void *
+_PyPegen_parse(Parser *p)
+{
+ // Initialize keywords
+ p->keywords = reserved_keywords;
+ p->n_keyword_lists = n_keyword_lists;
+
+ // Run parser
+ void *result = NULL;
+ if (p->start_rule == Py_file_input) {
+ result = file_rule(p);
+ } else if (p->start_rule == Py_single_input) {
+ result = interactive_rule(p);
+ } else if (p->start_rule == Py_eval_input) {
+ result = eval_rule(p);
+ } else if (p->start_rule == Py_fstring_input) {
+ result = fstring_rule(p);
+ }
+
+ return result;
+}
+
+// The end
diff --git a/Parser/pegen/parse_string.c b/Parser/pegen/parse_string.c
new file mode 100644
index 0000000..41485a9
--- /dev/null
+++ b/Parser/pegen/parse_string.c
@@ -0,0 +1,1387 @@
+#include <Python.h>
+
+#include "../tokenizer.h"
+#include "pegen.h"
+#include "parse_string.h"
+
+//// STRING HANDLING FUNCTIONS ////
+
+// These functions are ported directly from Python/ast.c with some modifications
+// to account for the use of "Parser *p", the fact that don't have parser nodes
+// to pass around and the usage of some specialized APIs present only in this
+// file (like "_PyPegen_raise_syntax_error").
+
+static int
+warn_invalid_escape_sequence(Parser *p, unsigned char first_invalid_escape_char)
+{
+ PyObject *msg =
+ PyUnicode_FromFormat("invalid escape sequence \\%c", first_invalid_escape_char);
+ if (msg == NULL) {
+ return -1;
+ }
+ if (PyErr_WarnExplicitObject(PyExc_DeprecationWarning, msg, p->tok->filename,
+ p->tok->lineno, NULL, NULL) < 0) {
+ if (PyErr_ExceptionMatches(PyExc_DeprecationWarning)) {
+ /* Replace the DeprecationWarning exception with a SyntaxError
+ to get a more accurate error report */
+ PyErr_Clear();
+ RAISE_SYNTAX_ERROR("invalid escape sequence \\%c", first_invalid_escape_char);
+ }
+ Py_DECREF(msg);
+ return -1;
+ }
+ Py_DECREF(msg);
+ return 0;
+}
+
+static PyObject *
+decode_utf8(const char **sPtr, const char *end)
+{
+ const char *s, *t;
+ t = s = *sPtr;
+ while (s < end && (*s & 0x80)) {
+ s++;
+ }
+ *sPtr = s;
+ return PyUnicode_DecodeUTF8(t, s - t, NULL);
+}
+
+static PyObject *
+decode_unicode_with_escapes(Parser *parser, const char *s, size_t len)
+{
+ PyObject *v, *u;
+ char *buf;
+ char *p;
+ const char *end;
+
+ /* check for integer overflow */
+ if (len > SIZE_MAX / 6) {
+ return NULL;
+ }
+ /* "ä" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5
+ "\ä" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */
+ u = PyBytes_FromStringAndSize((char *)NULL, len * 6);
+ if (u == NULL) {
+ return NULL;
+ }
+ p = buf = PyBytes_AsString(u);
+ end = s + len;
+ while (s < end) {
+ if (*s == '\\') {
+ *p++ = *s++;
+ if (s >= end || *s & 0x80) {
+ strcpy(p, "u005c");
+ p += 5;
+ if (s >= end) {
+ break;
+ }
+ }
+ }
+ if (*s & 0x80) {
+ PyObject *w;
+ int kind;
+ void *data;
+ Py_ssize_t len, i;
+ w = decode_utf8(&s, end);
+ if (w == NULL) {
+ Py_DECREF(u);
+ return NULL;
+ }
+ kind = PyUnicode_KIND(w);
+ data = PyUnicode_DATA(w);
+ len = PyUnicode_GET_LENGTH(w);
+ for (i = 0; i < len; i++) {
+ Py_UCS4 chr = PyUnicode_READ(kind, data, i);
+ sprintf(p, "\\U%08x", chr);
+ p += 10;
+ }
+ /* Should be impossible to overflow */
+ assert(p - buf <= PyBytes_GET_SIZE(u));
+ Py_DECREF(w);
+ }
+ else {
+ *p++ = *s++;
+ }
+ }
+ len = p - buf;
+ s = buf;
+
+ const char *first_invalid_escape;
+ v = _PyUnicode_DecodeUnicodeEscape(s, len, NULL, &first_invalid_escape);
+
+ if (v != NULL && first_invalid_escape != NULL) {
+ if (warn_invalid_escape_sequence(parser, *first_invalid_escape) < 0) {
+ /* We have not decref u before because first_invalid_escape points
+ inside u. */
+ Py_XDECREF(u);
+ Py_DECREF(v);
+ return NULL;
+ }
+ }
+ Py_XDECREF(u);
+ return v;
+}
+
+static PyObject *
+decode_bytes_with_escapes(Parser *p, const char *s, Py_ssize_t len)
+{
+ const char *first_invalid_escape;
+ PyObject *result = _PyBytes_DecodeEscape(s, len, NULL, &first_invalid_escape);
+ if (result == NULL) {
+ return NULL;
+ }
+
+ if (first_invalid_escape != NULL) {
+ if (warn_invalid_escape_sequence(p, *first_invalid_escape) < 0) {
+ Py_DECREF(result);
+ return NULL;
+ }
+ }
+ return result;
+}
+
+/* s must include the bracketing quote characters, and r, b, u,
+ &/or f prefixes (if any), and embedded escape sequences (if any).
+ _PyPegen_parsestr parses it, and sets *result to decoded Python string object.
+ If the string is an f-string, set *fstr and *fstrlen to the unparsed
+ string object. Return 0 if no errors occurred. */
+int
+_PyPegen_parsestr(Parser *p, const char *s, int *bytesmode, int *rawmode, PyObject **result,
+ const char **fstr, Py_ssize_t *fstrlen)
+{
+ size_t len;
+ int quote = Py_CHARMASK(*s);
+ int fmode = 0;
+ *bytesmode = 0;
+ *rawmode = 0;
+ *result = NULL;
+ *fstr = NULL;
+ if (Py_ISALPHA(quote)) {
+ while (!*bytesmode || !*rawmode) {
+ if (quote == 'b' || quote == 'B') {
+ quote = *++s;
+ *bytesmode = 1;
+ }
+ else if (quote == 'u' || quote == 'U') {
+ quote = *++s;
+ }
+ else if (quote == 'r' || quote == 'R') {
+ quote = *++s;
+ *rawmode = 1;
+ }
+ else if (quote == 'f' || quote == 'F') {
+ quote = *++s;
+ fmode = 1;
+ }
+ else {
+ break;
+ }
+ }
+ }
+
+ if (fmode && *bytesmode) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ if (quote != '\'' && quote != '\"') {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ /* Skip the leading quote char. */
+ s++;
+ len = strlen(s);
+ if (len > INT_MAX) {
+ PyErr_SetString(PyExc_OverflowError, "string to parse is too long");
+ return -1;
+ }
+ if (s[--len] != quote) {
+ /* Last quote char must match the first. */
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ if (len >= 4 && s[0] == quote && s[1] == quote) {
+ /* A triple quoted string. We've already skipped one quote at
+ the start and one at the end of the string. Now skip the
+ two at the start. */
+ s += 2;
+ len -= 2;
+ /* And check that the last two match. */
+ if (s[--len] != quote || s[--len] != quote) {
+ PyErr_BadInternalCall();
+ return -1;
+ }
+ }
+
+ if (fmode) {
+ /* Just return the bytes. The caller will parse the resulting
+ string. */
+ *fstr = s;
+ *fstrlen = len;
+ return 0;
+ }
+
+ /* Not an f-string. */
+ /* Avoid invoking escape decoding routines if possible. */
+ *rawmode = *rawmode || strchr(s, '\\') == NULL;
+ if (*bytesmode) {
+ /* Disallow non-ASCII characters. */
+ const char *ch;
+ for (ch = s; *ch; ch++) {
+ if (Py_CHARMASK(*ch) >= 0x80) {
+ RAISE_SYNTAX_ERROR(
+ "bytes can only contain ASCII "
+ "literal characters.");
+ return -1;
+ }
+ }
+ if (*rawmode) {
+ *result = PyBytes_FromStringAndSize(s, len);
+ }
+ else {
+ *result = decode_bytes_with_escapes(p, s, len);
+ }
+ }
+ else {
+ if (*rawmode) {
+ *result = PyUnicode_DecodeUTF8Stateful(s, len, NULL, NULL);
+ }
+ else {
+ *result = decode_unicode_with_escapes(p, s, len);
+ }
+ }
+ return *result == NULL ? -1 : 0;
+}
+
+
+
+// FSTRING STUFF
+
+static void fstring_shift_expr_locations(expr_ty n, int lineno, int col_offset);
+static void fstring_shift_argument(expr_ty parent, arg_ty args, int lineno, int col_offset);
+
+
+static inline void shift_expr(expr_ty parent, expr_ty n, int line, int col) {
+ if (parent->lineno < n->lineno) {
+ col = 0;
+ }
+ fstring_shift_expr_locations(n, line, col);
+}
+
+static inline void shift_arg(expr_ty parent, arg_ty n, int line, int col) {
+ if (parent->lineno < n->lineno) {
+ col = 0;
+ }
+ fstring_shift_argument(parent, n, line, col);
+}
+
+static void fstring_shift_seq_locations(expr_ty parent, asdl_seq *seq, int lineno, int col_offset) {
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+ expr_ty expr = asdl_seq_GET(seq, i);
+ if (expr == NULL){
+ continue;
+ }
+ shift_expr(parent, expr, lineno, col_offset);
+ }
+}
+
+static void fstring_shift_slice_locations(expr_ty parent, expr_ty slice, int lineno, int col_offset) {
+ switch (slice->kind) {
+ case Slice_kind:
+ if (slice->v.Slice.lower) {
+ shift_expr(parent, slice->v.Slice.lower, lineno, col_offset);
+ }
+ if (slice->v.Slice.upper) {
+ shift_expr(parent, slice->v.Slice.upper, lineno, col_offset);
+ }
+ if (slice->v.Slice.step) {
+ shift_expr(parent, slice->v.Slice.step, lineno, col_offset);
+ }
+ break;
+ case Tuple_kind:
+ fstring_shift_seq_locations(parent, slice->v.Tuple.elts, lineno, col_offset);
+ break;
+ default:
+ break;
+ }
+}
+
+static void fstring_shift_comprehension(expr_ty parent, comprehension_ty comp, int lineno, int col_offset) {
+ shift_expr(parent, comp->target, lineno, col_offset);
+ shift_expr(parent, comp->iter, lineno, col_offset);
+ fstring_shift_seq_locations(parent, comp->ifs, lineno, col_offset);
+}
+
+static void fstring_shift_argument(expr_ty parent, arg_ty arg, int lineno, int col_offset) {
+ if (arg->annotation != NULL){
+ shift_expr(parent, arg->annotation, lineno, col_offset);
+ }
+ arg->col_offset = arg->col_offset + col_offset;
+ arg->end_col_offset = arg->end_col_offset + col_offset;
+ arg->lineno = arg->lineno + lineno;
+ arg->end_lineno = arg->end_lineno + lineno;
+}
+
+static void fstring_shift_arguments(expr_ty parent, arguments_ty args, int lineno, int col_offset) {
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(args->posonlyargs); i < l; i++) {
+ arg_ty arg = asdl_seq_GET(args->posonlyargs, i);
+ shift_arg(parent, arg, lineno, col_offset);
+ }
+
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(args->args); i < l; i++) {
+ arg_ty arg = asdl_seq_GET(args->args, i);
+ shift_arg(parent, arg, lineno, col_offset);
+ }
+
+ if (args->vararg != NULL) {
+ shift_arg(parent, args->vararg, lineno, col_offset);
+ }
+
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(args->kwonlyargs); i < l; i++) {
+ arg_ty arg = asdl_seq_GET(args->kwonlyargs, i);
+ shift_arg(parent, arg, lineno, col_offset);
+ }
+
+ fstring_shift_seq_locations(parent, args->kw_defaults, lineno, col_offset);
+
+ if (args->kwarg != NULL) {
+ shift_arg(parent, args->kwarg, lineno, col_offset);
+ }
+
+ fstring_shift_seq_locations(parent, args->defaults, lineno, col_offset);
+}
+
+static void fstring_shift_children_locations(expr_ty n, int lineno, int col_offset) {
+ switch (n->kind) {
+ case BoolOp_kind:
+ fstring_shift_seq_locations(n, n->v.BoolOp.values, lineno, col_offset);
+ break;
+ case NamedExpr_kind:
+ shift_expr(n, n->v.NamedExpr.target, lineno, col_offset);
+ shift_expr(n, n->v.NamedExpr.value, lineno, col_offset);
+ break;
+ case BinOp_kind:
+ shift_expr(n, n->v.BinOp.left, lineno, col_offset);
+ shift_expr(n, n->v.BinOp.right, lineno, col_offset);
+ break;
+ case UnaryOp_kind:
+ shift_expr(n, n->v.UnaryOp.operand, lineno, col_offset);
+ break;
+ case Lambda_kind:
+ fstring_shift_arguments(n, n->v.Lambda.args, lineno, col_offset);
+ shift_expr(n, n->v.Lambda.body, lineno, col_offset);
+ break;
+ case IfExp_kind:
+ shift_expr(n, n->v.IfExp.test, lineno, col_offset);
+ shift_expr(n, n->v.IfExp.body, lineno, col_offset);
+ shift_expr(n, n->v.IfExp.orelse, lineno, col_offset);
+ break;
+ case Dict_kind:
+ fstring_shift_seq_locations(n, n->v.Dict.keys, lineno, col_offset);
+ fstring_shift_seq_locations(n, n->v.Dict.values, lineno, col_offset);
+ break;
+ case Set_kind:
+ fstring_shift_seq_locations(n, n->v.Set.elts, lineno, col_offset);
+ break;
+ case ListComp_kind:
+ shift_expr(n, n->v.ListComp.elt, lineno, col_offset);
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.ListComp.generators); i < l; i++) {
+ comprehension_ty comp = asdl_seq_GET(n->v.ListComp.generators, i);
+ fstring_shift_comprehension(n, comp, lineno, col_offset);
+ }
+ break;
+ case SetComp_kind:
+ shift_expr(n, n->v.SetComp.elt, lineno, col_offset);
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.SetComp.generators); i < l; i++) {
+ comprehension_ty comp = asdl_seq_GET(n->v.SetComp.generators, i);
+ fstring_shift_comprehension(n, comp, lineno, col_offset);
+ }
+ break;
+ case DictComp_kind:
+ shift_expr(n, n->v.DictComp.key, lineno, col_offset);
+ shift_expr(n, n->v.DictComp.value, lineno, col_offset);
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.DictComp.generators); i < l; i++) {
+ comprehension_ty comp = asdl_seq_GET(n->v.DictComp.generators, i);
+ fstring_shift_comprehension(n, comp, lineno, col_offset);
+ }
+ break;
+ case GeneratorExp_kind:
+ shift_expr(n, n->v.GeneratorExp.elt, lineno, col_offset);
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.GeneratorExp.generators); i < l; i++) {
+ comprehension_ty comp = asdl_seq_GET(n->v.GeneratorExp.generators, i);
+ fstring_shift_comprehension(n, comp, lineno, col_offset);
+ }
+ break;
+ case Await_kind:
+ shift_expr(n, n->v.Await.value, lineno, col_offset);
+ break;
+ case Yield_kind:
+ shift_expr(n, n->v.Yield.value, lineno, col_offset);
+ break;
+ case YieldFrom_kind:
+ shift_expr(n, n->v.YieldFrom.value, lineno, col_offset);
+ break;
+ case Compare_kind:
+ shift_expr(n, n->v.Compare.left, lineno, col_offset);
+ fstring_shift_seq_locations(n, n->v.Compare.comparators, lineno, col_offset);
+ break;
+ case Call_kind:
+ shift_expr(n, n->v.Call.func, lineno, col_offset);
+ fstring_shift_seq_locations(n, n->v.Call.args, lineno, col_offset);
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(n->v.Call.keywords); i < l; i++) {
+ keyword_ty keyword = asdl_seq_GET(n->v.Call.keywords, i);
+ shift_expr(n, keyword->value, lineno, col_offset);
+ }
+ break;
+ case Attribute_kind:
+ shift_expr(n, n->v.Attribute.value, lineno, col_offset);
+ break;
+ case Subscript_kind:
+ shift_expr(n, n->v.Subscript.value, lineno, col_offset);
+ fstring_shift_slice_locations(n, n->v.Subscript.slice, lineno, col_offset);
+ shift_expr(n, n->v.Subscript.slice, lineno, col_offset);
+ break;
+ case Starred_kind:
+ shift_expr(n, n->v.Starred.value, lineno, col_offset);
+ break;
+ case List_kind:
+ fstring_shift_seq_locations(n, n->v.List.elts, lineno, col_offset);
+ break;
+ case Tuple_kind:
+ fstring_shift_seq_locations(n, n->v.Tuple.elts, lineno, col_offset);
+ break;
+ default:
+ return;
+ }
+}
+
+/* Shift locations for the given node and all its children by adding `lineno`
+ and `col_offset` to existing locations. Note that n is the already parsed
+ expression. */
+static void fstring_shift_expr_locations(expr_ty n, int lineno, int col_offset)
+{
+ n->col_offset = n->col_offset + col_offset;
+
+ // The following is needed, in order for nodes spanning across multiple lines
+ // to be shifted correctly. An example of such a node is a Call node, the closing
+ // parenthesis of which is not on the same line as its name.
+ if (n->lineno == n->end_lineno) {
+ n->end_col_offset = n->end_col_offset + col_offset;
+ }
+
+ fstring_shift_children_locations(n, lineno, col_offset);
+ n->lineno = n->lineno + lineno;
+ n->end_lineno = n->end_lineno + lineno;
+}
+
+/* Fix locations for the given node and its children.
+
+ `parent` is the enclosing node.
+ `n` is the node which locations are going to be fixed relative to parent.
+ `expr_str` is the child node's string representation, including braces.
+*/
+static void
+fstring_fix_expr_location(Token *parent, expr_ty n, char *expr_str)
+{
+ char *substr = NULL;
+ char *start;
+ int lines = 0;
+ int cols = 0;
+
+ if (parent && parent->bytes) {
+ char *parent_str = PyBytes_AsString(parent->bytes);
+ if (!parent_str) {
+ return;
+ }
+ substr = strstr(parent_str, expr_str);
+ if (substr) {
+ // The following is needed, in order to correctly shift the column
+ // offset, in the case that (disregarding any whitespace) a newline
+ // immediately follows the opening curly brace of the fstring expression.
+ int newline_after_brace = 1;
+ start = substr + 1;
+ while (start && *start != '}' && *start != '\n') {
+ if (*start != ' ' && *start != '\t' && *start != '\f') {
+ newline_after_brace = 0;
+ break;
+ }
+ start++;
+ }
+
+ // Account for the characters from the last newline character to our
+ // left until the beginning of substr.
+ if (!newline_after_brace) {
+ start = substr;
+ while (start > parent_str && *start != '\n') {
+ start--;
+ }
+ cols += (int)(substr - start);
+ }
+ /* adjust the start based on the number of newlines encountered
+ before the f-string expression */
+ for (char* p = parent_str; p < substr; p++) {
+ if (*p == '\n') {
+ lines++;
+ }
+ }
+ }
+ }
+ fstring_shift_expr_locations(n, lines, cols);
+}
+
+
+/* Compile this expression in to an expr_ty. Add parens around the
+ expression, in order to allow leading spaces in the expression. */
+static expr_ty
+fstring_compile_expr(Parser *p, const char *expr_start, const char *expr_end,
+ Token *t)
+{
+ expr_ty expr = NULL;
+ char *str;
+ Py_ssize_t len;
+ const char *s;
+ expr_ty result = NULL;
+
+ assert(expr_end >= expr_start);
+ assert(*(expr_start-1) == '{');
+ assert(*expr_end == '}' || *expr_end == '!' || *expr_end == ':' ||
+ *expr_end == '=');
+
+ /* If the substring is all whitespace, it's an error. We need to catch this
+ here, and not when we call PyParser_SimpleParseStringFlagsFilename,
+ because turning the expression '' in to '()' would go from being invalid
+ to valid. */
+ for (s = expr_start; s != expr_end; s++) {
+ char c = *s;
+ /* The Python parser ignores only the following whitespace
+ characters (\r already is converted to \n). */
+ if (!(c == ' ' || c == '\t' || c == '\n' || c == '\f')) {
+ break;
+ }
+ }
+ if (s == expr_end) {
+ RAISE_SYNTAX_ERROR("f-string: empty expression not allowed");
+ return NULL;
+ }
+
+ len = expr_end - expr_start;
+ /* Allocate 3 extra bytes: open paren, close paren, null byte. */
+ str = PyMem_RawMalloc(len + 3);
+ if (str == NULL) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+
+ str[0] = '(';
+ memcpy(str+1, expr_start, len);
+ str[len+1] = ')';
+ str[len+2] = 0;
+
+ struct tok_state* tok = PyTokenizer_FromString(str, 1);
+ if (tok == NULL) {
+ return NULL;
+ }
+ tok->filename = PyUnicode_FromString("<fstring>");
+ if (!tok->filename) {
+ PyTokenizer_Free(tok);
+ return NULL;
+ }
+
+ Parser *p2 = _PyPegen_Parser_New(tok, Py_fstring_input, NULL, p->arena);
+ p2->starting_lineno = p->starting_lineno + p->tok->first_lineno - 1;
+ p2->starting_col_offset = p->tok->first_lineno == p->tok->lineno
+ ? p->starting_col_offset + t->col_offset : 0;
+
+ expr = _PyPegen_run_parser(p2);
+
+ if (expr == NULL) {
+ goto exit;
+ }
+
+ /* Reuse str to find the correct column offset. */
+ str[0] = '{';
+ str[len+1] = '}';
+ fstring_fix_expr_location(t, expr, str);
+
+ result = expr;
+
+exit:
+ _PyPegen_Parser_Free(p2);
+ PyTokenizer_Free(tok);
+ return result;
+}
+
+/* Return -1 on error.
+
+ Return 0 if we reached the end of the literal.
+
+ Return 1 if we haven't reached the end of the literal, but we want
+ the caller to process the literal up to this point. Used for
+ doubled braces.
+*/
+static int
+fstring_find_literal(Parser *p, const char **str, const char *end, int raw,
+ PyObject **literal, int recurse_lvl)
+{
+ /* Get any literal string. It ends when we hit an un-doubled left
+ brace (which isn't part of a unicode name escape such as
+ "\N{EULER CONSTANT}"), or the end of the string. */
+
+ const char *s = *str;
+ const char *literal_start = s;
+ int result = 0;
+
+ assert(*literal == NULL);
+ while (s < end) {
+ char ch = *s++;
+ if (!raw && ch == '\\' && s < end) {
+ ch = *s++;
+ if (ch == 'N') {
+ if (s < end && *s++ == '{') {
+ while (s < end && *s++ != '}') {
+ }
+ continue;
+ }
+ break;
+ }
+ if (ch == '{' && warn_invalid_escape_sequence(p, ch) < 0) {
+ return -1;
+ }
+ }
+ if (ch == '{' || ch == '}') {
+ /* Check for doubled braces, but only at the top level. If
+ we checked at every level, then f'{0:{3}}' would fail
+ with the two closing braces. */
+ if (recurse_lvl == 0) {
+ if (s < end && *s == ch) {
+ /* We're going to tell the caller that the literal ends
+ here, but that they should continue scanning. But also
+ skip over the second brace when we resume scanning. */
+ *str = s + 1;
+ result = 1;
+ goto done;
+ }
+
+ /* Where a single '{' is the start of a new expression, a
+ single '}' is not allowed. */
+ if (ch == '}') {
+ *str = s - 1;
+ RAISE_SYNTAX_ERROR("f-string: single '}' is not allowed");
+ return -1;
+ }
+ }
+ /* We're either at a '{', which means we're starting another
+ expression; or a '}', which means we're at the end of this
+ f-string (for a nested format_spec). */
+ s--;
+ break;
+ }
+ }
+ *str = s;
+ assert(s <= end);
+ assert(s == end || *s == '{' || *s == '}');
+done:
+ if (literal_start != s) {
+ if (raw)
+ *literal = PyUnicode_DecodeUTF8Stateful(literal_start,
+ s - literal_start,
+ NULL, NULL);
+ else
+ *literal = decode_unicode_with_escapes(p, literal_start,
+ s - literal_start);
+ if (!*literal)
+ return -1;
+ }
+ return result;
+}
+
+/* Forward declaration because parsing is recursive. */
+static expr_ty
+fstring_parse(Parser *p, const char **str, const char *end, int raw, int recurse_lvl,
+ Token *first_token, Token* t, Token *last_token);
+
+/* Parse the f-string at *str, ending at end. We know *str starts an
+ expression (so it must be a '{'). Returns the FormattedValue node, which
+ includes the expression, conversion character, format_spec expression, and
+ optionally the text of the expression (if = is used).
+
+ Note that I don't do a perfect job here: I don't make sure that a
+ closing brace doesn't match an opening paren, for example. It
+ doesn't need to error on all invalid expressions, just correctly
+ find the end of all valid ones. Any errors inside the expression
+ will be caught when we parse it later.
+
+ *expression is set to the expression. For an '=' "debug" expression,
+ *expr_text is set to the debug text (the original text of the expression,
+ including the '=' and any whitespace around it, as a string object). If
+ not a debug expression, *expr_text set to NULL. */
+static int
+fstring_find_expr(Parser *p, const char **str, const char *end, int raw, int recurse_lvl,
+ PyObject **expr_text, expr_ty *expression, Token *first_token,
+ Token *t, Token *last_token)
+{
+ /* Return -1 on error, else 0. */
+
+ const char *expr_start;
+ const char *expr_end;
+ expr_ty simple_expression;
+ expr_ty format_spec = NULL; /* Optional format specifier. */
+ int conversion = -1; /* The conversion char. Use default if not
+ specified, or !r if using = and no format
+ spec. */
+
+ /* 0 if we're not in a string, else the quote char we're trying to
+ match (single or double quote). */
+ char quote_char = 0;
+
+ /* If we're inside a string, 1=normal, 3=triple-quoted. */
+ int string_type = 0;
+
+ /* Keep track of nesting level for braces/parens/brackets in
+ expressions. */
+ Py_ssize_t nested_depth = 0;
+ char parenstack[MAXLEVEL];
+
+ *expr_text = NULL;
+
+ /* Can only nest one level deep. */
+ if (recurse_lvl >= 2) {
+ RAISE_SYNTAX_ERROR("f-string: expressions nested too deeply");
+ goto error;
+ }
+
+ /* The first char must be a left brace, or we wouldn't have gotten
+ here. Skip over it. */
+ assert(**str == '{');
+ *str += 1;
+
+ expr_start = *str;
+ for (; *str < end; (*str)++) {
+ char ch;
+
+ /* Loop invariants. */
+ assert(nested_depth >= 0);
+ assert(*str >= expr_start && *str < end);
+ if (quote_char)
+ assert(string_type == 1 || string_type == 3);
+ else
+ assert(string_type == 0);
+
+ ch = **str;
+ /* Nowhere inside an expression is a backslash allowed. */
+ if (ch == '\\') {
+ /* Error: can't include a backslash character, inside
+ parens or strings or not. */
+ RAISE_SYNTAX_ERROR(
+ "f-string expression part "
+ "cannot include a backslash");
+ goto error;
+ }
+ if (quote_char) {
+ /* We're inside a string. See if we're at the end. */
+ /* This code needs to implement the same non-error logic
+ as tok_get from tokenizer.c, at the letter_quote
+ label. To actually share that code would be a
+ nightmare. But, it's unlikely to change and is small,
+ so duplicate it here. Note we don't need to catch all
+ of the errors, since they'll be caught when parsing the
+ expression. We just need to match the non-error
+ cases. Thus we can ignore \n in single-quoted strings,
+ for example. Or non-terminated strings. */
+ if (ch == quote_char) {
+ /* Does this match the string_type (single or triple
+ quoted)? */
+ if (string_type == 3) {
+ if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) {
+ /* We're at the end of a triple quoted string. */
+ *str += 2;
+ string_type = 0;
+ quote_char = 0;
+ continue;
+ }
+ } else {
+ /* We're at the end of a normal string. */
+ quote_char = 0;
+ string_type = 0;
+ continue;
+ }
+ }
+ } else if (ch == '\'' || ch == '"') {
+ /* Is this a triple quoted string? */
+ if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) {
+ string_type = 3;
+ *str += 2;
+ } else {
+ /* Start of a normal string. */
+ string_type = 1;
+ }
+ /* Start looking for the end of the string. */
+ quote_char = ch;
+ } else if (ch == '[' || ch == '{' || ch == '(') {
+ if (nested_depth >= MAXLEVEL) {
+ RAISE_SYNTAX_ERROR("f-string: too many nested parenthesis");
+ goto error;
+ }
+ parenstack[nested_depth] = ch;
+ nested_depth++;
+ } else if (ch == '#') {
+ /* Error: can't include a comment character, inside parens
+ or not. */
+ RAISE_SYNTAX_ERROR("f-string expression part cannot include '#'");
+ goto error;
+ } else if (nested_depth == 0 &&
+ (ch == '!' || ch == ':' || ch == '}' ||
+ ch == '=' || ch == '>' || ch == '<')) {
+ /* See if there's a next character. */
+ if (*str+1 < end) {
+ char next = *(*str+1);
+
+ /* For "!=". since '=' is not an allowed conversion character,
+ nothing is lost in this test. */
+ if ((ch == '!' && next == '=') || /* != */
+ (ch == '=' && next == '=') || /* == */
+ (ch == '<' && next == '=') || /* <= */
+ (ch == '>' && next == '=') /* >= */
+ ) {
+ *str += 1;
+ continue;
+ }
+ /* Don't get out of the loop for these, if they're single
+ chars (not part of 2-char tokens). If by themselves, they
+ don't end an expression (unlike say '!'). */
+ if (ch == '>' || ch == '<') {
+ continue;
+ }
+ }
+
+ /* Normal way out of this loop. */
+ break;
+ } else if (ch == ']' || ch == '}' || ch == ')') {
+ if (!nested_depth) {
+ RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", ch);
+ goto error;
+ }
+ nested_depth--;
+ int opening = parenstack[nested_depth];
+ if (!((opening == '(' && ch == ')') ||
+ (opening == '[' && ch == ']') ||
+ (opening == '{' && ch == '}')))
+ {
+ RAISE_SYNTAX_ERROR(
+ "f-string: closing parenthesis '%c' "
+ "does not match opening parenthesis '%c'",
+ ch, opening);
+ goto error;
+ }
+ } else {
+ /* Just consume this char and loop around. */
+ }
+ }
+ expr_end = *str;
+ /* If we leave this loop in a string or with mismatched parens, we
+ don't care. We'll get a syntax error when compiling the
+ expression. But, we can produce a better error message, so
+ let's just do that.*/
+ if (quote_char) {
+ RAISE_SYNTAX_ERROR("f-string: unterminated string");
+ goto error;
+ }
+ if (nested_depth) {
+ int opening = parenstack[nested_depth - 1];
+ RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", opening);
+ goto error;
+ }
+
+ if (*str >= end)
+ goto unexpected_end_of_string;
+
+ /* Compile the expression as soon as possible, so we show errors
+ related to the expression before errors related to the
+ conversion or format_spec. */
+ simple_expression = fstring_compile_expr(p, expr_start, expr_end, t);
+ if (!simple_expression)
+ goto error;
+
+ /* Check for =, which puts the text value of the expression in
+ expr_text. */
+ if (**str == '=') {
+ *str += 1;
+
+ /* Skip over ASCII whitespace. No need to test for end of string
+ here, since we know there's at least a trailing quote somewhere
+ ahead. */
+ while (Py_ISSPACE(**str)) {
+ *str += 1;
+ }
+
+ /* Set *expr_text to the text of the expression. */
+ *expr_text = PyUnicode_FromStringAndSize(expr_start, *str-expr_start);
+ if (!*expr_text) {
+ goto error;
+ }
+ }
+
+ /* Check for a conversion char, if present. */
+ if (**str == '!') {
+ *str += 1;
+ if (*str >= end)
+ goto unexpected_end_of_string;
+
+ conversion = **str;
+ *str += 1;
+
+ /* Validate the conversion. */
+ if (!(conversion == 's' || conversion == 'r' || conversion == 'a')) {
+ RAISE_SYNTAX_ERROR(
+ "f-string: invalid conversion character: "
+ "expected 's', 'r', or 'a'");
+ goto error;
+ }
+
+ }
+
+ /* Check for the format spec, if present. */
+ if (*str >= end)
+ goto unexpected_end_of_string;
+ if (**str == ':') {
+ *str += 1;
+ if (*str >= end)
+ goto unexpected_end_of_string;
+
+ /* Parse the format spec. */
+ format_spec = fstring_parse(p, str, end, raw, recurse_lvl+1,
+ first_token, t, last_token);
+ if (!format_spec)
+ goto error;
+ }
+
+ if (*str >= end || **str != '}')
+ goto unexpected_end_of_string;
+
+ /* We're at a right brace. Consume it. */
+ assert(*str < end);
+ assert(**str == '}');
+ *str += 1;
+
+ /* If we're in = mode (detected by non-NULL expr_text), and have no format
+ spec and no explicit conversion, set the conversion to 'r'. */
+ if (*expr_text && format_spec == NULL && conversion == -1) {
+ conversion = 'r';
+ }
+
+ /* And now create the FormattedValue node that represents this
+ entire expression with the conversion and format spec. */
+ //TODO: Fix this
+ *expression = FormattedValue(simple_expression, conversion,
+ format_spec, first_token->lineno,
+ first_token->col_offset, last_token->end_lineno,
+ last_token->end_col_offset, p->arena);
+ if (!*expression)
+ goto error;
+
+ return 0;
+
+unexpected_end_of_string:
+ RAISE_SYNTAX_ERROR("f-string: expecting '}'");
+ /* Falls through to error. */
+
+error:
+ Py_XDECREF(*expr_text);
+ return -1;
+
+}
+
+/* Return -1 on error.
+
+ Return 0 if we have a literal (possible zero length) and an
+ expression (zero length if at the end of the string.
+
+ Return 1 if we have a literal, but no expression, and we want the
+ caller to call us again. This is used to deal with doubled
+ braces.
+
+ When called multiple times on the string 'a{{b{0}c', this function
+ will return:
+
+ 1. the literal 'a{' with no expression, and a return value
+ of 1. Despite the fact that there's no expression, the return
+ value of 1 means we're not finished yet.
+
+ 2. the literal 'b' and the expression '0', with a return value of
+ 0. The fact that there's an expression means we're not finished.
+
+ 3. literal 'c' with no expression and a return value of 0. The
+ combination of the return value of 0 with no expression means
+ we're finished.
+*/
+static int
+fstring_find_literal_and_expr(Parser *p, const char **str, const char *end, int raw,
+ int recurse_lvl, PyObject **literal,
+ PyObject **expr_text, expr_ty *expression,
+ Token *first_token, Token *t, Token *last_token)
+{
+ int result;
+
+ assert(*literal == NULL && *expression == NULL);
+
+ /* Get any literal string. */
+ result = fstring_find_literal(p, str, end, raw, literal, recurse_lvl);
+ if (result < 0)
+ goto error;
+
+ assert(result == 0 || result == 1);
+
+ if (result == 1)
+ /* We have a literal, but don't look at the expression. */
+ return 1;
+
+ if (*str >= end || **str == '}')
+ /* We're at the end of the string or the end of a nested
+ f-string: no expression. The top-level error case where we
+ expect to be at the end of the string but we're at a '}' is
+ handled later. */
+ return 0;
+
+ /* We must now be the start of an expression, on a '{'. */
+ assert(**str == '{');
+
+ if (fstring_find_expr(p, str, end, raw, recurse_lvl, expr_text,
+ expression, first_token, t, last_token) < 0)
+ goto error;
+
+ return 0;
+
+error:
+ Py_CLEAR(*literal);
+ return -1;
+}
+
+#ifdef NDEBUG
+#define ExprList_check_invariants(l)
+#else
+static void
+ExprList_check_invariants(ExprList *l)
+{
+ /* Check our invariants. Make sure this object is "live", and
+ hasn't been deallocated. */
+ assert(l->size >= 0);
+ assert(l->p != NULL);
+ if (l->size <= EXPRLIST_N_CACHED)
+ assert(l->data == l->p);
+}
+#endif
+
+static void
+ExprList_Init(ExprList *l)
+{
+ l->allocated = EXPRLIST_N_CACHED;
+ l->size = 0;
+
+ /* Until we start allocating dynamically, p points to data. */
+ l->p = l->data;
+
+ ExprList_check_invariants(l);
+}
+
+static int
+ExprList_Append(ExprList *l, expr_ty exp)
+{
+ ExprList_check_invariants(l);
+ if (l->size >= l->allocated) {
+ /* We need to alloc (or realloc) the memory. */
+ Py_ssize_t new_size = l->allocated * 2;
+
+ /* See if we've ever allocated anything dynamically. */
+ if (l->p == l->data) {
+ Py_ssize_t i;
+ /* We're still using the cached data. Switch to
+ alloc-ing. */
+ l->p = PyMem_RawMalloc(sizeof(expr_ty) * new_size);
+ if (!l->p)
+ return -1;
+ /* Copy the cached data into the new buffer. */
+ for (i = 0; i < l->size; i++)
+ l->p[i] = l->data[i];
+ } else {
+ /* Just realloc. */
+ expr_ty *tmp = PyMem_RawRealloc(l->p, sizeof(expr_ty) * new_size);
+ if (!tmp) {
+ PyMem_RawFree(l->p);
+ l->p = NULL;
+ return -1;
+ }
+ l->p = tmp;
+ }
+
+ l->allocated = new_size;
+ assert(l->allocated == 2 * l->size);
+ }
+
+ l->p[l->size++] = exp;
+
+ ExprList_check_invariants(l);
+ return 0;
+}
+
+static void
+ExprList_Dealloc(ExprList *l)
+{
+ ExprList_check_invariants(l);
+
+ /* If there's been an error, or we've never dynamically allocated,
+ do nothing. */
+ if (!l->p || l->p == l->data) {
+ /* Do nothing. */
+ } else {
+ /* We have dynamically allocated. Free the memory. */
+ PyMem_RawFree(l->p);
+ }
+ l->p = NULL;
+ l->size = -1;
+}
+
+static asdl_seq *
+ExprList_Finish(ExprList *l, PyArena *arena)
+{
+ asdl_seq *seq;
+
+ ExprList_check_invariants(l);
+
+ /* Allocate the asdl_seq and copy the expressions in to it. */
+ seq = _Py_asdl_seq_new(l->size, arena);
+ if (seq) {
+ Py_ssize_t i;
+ for (i = 0; i < l->size; i++)
+ asdl_seq_SET(seq, i, l->p[i]);
+ }
+ ExprList_Dealloc(l);
+ return seq;
+}
+
+#ifdef NDEBUG
+#define FstringParser_check_invariants(state)
+#else
+static void
+FstringParser_check_invariants(FstringParser *state)
+{
+ if (state->last_str)
+ assert(PyUnicode_CheckExact(state->last_str));
+ ExprList_check_invariants(&state->expr_list);
+}
+#endif
+
+void
+_PyPegen_FstringParser_Init(FstringParser *state)
+{
+ state->last_str = NULL;
+ state->fmode = 0;
+ ExprList_Init(&state->expr_list);
+ FstringParser_check_invariants(state);
+}
+
+void
+_PyPegen_FstringParser_Dealloc(FstringParser *state)
+{
+ FstringParser_check_invariants(state);
+
+ Py_XDECREF(state->last_str);
+ ExprList_Dealloc(&state->expr_list);
+}
+
+/* Make a Constant node, but decref the PyUnicode object being added. */
+static expr_ty
+make_str_node_and_del(Parser *p, PyObject **str, Token* first_token, Token *last_token)
+{
+ PyObject *s = *str;
+ PyObject *kind = NULL;
+ *str = NULL;
+ assert(PyUnicode_CheckExact(s));
+ if (PyArena_AddPyObject(p->arena, s) < 0) {
+ Py_DECREF(s);
+ return NULL;
+ }
+ const char* the_str = PyBytes_AsString(first_token->bytes);
+ if (the_str && the_str[0] == 'u') {
+ kind = _PyPegen_new_identifier(p, "u");
+ }
+
+ if (kind == NULL && PyErr_Occurred()) {
+ return NULL;
+ }
+
+ return Constant(s, kind, first_token->lineno, first_token->col_offset,
+ last_token->end_lineno, last_token->end_col_offset, p->arena);
+
+}
+
+
+/* Add a non-f-string (that is, a regular literal string). str is
+ decref'd. */
+int
+_PyPegen_FstringParser_ConcatAndDel(FstringParser *state, PyObject *str)
+{
+ FstringParser_check_invariants(state);
+
+ assert(PyUnicode_CheckExact(str));
+
+ if (PyUnicode_GET_LENGTH(str) == 0) {
+ Py_DECREF(str);
+ return 0;
+ }
+
+ if (!state->last_str) {
+ /* We didn't have a string before, so just remember this one. */
+ state->last_str = str;
+ } else {
+ /* Concatenate this with the previous string. */
+ PyUnicode_AppendAndDel(&state->last_str, str);
+ if (!state->last_str)
+ return -1;
+ }
+ FstringParser_check_invariants(state);
+ return 0;
+}
+
+/* Parse an f-string. The f-string is in *str to end, with no
+ 'f' or quotes. */
+int
+_PyPegen_FstringParser_ConcatFstring(Parser *p, FstringParser *state, const char **str,
+ const char *end, int raw, int recurse_lvl,
+ Token *first_token, Token* t, Token *last_token)
+{
+ FstringParser_check_invariants(state);
+ state->fmode = 1;
+
+ /* Parse the f-string. */
+ while (1) {
+ PyObject *literal = NULL;
+ PyObject *expr_text = NULL;
+ expr_ty expression = NULL;
+
+ /* If there's a zero length literal in front of the
+ expression, literal will be NULL. If we're at the end of
+ the f-string, expression will be NULL (unless result == 1,
+ see below). */
+ int result = fstring_find_literal_and_expr(p, str, end, raw, recurse_lvl,
+ &literal, &expr_text,
+ &expression, first_token, t, last_token);
+ if (result < 0)
+ return -1;
+
+ /* Add the literal, if any. */
+ if (literal && _PyPegen_FstringParser_ConcatAndDel(state, literal) < 0) {
+ Py_XDECREF(expr_text);
+ return -1;
+ }
+ /* Add the expr_text, if any. */
+ if (expr_text && _PyPegen_FstringParser_ConcatAndDel(state, expr_text) < 0) {
+ return -1;
+ }
+
+ /* We've dealt with the literal and expr_text, their ownership has
+ been transferred to the state object. Don't look at them again. */
+
+ /* See if we should just loop around to get the next literal
+ and expression, while ignoring the expression this
+ time. This is used for un-doubling braces, as an
+ optimization. */
+ if (result == 1)
+ continue;
+
+ if (!expression)
+ /* We're done with this f-string. */
+ break;
+
+ /* We know we have an expression. Convert any existing string
+ to a Constant node. */
+ if (!state->last_str) {
+ /* Do nothing. No previous literal. */
+ } else {
+ /* Convert the existing last_str literal to a Constant node. */
+ expr_ty str = make_str_node_and_del(p, &state->last_str, first_token, last_token);
+ if (!str || ExprList_Append(&state->expr_list, str) < 0)
+ return -1;
+ }
+
+ if (ExprList_Append(&state->expr_list, expression) < 0)
+ return -1;
+ }
+
+ /* If recurse_lvl is zero, then we must be at the end of the
+ string. Otherwise, we must be at a right brace. */
+
+ if (recurse_lvl == 0 && *str < end-1) {
+ RAISE_SYNTAX_ERROR("f-string: unexpected end of string");
+ return -1;
+ }
+ if (recurse_lvl != 0 && **str != '}') {
+ RAISE_SYNTAX_ERROR("f-string: expecting '}'");
+ return -1;
+ }
+
+ FstringParser_check_invariants(state);
+ return 0;
+}
+
+/* Convert the partial state reflected in last_str and expr_list to an
+ expr_ty. The expr_ty can be a Constant, or a JoinedStr. */
+expr_ty
+_PyPegen_FstringParser_Finish(Parser *p, FstringParser *state, Token* first_token,
+ Token *last_token)
+{
+ asdl_seq *seq;
+
+ FstringParser_check_invariants(state);
+
+ /* If we're just a constant string with no expressions, return
+ that. */
+ if (!state->fmode) {
+ assert(!state->expr_list.size);
+ if (!state->last_str) {
+ /* Create a zero length string. */
+ state->last_str = PyUnicode_FromStringAndSize(NULL, 0);
+ if (!state->last_str)
+ goto error;
+ }
+ return make_str_node_and_del(p, &state->last_str, first_token, last_token);
+ }
+
+ /* Create a Constant node out of last_str, if needed. It will be the
+ last node in our expression list. */
+ if (state->last_str) {
+ expr_ty str = make_str_node_and_del(p, &state->last_str, first_token, last_token);
+ if (!str || ExprList_Append(&state->expr_list, str) < 0)
+ goto error;
+ }
+ /* This has already been freed. */
+ assert(state->last_str == NULL);
+
+ seq = ExprList_Finish(&state->expr_list, p->arena);
+ if (!seq)
+ goto error;
+
+ return _Py_JoinedStr(seq, first_token->lineno, first_token->col_offset,
+ last_token->end_lineno, last_token->end_col_offset, p->arena);
+
+error:
+ _PyPegen_FstringParser_Dealloc(state);
+ return NULL;
+}
+
+/* Given an f-string (with no 'f' or quotes) that's in *str and ends
+ at end, parse it into an expr_ty. Return NULL on error. Adjust
+ str to point past the parsed portion. */
+static expr_ty
+fstring_parse(Parser *p, const char **str, const char *end, int raw,
+ int recurse_lvl, Token *first_token, Token* t, Token *last_token)
+{
+ FstringParser state;
+
+ _PyPegen_FstringParser_Init(&state);
+ if (_PyPegen_FstringParser_ConcatFstring(p, &state, str, end, raw, recurse_lvl,
+ first_token, t, last_token) < 0) {
+ _PyPegen_FstringParser_Dealloc(&state);
+ return NULL;
+ }
+
+ return _PyPegen_FstringParser_Finish(p, &state, t, t);
+}
diff --git a/Parser/pegen/parse_string.h b/Parser/pegen/parse_string.h
new file mode 100644
index 0000000..4f2aa94
--- /dev/null
+++ b/Parser/pegen/parse_string.h
@@ -0,0 +1,46 @@
+#ifndef STRINGS_H
+#define STRINGS_H
+
+#include <Python.h>
+#include <Python-ast.h>
+#include "pegen.h"
+
+#define EXPRLIST_N_CACHED 64
+
+typedef struct {
+ /* Incrementally build an array of expr_ty, so be used in an
+ asdl_seq. Cache some small but reasonably sized number of
+ expr_ty's, and then after that start dynamically allocating,
+ doubling the number allocated each time. Note that the f-string
+ f'{0}a{1}' contains 3 expr_ty's: 2 FormattedValue's, and one
+ Constant for the literal 'a'. So you add expr_ty's about twice as
+ fast as you add expressions in an f-string. */
+
+ Py_ssize_t allocated; /* Number we've allocated. */
+ Py_ssize_t size; /* Number we've used. */
+ expr_ty *p; /* Pointer to the memory we're actually
+ using. Will point to 'data' until we
+ start dynamically allocating. */
+ expr_ty data[EXPRLIST_N_CACHED];
+} ExprList;
+
+/* The FstringParser is designed to add a mix of strings and
+ f-strings, and concat them together as needed. Ultimately, it
+ generates an expr_ty. */
+typedef struct {
+ PyObject *last_str;
+ ExprList expr_list;
+ int fmode;
+} FstringParser;
+
+void _PyPegen_FstringParser_Init(FstringParser *);
+int _PyPegen_parsestr(Parser *, const char *, int *, int *, PyObject **,
+ const char **, Py_ssize_t *);
+int _PyPegen_FstringParser_ConcatFstring(Parser *, FstringParser *, const char **,
+ const char *, int, int, Token *, Token *,
+ Token *);
+int _PyPegen_FstringParser_ConcatAndDel(FstringParser *, PyObject *);
+expr_ty _PyPegen_FstringParser_Finish(Parser *, FstringParser *, Token *, Token *);
+void _PyPegen_FstringParser_Dealloc(FstringParser *);
+
+#endif
diff --git a/Parser/pegen/peg_api.c b/Parser/pegen/peg_api.c
new file mode 100644
index 0000000..7c6903c
--- /dev/null
+++ b/Parser/pegen/peg_api.c
@@ -0,0 +1,134 @@
+#include <pegen_interface.h>
+
+#include "../tokenizer.h"
+#include "pegen.h"
+
+mod_ty
+PyPegen_ASTFromString(const char *str, int mode, PyCompilerFlags *flags, PyArena *arena)
+{
+ PyObject *filename_ob = PyUnicode_FromString("<string>");
+ if (filename_ob == NULL) {
+ return NULL;
+ }
+ mod_ty result = PyPegen_ASTFromStringObject(str, filename_ob, mode, flags, arena);
+ Py_XDECREF(filename_ob);
+ return result;
+}
+
+mod_ty
+PyPegen_ASTFromStringObject(const char *str, PyObject* filename, int mode, PyCompilerFlags *flags, PyArena *arena)
+{
+ if (PySys_Audit("compile", "yO", str, filename) < 0) {
+ return NULL;
+ }
+
+ int iflags = flags != NULL ? flags->cf_flags : PyCF_IGNORE_COOKIE;
+ mod_ty result = _PyPegen_run_parser_from_string(str, mode, filename, iflags, arena);
+ return result;
+}
+
+mod_ty
+PyPegen_ASTFromFile(const char *filename, int mode, PyArena *arena)
+{
+ PyObject *filename_ob = PyUnicode_FromString(filename);
+ if (filename_ob == NULL) {
+ return NULL;
+ }
+
+ mod_ty result = _PyPegen_run_parser_from_file(filename, mode, filename_ob, arena);
+ Py_XDECREF(filename_ob);
+ return result;
+}
+
+mod_ty
+PyPegen_ASTFromFileObject(FILE *fp, PyObject *filename_ob, int mode,
+ const char *enc, const char *ps1, const char* ps2,
+ int *errcode, PyArena *arena)
+{
+ if (PySys_Audit("compile", "OO", Py_None, filename_ob) < 0) {
+ return NULL;
+ }
+ return _PyPegen_run_parser_from_file_pointer(fp, mode, filename_ob, enc, ps1, ps2,
+ errcode, arena);
+}
+
+PyCodeObject *
+PyPegen_CodeObjectFromString(const char *str, int mode, PyCompilerFlags *flags)
+{
+ PyArena *arena = PyArena_New();
+ if (arena == NULL) {
+ return NULL;
+ }
+
+ PyCodeObject *result = NULL;
+
+ PyObject *filename_ob = PyUnicode_FromString("<string>");
+ if (filename_ob == NULL) {
+ goto error;
+ }
+
+ mod_ty res = PyPegen_ASTFromString(str, mode, flags, arena);
+ if (res == NULL) {
+ goto error;
+ }
+
+ result = PyAST_CompileObject(res, filename_ob, NULL, -1, arena);
+
+error:
+ Py_XDECREF(filename_ob);
+ PyArena_Free(arena);
+ return result;
+}
+
+PyCodeObject *
+PyPegen_CodeObjectFromFile(const char *filename, int mode)
+{
+ PyArena *arena = PyArena_New();
+ if (arena == NULL) {
+ return NULL;
+ }
+
+ PyCodeObject *result = NULL;
+
+ PyObject *filename_ob = PyUnicode_FromString(filename);
+ if (filename_ob == NULL) {
+ goto error;
+ }
+
+ mod_ty res = PyPegen_ASTFromFile(filename, mode, arena);
+ if (res == NULL) {
+ goto error;
+ }
+
+ result = PyAST_CompileObject(res, filename_ob, NULL, -1, arena);
+
+error:
+ Py_XDECREF(filename_ob);
+ PyArena_Free(arena);
+ return result;
+}
+
+PyCodeObject *
+PyPegen_CodeObjectFromFileObject(FILE *fp, PyObject *filename_ob, int mode,
+ const char *ps1, const char *ps2, const char *enc,
+ int *errcode)
+{
+ PyArena *arena = PyArena_New();
+ if (arena == NULL) {
+ return NULL;
+ }
+
+ PyCodeObject *result = NULL;
+
+ mod_ty res = PyPegen_ASTFromFileObject(fp, filename_ob, mode, enc, ps1, ps2,
+ errcode, arena);
+ if (res == NULL) {
+ goto error;
+ }
+
+ result = PyAST_CompileObject(res, filename_ob, NULL, -1, arena);
+
+error:
+ PyArena_Free(arena);
+ return result;
+}
diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c
new file mode 100644
index 0000000..47b712f
--- /dev/null
+++ b/Parser/pegen/pegen.c
@@ -0,0 +1,1865 @@
+#include <Python.h>
+#include <errcode.h>
+#include "../tokenizer.h"
+
+#include "pegen.h"
+#include "parse_string.h"
+
+static int
+init_normalization(Parser *p)
+{
+ PyObject *m = PyImport_ImportModuleNoBlock("unicodedata");
+ if (!m)
+ {
+ return 0;
+ }
+ p->normalize = PyObject_GetAttrString(m, "normalize");
+ Py_DECREF(m);
+ if (!p->normalize)
+ {
+ return 0;
+ }
+ return 1;
+}
+
+PyObject *
+_PyPegen_new_identifier(Parser *p, char *n)
+{
+ PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL);
+ if (!id) {
+ goto error;
+ }
+ /* PyUnicode_DecodeUTF8 should always return a ready string. */
+ assert(PyUnicode_IS_READY(id));
+ /* Check whether there are non-ASCII characters in the
+ identifier; if so, normalize to NFKC. */
+ if (!PyUnicode_IS_ASCII(id))
+ {
+ PyObject *id2;
+ if (!p->normalize && !init_normalization(p))
+ {
+ Py_DECREF(id);
+ goto error;
+ }
+ PyObject *form = PyUnicode_InternFromString("NFKC");
+ if (form == NULL)
+ {
+ Py_DECREF(id);
+ goto error;
+ }
+ PyObject *args[2] = {form, id};
+ id2 = _PyObject_FastCall(p->normalize, args, 2);
+ Py_DECREF(id);
+ Py_DECREF(form);
+ if (!id2) {
+ goto error;
+ }
+ if (!PyUnicode_Check(id2))
+ {
+ PyErr_Format(PyExc_TypeError,
+ "unicodedata.normalize() must return a string, not "
+ "%.200s",
+ _PyType_Name(Py_TYPE(id2)));
+ Py_DECREF(id2);
+ goto error;
+ }
+ id = id2;
+ }
+ PyUnicode_InternInPlace(&id);
+ if (PyArena_AddPyObject(p->arena, id) < 0)
+ {
+ Py_DECREF(id);
+ goto error;
+ }
+ return id;
+
+error:
+ p->error_indicator = 1;
+ return NULL;
+}
+
+static PyObject *
+_create_dummy_identifier(Parser *p)
+{
+ return _PyPegen_new_identifier(p, "");
+}
+
+static inline Py_ssize_t
+byte_offset_to_character_offset(PyObject *line, int col_offset)
+{
+ const char *str = PyUnicode_AsUTF8(line);
+ PyObject *text = PyUnicode_DecodeUTF8(str, col_offset, NULL);
+ if (!text) {
+ return 0;
+ }
+ Py_ssize_t size = PyUnicode_GET_LENGTH(text);
+ Py_DECREF(text);
+ return size;
+}
+
+const char *
+_PyPegen_get_expr_name(expr_ty e)
+{
+ switch (e->kind) {
+ case Attribute_kind:
+ return "attribute";
+ case Subscript_kind:
+ return "subscript";
+ case Starred_kind:
+ return "starred";
+ case Name_kind:
+ return "name";
+ case List_kind:
+ return "list";
+ case Tuple_kind:
+ return "tuple";
+ case Lambda_kind:
+ return "lambda";
+ case Call_kind:
+ return "function call";
+ case BoolOp_kind:
+ case BinOp_kind:
+ case UnaryOp_kind:
+ return "operator";
+ case GeneratorExp_kind:
+ return "generator expression";
+ case Yield_kind:
+ case YieldFrom_kind:
+ return "yield expression";
+ case Await_kind:
+ return "await expression";
+ case ListComp_kind:
+ return "list comprehension";
+ case SetComp_kind:
+ return "set comprehension";
+ case DictComp_kind:
+ return "dict comprehension";
+ case Dict_kind:
+ return "dict display";
+ case Set_kind:
+ return "set display";
+ case JoinedStr_kind:
+ case FormattedValue_kind:
+ return "f-string expression";
+ case Constant_kind: {
+ PyObject *value = e->v.Constant.value;
+ if (value == Py_None) {
+ return "None";
+ }
+ if (value == Py_False) {
+ return "False";
+ }
+ if (value == Py_True) {
+ return "True";
+ }
+ if (value == Py_Ellipsis) {
+ return "Ellipsis";
+ }
+ return "literal";
+ }
+ case Compare_kind:
+ return "comparison";
+ case IfExp_kind:
+ return "conditional expression";
+ case NamedExpr_kind:
+ return "named expression";
+ default:
+ PyErr_Format(PyExc_SystemError,
+ "unexpected expression in assignment %d (line %d)",
+ e->kind, e->lineno);
+ return NULL;
+ }
+}
+
+static void
+raise_decode_error(Parser *p)
+{
+ const char *errtype = NULL;
+ if (PyErr_ExceptionMatches(PyExc_UnicodeError)) {
+ errtype = "unicode error";
+ }
+ else if (PyErr_ExceptionMatches(PyExc_ValueError)) {
+ errtype = "value error";
+ }
+ if (errtype) {
+ PyObject *type, *value, *tback, *errstr;
+ PyErr_Fetch(&type, &value, &tback);
+ errstr = PyObject_Str(value);
+ if (errstr) {
+ RAISE_SYNTAX_ERROR("(%s) %U", errtype, errstr);
+ Py_DECREF(errstr);
+ }
+ else {
+ PyErr_Clear();
+ RAISE_SYNTAX_ERROR("(%s) unknown error", errtype);
+ }
+ Py_XDECREF(type);
+ Py_XDECREF(value);
+ Py_XDECREF(tback);
+ }
+}
+
+static void
+raise_tokenizer_init_error(PyObject *filename)
+{
+ if (!(PyErr_ExceptionMatches(PyExc_LookupError)
+ || PyErr_ExceptionMatches(PyExc_ValueError)
+ || PyErr_ExceptionMatches(PyExc_UnicodeDecodeError))) {
+ return;
+ }
+ PyObject *type, *value, *tback, *errstr;
+ PyErr_Fetch(&type, &value, &tback);
+ errstr = PyObject_Str(value);
+
+ Py_INCREF(Py_None);
+ PyObject *tmp = Py_BuildValue("(OiiN)", filename, 0, -1, Py_None);
+ if (!tmp) {
+ goto error;
+ }
+
+ value = PyTuple_Pack(2, errstr, tmp);
+ Py_DECREF(tmp);
+ if (!value) {
+ goto error;
+ }
+ PyErr_SetObject(PyExc_SyntaxError, value);
+
+error:
+ Py_XDECREF(type);
+ Py_XDECREF(value);
+ Py_XDECREF(tback);
+}
+
+static inline PyObject *
+get_error_line(char *buffer)
+{
+ char *newline = strchr(buffer, '\n');
+ if (newline) {
+ return PyUnicode_FromStringAndSize(buffer, newline - buffer);
+ }
+ else {
+ return PyUnicode_FromString(buffer);
+ }
+}
+
+static int
+tokenizer_error_with_col_offset(Parser *p, PyObject *errtype, const char *errmsg)
+{
+ PyObject *errstr = NULL;
+ PyObject *value = NULL;
+ int col_number = -1;
+
+ errstr = PyUnicode_FromString(errmsg);
+ if (!errstr) {
+ return -1;
+ }
+
+ PyObject *loc = NULL;
+ if (p->start_rule == Py_file_input) {
+ loc = PyErr_ProgramTextObject(p->tok->filename, p->tok->lineno);
+ }
+ if (!loc) {
+ loc = get_error_line(p->tok->buf);
+ }
+
+ if (loc) {
+ col_number = p->tok->cur - p->tok->buf;
+ }
+ else {
+ Py_INCREF(Py_None);
+ loc = Py_None;
+ }
+
+ PyObject *tmp = Py_BuildValue("(OiiN)", p->tok->filename, p->tok->lineno,
+ col_number, loc);
+ if (!tmp) {
+ goto error;
+ }
+
+ value = PyTuple_Pack(2, errstr, tmp);
+ Py_DECREF(tmp);
+ if (!value) {
+ goto error;
+ }
+ PyErr_SetObject(errtype, value);
+
+ Py_XDECREF(value);
+ Py_XDECREF(errstr);
+ return -1;
+
+error:
+ Py_XDECREF(errstr);
+ Py_XDECREF(loc);
+ return -1;
+}
+
+static int
+tokenizer_error(Parser *p)
+{
+ if (PyErr_Occurred()) {
+ return -1;
+ }
+
+ const char *msg = NULL;
+ PyObject* errtype = PyExc_SyntaxError;
+ switch (p->tok->done) {
+ case E_TOKEN:
+ msg = "invalid token";
+ break;
+ case E_IDENTIFIER:
+ msg = "invalid character in identifier";
+ break;
+ case E_BADPREFIX:
+ return tokenizer_error_with_col_offset(p,
+ PyExc_SyntaxError, "invalid string prefix");
+ case E_EOFS:
+ return tokenizer_error_with_col_offset(p,
+ PyExc_SyntaxError, "EOF while scanning triple-quoted string literal");
+ case E_EOLS:
+ return tokenizer_error_with_col_offset(p,
+ PyExc_SyntaxError, "EOL while scanning string literal");
+ case E_DEDENT:
+ return tokenizer_error_with_col_offset(p,
+ PyExc_IndentationError, "unindent does not match any outer indentation level");
+ case E_INTR:
+ if (!PyErr_Occurred()) {
+ PyErr_SetNone(PyExc_KeyboardInterrupt);
+ }
+ return -1;
+ case E_NOMEM:
+ PyErr_NoMemory();
+ return -1;
+ case E_TABSPACE:
+ errtype = PyExc_TabError;
+ msg = "inconsistent use of tabs and spaces in indentation";
+ break;
+ case E_TOODEEP:
+ errtype = PyExc_IndentationError;
+ msg = "too many levels of indentation";
+ break;
+ case E_DECODE:
+ raise_decode_error(p);
+ return -1;
+ case E_LINECONT:
+ msg = "unexpected character after line continuation character";
+ break;
+ default:
+ msg = "unknown parsing error";
+ }
+
+ PyErr_Format(errtype, msg);
+ // There is no reliable column information for this error
+ PyErr_SyntaxLocationObject(p->tok->filename, p->tok->lineno, 0);
+
+ return -1;
+}
+
+void *
+_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...)
+{
+ PyObject *value = NULL;
+ PyObject *errstr = NULL;
+ PyObject *loc = NULL;
+ PyObject *tmp = NULL;
+ Token *t = p->tokens[p->fill - 1];
+ Py_ssize_t col_number = 0;
+ va_list va;
+
+ va_start(va, errmsg);
+ errstr = PyUnicode_FromFormatV(errmsg, va);
+ va_end(va);
+ if (!errstr) {
+ goto error;
+ }
+
+ if (p->start_rule == Py_file_input) {
+ loc = PyErr_ProgramTextObject(p->tok->filename, t->lineno);
+ }
+
+ if (!loc) {
+ loc = get_error_line(p->tok->buf);
+ }
+
+ if (loc) {
+ int col_offset = t->col_offset == -1 ? 0 : t->col_offset;
+ col_number = byte_offset_to_character_offset(loc, col_offset) + 1;
+ }
+ else {
+ Py_INCREF(Py_None);
+ loc = Py_None;
+ }
+
+
+ tmp = Py_BuildValue("(OiiN)", p->tok->filename, t->lineno, col_number, loc);
+ if (!tmp) {
+ goto error;
+ }
+ value = PyTuple_Pack(2, errstr, tmp);
+ Py_DECREF(tmp);
+ if (!value) {
+ goto error;
+ }
+ PyErr_SetObject(errtype, value);
+
+ Py_DECREF(errstr);
+ Py_DECREF(value);
+ return NULL;
+
+error:
+ Py_XDECREF(errstr);
+ Py_XDECREF(loc);
+ return NULL;
+}
+
+void *_PyPegen_arguments_parsing_error(Parser *p, expr_ty e) {
+ int kwarg_unpacking = 0;
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) {
+ keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i);
+ if (!keyword->arg) {
+ kwarg_unpacking = 1;
+ }
+ }
+
+ const char *msg = NULL;
+ if (kwarg_unpacking) {
+ msg = "positional argument follows keyword argument unpacking";
+ } else {
+ msg = "positional argument follows keyword argument";
+ }
+
+ return RAISE_SYNTAX_ERROR(msg);
+}
+
+#if 0
+static const char *
+token_name(int type)
+{
+ if (0 <= type && type <= N_TOKENS) {
+ return _PyParser_TokenNames[type];
+ }
+ return "<Huh?>";
+}
+#endif
+
+// Here, mark is the start of the node, while p->mark is the end.
+// If node==NULL, they should be the same.
+int
+_PyPegen_insert_memo(Parser *p, int mark, int type, void *node)
+{
+ // Insert in front
+ Memo *m = PyArena_Malloc(p->arena, sizeof(Memo));
+ if (m == NULL) {
+ return -1;
+ }
+ m->type = type;
+ m->node = node;
+ m->mark = p->mark;
+ m->next = p->tokens[mark]->memo;
+ p->tokens[mark]->memo = m;
+ return 0;
+}
+
+// Like _PyPegen_insert_memo(), but updates an existing node if found.
+int
+_PyPegen_update_memo(Parser *p, int mark, int type, void *node)
+{
+ for (Memo *m = p->tokens[mark]->memo; m != NULL; m = m->next) {
+ if (m->type == type) {
+ // Update existing node.
+ m->node = node;
+ m->mark = p->mark;
+ return 0;
+ }
+ }
+ // Insert new node.
+ return _PyPegen_insert_memo(p, mark, type, node);
+}
+
+// Return dummy NAME.
+void *
+_PyPegen_dummy_name(Parser *p, ...)
+{
+ static void *cache = NULL;
+
+ if (cache != NULL) {
+ return cache;
+ }
+
+ PyObject *id = _create_dummy_identifier(p);
+ if (!id) {
+ return NULL;
+ }
+ cache = Name(id, Load, 1, 0, 1, 0, p->arena);
+ return cache;
+}
+
+static int
+_get_keyword_or_name_type(Parser *p, const char *name, int name_len)
+{
+ if (name_len >= p->n_keyword_lists || p->keywords[name_len] == NULL) {
+ return NAME;
+ }
+ for (KeywordToken *k = p->keywords[name_len]; k->type != -1; k++) {
+ if (strncmp(k->str, name, name_len) == 0) {
+ return k->type;
+ }
+ }
+ return NAME;
+}
+
+int
+_PyPegen_fill_token(Parser *p)
+{
+ const char *start, *end;
+ int type = PyTokenizer_Get(p->tok, &start, &end);
+ if (type == ERRORTOKEN) {
+ return tokenizer_error(p);
+ }
+ if (type == ENDMARKER && p->start_rule == Py_single_input && p->parsing_started) {
+ type = NEWLINE; /* Add an extra newline */
+ p->parsing_started = 0;
+
+ if (p->tok->indent) {
+ p->tok->pendin = -p->tok->indent;
+ p->tok->indent = 0;
+ }
+ }
+ else {
+ p->parsing_started = 1;
+ }
+
+ if (p->fill == p->size) {
+ int newsize = p->size * 2;
+ p->tokens = PyMem_Realloc(p->tokens, newsize * sizeof(Token *));
+ if (p->tokens == NULL) {
+ PyErr_Format(PyExc_MemoryError, "Realloc tokens failed");
+ return -1;
+ }
+ for (int i = p->size; i < newsize; i++) {
+ p->tokens[i] = PyMem_Malloc(sizeof(Token));
+ memset(p->tokens[i], '\0', sizeof(Token));
+ }
+ p->size = newsize;
+ }
+
+ Token *t = p->tokens[p->fill];
+ t->type = (type == NAME) ? _get_keyword_or_name_type(p, start, (int)(end - start)) : type;
+ t->bytes = PyBytes_FromStringAndSize(start, end - start);
+ if (t->bytes == NULL) {
+ return -1;
+ }
+ PyArena_AddPyObject(p->arena, t->bytes);
+
+ int lineno = type == STRING ? p->tok->first_lineno : p->tok->lineno;
+ const char *line_start = type == STRING ? p->tok->multi_line_start : p->tok->line_start;
+ int end_lineno = p->tok->lineno;
+ int col_offset = -1, end_col_offset = -1;
+ if (start != NULL && start >= line_start) {
+ col_offset = start - line_start;
+ }
+ if (end != NULL && end >= p->tok->line_start) {
+ end_col_offset = end - p->tok->line_start;
+ }
+
+ t->lineno = p->starting_lineno + lineno;
+ t->col_offset = p->tok->lineno == 1 ? p->starting_col_offset + col_offset : col_offset;
+ t->end_lineno = p->starting_lineno + end_lineno;
+ t->end_col_offset = p->tok->lineno == 1 ? p->starting_col_offset + end_col_offset : end_col_offset;
+
+ // if (p->fill % 100 == 0) fprintf(stderr, "Filled at %d: %s \"%s\"\n", p->fill,
+ // token_name(type), PyBytes_AsString(t->bytes));
+ p->fill += 1;
+ return 0;
+}
+
+// Instrumentation to count the effectiveness of memoization.
+// The array counts the number of tokens skipped by memoization,
+// indexed by type.
+
+#define NSTATISTICS 2000
+static long memo_statistics[NSTATISTICS];
+
+void
+_PyPegen_clear_memo_statistics()
+{
+ for (int i = 0; i < NSTATISTICS; i++) {
+ memo_statistics[i] = 0;
+ }
+}
+
+PyObject *
+_PyPegen_get_memo_statistics()
+{
+ PyObject *ret = PyList_New(NSTATISTICS);
+ if (ret == NULL) {
+ return NULL;
+ }
+ for (int i = 0; i < NSTATISTICS; i++) {
+ PyObject *value = PyLong_FromLong(memo_statistics[i]);
+ if (value == NULL) {
+ Py_DECREF(ret);
+ return NULL;
+ }
+ // PyList_SetItem borrows a reference to value.
+ if (PyList_SetItem(ret, i, value) < 0) {
+ Py_DECREF(ret);
+ return NULL;
+ }
+ }
+ return ret;
+}
+
+int // bool
+_PyPegen_is_memoized(Parser *p, int type, void *pres)
+{
+ if (p->mark == p->fill) {
+ if (_PyPegen_fill_token(p) < 0) {
+ return -1;
+ }
+ }
+
+ Token *t = p->tokens[p->mark];
+
+ for (Memo *m = t->memo; m != NULL; m = m->next) {
+ if (m->type == type) {
+ if (0 <= type && type < NSTATISTICS) {
+ long count = m->mark - p->mark;
+ // A memoized negative result counts for one.
+ if (count <= 0) {
+ count = 1;
+ }
+ memo_statistics[type] += count;
+ }
+ p->mark = m->mark;
+ *(void **)(pres) = m->node;
+ // fprintf(stderr, "%d < %d: memoized!\n", p->mark, p->fill);
+ return 1;
+ }
+ }
+ // fprintf(stderr, "%d < %d: not memoized\n", p->mark, p->fill);
+ return 0;
+}
+
+int
+_PyPegen_lookahead_with_string(int positive, void *(func)(Parser *, const char *), Parser *p,
+ const char *arg)
+{
+ int mark = p->mark;
+ void *res = func(p, arg);
+ p->mark = mark;
+ return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead_with_int(int positive, Token *(func)(Parser *, int), Parser *p, int arg)
+{
+ int mark = p->mark;
+ void *res = func(p, arg);
+ p->mark = mark;
+ return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead(int positive, void *(func)(Parser *), Parser *p)
+{
+ int mark = p->mark;
+ void *res = func(p);
+ p->mark = mark;
+ return (res != NULL) == positive;
+}
+
+Token *
+_PyPegen_expect_token(Parser *p, int type)
+{
+ if (p->mark == p->fill) {
+ if (_PyPegen_fill_token(p) < 0) {
+ return NULL;
+ }
+ }
+ Token *t = p->tokens[p->mark];
+ if (t->type != type) {
+ // fprintf(stderr, "No %s at %d\n", token_name(type), p->mark);
+ return NULL;
+ }
+ p->mark += 1;
+ // fprintf(stderr, "Got %s at %d: %s\n", token_name(type), p->mark,
+ // PyBytes_AsString(t->bytes));
+
+ return t;
+}
+
+Token *
+_PyPegen_get_last_nonnwhitespace_token(Parser *p)
+{
+ assert(p->mark >= 0);
+ Token *token = NULL;
+ for (int m = p->mark - 1; m >= 0; m--) {
+ token = p->tokens[m];
+ if (token->type != ENDMARKER && (token->type < NEWLINE || token->type > DEDENT)) {
+ break;
+ }
+ }
+ return token;
+}
+
+void *
+_PyPegen_async_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, ASYNC);
+}
+
+void *
+_PyPegen_await_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, AWAIT);
+}
+
+void *
+_PyPegen_endmarker_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, ENDMARKER);
+}
+
+expr_ty
+_PyPegen_name_token(Parser *p)
+{
+ Token *t = _PyPegen_expect_token(p, NAME);
+ if (t == NULL) {
+ return NULL;
+ }
+ char* s = PyBytes_AsString(t->bytes);
+ if (!s) {
+ return NULL;
+ }
+ PyObject *id = _PyPegen_new_identifier(p, s);
+ if (id == NULL) {
+ return NULL;
+ }
+ return Name(id, Load, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset,
+ p->arena);
+}
+
+void *
+_PyPegen_string_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, STRING);
+}
+
+void *
+_PyPegen_newline_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, NEWLINE);
+}
+
+void *
+_PyPegen_indent_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, INDENT);
+}
+
+void *
+_PyPegen_dedent_token(Parser *p)
+{
+ return _PyPegen_expect_token(p, DEDENT);
+}
+
+static PyObject *
+parsenumber_raw(const char *s)
+{
+ const char *end;
+ long x;
+ double dx;
+ Py_complex compl;
+ int imflag;
+
+ assert(s != NULL);
+ errno = 0;
+ end = s + strlen(s) - 1;
+ imflag = *end == 'j' || *end == 'J';
+ if (s[0] == '0') {
+ x = (long)PyOS_strtoul(s, (char **)&end, 0);
+ if (x < 0 && errno == 0) {
+ return PyLong_FromString(s, (char **)0, 0);
+ }
+ }
+ else
+ x = PyOS_strtol(s, (char **)&end, 0);
+ if (*end == '\0') {
+ if (errno != 0)
+ return PyLong_FromString(s, (char **)0, 0);
+ return PyLong_FromLong(x);
+ }
+ /* XXX Huge floats may silently fail */
+ if (imflag) {
+ compl.real = 0.;
+ compl.imag = PyOS_string_to_double(s, (char **)&end, NULL);
+ if (compl.imag == -1.0 && PyErr_Occurred())
+ return NULL;
+ return PyComplex_FromCComplex(compl);
+ }
+ else {
+ dx = PyOS_string_to_double(s, NULL, NULL);
+ if (dx == -1.0 && PyErr_Occurred())
+ return NULL;
+ return PyFloat_FromDouble(dx);
+ }
+}
+
+static PyObject *
+parsenumber(const char *s)
+{
+ char *dup, *end;
+ PyObject *res = NULL;
+
+ assert(s != NULL);
+
+ if (strchr(s, '_') == NULL) {
+ return parsenumber_raw(s);
+ }
+ /* Create a duplicate without underscores. */
+ dup = PyMem_Malloc(strlen(s) + 1);
+ if (dup == NULL) {
+ return PyErr_NoMemory();
+ }
+ end = dup;
+ for (; *s; s++) {
+ if (*s != '_') {
+ *end++ = *s;
+ }
+ }
+ *end = '\0';
+ res = parsenumber_raw(dup);
+ PyMem_Free(dup);
+ return res;
+}
+
+expr_ty
+_PyPegen_number_token(Parser *p)
+{
+ Token *t = _PyPegen_expect_token(p, NUMBER);
+ if (t == NULL) {
+ return NULL;
+ }
+
+ char *num_raw = PyBytes_AsString(t->bytes);
+
+ if (num_raw == NULL) {
+ return NULL;
+ }
+
+ PyObject *c = parsenumber(num_raw);
+
+ if (c == NULL) {
+ return NULL;
+ }
+
+ if (PyArena_AddPyObject(p->arena, c) < 0) {
+ Py_DECREF(c);
+ return NULL;
+ }
+
+ return Constant(c, NULL, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset,
+ p->arena);
+}
+
+void
+_PyPegen_Parser_Free(Parser *p)
+{
+ Py_XDECREF(p->normalize);
+ for (int i = 0; i < p->size; i++) {
+ PyMem_Free(p->tokens[i]);
+ }
+ PyMem_Free(p->tokens);
+ PyMem_Free(p);
+}
+
+Parser *
+_PyPegen_Parser_New(struct tok_state *tok, int start_rule, int *errcode, PyArena *arena)
+{
+ Parser *p = PyMem_Malloc(sizeof(Parser));
+ if (p == NULL) {
+ PyErr_Format(PyExc_MemoryError, "Out of memory for Parser");
+ return NULL;
+ }
+ assert(tok != NULL);
+ p->tok = tok;
+ p->keywords = NULL;
+ p->n_keyword_lists = -1;
+ p->tokens = PyMem_Malloc(sizeof(Token *));
+ if (!p->tokens) {
+ PyMem_Free(p);
+ PyErr_Format(PyExc_MemoryError, "Out of memory for tokens");
+ return NULL;
+ }
+ p->tokens[0] = PyMem_Malloc(sizeof(Token));
+ memset(p->tokens[0], '\0', sizeof(Token));
+ p->mark = 0;
+ p->fill = 0;
+ p->size = 1;
+
+ p->errcode = errcode;
+ p->arena = arena;
+ p->start_rule = start_rule;
+ p->parsing_started = 0;
+ p->normalize = NULL;
+ p->error_indicator = 0;
+
+ p->starting_lineno = 0;
+ p->starting_col_offset = 0;
+
+ return p;
+}
+
+void *
+_PyPegen_run_parser(Parser *p)
+{
+ void *res = _PyPegen_parse(p);
+ if (res == NULL) {
+ if (PyErr_Occurred()) {
+ return NULL;
+ }
+ if (p->fill == 0) {
+ RAISE_SYNTAX_ERROR("error at start before reading any input");
+ }
+ else if (p->tok->done == E_EOF) {
+ RAISE_SYNTAX_ERROR("unexpected EOF while parsing");
+ }
+ else {
+ if (p->tokens[p->fill-1]->type == INDENT) {
+ RAISE_INDENTATION_ERROR("unexpected indent");
+ }
+ else if (p->tokens[p->fill-1]->type == DEDENT) {
+ RAISE_INDENTATION_ERROR("unexpected unindent");
+ }
+ else {
+ RAISE_SYNTAX_ERROR("invalid syntax");
+ }
+ }
+ return NULL;
+ }
+
+ return res;
+}
+
+mod_ty
+_PyPegen_run_parser_from_file_pointer(FILE *fp, int start_rule, PyObject *filename_ob,
+ const char *enc, const char *ps1, const char *ps2,
+ int *errcode, PyArena *arena)
+{
+ struct tok_state *tok = PyTokenizer_FromFile(fp, enc, ps1, ps2);
+ if (tok == NULL) {
+ if (PyErr_Occurred()) {
+ raise_tokenizer_init_error(filename_ob);
+ return NULL;
+ }
+ return NULL;
+ }
+ // This transfers the ownership to the tokenizer
+ tok->filename = filename_ob;
+ Py_INCREF(filename_ob);
+
+ // From here on we need to clean up even if there's an error
+ mod_ty result = NULL;
+
+ Parser *p = _PyPegen_Parser_New(tok, start_rule, errcode, arena);
+ if (p == NULL) {
+ goto error;
+ }
+
+ result = _PyPegen_run_parser(p);
+ _PyPegen_Parser_Free(p);
+
+error:
+ PyTokenizer_Free(tok);
+ return result;
+}
+
+mod_ty
+_PyPegen_run_parser_from_file(const char *filename, int start_rule,
+ PyObject *filename_ob, PyArena *arena)
+{
+ FILE *fp = fopen(filename, "rb");
+ if (fp == NULL) {
+ PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
+ return NULL;
+ }
+
+ mod_ty result = _PyPegen_run_parser_from_file_pointer(fp, start_rule, filename_ob,
+ NULL, NULL, NULL, NULL, arena);
+
+ fclose(fp);
+ return result;
+}
+
+mod_ty
+_PyPegen_run_parser_from_string(const char *str, int start_rule, PyObject *filename_ob,
+ int iflags, PyArena *arena)
+{
+ int exec_input = start_rule == Py_file_input;
+
+ struct tok_state *tok;
+ if (iflags & PyCF_IGNORE_COOKIE) {
+ tok = PyTokenizer_FromUTF8(str, exec_input);
+ } else {
+ tok = PyTokenizer_FromString(str, exec_input);
+ }
+ if (tok == NULL) {
+ if (PyErr_Occurred()) {
+ raise_tokenizer_init_error(filename_ob);
+ }
+ return NULL;
+ }
+ // This transfers the ownership to the tokenizer
+ tok->filename = filename_ob;
+ Py_INCREF(filename_ob);
+
+ // We need to clear up from here on
+ mod_ty result = NULL;
+
+ Parser *p = _PyPegen_Parser_New(tok, start_rule, NULL, arena);
+ if (p == NULL) {
+ goto error;
+ }
+
+ result = _PyPegen_run_parser(p);
+ _PyPegen_Parser_Free(p);
+
+error:
+ PyTokenizer_Free(tok);
+ return result;
+}
+
+void *
+_PyPegen_interactive_exit(Parser *p)
+{
+ if (p->errcode) {
+ *(p->errcode) = E_EOF;
+ }
+ return NULL;
+}
+
+/* Creates a single-element asdl_seq* that contains a */
+asdl_seq *
+_PyPegen_singleton_seq(Parser *p, void *a)
+{
+ assert(a != NULL);
+ asdl_seq *seq = _Py_asdl_seq_new(1, p->arena);
+ if (!seq) {
+ return NULL;
+ }
+ asdl_seq_SET(seq, 0, a);
+ return seq;
+}
+
+/* Creates a copy of seq and prepends a to it */
+asdl_seq *
+_PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq)
+{
+ assert(a != NULL);
+ if (!seq) {
+ return _PyPegen_singleton_seq(p, a);
+ }
+
+ asdl_seq *new_seq = _Py_asdl_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+
+ asdl_seq_SET(new_seq, 0, a);
+ for (int i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
+ asdl_seq_SET(new_seq, i, asdl_seq_GET(seq, i - 1));
+ }
+ return new_seq;
+}
+
+static int
+_get_flattened_seq_size(asdl_seq *seqs)
+{
+ int size = 0;
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+ asdl_seq *inner_seq = asdl_seq_GET(seqs, i);
+ size += asdl_seq_LEN(inner_seq);
+ }
+ return size;
+}
+
+/* Flattens an asdl_seq* of asdl_seq*s */
+asdl_seq *
+_PyPegen_seq_flatten(Parser *p, asdl_seq *seqs)
+{
+ int flattened_seq_size = _get_flattened_seq_size(seqs);
+ assert(flattened_seq_size > 0);
+
+ asdl_seq *flattened_seq = _Py_asdl_seq_new(flattened_seq_size, p->arena);
+ if (!flattened_seq) {
+ return NULL;
+ }
+
+ int flattened_seq_idx = 0;
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+ asdl_seq *inner_seq = asdl_seq_GET(seqs, i);
+ for (int j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
+ asdl_seq_SET(flattened_seq, flattened_seq_idx++, asdl_seq_GET(inner_seq, j));
+ }
+ }
+ assert(flattened_seq_idx == flattened_seq_size);
+
+ return flattened_seq;
+}
+
+/* Creates a new name of the form <first_name>.<second_name> */
+expr_ty
+_PyPegen_join_names_with_dot(Parser *p, expr_ty first_name, expr_ty second_name)
+{
+ assert(first_name != NULL && second_name != NULL);
+ PyObject *first_identifier = first_name->v.Name.id;
+ PyObject *second_identifier = second_name->v.Name.id;
+
+ if (PyUnicode_READY(first_identifier) == -1) {
+ return NULL;
+ }
+ if (PyUnicode_READY(second_identifier) == -1) {
+ return NULL;
+ }
+ const char *first_str = PyUnicode_AsUTF8(first_identifier);
+ if (!first_str) {
+ return NULL;
+ }
+ const char *second_str = PyUnicode_AsUTF8(second_identifier);
+ if (!second_str) {
+ return NULL;
+ }
+ ssize_t len = strlen(first_str) + strlen(second_str) + 1; // +1 for the dot
+
+ PyObject *str = PyBytes_FromStringAndSize(NULL, len);
+ if (!str) {
+ return NULL;
+ }
+
+ char *s = PyBytes_AS_STRING(str);
+ if (!s) {
+ return NULL;
+ }
+
+ strcpy(s, first_str);
+ s += strlen(first_str);
+ *s++ = '.';
+ strcpy(s, second_str);
+ s += strlen(second_str);
+ *s = '\0';
+
+ PyObject *uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL);
+ Py_DECREF(str);
+ if (!uni) {
+ return NULL;
+ }
+ PyUnicode_InternInPlace(&uni);
+ if (PyArena_AddPyObject(p->arena, uni) < 0) {
+ Py_DECREF(uni);
+ return NULL;
+ }
+
+ return _Py_Name(uni, Load, EXTRA_EXPR(first_name, second_name));
+}
+
+/* Counts the total number of dots in seq's tokens */
+int
+_PyPegen_seq_count_dots(asdl_seq *seq)
+{
+ int number_of_dots = 0;
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+ Token *current_expr = asdl_seq_GET(seq, i);
+ switch (current_expr->type) {
+ case ELLIPSIS:
+ number_of_dots += 3;
+ break;
+ case DOT:
+ number_of_dots += 1;
+ break;
+ default:
+ assert(current_expr->type == ELLIPSIS || current_expr->type == DOT);
+ }
+ }
+
+ return number_of_dots;
+}
+
+/* Creates an alias with '*' as the identifier name */
+alias_ty
+_PyPegen_alias_for_star(Parser *p)
+{
+ PyObject *str = PyUnicode_InternFromString("*");
+ if (!str) {
+ return NULL;
+ }
+ if (PyArena_AddPyObject(p->arena, str) < 0) {
+ Py_DECREF(str);
+ return NULL;
+ }
+ return alias(str, NULL, p->arena);
+}
+
+/* Creates a new asdl_seq* with the identifiers of all the names in seq */
+asdl_seq *
+_PyPegen_map_names_to_ids(Parser *p, asdl_seq *seq)
+{
+ int len = asdl_seq_LEN(seq);
+ assert(len > 0);
+
+ asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ expr_ty e = asdl_seq_GET(seq, i);
+ asdl_seq_SET(new_seq, i, e->v.Name.id);
+ }
+ return new_seq;
+}
+
+/* Constructs a CmpopExprPair */
+CmpopExprPair *
+_PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop, expr_ty expr)
+{
+ assert(expr != NULL);
+ CmpopExprPair *a = PyArena_Malloc(p->arena, sizeof(CmpopExprPair));
+ if (!a) {
+ return NULL;
+ }
+ a->cmpop = cmpop;
+ a->expr = expr;
+ return a;
+}
+
+asdl_int_seq *
+_PyPegen_get_cmpops(Parser *p, asdl_seq *seq)
+{
+ int len = asdl_seq_LEN(seq);
+ assert(len > 0);
+
+ asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ CmpopExprPair *pair = asdl_seq_GET(seq, i);
+ asdl_seq_SET(new_seq, i, pair->cmpop);
+ }
+ return new_seq;
+}
+
+asdl_seq *
+_PyPegen_get_exprs(Parser *p, asdl_seq *seq)
+{
+ int len = asdl_seq_LEN(seq);
+ assert(len > 0);
+
+ asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ CmpopExprPair *pair = asdl_seq_GET(seq, i);
+ asdl_seq_SET(new_seq, i, pair->expr);
+ }
+ return new_seq;
+}
+
+/* Creates an asdl_seq* where all the elements have been changed to have ctx as context */
+static asdl_seq *
+_set_seq_context(Parser *p, asdl_seq *seq, expr_context_ty ctx)
+{
+ int len = asdl_seq_LEN(seq);
+ if (len == 0) {
+ return NULL;
+ }
+
+ asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ expr_ty e = asdl_seq_GET(seq, i);
+ asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx));
+ }
+ return new_seq;
+}
+
+static expr_ty
+_set_name_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+ return _Py_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+ return _Py_Tuple(_set_seq_context(p, e->v.Tuple.elts, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_list_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+ return _Py_List(_set_seq_context(p, e->v.List.elts, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_subscript_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+ return _Py_Subscript(e->v.Subscript.value, e->v.Subscript.slice, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_attribute_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+ return _Py_Attribute(e->v.Attribute.value, e->v.Attribute.attr, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+ return _Py_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+/* Creates an `expr_ty` equivalent to `expr` but with `ctx` as context */
+expr_ty
+_PyPegen_set_expr_context(Parser *p, expr_ty expr, expr_context_ty ctx)
+{
+ assert(expr != NULL);
+
+ expr_ty new = NULL;
+ switch (expr->kind) {
+ case Name_kind:
+ new = _set_name_context(p, expr, ctx);
+ break;
+ case Tuple_kind:
+ new = _set_tuple_context(p, expr, ctx);
+ break;
+ case List_kind:
+ new = _set_list_context(p, expr, ctx);
+ break;
+ case Subscript_kind:
+ new = _set_subscript_context(p, expr, ctx);
+ break;
+ case Attribute_kind:
+ new = _set_attribute_context(p, expr, ctx);
+ break;
+ case Starred_kind:
+ new = _set_starred_context(p, expr, ctx);
+ break;
+ default:
+ new = expr;
+ }
+ return new;
+}
+
+/* Constructs a KeyValuePair that is used when parsing a dict's key value pairs */
+KeyValuePair *
+_PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value)
+{
+ KeyValuePair *a = PyArena_Malloc(p->arena, sizeof(KeyValuePair));
+ if (!a) {
+ return NULL;
+ }
+ a->key = key;
+ a->value = value;
+ return a;
+}
+
+/* Extracts all keys from an asdl_seq* of KeyValuePair*'s */
+asdl_seq *
+_PyPegen_get_keys(Parser *p, asdl_seq *seq)
+{
+ int len = asdl_seq_LEN(seq);
+ asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ KeyValuePair *pair = asdl_seq_GET(seq, i);
+ asdl_seq_SET(new_seq, i, pair->key);
+ }
+ return new_seq;
+}
+
+/* Extracts all values from an asdl_seq* of KeyValuePair*'s */
+asdl_seq *
+_PyPegen_get_values(Parser *p, asdl_seq *seq)
+{
+ int len = asdl_seq_LEN(seq);
+ asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ KeyValuePair *pair = asdl_seq_GET(seq, i);
+ asdl_seq_SET(new_seq, i, pair->value);
+ }
+ return new_seq;
+}
+
+/* Constructs a NameDefaultPair */
+NameDefaultPair *
+_PyPegen_name_default_pair(Parser *p, arg_ty arg, expr_ty value)
+{
+ NameDefaultPair *a = PyArena_Malloc(p->arena, sizeof(NameDefaultPair));
+ if (!a) {
+ return NULL;
+ }
+ a->arg = arg;
+ a->value = value;
+ return a;
+}
+
+/* Constructs a SlashWithDefault */
+SlashWithDefault *
+_PyPegen_slash_with_default(Parser *p, asdl_seq *plain_names, asdl_seq *names_with_defaults)
+{
+ SlashWithDefault *a = PyArena_Malloc(p->arena, sizeof(SlashWithDefault));
+ if (!a) {
+ return NULL;
+ }
+ a->plain_names = plain_names;
+ a->names_with_defaults = names_with_defaults;
+ return a;
+}
+
+/* Constructs a StarEtc */
+StarEtc *
+_PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs, arg_ty kwarg)
+{
+ StarEtc *a = PyArena_Malloc(p->arena, sizeof(StarEtc));
+ if (!a) {
+ return NULL;
+ }
+ a->vararg = vararg;
+ a->kwonlyargs = kwonlyargs;
+ a->kwarg = kwarg;
+ return a;
+}
+
+asdl_seq *
+_PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b)
+{
+ int first_len = asdl_seq_LEN(a);
+ int second_len = asdl_seq_LEN(b);
+ asdl_seq *new_seq = _Py_asdl_seq_new(first_len + second_len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+
+ int k = 0;
+ for (Py_ssize_t i = 0; i < first_len; i++) {
+ asdl_seq_SET(new_seq, k++, asdl_seq_GET(a, i));
+ }
+ for (Py_ssize_t i = 0; i < second_len; i++) {
+ asdl_seq_SET(new_seq, k++, asdl_seq_GET(b, i));
+ }
+
+ return new_seq;
+}
+
+static asdl_seq *
+_get_names(Parser *p, asdl_seq *names_with_defaults)
+{
+ int len = asdl_seq_LEN(names_with_defaults);
+ asdl_seq *seq = _Py_asdl_seq_new(len, p->arena);
+ if (!seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i);
+ asdl_seq_SET(seq, i, pair->arg);
+ }
+ return seq;
+}
+
+static asdl_seq *
+_get_defaults(Parser *p, asdl_seq *names_with_defaults)
+{
+ int len = asdl_seq_LEN(names_with_defaults);
+ asdl_seq *seq = _Py_asdl_seq_new(len, p->arena);
+ if (!seq) {
+ return NULL;
+ }
+ for (Py_ssize_t i = 0; i < len; i++) {
+ NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i);
+ asdl_seq_SET(seq, i, pair->value);
+ }
+ return seq;
+}
+
+/* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */
+arguments_ty
+_PyPegen_make_arguments(Parser *p, asdl_seq *slash_without_default,
+ SlashWithDefault *slash_with_default, asdl_seq *plain_names,
+ asdl_seq *names_with_default, StarEtc *star_etc)
+{
+ asdl_seq *posonlyargs;
+ if (slash_without_default != NULL) {
+ posonlyargs = slash_without_default;
+ }
+ else if (slash_with_default != NULL) {
+ asdl_seq *slash_with_default_names =
+ _get_names(p, slash_with_default->names_with_defaults);
+ if (!slash_with_default_names) {
+ return NULL;
+ }
+ posonlyargs = _PyPegen_join_sequences(p, slash_with_default->plain_names, slash_with_default_names);
+ if (!posonlyargs) {
+ return NULL;
+ }
+ }
+ else {
+ posonlyargs = _Py_asdl_seq_new(0, p->arena);
+ if (!posonlyargs) {
+ return NULL;
+ }
+ }
+
+ asdl_seq *posargs;
+ if (plain_names != NULL && names_with_default != NULL) {
+ asdl_seq *names_with_default_names = _get_names(p, names_with_default);
+ if (!names_with_default_names) {
+ return NULL;
+ }
+ posargs = _PyPegen_join_sequences(p, plain_names, names_with_default_names);
+ if (!posargs) {
+ return NULL;
+ }
+ }
+ else if (plain_names == NULL && names_with_default != NULL) {
+ posargs = _get_names(p, names_with_default);
+ if (!posargs) {
+ return NULL;
+ }
+ }
+ else if (plain_names != NULL && names_with_default == NULL) {
+ posargs = plain_names;
+ }
+ else {
+ posargs = _Py_asdl_seq_new(0, p->arena);
+ if (!posargs) {
+ return NULL;
+ }
+ }
+
+ asdl_seq *posdefaults;
+ if (slash_with_default != NULL && names_with_default != NULL) {
+ asdl_seq *slash_with_default_values =
+ _get_defaults(p, slash_with_default->names_with_defaults);
+ if (!slash_with_default_values) {
+ return NULL;
+ }
+ asdl_seq *names_with_default_values = _get_defaults(p, names_with_default);
+ if (!names_with_default_values) {
+ return NULL;
+ }
+ posdefaults = _PyPegen_join_sequences(p, slash_with_default_values, names_with_default_values);
+ if (!posdefaults) {
+ return NULL;
+ }
+ }
+ else if (slash_with_default == NULL && names_with_default != NULL) {
+ posdefaults = _get_defaults(p, names_with_default);
+ if (!posdefaults) {
+ return NULL;
+ }
+ }
+ else if (slash_with_default != NULL && names_with_default == NULL) {
+ posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
+ if (!posdefaults) {
+ return NULL;
+ }
+ }
+ else {
+ posdefaults = _Py_asdl_seq_new(0, p->arena);
+ if (!posdefaults) {
+ return NULL;
+ }
+ }
+
+ arg_ty vararg = NULL;
+ if (star_etc != NULL && star_etc->vararg != NULL) {
+ vararg = star_etc->vararg;
+ }
+
+ asdl_seq *kwonlyargs;
+ if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+ kwonlyargs = _get_names(p, star_etc->kwonlyargs);
+ if (!kwonlyargs) {
+ return NULL;
+ }
+ }
+ else {
+ kwonlyargs = _Py_asdl_seq_new(0, p->arena);
+ if (!kwonlyargs) {
+ return NULL;
+ }
+ }
+
+ asdl_seq *kwdefaults;
+ if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+ kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
+ if (!kwdefaults) {
+ return NULL;
+ }
+ }
+ else {
+ kwdefaults = _Py_asdl_seq_new(0, p->arena);
+ if (!kwdefaults) {
+ return NULL;
+ }
+ }
+
+ arg_ty kwarg = NULL;
+ if (star_etc != NULL && star_etc->kwarg != NULL) {
+ kwarg = star_etc->kwarg;
+ }
+
+ return _Py_arguments(posonlyargs, posargs, vararg, kwonlyargs, kwdefaults, kwarg,
+ posdefaults, p->arena);
+}
+
+/* Constructs an empty arguments_ty object, that gets used when a function accepts no
+ * arguments. */
+arguments_ty
+_PyPegen_empty_arguments(Parser *p)
+{
+ asdl_seq *posonlyargs = _Py_asdl_seq_new(0, p->arena);
+ if (!posonlyargs) {
+ return NULL;
+ }
+ asdl_seq *posargs = _Py_asdl_seq_new(0, p->arena);
+ if (!posargs) {
+ return NULL;
+ }
+ asdl_seq *posdefaults = _Py_asdl_seq_new(0, p->arena);
+ if (!posdefaults) {
+ return NULL;
+ }
+ asdl_seq *kwonlyargs = _Py_asdl_seq_new(0, p->arena);
+ if (!kwonlyargs) {
+ return NULL;
+ }
+ asdl_seq *kwdefaults = _Py_asdl_seq_new(0, p->arena);
+ if (!kwdefaults) {
+ return NULL;
+ }
+
+ return _Py_arguments(posonlyargs, posargs, NULL, kwonlyargs, kwdefaults, NULL, kwdefaults,
+ p->arena);
+}
+
+/* Encapsulates the value of an operator_ty into an AugOperator struct */
+AugOperator *
+_PyPegen_augoperator(Parser *p, operator_ty kind)
+{
+ AugOperator *a = PyArena_Malloc(p->arena, sizeof(AugOperator));
+ if (!a) {
+ return NULL;
+ }
+ a->kind = kind;
+ return a;
+}
+
+/* Construct a FunctionDef equivalent to function_def, but with decorators */
+stmt_ty
+_PyPegen_function_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty function_def)
+{
+ assert(function_def != NULL);
+ if (function_def->kind == AsyncFunctionDef_kind) {
+ return _Py_AsyncFunctionDef(
+ function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+ function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns,
+ function_def->v.FunctionDef.type_comment, function_def->lineno,
+ function_def->col_offset, function_def->end_lineno, function_def->end_col_offset,
+ p->arena);
+ }
+
+ return _Py_FunctionDef(function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+ function_def->v.FunctionDef.body, decorators,
+ function_def->v.FunctionDef.returns,
+ function_def->v.FunctionDef.type_comment, function_def->lineno,
+ function_def->col_offset, function_def->end_lineno,
+ function_def->end_col_offset, p->arena);
+}
+
+/* Construct a ClassDef equivalent to class_def, but with decorators */
+stmt_ty
+_PyPegen_class_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty class_def)
+{
+ assert(class_def != NULL);
+ return _Py_ClassDef(class_def->v.ClassDef.name, class_def->v.ClassDef.bases,
+ class_def->v.ClassDef.keywords, class_def->v.ClassDef.body, decorators,
+ class_def->lineno, class_def->col_offset, class_def->end_lineno,
+ class_def->end_col_offset, p->arena);
+}
+
+/* Construct a KeywordOrStarred */
+KeywordOrStarred *
+_PyPegen_keyword_or_starred(Parser *p, void *element, int is_keyword)
+{
+ KeywordOrStarred *a = PyArena_Malloc(p->arena, sizeof(KeywordOrStarred));
+ if (!a) {
+ return NULL;
+ }
+ a->element = element;
+ a->is_keyword = is_keyword;
+ return a;
+}
+
+/* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s */
+static int
+_seq_number_of_starred_exprs(asdl_seq *seq)
+{
+ int n = 0;
+ for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+ KeywordOrStarred *k = asdl_seq_GET(seq, i);
+ if (!k->is_keyword) {
+ n++;
+ }
+ }
+ return n;
+}
+
+/* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */
+asdl_seq *
+_PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs)
+{
+ int new_len = _seq_number_of_starred_exprs(kwargs);
+ if (new_len == 0) {
+ return NULL;
+ }
+ asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+
+ int idx = 0;
+ for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) {
+ KeywordOrStarred *k = asdl_seq_GET(kwargs, i);
+ if (!k->is_keyword) {
+ asdl_seq_SET(new_seq, idx++, k->element);
+ }
+ }
+ return new_seq;
+}
+
+/* Return a new asdl_seq* with only the keywords in kwargs */
+asdl_seq *
+_PyPegen_seq_delete_starred_exprs(Parser *p, asdl_seq *kwargs)
+{
+ int len = asdl_seq_LEN(kwargs);
+ int new_len = len - _seq_number_of_starred_exprs(kwargs);
+ if (new_len == 0) {
+ return NULL;
+ }
+ asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena);
+ if (!new_seq) {
+ return NULL;
+ }
+
+ int idx = 0;
+ for (Py_ssize_t i = 0; i < len; i++) {
+ KeywordOrStarred *k = asdl_seq_GET(kwargs, i);
+ if (k->is_keyword) {
+ asdl_seq_SET(new_seq, idx++, k->element);
+ }
+ }
+ return new_seq;
+}
+
+expr_ty
+_PyPegen_concatenate_strings(Parser *p, asdl_seq *strings)
+{
+ int len = asdl_seq_LEN(strings);
+ assert(len > 0);
+
+ Token *first = asdl_seq_GET(strings, 0);
+ Token *last = asdl_seq_GET(strings, len - 1);
+
+ int bytesmode = 0;
+ PyObject *bytes_str = NULL;
+
+ FstringParser state;
+ _PyPegen_FstringParser_Init(&state);
+
+ for (Py_ssize_t i = 0; i < len; i++) {
+ Token *t = asdl_seq_GET(strings, i);
+
+ int this_bytesmode;
+ int this_rawmode;
+ PyObject *s;
+ const char *fstr;
+ Py_ssize_t fstrlen = -1;
+
+ char *this_str = PyBytes_AsString(t->bytes);
+ if (!this_str) {
+ goto error;
+ }
+
+ if (_PyPegen_parsestr(p, this_str, &this_bytesmode, &this_rawmode, &s, &fstr, &fstrlen) != 0) {
+ goto error;
+ }
+
+ /* Check that we are not mixing bytes with unicode. */
+ if (i != 0 && bytesmode != this_bytesmode) {
+ RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals");
+ Py_XDECREF(s);
+ goto error;
+ }
+ bytesmode = this_bytesmode;
+
+ if (fstr != NULL) {
+ assert(s == NULL && !bytesmode);
+
+ int result = _PyPegen_FstringParser_ConcatFstring(p, &state, &fstr, fstr + fstrlen,
+ this_rawmode, 0, first, t, last);
+ if (result < 0) {
+ goto error;
+ }
+ }
+ else {
+ /* String or byte string. */
+ assert(s != NULL && fstr == NULL);
+ assert(bytesmode ? PyBytes_CheckExact(s) : PyUnicode_CheckExact(s));
+
+ if (bytesmode) {
+ if (i == 0) {
+ bytes_str = s;
+ }
+ else {
+ PyBytes_ConcatAndDel(&bytes_str, s);
+ if (!bytes_str) {
+ goto error;
+ }
+ }
+ }
+ else {
+ /* This is a regular string. Concatenate it. */
+ if (_PyPegen_FstringParser_ConcatAndDel(&state, s) < 0) {
+ goto error;
+ }
+ }
+ }
+ }
+
+ if (bytesmode) {
+ if (PyArena_AddPyObject(p->arena, bytes_str) < 0) {
+ goto error;
+ }
+ return Constant(bytes_str, NULL, first->lineno, first->col_offset, last->end_lineno,
+ last->end_col_offset, p->arena);
+ }
+
+ return _PyPegen_FstringParser_Finish(p, &state, first, last);
+
+error:
+ Py_XDECREF(bytes_str);
+ _PyPegen_FstringParser_Dealloc(&state);
+ if (PyErr_Occurred()) {
+ raise_decode_error(p);
+ }
+ return NULL;
+}
diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h
new file mode 100644
index 0000000..5acd988
--- /dev/null
+++ b/Parser/pegen/pegen.h
@@ -0,0 +1,179 @@
+#ifndef PEGEN_H
+#define PEGEN_H
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <token.h>
+#include <Python-ast.h>
+#include <pyarena.h>
+
+typedef struct _memo {
+ int type;
+ void *node;
+ int mark;
+ struct _memo *next;
+} Memo;
+
+typedef struct {
+ int type;
+ PyObject *bytes;
+ int lineno, col_offset, end_lineno, end_col_offset;
+ Memo *memo;
+} Token;
+
+typedef struct {
+ char *str;
+ int type;
+} KeywordToken;
+
+typedef struct {
+ struct tok_state *tok;
+ Token **tokens;
+ int mark;
+ int fill, size;
+ PyArena *arena;
+ KeywordToken **keywords;
+ int n_keyword_lists;
+ int start_rule;
+ int *errcode;
+ int parsing_started;
+ PyObject* normalize;
+ int starting_lineno;
+ int starting_col_offset;
+ int error_indicator;
+} Parser;
+
+typedef struct {
+ cmpop_ty cmpop;
+ expr_ty expr;
+} CmpopExprPair;
+
+typedef struct {
+ expr_ty key;
+ expr_ty value;
+} KeyValuePair;
+
+typedef struct {
+ arg_ty arg;
+ expr_ty value;
+} NameDefaultPair;
+
+typedef struct {
+ asdl_seq *plain_names;
+ asdl_seq *names_with_defaults; // asdl_seq* of NameDefaultsPair's
+} SlashWithDefault;
+
+typedef struct {
+ arg_ty vararg;
+ asdl_seq *kwonlyargs; // asdl_seq* of NameDefaultsPair's
+ arg_ty kwarg;
+} StarEtc;
+
+typedef struct {
+ operator_ty kind;
+} AugOperator;
+
+typedef struct {
+ void *element;
+ int is_keyword;
+} KeywordOrStarred;
+
+void _PyPegen_clear_memo_statistics(void);
+PyObject *_PyPegen_get_memo_statistics(void);
+
+int _PyPegen_insert_memo(Parser *p, int mark, int type, void *node);
+int _PyPegen_update_memo(Parser *p, int mark, int type, void *node);
+int _PyPegen_is_memoized(Parser *p, int type, void *pres);
+
+int _PyPegen_lookahead_with_string(int, void *(func)(Parser *, const char *), Parser *, const char *);
+int _PyPegen_lookahead_with_int(int, Token *(func)(Parser *, int), Parser *, int);
+int _PyPegen_lookahead(int, void *(func)(Parser *), Parser *);
+
+Token *_PyPegen_expect_token(Parser *p, int type);
+Token *_PyPegen_get_last_nonnwhitespace_token(Parser *);
+int _PyPegen_fill_token(Parser *p);
+void *_PyPegen_async_token(Parser *p);
+void *_PyPegen_await_token(Parser *p);
+void *_PyPegen_endmarker_token(Parser *p);
+expr_ty _PyPegen_name_token(Parser *p);
+void *_PyPegen_newline_token(Parser *p);
+void *_PyPegen_indent_token(Parser *p);
+void *_PyPegen_dedent_token(Parser *p);
+expr_ty _PyPegen_number_token(Parser *p);
+void *_PyPegen_string_token(Parser *p);
+const char *_PyPegen_get_expr_name(expr_ty);
+void *_PyPegen_raise_error(Parser *p, PyObject *, const char *errmsg, ...);
+void *_PyPegen_dummy_name(Parser *p, ...);
+
+#define UNUSED(expr) do { (void)(expr); } while (0)
+#define EXTRA_EXPR(head, tail) head->lineno, head->col_offset, tail->end_lineno, tail->end_col_offset, p->arena
+#define EXTRA start_lineno, start_col_offset, end_lineno, end_col_offset, p->arena
+#define RAISE_SYNTAX_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_SyntaxError, msg, ##__VA_ARGS__)
+#define RAISE_INDENTATION_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_IndentationError, msg, ##__VA_ARGS__)
+
+Py_LOCAL_INLINE(void *)
+CHECK_CALL(Parser *p, void *result)
+{
+ if (result == NULL) {
+ assert(PyErr_Occurred());
+ p->error_indicator = 1;
+ }
+ return result;
+}
+
+/* This is needed for helper functions that are allowed to
+ return NULL without an error. Example: _PyPegen_seq_extract_starred_exprs */
+Py_LOCAL_INLINE(void *)
+CHECK_CALL_NULL_ALLOWED(Parser *p, void *result)
+{
+ if (result == NULL && PyErr_Occurred()) {
+ p->error_indicator = 1;
+ }
+ return result;
+}
+
+#define CHECK(result) CHECK_CALL(p, result)
+#define CHECK_NULL_ALLOWED(result) CHECK_CALL_NULL_ALLOWED(p, result)
+
+PyObject *_PyPegen_new_identifier(Parser *, char *);
+Parser *_PyPegen_Parser_New(struct tok_state *, int, int *, PyArena *);
+void _PyPegen_Parser_Free(Parser *);
+mod_ty _PyPegen_run_parser_from_file_pointer(FILE *, int, PyObject *, const char *,
+ const char *, const char *, int *, PyArena *);
+void *_PyPegen_run_parser(Parser *);
+mod_ty _PyPegen_run_parser_from_file(const char *, int, PyObject *, PyArena *);
+mod_ty _PyPegen_run_parser_from_string(const char *, int, PyObject *, int, PyArena *);
+void *_PyPegen_interactive_exit(Parser *);
+asdl_seq *_PyPegen_singleton_seq(Parser *, void *);
+asdl_seq *_PyPegen_seq_insert_in_front(Parser *, void *, asdl_seq *);
+asdl_seq *_PyPegen_seq_flatten(Parser *, asdl_seq *);
+expr_ty _PyPegen_join_names_with_dot(Parser *, expr_ty, expr_ty);
+int _PyPegen_seq_count_dots(asdl_seq *);
+alias_ty _PyPegen_alias_for_star(Parser *);
+asdl_seq *_PyPegen_map_names_to_ids(Parser *, asdl_seq *);
+CmpopExprPair *_PyPegen_cmpop_expr_pair(Parser *, cmpop_ty, expr_ty);
+asdl_int_seq *_PyPegen_get_cmpops(Parser *p, asdl_seq *);
+asdl_seq *_PyPegen_get_exprs(Parser *, asdl_seq *);
+expr_ty _PyPegen_set_expr_context(Parser *, expr_ty, expr_context_ty);
+KeyValuePair *_PyPegen_key_value_pair(Parser *, expr_ty, expr_ty);
+asdl_seq *_PyPegen_get_keys(Parser *, asdl_seq *);
+asdl_seq *_PyPegen_get_values(Parser *, asdl_seq *);
+NameDefaultPair *_PyPegen_name_default_pair(Parser *, arg_ty, expr_ty);
+SlashWithDefault *_PyPegen_slash_with_default(Parser *, asdl_seq *, asdl_seq *);
+StarEtc *_PyPegen_star_etc(Parser *, arg_ty, asdl_seq *, arg_ty);
+arguments_ty _PyPegen_make_arguments(Parser *, asdl_seq *, SlashWithDefault *,
+ asdl_seq *, asdl_seq *, StarEtc *);
+arguments_ty _PyPegen_empty_arguments(Parser *);
+AugOperator *_PyPegen_augoperator(Parser*, operator_ty type);
+stmt_ty _PyPegen_function_def_decorators(Parser *, asdl_seq *, stmt_ty);
+stmt_ty _PyPegen_class_def_decorators(Parser *, asdl_seq *, stmt_ty);
+KeywordOrStarred *_PyPegen_keyword_or_starred(Parser *, void *, int);
+asdl_seq *_PyPegen_seq_extract_starred_exprs(Parser *, asdl_seq *);
+asdl_seq *_PyPegen_seq_delete_starred_exprs(Parser *, asdl_seq *);
+expr_ty _PyPegen_concatenate_strings(Parser *p, asdl_seq *);
+asdl_seq *_PyPegen_join_sequences(Parser *, asdl_seq *, asdl_seq *);
+void *_PyPegen_arguments_parsing_error(Parser *, expr_ty);
+
+void *_PyPegen_parse(Parser *);
+
+#endif