diff options
Diffstat (limited to 'Parser/parser.c')
| -rw-r--r-- | Parser/parser.c | 2011 |
1 files changed, 1272 insertions, 739 deletions
diff --git a/Parser/parser.c b/Parser/parser.c index e8328ce..5baf82b 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -119,373 +119,377 @@ static char *soft_keywords[] = { #define or_pattern_type 1045 #define closed_pattern_type 1046 #define literal_pattern_type 1047 -#define signed_number_type 1048 -#define capture_pattern_type 1049 -#define wildcard_pattern_type 1050 -#define value_pattern_type 1051 -#define attr_type 1052 // Left-recursive -#define name_or_attr_type 1053 // Left-recursive -#define group_pattern_type 1054 -#define sequence_pattern_type 1055 -#define open_sequence_pattern_type 1056 -#define maybe_sequence_pattern_type 1057 -#define maybe_star_pattern_type 1058 -#define star_pattern_type 1059 -#define mapping_pattern_type 1060 -#define items_pattern_type 1061 -#define key_value_pattern_type 1062 -#define double_star_pattern_type 1063 -#define class_pattern_type 1064 -#define positional_patterns_type 1065 -#define keyword_patterns_type 1066 -#define keyword_pattern_type 1067 -#define return_stmt_type 1068 -#define raise_stmt_type 1069 -#define function_def_type 1070 -#define function_def_raw_type 1071 -#define func_type_comment_type 1072 -#define params_type 1073 -#define parameters_type 1074 -#define slash_no_default_type 1075 -#define slash_with_default_type 1076 -#define star_etc_type 1077 -#define kwds_type 1078 -#define param_no_default_type 1079 -#define param_with_default_type 1080 -#define param_maybe_default_type 1081 -#define param_type 1082 -#define annotation_type 1083 -#define default_type 1084 -#define decorators_type 1085 -#define class_def_type 1086 -#define class_def_raw_type 1087 -#define block_type 1088 -#define star_expressions_type 1089 -#define star_expression_type 1090 -#define star_named_expressions_type 1091 -#define star_named_expression_type 1092 -#define named_expression_type 1093 -#define direct_named_expression_type 1094 -#define annotated_rhs_type 1095 -#define expressions_type 1096 -#define expression_type 1097 -#define lambdef_type 1098 -#define lambda_params_type 1099 -#define lambda_parameters_type 1100 -#define lambda_slash_no_default_type 1101 -#define lambda_slash_with_default_type 1102 -#define lambda_star_etc_type 1103 -#define lambda_kwds_type 1104 -#define lambda_param_no_default_type 1105 -#define lambda_param_with_default_type 1106 -#define lambda_param_maybe_default_type 1107 -#define lambda_param_type 1108 -#define disjunction_type 1109 -#define conjunction_type 1110 -#define inversion_type 1111 -#define comparison_type 1112 -#define compare_op_bitwise_or_pair_type 1113 -#define eq_bitwise_or_type 1114 -#define noteq_bitwise_or_type 1115 -#define lte_bitwise_or_type 1116 -#define lt_bitwise_or_type 1117 -#define gte_bitwise_or_type 1118 -#define gt_bitwise_or_type 1119 -#define notin_bitwise_or_type 1120 -#define in_bitwise_or_type 1121 -#define isnot_bitwise_or_type 1122 -#define is_bitwise_or_type 1123 -#define bitwise_or_type 1124 // Left-recursive -#define bitwise_xor_type 1125 // Left-recursive -#define bitwise_and_type 1126 // Left-recursive -#define shift_expr_type 1127 // Left-recursive -#define sum_type 1128 // Left-recursive -#define term_type 1129 // Left-recursive -#define factor_type 1130 -#define power_type 1131 -#define await_primary_type 1132 -#define primary_type 1133 // Left-recursive -#define slices_type 1134 -#define slice_type 1135 -#define atom_type 1136 -#define strings_type 1137 -#define list_type 1138 -#define listcomp_type 1139 -#define tuple_type 1140 -#define group_type 1141 -#define genexp_type 1142 -#define set_type 1143 -#define setcomp_type 1144 -#define dict_type 1145 -#define dictcomp_type 1146 -#define double_starred_kvpairs_type 1147 -#define double_starred_kvpair_type 1148 -#define kvpair_type 1149 -#define for_if_clauses_type 1150 -#define for_if_clause_type 1151 -#define yield_expr_type 1152 -#define arguments_type 1153 -#define args_type 1154 -#define kwargs_type 1155 -#define starred_expression_type 1156 -#define kwarg_or_starred_type 1157 -#define kwarg_or_double_starred_type 1158 -#define star_targets_type 1159 -#define star_targets_list_seq_type 1160 -#define star_targets_tuple_seq_type 1161 -#define star_target_type 1162 -#define target_with_star_atom_type 1163 -#define star_atom_type 1164 -#define single_target_type 1165 -#define single_subscript_attribute_target_type 1166 -#define del_targets_type 1167 -#define del_target_type 1168 -#define del_t_atom_type 1169 -#define targets_type 1170 -#define target_type 1171 -#define t_primary_type 1172 // Left-recursive -#define t_lookahead_type 1173 -#define t_atom_type 1174 -#define invalid_arguments_type 1175 -#define invalid_kwarg_type 1176 -#define invalid_expression_type 1177 -#define invalid_named_expression_type 1178 -#define invalid_assignment_type 1179 -#define invalid_ann_assign_target_type 1180 -#define invalid_del_stmt_type 1181 -#define invalid_block_type 1182 -#define invalid_primary_type 1183 // Left-recursive -#define invalid_comprehension_type 1184 -#define invalid_dict_comprehension_type 1185 -#define invalid_parameters_type 1186 -#define invalid_parameters_helper_type 1187 -#define invalid_lambda_parameters_type 1188 -#define invalid_lambda_parameters_helper_type 1189 -#define invalid_star_etc_type 1190 -#define invalid_lambda_star_etc_type 1191 -#define invalid_double_type_comments_type 1192 -#define invalid_with_item_type 1193 -#define invalid_for_target_type 1194 -#define invalid_group_type 1195 -#define invalid_import_from_targets_type 1196 -#define invalid_with_stmt_type 1197 -#define invalid_with_stmt_indent_type 1198 -#define invalid_try_stmt_type 1199 -#define invalid_except_stmt_type 1200 -#define invalid_finally_stmt_type 1201 -#define invalid_except_stmt_indent_type 1202 -#define invalid_match_stmt_type 1203 -#define invalid_case_block_type 1204 -#define invalid_if_stmt_type 1205 -#define invalid_elif_stmt_type 1206 -#define invalid_else_stmt_type 1207 -#define invalid_while_stmt_type 1208 -#define invalid_for_stmt_type 1209 -#define invalid_def_raw_type 1210 -#define invalid_class_def_raw_type 1211 -#define invalid_double_starred_kvpairs_type 1212 -#define invalid_kvpair_type 1213 -#define _loop0_1_type 1214 -#define _loop0_2_type 1215 -#define _loop0_4_type 1216 -#define _gather_3_type 1217 -#define _loop0_6_type 1218 -#define _gather_5_type 1219 -#define _loop0_8_type 1220 -#define _gather_7_type 1221 -#define _loop0_10_type 1222 -#define _gather_9_type 1223 -#define _loop1_11_type 1224 -#define _loop0_13_type 1225 -#define _gather_12_type 1226 -#define _tmp_14_type 1227 -#define _tmp_15_type 1228 -#define _tmp_16_type 1229 -#define _tmp_17_type 1230 -#define _tmp_18_type 1231 -#define _tmp_19_type 1232 -#define _tmp_20_type 1233 -#define _tmp_21_type 1234 -#define _loop1_22_type 1235 -#define _tmp_23_type 1236 -#define _tmp_24_type 1237 -#define _loop0_26_type 1238 -#define _gather_25_type 1239 -#define _loop0_28_type 1240 -#define _gather_27_type 1241 -#define _tmp_29_type 1242 -#define _tmp_30_type 1243 -#define _loop0_31_type 1244 -#define _loop1_32_type 1245 -#define _loop0_34_type 1246 -#define _gather_33_type 1247 -#define _tmp_35_type 1248 -#define _loop0_37_type 1249 -#define _gather_36_type 1250 -#define _tmp_38_type 1251 -#define _loop0_40_type 1252 -#define _gather_39_type 1253 -#define _loop0_42_type 1254 -#define _gather_41_type 1255 -#define _loop0_44_type 1256 -#define _gather_43_type 1257 -#define _loop0_46_type 1258 -#define _gather_45_type 1259 -#define _tmp_47_type 1260 -#define _loop1_48_type 1261 -#define _tmp_49_type 1262 -#define _loop1_50_type 1263 -#define _loop0_52_type 1264 -#define _gather_51_type 1265 -#define _tmp_53_type 1266 -#define _tmp_54_type 1267 -#define _tmp_55_type 1268 -#define _loop0_57_type 1269 -#define _gather_56_type 1270 -#define _tmp_58_type 1271 -#define _loop0_60_type 1272 -#define _gather_59_type 1273 -#define _tmp_61_type 1274 -#define _loop0_63_type 1275 -#define _gather_62_type 1276 -#define _loop0_65_type 1277 -#define _gather_64_type 1278 -#define _tmp_66_type 1279 -#define _tmp_67_type 1280 -#define _tmp_68_type 1281 -#define _tmp_69_type 1282 -#define _loop0_70_type 1283 -#define _loop0_71_type 1284 -#define _loop0_72_type 1285 -#define _loop1_73_type 1286 -#define _loop0_74_type 1287 -#define _loop1_75_type 1288 -#define _loop1_76_type 1289 -#define _loop1_77_type 1290 -#define _loop0_78_type 1291 -#define _loop1_79_type 1292 -#define _loop0_80_type 1293 -#define _loop1_81_type 1294 -#define _loop0_82_type 1295 -#define _loop1_83_type 1296 -#define _loop1_84_type 1297 -#define _tmp_85_type 1298 -#define _loop1_86_type 1299 -#define _loop0_88_type 1300 -#define _gather_87_type 1301 -#define _loop1_89_type 1302 -#define _loop0_90_type 1303 -#define _loop0_91_type 1304 -#define _loop0_92_type 1305 -#define _loop1_93_type 1306 -#define _loop0_94_type 1307 -#define _loop1_95_type 1308 -#define _loop1_96_type 1309 -#define _loop1_97_type 1310 -#define _loop0_98_type 1311 -#define _loop1_99_type 1312 -#define _loop0_100_type 1313 -#define _loop1_101_type 1314 -#define _loop0_102_type 1315 -#define _loop1_103_type 1316 -#define _loop1_104_type 1317 -#define _loop1_105_type 1318 -#define _loop1_106_type 1319 -#define _tmp_107_type 1320 -#define _loop0_109_type 1321 -#define _gather_108_type 1322 -#define _tmp_110_type 1323 -#define _tmp_111_type 1324 -#define _tmp_112_type 1325 -#define _tmp_113_type 1326 -#define _loop1_114_type 1327 -#define _tmp_115_type 1328 -#define _tmp_116_type 1329 -#define _loop0_118_type 1330 -#define _gather_117_type 1331 -#define _loop1_119_type 1332 -#define _loop0_120_type 1333 -#define _loop0_121_type 1334 -#define _loop0_123_type 1335 -#define _gather_122_type 1336 -#define _tmp_124_type 1337 -#define _loop0_126_type 1338 -#define _gather_125_type 1339 -#define _loop0_128_type 1340 -#define _gather_127_type 1341 -#define _loop0_130_type 1342 -#define _gather_129_type 1343 -#define _loop0_132_type 1344 -#define _gather_131_type 1345 -#define _loop0_133_type 1346 -#define _loop0_135_type 1347 -#define _gather_134_type 1348 -#define _loop1_136_type 1349 -#define _tmp_137_type 1350 -#define _loop0_139_type 1351 -#define _gather_138_type 1352 -#define _loop0_141_type 1353 -#define _gather_140_type 1354 -#define _tmp_142_type 1355 -#define _tmp_143_type 1356 -#define _tmp_144_type 1357 -#define _tmp_145_type 1358 -#define _tmp_146_type 1359 -#define _loop0_147_type 1360 -#define _loop0_148_type 1361 -#define _loop0_149_type 1362 -#define _tmp_150_type 1363 -#define _tmp_151_type 1364 -#define _tmp_152_type 1365 -#define _tmp_153_type 1366 -#define _loop0_154_type 1367 -#define _loop1_155_type 1368 -#define _loop0_156_type 1369 -#define _loop1_157_type 1370 -#define _tmp_158_type 1371 -#define _tmp_159_type 1372 -#define _tmp_160_type 1373 -#define _loop0_162_type 1374 -#define _gather_161_type 1375 -#define _loop0_164_type 1376 -#define _gather_163_type 1377 -#define _loop0_166_type 1378 -#define _gather_165_type 1379 -#define _loop0_168_type 1380 -#define _gather_167_type 1381 -#define _tmp_169_type 1382 -#define _tmp_170_type 1383 -#define _tmp_171_type 1384 -#define _tmp_172_type 1385 -#define _tmp_173_type 1386 -#define _loop0_175_type 1387 -#define _gather_174_type 1388 -#define _tmp_176_type 1389 -#define _tmp_177_type 1390 -#define _tmp_178_type 1391 -#define _tmp_179_type 1392 -#define _tmp_180_type 1393 -#define _tmp_181_type 1394 -#define _tmp_182_type 1395 -#define _tmp_183_type 1396 -#define _tmp_184_type 1397 -#define _tmp_185_type 1398 -#define _tmp_186_type 1399 -#define _tmp_187_type 1400 -#define _tmp_188_type 1401 -#define _tmp_189_type 1402 -#define _tmp_190_type 1403 -#define _tmp_191_type 1404 -#define _tmp_192_type 1405 -#define _tmp_193_type 1406 -#define _tmp_194_type 1407 -#define _tmp_195_type 1408 -#define _tmp_196_type 1409 -#define _tmp_197_type 1410 -#define _tmp_198_type 1411 -#define _tmp_199_type 1412 -#define _tmp_200_type 1413 -#define _tmp_201_type 1414 +#define literal_expr_type 1048 +#define complex_number_type 1049 +#define signed_number_type 1050 +#define imaginary_number_type 1051 +#define capture_pattern_type 1052 +#define pattern_capture_target_type 1053 +#define wildcard_pattern_type 1054 +#define value_pattern_type 1055 +#define attr_type 1056 // Left-recursive +#define name_or_attr_type 1057 // Left-recursive +#define group_pattern_type 1058 +#define sequence_pattern_type 1059 +#define open_sequence_pattern_type 1060 +#define maybe_sequence_pattern_type 1061 +#define maybe_star_pattern_type 1062 +#define star_pattern_type 1063 +#define mapping_pattern_type 1064 +#define items_pattern_type 1065 +#define key_value_pattern_type 1066 +#define double_star_pattern_type 1067 +#define class_pattern_type 1068 +#define positional_patterns_type 1069 +#define keyword_patterns_type 1070 +#define keyword_pattern_type 1071 +#define return_stmt_type 1072 +#define raise_stmt_type 1073 +#define function_def_type 1074 +#define function_def_raw_type 1075 +#define func_type_comment_type 1076 +#define params_type 1077 +#define parameters_type 1078 +#define slash_no_default_type 1079 +#define slash_with_default_type 1080 +#define star_etc_type 1081 +#define kwds_type 1082 +#define param_no_default_type 1083 +#define param_with_default_type 1084 +#define param_maybe_default_type 1085 +#define param_type 1086 +#define annotation_type 1087 +#define default_type 1088 +#define decorators_type 1089 +#define class_def_type 1090 +#define class_def_raw_type 1091 +#define block_type 1092 +#define star_expressions_type 1093 +#define star_expression_type 1094 +#define star_named_expressions_type 1095 +#define star_named_expression_type 1096 +#define named_expression_type 1097 +#define direct_named_expression_type 1098 +#define annotated_rhs_type 1099 +#define expressions_type 1100 +#define expression_type 1101 +#define lambdef_type 1102 +#define lambda_params_type 1103 +#define lambda_parameters_type 1104 +#define lambda_slash_no_default_type 1105 +#define lambda_slash_with_default_type 1106 +#define lambda_star_etc_type 1107 +#define lambda_kwds_type 1108 +#define lambda_param_no_default_type 1109 +#define lambda_param_with_default_type 1110 +#define lambda_param_maybe_default_type 1111 +#define lambda_param_type 1112 +#define disjunction_type 1113 +#define conjunction_type 1114 +#define inversion_type 1115 +#define comparison_type 1116 +#define compare_op_bitwise_or_pair_type 1117 +#define eq_bitwise_or_type 1118 +#define noteq_bitwise_or_type 1119 +#define lte_bitwise_or_type 1120 +#define lt_bitwise_or_type 1121 +#define gte_bitwise_or_type 1122 +#define gt_bitwise_or_type 1123 +#define notin_bitwise_or_type 1124 +#define in_bitwise_or_type 1125 +#define isnot_bitwise_or_type 1126 +#define is_bitwise_or_type 1127 +#define bitwise_or_type 1128 // Left-recursive +#define bitwise_xor_type 1129 // Left-recursive +#define bitwise_and_type 1130 // Left-recursive +#define shift_expr_type 1131 // Left-recursive +#define sum_type 1132 // Left-recursive +#define term_type 1133 // Left-recursive +#define factor_type 1134 +#define power_type 1135 +#define await_primary_type 1136 +#define primary_type 1137 // Left-recursive +#define slices_type 1138 +#define slice_type 1139 +#define atom_type 1140 +#define strings_type 1141 +#define list_type 1142 +#define listcomp_type 1143 +#define tuple_type 1144 +#define group_type 1145 +#define genexp_type 1146 +#define set_type 1147 +#define setcomp_type 1148 +#define dict_type 1149 +#define dictcomp_type 1150 +#define double_starred_kvpairs_type 1151 +#define double_starred_kvpair_type 1152 +#define kvpair_type 1153 +#define for_if_clauses_type 1154 +#define for_if_clause_type 1155 +#define yield_expr_type 1156 +#define arguments_type 1157 +#define args_type 1158 +#define kwargs_type 1159 +#define starred_expression_type 1160 +#define kwarg_or_starred_type 1161 +#define kwarg_or_double_starred_type 1162 +#define star_targets_type 1163 +#define star_targets_list_seq_type 1164 +#define star_targets_tuple_seq_type 1165 +#define star_target_type 1166 +#define target_with_star_atom_type 1167 +#define star_atom_type 1168 +#define single_target_type 1169 +#define single_subscript_attribute_target_type 1170 +#define del_targets_type 1171 +#define del_target_type 1172 +#define del_t_atom_type 1173 +#define targets_type 1174 +#define target_type 1175 +#define t_primary_type 1176 // Left-recursive +#define t_lookahead_type 1177 +#define t_atom_type 1178 +#define invalid_arguments_type 1179 +#define invalid_kwarg_type 1180 +#define invalid_expression_type 1181 +#define invalid_named_expression_type 1182 +#define invalid_assignment_type 1183 +#define invalid_ann_assign_target_type 1184 +#define invalid_del_stmt_type 1185 +#define invalid_block_type 1186 +#define invalid_primary_type 1187 // Left-recursive +#define invalid_comprehension_type 1188 +#define invalid_dict_comprehension_type 1189 +#define invalid_parameters_type 1190 +#define invalid_parameters_helper_type 1191 +#define invalid_lambda_parameters_type 1192 +#define invalid_lambda_parameters_helper_type 1193 +#define invalid_star_etc_type 1194 +#define invalid_lambda_star_etc_type 1195 +#define invalid_double_type_comments_type 1196 +#define invalid_with_item_type 1197 +#define invalid_for_target_type 1198 +#define invalid_group_type 1199 +#define invalid_import_from_targets_type 1200 +#define invalid_with_stmt_type 1201 +#define invalid_with_stmt_indent_type 1202 +#define invalid_try_stmt_type 1203 +#define invalid_except_stmt_type 1204 +#define invalid_finally_stmt_type 1205 +#define invalid_except_stmt_indent_type 1206 +#define invalid_match_stmt_type 1207 +#define invalid_case_block_type 1208 +#define invalid_if_stmt_type 1209 +#define invalid_elif_stmt_type 1210 +#define invalid_else_stmt_type 1211 +#define invalid_while_stmt_type 1212 +#define invalid_for_stmt_type 1213 +#define invalid_def_raw_type 1214 +#define invalid_class_def_raw_type 1215 +#define invalid_double_starred_kvpairs_type 1216 +#define invalid_kvpair_type 1217 +#define _loop0_1_type 1218 +#define _loop0_2_type 1219 +#define _loop0_4_type 1220 +#define _gather_3_type 1221 +#define _loop0_6_type 1222 +#define _gather_5_type 1223 +#define _loop0_8_type 1224 +#define _gather_7_type 1225 +#define _loop0_10_type 1226 +#define _gather_9_type 1227 +#define _loop1_11_type 1228 +#define _loop0_13_type 1229 +#define _gather_12_type 1230 +#define _tmp_14_type 1231 +#define _tmp_15_type 1232 +#define _tmp_16_type 1233 +#define _tmp_17_type 1234 +#define _tmp_18_type 1235 +#define _tmp_19_type 1236 +#define _tmp_20_type 1237 +#define _tmp_21_type 1238 +#define _loop1_22_type 1239 +#define _tmp_23_type 1240 +#define _tmp_24_type 1241 +#define _loop0_26_type 1242 +#define _gather_25_type 1243 +#define _loop0_28_type 1244 +#define _gather_27_type 1245 +#define _tmp_29_type 1246 +#define _tmp_30_type 1247 +#define _loop0_31_type 1248 +#define _loop1_32_type 1249 +#define _loop0_34_type 1250 +#define _gather_33_type 1251 +#define _tmp_35_type 1252 +#define _loop0_37_type 1253 +#define _gather_36_type 1254 +#define _tmp_38_type 1255 +#define _loop0_40_type 1256 +#define _gather_39_type 1257 +#define _loop0_42_type 1258 +#define _gather_41_type 1259 +#define _loop0_44_type 1260 +#define _gather_43_type 1261 +#define _loop0_46_type 1262 +#define _gather_45_type 1263 +#define _tmp_47_type 1264 +#define _loop1_48_type 1265 +#define _tmp_49_type 1266 +#define _loop1_50_type 1267 +#define _loop0_52_type 1268 +#define _gather_51_type 1269 +#define _tmp_53_type 1270 +#define _tmp_54_type 1271 +#define _tmp_55_type 1272 +#define _tmp_56_type 1273 +#define _loop0_58_type 1274 +#define _gather_57_type 1275 +#define _loop0_60_type 1276 +#define _gather_59_type 1277 +#define _tmp_61_type 1278 +#define _loop0_63_type 1279 +#define _gather_62_type 1280 +#define _loop0_65_type 1281 +#define _gather_64_type 1282 +#define _tmp_66_type 1283 +#define _tmp_67_type 1284 +#define _tmp_68_type 1285 +#define _tmp_69_type 1286 +#define _loop0_70_type 1287 +#define _loop0_71_type 1288 +#define _loop0_72_type 1289 +#define _loop1_73_type 1290 +#define _loop0_74_type 1291 +#define _loop1_75_type 1292 +#define _loop1_76_type 1293 +#define _loop1_77_type 1294 +#define _loop0_78_type 1295 +#define _loop1_79_type 1296 +#define _loop0_80_type 1297 +#define _loop1_81_type 1298 +#define _loop0_82_type 1299 +#define _loop1_83_type 1300 +#define _loop1_84_type 1301 +#define _tmp_85_type 1302 +#define _loop1_86_type 1303 +#define _loop0_88_type 1304 +#define _gather_87_type 1305 +#define _loop1_89_type 1306 +#define _loop0_90_type 1307 +#define _loop0_91_type 1308 +#define _loop0_92_type 1309 +#define _loop1_93_type 1310 +#define _loop0_94_type 1311 +#define _loop1_95_type 1312 +#define _loop1_96_type 1313 +#define _loop1_97_type 1314 +#define _loop0_98_type 1315 +#define _loop1_99_type 1316 +#define _loop0_100_type 1317 +#define _loop1_101_type 1318 +#define _loop0_102_type 1319 +#define _loop1_103_type 1320 +#define _loop1_104_type 1321 +#define _loop1_105_type 1322 +#define _loop1_106_type 1323 +#define _tmp_107_type 1324 +#define _loop0_109_type 1325 +#define _gather_108_type 1326 +#define _tmp_110_type 1327 +#define _tmp_111_type 1328 +#define _tmp_112_type 1329 +#define _tmp_113_type 1330 +#define _loop1_114_type 1331 +#define _tmp_115_type 1332 +#define _tmp_116_type 1333 +#define _loop0_118_type 1334 +#define _gather_117_type 1335 +#define _loop1_119_type 1336 +#define _loop0_120_type 1337 +#define _loop0_121_type 1338 +#define _loop0_123_type 1339 +#define _gather_122_type 1340 +#define _tmp_124_type 1341 +#define _loop0_126_type 1342 +#define _gather_125_type 1343 +#define _loop0_128_type 1344 +#define _gather_127_type 1345 +#define _loop0_130_type 1346 +#define _gather_129_type 1347 +#define _loop0_132_type 1348 +#define _gather_131_type 1349 +#define _loop0_133_type 1350 +#define _loop0_135_type 1351 +#define _gather_134_type 1352 +#define _loop1_136_type 1353 +#define _tmp_137_type 1354 +#define _loop0_139_type 1355 +#define _gather_138_type 1356 +#define _loop0_141_type 1357 +#define _gather_140_type 1358 +#define _tmp_142_type 1359 +#define _tmp_143_type 1360 +#define _tmp_144_type 1361 +#define _tmp_145_type 1362 +#define _tmp_146_type 1363 +#define _loop0_147_type 1364 +#define _loop0_148_type 1365 +#define _loop0_149_type 1366 +#define _tmp_150_type 1367 +#define _tmp_151_type 1368 +#define _tmp_152_type 1369 +#define _tmp_153_type 1370 +#define _loop0_154_type 1371 +#define _loop1_155_type 1372 +#define _loop0_156_type 1373 +#define _loop1_157_type 1374 +#define _tmp_158_type 1375 +#define _tmp_159_type 1376 +#define _tmp_160_type 1377 +#define _loop0_162_type 1378 +#define _gather_161_type 1379 +#define _loop0_164_type 1380 +#define _gather_163_type 1381 +#define _loop0_166_type 1382 +#define _gather_165_type 1383 +#define _loop0_168_type 1384 +#define _gather_167_type 1385 +#define _tmp_169_type 1386 +#define _tmp_170_type 1387 +#define _tmp_171_type 1388 +#define _tmp_172_type 1389 +#define _tmp_173_type 1390 +#define _loop0_175_type 1391 +#define _gather_174_type 1392 +#define _tmp_176_type 1393 +#define _tmp_177_type 1394 +#define _tmp_178_type 1395 +#define _tmp_179_type 1396 +#define _tmp_180_type 1397 +#define _tmp_181_type 1398 +#define _tmp_182_type 1399 +#define _tmp_183_type 1400 +#define _tmp_184_type 1401 +#define _tmp_185_type 1402 +#define _tmp_186_type 1403 +#define _tmp_187_type 1404 +#define _tmp_188_type 1405 +#define _tmp_189_type 1406 +#define _tmp_190_type 1407 +#define _tmp_191_type 1408 +#define _tmp_192_type 1409 +#define _tmp_193_type 1410 +#define _tmp_194_type 1411 +#define _tmp_195_type 1412 +#define _tmp_196_type 1413 +#define _tmp_197_type 1414 +#define _tmp_198_type 1415 +#define _tmp_199_type 1416 +#define _tmp_200_type 1417 +#define _tmp_201_type 1418 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -529,32 +533,36 @@ static stmt_ty match_stmt_rule(Parser *p); static expr_ty subject_expr_rule(Parser *p); static match_case_ty case_block_rule(Parser *p); static expr_ty guard_rule(Parser *p); -static expr_ty patterns_rule(Parser *p); -static expr_ty pattern_rule(Parser *p); -static expr_ty as_pattern_rule(Parser *p); -static expr_ty or_pattern_rule(Parser *p); -static expr_ty closed_pattern_rule(Parser *p); -static expr_ty literal_pattern_rule(Parser *p); +static pattern_ty patterns_rule(Parser *p); +static pattern_ty pattern_rule(Parser *p); +static pattern_ty as_pattern_rule(Parser *p); +static pattern_ty or_pattern_rule(Parser *p); +static pattern_ty closed_pattern_rule(Parser *p); +static pattern_ty literal_pattern_rule(Parser *p); +static expr_ty literal_expr_rule(Parser *p); +static expr_ty complex_number_rule(Parser *p); static expr_ty signed_number_rule(Parser *p); -static expr_ty capture_pattern_rule(Parser *p); -static expr_ty wildcard_pattern_rule(Parser *p); -static expr_ty value_pattern_rule(Parser *p); +static expr_ty imaginary_number_rule(Parser *p); +static pattern_ty capture_pattern_rule(Parser *p); +static expr_ty pattern_capture_target_rule(Parser *p); +static pattern_ty wildcard_pattern_rule(Parser *p); +static pattern_ty value_pattern_rule(Parser *p); static expr_ty attr_rule(Parser *p); static expr_ty name_or_attr_rule(Parser *p); -static expr_ty group_pattern_rule(Parser *p); -static expr_ty sequence_pattern_rule(Parser *p); +static pattern_ty group_pattern_rule(Parser *p); +static pattern_ty sequence_pattern_rule(Parser *p); static asdl_seq* open_sequence_pattern_rule(Parser *p); static asdl_seq* maybe_sequence_pattern_rule(Parser *p); -static expr_ty maybe_star_pattern_rule(Parser *p); -static expr_ty star_pattern_rule(Parser *p); -static expr_ty mapping_pattern_rule(Parser *p); +static pattern_ty maybe_star_pattern_rule(Parser *p); +static pattern_ty star_pattern_rule(Parser *p); +static pattern_ty mapping_pattern_rule(Parser *p); static asdl_seq* items_pattern_rule(Parser *p); -static KeyValuePair* key_value_pattern_rule(Parser *p); -static KeyValuePair* double_star_pattern_rule(Parser *p); -static expr_ty class_pattern_rule(Parser *p); -static asdl_expr_seq* positional_patterns_rule(Parser *p); -static asdl_keyword_seq* keyword_patterns_rule(Parser *p); -static keyword_ty keyword_pattern_rule(Parser *p); +static KeyPatternPair* key_value_pattern_rule(Parser *p); +static expr_ty double_star_pattern_rule(Parser *p); +static pattern_ty class_pattern_rule(Parser *p); +static asdl_pattern_seq* positional_patterns_rule(Parser *p); +static asdl_seq* keyword_patterns_rule(Parser *p); +static KeyPatternPair* keyword_pattern_rule(Parser *p); static stmt_ty return_stmt_rule(Parser *p); static stmt_ty raise_stmt_rule(Parser *p); static stmt_ty function_def_rule(Parser *p); @@ -756,9 +764,9 @@ static asdl_seq *_gather_51_rule(Parser *p); static void *_tmp_53_rule(Parser *p); static void *_tmp_54_rule(Parser *p); static void *_tmp_55_rule(Parser *p); -static asdl_seq *_loop0_57_rule(Parser *p); -static asdl_seq *_gather_56_rule(Parser *p); -static void *_tmp_58_rule(Parser *p); +static void *_tmp_56_rule(Parser *p); +static asdl_seq *_loop0_58_rule(Parser *p); +static asdl_seq *_gather_57_rule(Parser *p); static asdl_seq *_loop0_60_rule(Parser *p); static asdl_seq *_gather_59_rule(Parser *p); static void *_tmp_61_rule(Parser *p); @@ -5378,7 +5386,7 @@ case_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* body; void *guard; - expr_ty pattern; + pattern_ty pattern; if ( (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' && @@ -5455,7 +5463,7 @@ guard_rule(Parser *p) } // patterns: open_sequence_pattern | pattern -static expr_ty +static pattern_ty patterns_rule(Parser *p) { D(p->level++); @@ -5463,7 +5471,7 @@ patterns_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -5480,9 +5488,9 @@ patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern")); - asdl_expr_seq* values; + asdl_pattern_seq* patterns; if ( - (values = (asdl_expr_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern + (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern ) { D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern")); @@ -5495,7 +5503,7 @@ patterns_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Tuple ( values , Load , EXTRA ); + _res = _PyAST_MatchSequence ( patterns , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -5513,7 +5521,7 @@ patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern")); - expr_ty pattern_var; + pattern_ty pattern_var; if ( (pattern_var = pattern_rule(p)) // pattern ) @@ -5533,7 +5541,7 @@ patterns_rule(Parser *p) } // pattern: as_pattern | or_pattern -static expr_ty +static pattern_ty pattern_rule(Parser *p) { D(p->level++); @@ -5541,7 +5549,7 @@ pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; { // as_pattern if (p->error_indicator) { @@ -5549,7 +5557,7 @@ pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "as_pattern")); - expr_ty as_pattern_var; + pattern_ty as_pattern_var; if ( (as_pattern_var = as_pattern_rule(p)) // as_pattern ) @@ -5568,7 +5576,7 @@ pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern")); - expr_ty or_pattern_var; + pattern_ty or_pattern_var; if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern ) @@ -5587,8 +5595,8 @@ pattern_rule(Parser *p) return _res; } -// as_pattern: or_pattern 'as' capture_pattern -static expr_ty +// as_pattern: or_pattern 'as' pattern_capture_target +static pattern_ty as_pattern_rule(Parser *p) { D(p->level++); @@ -5596,7 +5604,7 @@ as_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -5607,24 +5615,24 @@ as_pattern_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // or_pattern 'as' capture_pattern + { // or_pattern 'as' pattern_capture_target if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' capture_pattern")); + D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' pattern_capture_target")); Token * _keyword; - expr_ty pattern; + pattern_ty pattern; expr_ty target; if ( (pattern = or_pattern_rule(p)) // or_pattern && (_keyword = _PyPegen_expect_token(p, 520)) // token='as' && - (target = capture_pattern_rule(p)) // capture_pattern + (target = pattern_capture_target_rule(p)) // pattern_capture_target ) { - D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' capture_pattern")); + D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' pattern_capture_target")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -5644,7 +5652,7 @@ as_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' capture_pattern")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' pattern_capture_target")); } _res = NULL; done: @@ -5653,7 +5661,7 @@ as_pattern_rule(Parser *p) } // or_pattern: '|'.closed_pattern+ -static expr_ty +static pattern_ty or_pattern_rule(Parser *p) { D(p->level++); @@ -5661,7 +5669,7 @@ or_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -5678,9 +5686,9 @@ or_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> or_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+")); - asdl_expr_seq* patterns; + asdl_pattern_seq* patterns; if ( - (patterns = (asdl_expr_seq*)_gather_51_rule(p)) // '|'.closed_pattern+ + (patterns = (asdl_pattern_seq*)_gather_51_rule(p)) // '|'.closed_pattern+ ) { D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+")); @@ -5720,7 +5728,7 @@ or_pattern_rule(Parser *p) // | sequence_pattern // | mapping_pattern // | class_pattern -static expr_ty +static pattern_ty closed_pattern_rule(Parser *p) { D(p->level++); @@ -5728,7 +5736,7 @@ closed_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; { // literal_pattern if (p->error_indicator) { @@ -5736,7 +5744,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_pattern")); - expr_ty literal_pattern_var; + pattern_ty literal_pattern_var; if ( (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern ) @@ -5755,7 +5763,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_pattern")); - expr_ty capture_pattern_var; + pattern_ty capture_pattern_var; if ( (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern ) @@ -5774,7 +5782,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pattern")); - expr_ty wildcard_pattern_var; + pattern_ty wildcard_pattern_var; if ( (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern ) @@ -5793,7 +5801,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_pattern")); - expr_ty value_pattern_var; + pattern_ty value_pattern_var; if ( (value_pattern_var = value_pattern_rule(p)) // value_pattern ) @@ -5812,7 +5820,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group_pattern")); - expr_ty group_pattern_var; + pattern_ty group_pattern_var; if ( (group_pattern_var = group_pattern_rule(p)) // group_pattern ) @@ -5831,7 +5839,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sequence_pattern")); - expr_ty sequence_pattern_var; + pattern_ty sequence_pattern_var; if ( (sequence_pattern_var = sequence_pattern_rule(p)) // sequence_pattern ) @@ -5850,7 +5858,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "mapping_pattern")); - expr_ty mapping_pattern_var; + pattern_ty mapping_pattern_var; if ( (mapping_pattern_var = mapping_pattern_rule(p)) // mapping_pattern ) @@ -5869,7 +5877,7 @@ closed_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_pattern")); - expr_ty class_pattern_var; + pattern_ty class_pattern_var; if ( (class_pattern_var = class_pattern_rule(p)) // class_pattern ) @@ -5890,13 +5898,12 @@ closed_pattern_rule(Parser *p) // literal_pattern: // | signed_number !('+' | '-') -// | signed_number '+' NUMBER -// | signed_number '-' NUMBER +// | complex_number // | strings // | 'None' // | 'True' // | 'False' -static expr_ty +static pattern_ty literal_pattern_rule(Parser *p) { D(p->level++); @@ -5904,7 +5911,7 @@ literal_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -5921,39 +5928,47 @@ literal_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); - expr_ty signed_number_var; + expr_ty value; if ( - (signed_number_var = signed_number_rule(p)) // signed_number + (value = signed_number_rule(p)) // signed_number && _PyPegen_lookahead(0, _tmp_53_rule, p) ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); - _res = signed_number_var; + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchValue ( value , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); } - { // signed_number '+' NUMBER + { // complex_number if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number '+' NUMBER")); - Token * _literal; - expr_ty imag; - expr_ty real; + D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number")); + expr_ty value; if ( - (real = signed_number_rule(p)) // signed_number - && - (_literal = _PyPegen_expect_token(p, 14)) // token='+' - && - (imag = _PyPegen_number_token(p)) // NUMBER + (value = complex_number_rule(p)) // complex_number ) { - D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number '+' NUMBER")); + D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -5963,7 +5978,7 @@ literal_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_BinOp ( real , Add , imag , EXTRA ); + _res = _PyAST_MatchValue ( value , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -5973,26 +5988,20 @@ literal_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number '+' NUMBER")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); } - { // signed_number '-' NUMBER + { // strings if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number '-' NUMBER")); - Token * _literal; - expr_ty imag; - expr_ty real; + D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); + expr_ty value; if ( - (real = signed_number_rule(p)) // signed_number - && - (_literal = _PyPegen_expect_token(p, 15)) // token='-' - && - (imag = _PyPegen_number_token(p)) // NUMBER + (value = strings_rule(p)) // strings ) { - D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number '-' NUMBER")); + D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -6002,7 +6011,106 @@ literal_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_BinOp ( real , Sub , imag , EXTRA ); + _res = _PyAST_MatchValue ( value , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); + } + { // 'None' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 523)) // token='None' + ) + { + D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchSingleton ( Py_None , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); + } + { // 'True' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 524)) // token='True' + ) + { + D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchSingleton ( Py_True , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); + } + { // 'False' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 525)) // token='False' + ) + { + D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchSingleton ( Py_False , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6012,25 +6120,97 @@ literal_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number '-' NUMBER")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); + } + _res = NULL; + done: + D(p->level--); + return _res; +} + +// literal_expr: +// | signed_number !('+' | '-') +// | complex_number +// | strings +// | 'None' +// | 'True' +// | 'False' +static expr_ty +literal_expr_rule(Parser *p) +{ + D(p->level++); + if (p->error_indicator) { + D(p->level--); + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // signed_number !('+' | '-') + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); + expr_ty signed_number_var; + if ( + (signed_number_var = signed_number_rule(p)) // signed_number + && + _PyPegen_lookahead(0, _tmp_54_rule, p) + ) + { + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); + _res = signed_number_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); + } + { // complex_number + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number")); + expr_ty complex_number_var; + if ( + (complex_number_var = complex_number_rule(p)) // complex_number + ) + { + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number")); + _res = complex_number_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); } { // strings if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); expr_ty strings_var; if ( (strings_var = strings_rule(p)) // strings ) { - D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings")); + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings")); _res = strings_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); } { // 'None' @@ -6038,13 +6218,13 @@ literal_pattern_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 523)) // token='None' ) { - D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -6063,7 +6243,7 @@ literal_pattern_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } { // 'True' @@ -6071,13 +6251,13 @@ literal_pattern_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 524)) // token='True' ) { - D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -6096,7 +6276,7 @@ literal_pattern_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'False' @@ -6104,13 +6284,13 @@ literal_pattern_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( (_keyword = _PyPegen_expect_token(p, 525)) // token='False' ) { - D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -6129,7 +6309,7 @@ literal_pattern_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } _res = NULL; @@ -6138,6 +6318,110 @@ literal_pattern_rule(Parser *p) return _res; } +// complex_number: signed_number '+' imaginary_number | signed_number '-' imaginary_number +static expr_ty +complex_number_rule(Parser *p) +{ + D(p->level++); + if (p->error_indicator) { + D(p->level--); + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // signed_number '+' imaginary_number + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number '+' imaginary_number")); + Token * _literal; + expr_ty imag; + expr_ty real; + if ( + (real = signed_number_rule(p)) // signed_number + && + (_literal = _PyPegen_expect_token(p, 14)) // token='+' + && + (imag = imaginary_number_rule(p)) // imaginary_number + ) + { + D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number '+' imaginary_number")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_BinOp ( real , Add , imag , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number '+' imaginary_number")); + } + { // signed_number '-' imaginary_number + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number '-' imaginary_number")); + Token * _literal; + expr_ty imag; + expr_ty real; + if ( + (real = signed_number_rule(p)) // signed_number + && + (_literal = _PyPegen_expect_token(p, 15)) // token='-' + && + (imag = imaginary_number_rule(p)) // imaginary_number + ) + { + D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number '-' imaginary_number")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_BinOp ( real , Sub , imag , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number '-' imaginary_number")); + } + _res = NULL; + done: + D(p->level--); + return _res; +} + // signed_number: NUMBER | '-' NUMBER static expr_ty signed_number_rule(Parser *p) @@ -6219,8 +6503,49 @@ signed_number_rule(Parser *p) return _res; } -// capture_pattern: !"_" NAME !('.' | '(' | '=') +// imaginary_number: NUMBER static expr_ty +imaginary_number_rule(Parser *p) +{ + D(p->level++); + if (p->error_indicator) { + D(p->level--); + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + { // NUMBER + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> imaginary_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); + expr_ty imag; + if ( + (imag = _PyPegen_number_token(p)) // NUMBER + ) + { + D(fprintf(stderr, "%*c+ imaginary_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); + _res = _PyPegen_ensure_imaginary ( p , imag ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s imaginary_number[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); + } + _res = NULL; + done: + D(p->level--); + return _res; +} + +// capture_pattern: pattern_capture_target +static pattern_ty capture_pattern_rule(Parser *p) { D(p->level++); @@ -6228,6 +6553,65 @@ capture_pattern_rule(Parser *p) D(p->level--); return NULL; } + pattern_ty _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro + { // pattern_capture_target + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern_capture_target")); + expr_ty target; + if ( + (target = pattern_capture_target_rule(p)) // pattern_capture_target + ) + { + D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern_capture_target")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s capture_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern_capture_target")); + } + _res = NULL; + done: + D(p->level--); + return _res; +} + +// pattern_capture_target: !"_" NAME !('.' | '(' | '=') +static expr_ty +pattern_capture_target_rule(Parser *p) +{ + D(p->level++); + if (p->error_indicator) { + D(p->level--); + return NULL; + } expr_ty _res = NULL; int _mark = p->mark; { // !"_" NAME !('.' | '(' | '=') @@ -6235,17 +6619,17 @@ capture_pattern_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); + D(fprintf(stderr, "%*c> pattern_capture_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); expr_ty name; if ( _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_") && (name = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(0, _tmp_54_rule, p) + _PyPegen_lookahead(0, _tmp_55_rule, p) ) { - D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); + D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); _res = _PyPegen_set_expr_context ( p , name , Store ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -6255,7 +6639,7 @@ capture_pattern_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s capture_pattern[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s pattern_capture_target[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); } _res = NULL; @@ -6265,7 +6649,7 @@ capture_pattern_rule(Parser *p) } // wildcard_pattern: "_" -static expr_ty +static pattern_ty wildcard_pattern_rule(Parser *p) { D(p->level++); @@ -6273,7 +6657,7 @@ wildcard_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -6305,7 +6689,7 @@ wildcard_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Name ( CHECK ( PyObject * , _PyPegen_new_identifier ( p , "_" ) ) , Store , EXTRA ); + _res = _PyAST_MatchAs ( NULL , NULL , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6324,7 +6708,7 @@ wildcard_pattern_rule(Parser *p) } // value_pattern: attr !('.' | '(' | '=') -static expr_ty +static pattern_ty value_pattern_rule(Parser *p) { D(p->level++); @@ -6332,8 +6716,17 @@ value_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + UNUSED(_start_lineno); // Only used by EXTRA macro + int _start_col_offset = p->tokens[_mark]->col_offset; + UNUSED(_start_col_offset); // Only used by EXTRA macro { // attr !('.' | '(' | '=') if (p->error_indicator) { D(p->level--); @@ -6344,11 +6737,20 @@ value_pattern_rule(Parser *p) if ( (attr = attr_rule(p)) // attr && - _PyPegen_lookahead(0, _tmp_55_rule, p) + _PyPegen_lookahead(0, _tmp_56_rule, p) ) { D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')")); - _res = attr; + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchValue ( attr , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6520,7 +6922,7 @@ name_or_attr_rule(Parser *p) } // group_pattern: '(' pattern ')' -static expr_ty +static pattern_ty group_pattern_rule(Parser *p) { D(p->level++); @@ -6528,7 +6930,7 @@ group_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; { // '(' pattern ')' if (p->error_indicator) { @@ -6538,7 +6940,7 @@ group_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> group_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' pattern ')'")); Token * _literal; Token * _literal_1; - expr_ty pattern; + pattern_ty pattern; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -6567,7 +6969,7 @@ group_pattern_rule(Parser *p) } // sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')' -static expr_ty +static pattern_ty sequence_pattern_rule(Parser *p) { D(p->level++); @@ -6575,7 +6977,7 @@ sequence_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -6594,11 +6996,11 @@ sequence_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'")); Token * _literal; Token * _literal_1; - void *values; + void *patterns; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' && - (values = maybe_sequence_pattern_rule(p), 1) // maybe_sequence_pattern? + (patterns = maybe_sequence_pattern_rule(p), 1) // maybe_sequence_pattern? && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' ) @@ -6613,7 +7015,7 @@ sequence_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_List ( values , Load , EXTRA ); + _res = _PyAST_MatchSequence ( patterns , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6633,11 +7035,11 @@ sequence_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' open_sequence_pattern? ')'")); Token * _literal; Token * _literal_1; - void *values; + void *patterns; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (values = open_sequence_pattern_rule(p), 1) // open_sequence_pattern? + (patterns = open_sequence_pattern_rule(p), 1) // open_sequence_pattern? && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -6652,7 +7054,7 @@ sequence_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Tuple ( values , Load , EXTRA ); + _res = _PyAST_MatchSequence ( patterns , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6688,18 +7090,18 @@ open_sequence_pattern_rule(Parser *p) } D(fprintf(stderr, "%*c> open_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?")); Token * _literal; - expr_ty value; - void *values; + pattern_ty pattern; + void *patterns; if ( - (value = maybe_star_pattern_rule(p)) // maybe_star_pattern + (pattern = maybe_star_pattern_rule(p)) // maybe_star_pattern && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (values = maybe_sequence_pattern_rule(p), 1) // maybe_sequence_pattern? + (patterns = maybe_sequence_pattern_rule(p), 1) // maybe_sequence_pattern? ) { D(fprintf(stderr, "%*c+ open_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?")); - _res = _PyPegen_seq_insert_in_front ( p , value , values ); + _res = _PyPegen_seq_insert_in_front ( p , pattern , patterns ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6736,15 +7138,15 @@ maybe_sequence_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> maybe_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - asdl_seq * values; + asdl_seq * patterns; if ( - (values = _gather_56_rule(p)) // ','.maybe_star_pattern+ + (patterns = _gather_57_rule(p)) // ','.maybe_star_pattern+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) { D(fprintf(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?")); - _res = values; + _res = patterns; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6763,7 +7165,7 @@ maybe_sequence_pattern_rule(Parser *p) } // maybe_star_pattern: star_pattern | pattern -static expr_ty +static pattern_ty maybe_star_pattern_rule(Parser *p) { D(p->level++); @@ -6771,7 +7173,7 @@ maybe_star_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; { // star_pattern if (p->error_indicator) { @@ -6779,7 +7181,7 @@ maybe_star_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_pattern")); - expr_ty star_pattern_var; + pattern_ty star_pattern_var; if ( (star_pattern_var = star_pattern_rule(p)) // star_pattern ) @@ -6798,7 +7200,7 @@ maybe_star_pattern_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern")); - expr_ty pattern_var; + pattern_ty pattern_var; if ( (pattern_var = pattern_rule(p)) // pattern ) @@ -6817,8 +7219,8 @@ maybe_star_pattern_rule(Parser *p) return _res; } -// star_pattern: '*' (capture_pattern | wildcard_pattern) -static expr_ty +// star_pattern: '*' pattern_capture_target | '*' wildcard_pattern +static pattern_ty star_pattern_rule(Parser *p) { D(p->level++); @@ -6826,7 +7228,7 @@ star_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -6837,21 +7239,57 @@ star_pattern_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // '*' (capture_pattern | wildcard_pattern) + { // '*' pattern_capture_target if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (capture_pattern | wildcard_pattern)")); + D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target")); Token * _literal; - void *value; + expr_ty target; + if ( + (_literal = _PyPegen_expect_token(p, 16)) // token='*' + && + (target = pattern_capture_target_rule(p)) // pattern_capture_target + ) + { + D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchStar ( target -> v . Name . id , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' pattern_capture_target")); + } + { // '*' wildcard_pattern + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern")); + Token * _literal; + pattern_ty wildcard_pattern_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (value = _tmp_58_rule(p)) // capture_pattern | wildcard_pattern + (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern ) { - D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (capture_pattern | wildcard_pattern)")); + D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -6861,7 +7299,7 @@ star_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Starred ( value , Store , EXTRA ); + _res = _PyAST_MatchStar ( NULL , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6871,7 +7309,7 @@ star_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (capture_pattern | wildcard_pattern)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' wildcard_pattern")); } _res = NULL; done: @@ -6879,8 +7317,12 @@ star_pattern_rule(Parser *p) return _res; } -// mapping_pattern: '{' items_pattern? '}' -static expr_ty +// mapping_pattern: +// | '{' '}' +// | '{' double_star_pattern ','? '}' +// | '{' items_pattern ',' double_star_pattern ','? '}' +// | '{' items_pattern ','? '}' +static pattern_ty mapping_pattern_rule(Parser *p) { D(p->level++); @@ -6888,7 +7330,7 @@ mapping_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -6899,24 +7341,156 @@ mapping_pattern_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // '{' items_pattern? '}' + { // '{' '}' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'")); + Token * _literal; + Token * _literal_1; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchMapping ( NULL , NULL , NULL , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'")); + } + { // '{' double_star_pattern ','? '}' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'")); + Token * _literal; + Token * _literal_1; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + expr_ty rest; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (rest = double_star_pattern_rule(p)) // double_star_pattern + && + (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? + && + (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchMapping ( NULL , NULL , rest -> v . Name . id , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_star_pattern ','? '}'")); + } + { // '{' items_pattern ',' double_star_pattern ','? '}' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'")); + Token * _literal; + Token * _literal_1; + Token * _literal_2; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_seq* items; + expr_ty rest; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (items = items_pattern_rule(p)) // items_pattern + && + (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' + && + (rest = double_star_pattern_rule(p)) // double_star_pattern + && + (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? + && + (_literal_2 = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + D(p->level--); + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_MatchMapping ( CHECK ( asdl_expr_seq * , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq * , _PyPegen_get_patterns ( p , items ) ) , rest -> v . Name . id , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + D(p->level--); + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'")); + } + { // '{' items_pattern ','? '}' if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern? '}'")); + D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'")); Token * _literal; Token * _literal_1; - void *items; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_seq* items; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (items = items_pattern_rule(p), 1) // items_pattern? + (items = items_pattern_rule(p)) // items_pattern + && + (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? && (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern? '}'")); + D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { D(p->level--); @@ -6926,7 +7500,7 @@ mapping_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Dict ( CHECK ( asdl_expr_seq * , _PyPegen_get_keys ( p , items ) ) , CHECK ( asdl_expr_seq * , _PyPegen_get_values ( p , items ) ) , EXTRA ); + _res = _PyAST_MatchMapping ( CHECK ( asdl_expr_seq * , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq * , _PyPegen_get_patterns ( p , items ) ) , NULL , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -6936,7 +7510,7 @@ mapping_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern? '}'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ','? '}'")); } _res = NULL; done: @@ -6944,7 +7518,7 @@ mapping_pattern_rule(Parser *p) return _res; } -// items_pattern: ','.key_value_pattern+ ','? +// items_pattern: ','.key_value_pattern+ static asdl_seq* items_pattern_rule(Parser *p) { @@ -6955,22 +7529,18 @@ items_pattern_rule(Parser *p) } asdl_seq* _res = NULL; int _mark = p->mark; - { // ','.key_value_pattern+ ','? + { // ','.key_value_pattern+ if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+ ','?")); - void *_opt_var; - UNUSED(_opt_var); // Silence compiler warnings + D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+")); asdl_seq * items; if ( (items = _gather_59_rule(p)) // ','.key_value_pattern+ - && - (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) { - D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+ ','?")); + D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+")); _res = items; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -6981,7 +7551,7 @@ items_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s items_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.key_value_pattern+ ','?")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.key_value_pattern+")); } _res = NULL; done: @@ -6989,8 +7559,8 @@ items_pattern_rule(Parser *p) return _res; } -// key_value_pattern: (literal_pattern | value_pattern) ':' pattern | double_star_pattern -static KeyValuePair* +// key_value_pattern: (literal_expr | attr) ':' pattern +static KeyPatternPair* key_value_pattern_rule(Parser *p) { D(p->level++); @@ -6998,27 +7568,27 @@ key_value_pattern_rule(Parser *p) D(p->level--); return NULL; } - KeyValuePair* _res = NULL; + KeyPatternPair* _res = NULL; int _mark = p->mark; - { // (literal_pattern | value_pattern) ':' pattern + { // (literal_expr | attr) ':' pattern if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(literal_pattern | value_pattern) ':' pattern")); + D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(literal_expr | attr) ':' pattern")); Token * _literal; void *key; - expr_ty value; + pattern_ty pattern; if ( - (key = _tmp_61_rule(p)) // literal_pattern | value_pattern + (key = _tmp_61_rule(p)) // literal_expr | attr && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (value = pattern_rule(p)) // pattern + (pattern = pattern_rule(p)) // pattern ) { - D(fprintf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(literal_pattern | value_pattern) ':' pattern")); - _res = _PyPegen_key_value_pair ( p , key , value ); + D(fprintf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(literal_expr | attr) ':' pattern")); + _res = _PyPegen_key_pattern_pair ( p , key , pattern ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -7028,26 +7598,7 @@ key_value_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s key_value_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(literal_pattern | value_pattern) ':' pattern")); - } - { // double_star_pattern - if (p->error_indicator) { - D(p->level--); - return NULL; - } - D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_star_pattern")); - KeyValuePair* double_star_pattern_var; - if ( - (double_star_pattern_var = double_star_pattern_rule(p)) // double_star_pattern - ) - { - D(fprintf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_star_pattern")); - _res = double_star_pattern_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s key_value_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_star_pattern")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(literal_expr | attr) ':' pattern")); } _res = NULL; done: @@ -7055,8 +7606,8 @@ key_value_pattern_rule(Parser *p) return _res; } -// double_star_pattern: '**' capture_pattern -static KeyValuePair* +// double_star_pattern: '**' pattern_capture_target +static expr_ty double_star_pattern_rule(Parser *p) { D(p->level++); @@ -7064,24 +7615,24 @@ double_star_pattern_rule(Parser *p) D(p->level--); return NULL; } - KeyValuePair* _res = NULL; + expr_ty _res = NULL; int _mark = p->mark; - { // '**' capture_pattern + { // '**' pattern_capture_target if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> double_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' capture_pattern")); + D(fprintf(stderr, "%*c> double_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' pattern_capture_target")); Token * _literal; - expr_ty value; + expr_ty target; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' && - (value = capture_pattern_rule(p)) // capture_pattern + (target = pattern_capture_target_rule(p)) // pattern_capture_target ) { - D(fprintf(stderr, "%*c+ double_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' capture_pattern")); - _res = _PyPegen_key_value_pair ( p , NULL , value ); + D(fprintf(stderr, "%*c+ double_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' pattern_capture_target")); + _res = target; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -7091,7 +7642,7 @@ double_star_pattern_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s double_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' capture_pattern")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' pattern_capture_target")); } _res = NULL; done: @@ -7104,7 +7655,7 @@ double_star_pattern_rule(Parser *p) // | name_or_attr '(' positional_patterns ','? ')' // | name_or_attr '(' keyword_patterns ','? ')' // | name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')' -static expr_ty +static pattern_ty class_pattern_rule(Parser *p) { D(p->level++); @@ -7112,7 +7663,7 @@ class_pattern_rule(Parser *p) D(p->level--); return NULL; } - expr_ty _res = NULL; + pattern_ty _res = NULL; int _mark = p->mark; if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { p->error_indicator = 1; @@ -7131,9 +7682,9 @@ class_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' ')'")); Token * _literal; Token * _literal_1; - expr_ty func; + expr_ty cls; if ( - (func = name_or_attr_rule(p)) // name_or_attr + (cls = name_or_attr_rule(p)) // name_or_attr && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -7150,7 +7701,7 @@ class_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Call ( func , NULL , NULL , EXTRA ); + _res = _PyAST_MatchClass ( cls , NULL , NULL , NULL , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -7172,14 +7723,14 @@ class_pattern_rule(Parser *p) Token * _literal_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - asdl_expr_seq* args; - expr_ty func; + expr_ty cls; + asdl_pattern_seq* patterns; if ( - (func = name_or_attr_rule(p)) // name_or_attr + (cls = name_or_attr_rule(p)) // name_or_attr && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (args = positional_patterns_rule(p)) // positional_patterns + (patterns = positional_patterns_rule(p)) // positional_patterns && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? && @@ -7196,7 +7747,7 @@ class_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Call ( func , args , NULL , EXTRA ); + _res = _PyAST_MatchClass ( cls , patterns , NULL , NULL , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -7218,10 +7769,10 @@ class_pattern_rule(Parser *p) Token * _literal_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - expr_ty func; - asdl_keyword_seq* keywords; + expr_ty cls; + asdl_seq* keywords; if ( - (func = name_or_attr_rule(p)) // name_or_attr + (cls = name_or_attr_rule(p)) // name_or_attr && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -7242,7 +7793,7 @@ class_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Call ( func , NULL , keywords , EXTRA ); + _res = _PyAST_MatchClass ( cls , NULL , CHECK ( asdl_identifier_seq * , _PyPegen_map_names_to_ids ( p , CHECK ( asdl_expr_seq * , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( asdl_pattern_seq * , _PyPegen_get_patterns ( p , keywords ) ) , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -7265,15 +7816,15 @@ class_pattern_rule(Parser *p) Token * _literal_2; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - asdl_expr_seq* args; - expr_ty func; - asdl_keyword_seq* keywords; + expr_ty cls; + asdl_seq* keywords; + asdl_pattern_seq* patterns; if ( - (func = name_or_attr_rule(p)) // name_or_attr + (cls = name_or_attr_rule(p)) // name_or_attr && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (args = positional_patterns_rule(p)) // positional_patterns + (patterns = positional_patterns_rule(p)) // positional_patterns && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && @@ -7294,7 +7845,7 @@ class_pattern_rule(Parser *p) UNUSED(_end_lineno); // Only used by EXTRA macro int _end_col_offset = _token->end_col_offset; UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_Call ( func , args , keywords , EXTRA ); + _res = _PyAST_MatchClass ( cls , patterns , CHECK ( asdl_identifier_seq * , _PyPegen_map_names_to_ids ( p , CHECK ( asdl_expr_seq * , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( asdl_pattern_seq * , _PyPegen_get_patterns ( p , keywords ) ) , EXTRA ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -7313,7 +7864,7 @@ class_pattern_rule(Parser *p) } // positional_patterns: ','.pattern+ -static asdl_expr_seq* +static asdl_pattern_seq* positional_patterns_rule(Parser *p) { D(p->level++); @@ -7321,7 +7872,7 @@ positional_patterns_rule(Parser *p) D(p->level--); return NULL; } - asdl_expr_seq* _res = NULL; + asdl_pattern_seq* _res = NULL; int _mark = p->mark; { // ','.pattern+ if (p->error_indicator) { @@ -7329,9 +7880,9 @@ positional_patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pattern+")); - asdl_expr_seq* args; + asdl_pattern_seq* args; if ( - (args = (asdl_expr_seq*)_gather_62_rule(p)) // ','.pattern+ + (args = (asdl_pattern_seq*)_gather_62_rule(p)) // ','.pattern+ ) { D(fprintf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.pattern+")); @@ -7354,7 +7905,7 @@ positional_patterns_rule(Parser *p) } // keyword_patterns: ','.keyword_pattern+ -static asdl_keyword_seq* +static asdl_seq* keyword_patterns_rule(Parser *p) { D(p->level++); @@ -7362,7 +7913,7 @@ keyword_patterns_rule(Parser *p) D(p->level--); return NULL; } - asdl_keyword_seq* _res = NULL; + asdl_seq* _res = NULL; int _mark = p->mark; { // ','.keyword_pattern+ if (p->error_indicator) { @@ -7370,9 +7921,9 @@ keyword_patterns_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+")); - asdl_keyword_seq* keywords; + asdl_seq* keywords; if ( - (keywords = (asdl_keyword_seq*)_gather_64_rule(p)) // ','.keyword_pattern+ + (keywords = (asdl_seq*)_gather_64_rule(p)) // ','.keyword_pattern+ ) { D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+")); @@ -7395,7 +7946,7 @@ keyword_patterns_rule(Parser *p) } // keyword_pattern: NAME '=' pattern -static keyword_ty +static KeyPatternPair* keyword_pattern_rule(Parser *p) { D(p->level++); @@ -7403,17 +7954,8 @@ keyword_pattern_rule(Parser *p) D(p->level--); return NULL; } - keyword_ty _res = NULL; + KeyPatternPair* _res = NULL; int _mark = p->mark; - if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { - p->error_indicator = 1; - D(p->level--); - return NULL; - } - int _start_lineno = p->tokens[_mark]->lineno; - UNUSED(_start_lineno); // Only used by EXTRA macro - int _start_col_offset = p->tokens[_mark]->col_offset; - UNUSED(_start_col_offset); // Only used by EXTRA macro { // NAME '=' pattern if (p->error_indicator) { D(p->level--); @@ -7422,7 +7964,7 @@ keyword_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> keyword_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern")); Token * _literal; expr_ty arg; - expr_ty value; + pattern_ty value; if ( (arg = _PyPegen_name_token(p)) // NAME && @@ -7432,16 +7974,7 @@ keyword_pattern_rule(Parser *p) ) { D(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern")); - Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); - if (_token == NULL) { - D(p->level--); - return NULL; - } - int _end_lineno = _token->end_lineno; - UNUSED(_end_lineno); // Only used by EXTRA macro - int _end_col_offset = _token->end_col_offset; - UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_keyword ( arg -> v . Name . id , value , EXTRA ); + _res = _PyPegen_key_pattern_pair ( p , arg , value ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; D(p->level--); @@ -19650,7 +20183,7 @@ invalid_case_block_rule(Parser *p) expr_ty _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - expr_ty patterns_var; + pattern_ty patterns_var; if ( (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' && @@ -19685,7 +20218,7 @@ invalid_case_block_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings expr_ty a; Token * newline_var; - expr_ty patterns_var; + pattern_ty patterns_var; if ( (a = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' && @@ -23345,7 +23878,7 @@ _loop0_52_rule(Parser *p) } D(fprintf(stderr, "%*c> _loop0_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|' closed_pattern")); Token * _literal; - expr_ty elem; + pattern_ty elem; while ( (_literal = _PyPegen_expect_token(p, 18)) // token='|' && @@ -23409,7 +23942,7 @@ _gather_51_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _gather_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_52")); - expr_ty elem; + pattern_ty elem; asdl_seq * seq; if ( (elem = closed_pattern_rule(p)) // closed_pattern @@ -23486,7 +24019,7 @@ _tmp_53_rule(Parser *p) return _res; } -// _tmp_54: '.' | '(' | '=' +// _tmp_54: '+' | '-' static void * _tmp_54_rule(Parser *p) { @@ -23497,23 +24030,78 @@ _tmp_54_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + { // '+' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 14)) // token='+' + ) + { + D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); + } + { // '-' + if (p->error_indicator) { + D(p->level--); + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 15)) // token='-' + ) + { + D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); + } + _res = NULL; + done: + D(p->level--); + return _res; +} + +// _tmp_55: '.' | '(' | '=' +static void * +_tmp_55_rule(Parser *p) +{ + D(p->level++); + if (p->error_indicator) { + D(p->level--); + return NULL; + } + void * _res = NULL; + int _mark = p->mark; { // '.' if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } { // '(' @@ -23521,18 +24109,18 @@ _tmp_54_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); } { // '=' @@ -23540,18 +24128,18 @@ _tmp_54_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_54[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_54[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } _res = NULL; @@ -23560,9 +24148,9 @@ _tmp_54_rule(Parser *p) return _res; } -// _tmp_55: '.' | '(' | '=' +// _tmp_56: '.' | '(' | '=' static void * -_tmp_55_rule(Parser *p) +_tmp_56_rule(Parser *p) { D(p->level++); if (p->error_indicator) { @@ -23576,18 +24164,18 @@ _tmp_55_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c> _tmp_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_56[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } { // '(' @@ -23595,18 +24183,18 @@ _tmp_55_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c> _tmp_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); + D(fprintf(stderr, "%*c+ _tmp_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_56[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); } { // '=' @@ -23614,18 +24202,18 @@ _tmp_55_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_55[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_56[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } _res = NULL; @@ -23634,9 +24222,9 @@ _tmp_55_rule(Parser *p) return _res; } -// _loop0_57: ',' maybe_star_pattern +// _loop0_58: ',' maybe_star_pattern static asdl_seq * -_loop0_57_rule(Parser *p) +_loop0_58_rule(Parser *p) { D(p->level++); if (p->error_indicator) { @@ -23660,9 +24248,9 @@ _loop0_57_rule(Parser *p) D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _loop0_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pattern")); + D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pattern")); Token * _literal; - expr_ty elem; + pattern_ty elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -23691,7 +24279,7 @@ _loop0_57_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_57[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' maybe_star_pattern")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -23704,14 +24292,14 @@ _loop0_57_rule(Parser *p) } for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_57_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq); D(p->level--); return _seq; } -// _gather_56: maybe_star_pattern _loop0_57 +// _gather_57: maybe_star_pattern _loop0_58 static asdl_seq * -_gather_56_rule(Parser *p) +_gather_57_rule(Parser *p) { D(p->level++); if (p->error_indicator) { @@ -23720,82 +24308,27 @@ _gather_56_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // maybe_star_pattern _loop0_57 + { // maybe_star_pattern _loop0_58 if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _gather_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_57")); - expr_ty elem; + D(fprintf(stderr, "%*c> _gather_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_58")); + pattern_ty elem; asdl_seq * seq; if ( (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern && - (seq = _loop0_57_rule(p)) // _loop0_57 + (seq = _loop0_58_rule(p)) // _loop0_58 ) { - D(fprintf(stderr, "%*c+ _gather_56[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_57")); + D(fprintf(stderr, "%*c+ _gather_57[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_58")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_56[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_57")); - } - _res = NULL; - done: - D(p->level--); - return _res; -} - -// _tmp_58: capture_pattern | wildcard_pattern -static void * -_tmp_58_rule(Parser *p) -{ - D(p->level++); - if (p->error_indicator) { - D(p->level--); - return NULL; - } - void * _res = NULL; - int _mark = p->mark; - { // capture_pattern - if (p->error_indicator) { - D(p->level--); - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_pattern")); - expr_ty capture_pattern_var; - if ( - (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern - ) - { - D(fprintf(stderr, "%*c+ _tmp_58[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "capture_pattern")); - _res = capture_pattern_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_58[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern")); - } - { // wildcard_pattern - if (p->error_indicator) { - D(p->level--); - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pattern")); - expr_ty wildcard_pattern_var; - if ( - (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern - ) - { - D(fprintf(stderr, "%*c+ _tmp_58[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "wildcard_pattern")); - _res = wildcard_pattern_var; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_58[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern")); + D(fprintf(stderr, "%*c%s _gather_57[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_58")); } _res = NULL; done: @@ -23831,7 +24364,7 @@ _loop0_60_rule(Parser *p) } D(fprintf(stderr, "%*c> _loop0_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pattern")); Token * _literal; - KeyValuePair* elem; + KeyPatternPair* elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -23895,7 +24428,7 @@ _gather_59_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _gather_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_60")); - KeyValuePair* elem; + KeyPatternPair* elem; asdl_seq * seq; if ( (elem = key_value_pattern_rule(p)) // key_value_pattern @@ -23917,7 +24450,7 @@ _gather_59_rule(Parser *p) return _res; } -// _tmp_61: literal_pattern | value_pattern +// _tmp_61: literal_expr | attr static void * _tmp_61_rule(Parser *p) { @@ -23928,43 +24461,43 @@ _tmp_61_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // literal_pattern + { // literal_expr if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_pattern")); - expr_ty literal_pattern_var; + D(fprintf(stderr, "%*c> _tmp_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr")); + expr_ty literal_expr_var; if ( - (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern + (literal_expr_var = literal_expr_rule(p)) // literal_expr ) { - D(fprintf(stderr, "%*c+ _tmp_61[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_pattern")); - _res = literal_pattern_var; + D(fprintf(stderr, "%*c+ _tmp_61[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_expr")); + _res = literal_expr_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s _tmp_61[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr")); } - { // value_pattern + { // attr if (p->error_indicator) { D(p->level--); return NULL; } - D(fprintf(stderr, "%*c> _tmp_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_pattern")); - expr_ty value_pattern_var; + D(fprintf(stderr, "%*c> _tmp_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); + expr_ty attr_var; if ( - (value_pattern_var = value_pattern_rule(p)) // value_pattern + (attr_var = attr_rule(p)) // attr ) { - D(fprintf(stderr, "%*c+ _tmp_61[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "value_pattern")); - _res = value_pattern_var; + D(fprintf(stderr, "%*c+ _tmp_61[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr")); + _res = attr_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s _tmp_61[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); } _res = NULL; done: @@ -24000,7 +24533,7 @@ _loop0_63_rule(Parser *p) } D(fprintf(stderr, "%*c> _loop0_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern")); Token * _literal; - expr_ty elem; + pattern_ty elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24064,7 +24597,7 @@ _gather_62_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _gather_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_63")); - expr_ty elem; + pattern_ty elem; asdl_seq * seq; if ( (elem = pattern_rule(p)) // pattern @@ -24114,7 +24647,7 @@ _loop0_65_rule(Parser *p) } D(fprintf(stderr, "%*c> _loop0_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_pattern")); Token * _literal; - keyword_ty elem; + KeyPatternPair* elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -24178,7 +24711,7 @@ _gather_64_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _gather_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_65")); - keyword_ty elem; + KeyPatternPair* elem; asdl_seq * seq; if ( (elem = keyword_pattern_rule(p)) // keyword_pattern |