/home/mdboom/Work/builds/cpython/Parser/parser.c
Line | Count | Source (jump to first uncovered line) |
1 | // @generated by pegen from python.gram |
2 | #include "pegen.h" |
3 | |
4 | #if defined(Py_DEBUG) && defined(Py_BUILD_CORE) |
5 | # define D(x) if (p->debug) { x; } |
6 | #else |
7 | # define D(x) |
8 | #endif |
9 | |
10 | #ifdef __wasi__ |
11 | # define MAXSTACK 4000 |
12 | #else |
13 | # define MAXSTACK 6000 |
14 | #endif |
15 | static const int n_keyword_lists = 9; |
16 | static KeywordToken *reserved_keywords[] = { |
17 | (KeywordToken[]) {{NULL, -1}}, |
18 | (KeywordToken[]) {{NULL, -1}}, |
19 | (KeywordToken[]) { |
20 | {"if", 634}, |
21 | {"as", 632}, |
22 | {"in", 643}, |
23 | {"or", 574}, |
24 | {"is", 582}, |
25 | {NULL, -1}, |
26 | }, |
27 | (KeywordToken[]) { |
28 | {"del", 603}, |
29 | {"def", 644}, |
30 | {"for", 642}, |
31 | {"try", 618}, |
32 | {"and", 575}, |
33 | {"not", 581}, |
34 | {NULL, -1}, |
35 | }, |
36 | (KeywordToken[]) { |
37 | {"from", 572}, |
38 | {"pass", 504}, |
39 | {"with", 612}, |
40 | {"elif", 636}, |
41 | {"else", 637}, |
42 | {"None", 601}, |
43 | {"True", 600}, |
44 | {NULL, -1}, |
45 | }, |
46 | (KeywordToken[]) { |
47 | {"raise", 522}, |
48 | {"yield", 573}, |
49 | {"break", 508}, |
50 | {"class", 646}, |
51 | {"while", 639}, |
52 | {"False", 602}, |
53 | {NULL, -1}, |
54 | }, |
55 | (KeywordToken[]) { |
56 | {"return", 519}, |
57 | {"import", 531}, |
58 | {"assert", 526}, |
59 | {"global", 523}, |
60 | {"except", 629}, |
61 | {"lambda", 586}, |
62 | {NULL, -1}, |
63 | }, |
64 | (KeywordToken[]) { |
65 | {"finally", 625}, |
66 | {NULL, -1}, |
67 | }, |
68 | (KeywordToken[]) { |
69 | {"continue", 509}, |
70 | {"nonlocal", 524}, |
71 | {NULL, -1}, |
72 | }, |
73 | }; |
74 | static char *soft_keywords[] = { |
75 | "_", |
76 | "case", |
77 | "match", |
78 | NULL, |
79 | }; |
80 | #define file_type 1000 |
81 | #define interactive_type 1001 |
82 | #define eval_type 1002 |
83 | #define func_type_type 1003 |
84 | #define fstring_type 1004 |
85 | #define statements_type 1005 |
86 | #define statement_type 1006 |
87 | #define statement_newline_type 1007 |
88 | #define simple_stmts_type 1008 |
89 | #define simple_stmt_type 1009 |
90 | #define compound_stmt_type 1010 |
91 | #define assignment_type 1011 |
92 | #define annotated_rhs_type 1012 |
93 | #define augassign_type 1013 |
94 | #define return_stmt_type 1014 |
95 | #define raise_stmt_type 1015 |
96 | #define global_stmt_type 1016 |
97 | #define nonlocal_stmt_type 1017 |
98 | #define del_stmt_type 1018 |
99 | #define yield_stmt_type 1019 |
100 | #define assert_stmt_type 1020 |
101 | #define import_stmt_type 1021 |
102 | #define import_name_type 1022 |
103 | #define import_from_type 1023 |
104 | #define import_from_targets_type 1024 |
105 | #define import_from_as_names_type 1025 |
106 | #define import_from_as_name_type 1026 |
107 | #define dotted_as_names_type 1027 |
108 | #define dotted_as_name_type 1028 |
109 | #define dotted_name_type 1029 // Left-recursive |
110 | #define block_type 1030 |
111 | #define decorators_type 1031 |
112 | #define class_def_type 1032 |
113 | #define class_def_raw_type 1033 |
114 | #define function_def_type 1034 |
115 | #define function_def_raw_type 1035 |
116 | #define params_type 1036 |
117 | #define parameters_type 1037 |
118 | #define slash_no_default_type 1038 |
119 | #define slash_with_default_type 1039 |
120 | #define star_etc_type 1040 |
121 | #define kwds_type 1041 |
122 | #define param_no_default_type 1042 |
123 | #define param_no_default_star_annotation_type 1043 |
124 | #define param_with_default_type 1044 |
125 | #define param_maybe_default_type 1045 |
126 | #define param_type 1046 |
127 | #define param_star_annotation_type 1047 |
128 | #define annotation_type 1048 |
129 | #define star_annotation_type 1049 |
130 | #define default_type 1050 |
131 | #define if_stmt_type 1051 |
132 | #define elif_stmt_type 1052 |
133 | #define else_block_type 1053 |
134 | #define while_stmt_type 1054 |
135 | #define for_stmt_type 1055 |
136 | #define with_stmt_type 1056 |
137 | #define with_item_type 1057 |
138 | #define try_stmt_type 1058 |
139 | #define except_block_type 1059 |
140 | #define except_star_block_type 1060 |
141 | #define finally_block_type 1061 |
142 | #define match_stmt_type 1062 |
143 | #define subject_expr_type 1063 |
144 | #define case_block_type 1064 |
145 | #define guard_type 1065 |
146 | #define patterns_type 1066 |
147 | #define pattern_type 1067 |
148 | #define as_pattern_type 1068 |
149 | #define or_pattern_type 1069 |
150 | #define closed_pattern_type 1070 |
151 | #define literal_pattern_type 1071 |
152 | #define literal_expr_type 1072 |
153 | #define complex_number_type 1073 |
154 | #define signed_number_type 1074 |
155 | #define signed_real_number_type 1075 |
156 | #define real_number_type 1076 |
157 | #define imaginary_number_type 1077 |
158 | #define capture_pattern_type 1078 |
159 | #define pattern_capture_target_type 1079 |
160 | #define wildcard_pattern_type 1080 |
161 | #define value_pattern_type 1081 |
162 | #define attr_type 1082 // Left-recursive |
163 | #define name_or_attr_type 1083 // Left-recursive |
164 | #define group_pattern_type 1084 |
165 | #define sequence_pattern_type 1085 |
166 | #define open_sequence_pattern_type 1086 |
167 | #define maybe_sequence_pattern_type 1087 |
168 | #define maybe_star_pattern_type 1088 |
169 | #define star_pattern_type 1089 |
170 | #define mapping_pattern_type 1090 |
171 | #define items_pattern_type 1091 |
172 | #define key_value_pattern_type 1092 |
173 | #define double_star_pattern_type 1093 |
174 | #define class_pattern_type 1094 |
175 | #define positional_patterns_type 1095 |
176 | #define keyword_patterns_type 1096 |
177 | #define keyword_pattern_type 1097 |
178 | #define expressions_type 1098 |
179 | #define expression_type 1099 |
180 | #define yield_expr_type 1100 |
181 | #define star_expressions_type 1101 |
182 | #define star_expression_type 1102 |
183 | #define star_named_expressions_type 1103 |
184 | #define star_named_expression_type 1104 |
185 | #define assignment_expression_type 1105 |
186 | #define named_expression_type 1106 |
187 | #define disjunction_type 1107 |
188 | #define conjunction_type 1108 |
189 | #define inversion_type 1109 |
190 | #define comparison_type 1110 |
191 | #define compare_op_bitwise_or_pair_type 1111 |
192 | #define eq_bitwise_or_type 1112 |
193 | #define noteq_bitwise_or_type 1113 |
194 | #define lte_bitwise_or_type 1114 |
195 | #define lt_bitwise_or_type 1115 |
196 | #define gte_bitwise_or_type 1116 |
197 | #define gt_bitwise_or_type 1117 |
198 | #define notin_bitwise_or_type 1118 |
199 | #define in_bitwise_or_type 1119 |
200 | #define isnot_bitwise_or_type 1120 |
201 | #define is_bitwise_or_type 1121 |
202 | #define bitwise_or_type 1122 // Left-recursive |
203 | #define bitwise_xor_type 1123 // Left-recursive |
204 | #define bitwise_and_type 1124 // Left-recursive |
205 | #define shift_expr_type 1125 // Left-recursive |
206 | #define sum_type 1126 // Left-recursive |
207 | #define term_type 1127 // Left-recursive |
208 | #define factor_type 1128 |
209 | #define power_type 1129 |
210 | #define await_primary_type 1130 |
211 | #define primary_type 1131 // Left-recursive |
212 | #define slices_type 1132 |
213 | #define slice_type 1133 |
214 | #define atom_type 1134 |
215 | #define group_type 1135 |
216 | #define lambdef_type 1136 |
217 | #define lambda_params_type 1137 |
218 | #define lambda_parameters_type 1138 |
219 | #define lambda_slash_no_default_type 1139 |
220 | #define lambda_slash_with_default_type 1140 |
221 | #define lambda_star_etc_type 1141 |
222 | #define lambda_kwds_type 1142 |
223 | #define lambda_param_no_default_type 1143 |
224 | #define lambda_param_with_default_type 1144 |
225 | #define lambda_param_maybe_default_type 1145 |
226 | #define lambda_param_type 1146 |
227 | #define strings_type 1147 |
228 | #define list_type 1148 |
229 | #define tuple_type 1149 |
230 | #define set_type 1150 |
231 | #define dict_type 1151 |
232 | #define double_starred_kvpairs_type 1152 |
233 | #define double_starred_kvpair_type 1153 |
234 | #define kvpair_type 1154 |
235 | #define for_if_clauses_type 1155 |
236 | #define for_if_clause_type 1156 |
237 | #define listcomp_type 1157 |
238 | #define setcomp_type 1158 |
239 | #define genexp_type 1159 |
240 | #define dictcomp_type 1160 |
241 | #define arguments_type 1161 |
242 | #define args_type 1162 |
243 | #define kwargs_type 1163 |
244 | #define starred_expression_type 1164 |
245 | #define kwarg_or_starred_type 1165 |
246 | #define kwarg_or_double_starred_type 1166 |
247 | #define star_targets_type 1167 |
248 | #define star_targets_list_seq_type 1168 |
249 | #define star_targets_tuple_seq_type 1169 |
250 | #define star_target_type 1170 |
251 | #define target_with_star_atom_type 1171 |
252 | #define star_atom_type 1172 |
253 | #define single_target_type 1173 |
254 | #define single_subscript_attribute_target_type 1174 |
255 | #define t_primary_type 1175 // Left-recursive |
256 | #define t_lookahead_type 1176 |
257 | #define del_targets_type 1177 |
258 | #define del_target_type 1178 |
259 | #define del_t_atom_type 1179 |
260 | #define type_expressions_type 1180 |
261 | #define func_type_comment_type 1181 |
262 | #define invalid_arguments_type 1182 |
263 | #define invalid_kwarg_type 1183 |
264 | #define expression_without_invalid_type 1184 |
265 | #define invalid_legacy_expression_type 1185 |
266 | #define invalid_expression_type 1186 |
267 | #define invalid_named_expression_type 1187 |
268 | #define invalid_assignment_type 1188 |
269 | #define invalid_ann_assign_target_type 1189 |
270 | #define invalid_del_stmt_type 1190 |
271 | #define invalid_block_type 1191 |
272 | #define invalid_comprehension_type 1192 |
273 | #define invalid_dict_comprehension_type 1193 |
274 | #define invalid_parameters_type 1194 |
275 | #define invalid_default_type 1195 |
276 | #define invalid_star_etc_type 1196 |
277 | #define invalid_kwds_type 1197 |
278 | #define invalid_parameters_helper_type 1198 |
279 | #define invalid_lambda_parameters_type 1199 |
280 | #define invalid_lambda_parameters_helper_type 1200 |
281 | #define invalid_lambda_star_etc_type 1201 |
282 | #define invalid_lambda_kwds_type 1202 |
283 | #define invalid_double_type_comments_type 1203 |
284 | #define invalid_with_item_type 1204 |
285 | #define invalid_for_target_type 1205 |
286 | #define invalid_group_type 1206 |
287 | #define invalid_import_from_targets_type 1207 |
288 | #define invalid_with_stmt_type 1208 |
289 | #define invalid_with_stmt_indent_type 1209 |
290 | #define invalid_try_stmt_type 1210 |
291 | #define invalid_except_stmt_type 1211 |
292 | #define invalid_finally_stmt_type 1212 |
293 | #define invalid_except_stmt_indent_type 1213 |
294 | #define invalid_except_star_stmt_indent_type 1214 |
295 | #define invalid_match_stmt_type 1215 |
296 | #define invalid_case_block_type 1216 |
297 | #define invalid_as_pattern_type 1217 |
298 | #define invalid_class_pattern_type 1218 |
299 | #define invalid_class_argument_pattern_type 1219 |
300 | #define invalid_if_stmt_type 1220 |
301 | #define invalid_elif_stmt_type 1221 |
302 | #define invalid_else_stmt_type 1222 |
303 | #define invalid_while_stmt_type 1223 |
304 | #define invalid_for_stmt_type 1224 |
305 | #define invalid_def_raw_type 1225 |
306 | #define invalid_class_def_raw_type 1226 |
307 | #define invalid_double_starred_kvpairs_type 1227 |
308 | #define invalid_kvpair_type 1228 |
309 | #define _loop0_1_type 1229 |
310 | #define _loop0_2_type 1230 |
311 | #define _loop1_3_type 1231 |
312 | #define _loop0_5_type 1232 |
313 | #define _gather_4_type 1233 |
314 | #define _tmp_6_type 1234 |
315 | #define _tmp_7_type 1235 |
316 | #define _tmp_8_type 1236 |
317 | #define _tmp_9_type 1237 |
318 | #define _tmp_10_type 1238 |
319 | #define _tmp_11_type 1239 |
320 | #define _tmp_12_type 1240 |
321 | #define _tmp_13_type 1241 |
322 | #define _loop1_14_type 1242 |
323 | #define _tmp_15_type 1243 |
324 | #define _tmp_16_type 1244 |
325 | #define _tmp_17_type 1245 |
326 | #define _loop0_19_type 1246 |
327 | #define _gather_18_type 1247 |
328 | #define _loop0_21_type 1248 |
329 | #define _gather_20_type 1249 |
330 | #define _tmp_22_type 1250 |
331 | #define _tmp_23_type 1251 |
332 | #define _loop0_24_type 1252 |
333 | #define _loop1_25_type 1253 |
334 | #define _loop0_27_type 1254 |
335 | #define _gather_26_type 1255 |
336 | #define _tmp_28_type 1256 |
337 | #define _loop0_30_type 1257 |
338 | #define _gather_29_type 1258 |
339 | #define _tmp_31_type 1259 |
340 | #define _loop1_32_type 1260 |
341 | #define _tmp_33_type 1261 |
342 | #define _tmp_34_type 1262 |
343 | #define _tmp_35_type 1263 |
344 | #define _loop0_36_type 1264 |
345 | #define _loop0_37_type 1265 |
346 | #define _loop0_38_type 1266 |
347 | #define _loop1_39_type 1267 |
348 | #define _loop0_40_type 1268 |
349 | #define _loop1_41_type 1269 |
350 | #define _loop1_42_type 1270 |
351 | #define _loop1_43_type 1271 |
352 | #define _loop0_44_type 1272 |
353 | #define _loop1_45_type 1273 |
354 | #define _loop0_46_type 1274 |
355 | #define _loop1_47_type 1275 |
356 | #define _loop0_48_type 1276 |
357 | #define _loop0_49_type 1277 |
358 | #define _loop1_50_type 1278 |
359 | #define _loop0_52_type 1279 |
360 | #define _gather_51_type 1280 |
361 | #define _loop0_54_type 1281 |
362 | #define _gather_53_type 1282 |
363 | #define _loop0_56_type 1283 |
364 | #define _gather_55_type 1284 |
365 | #define _loop0_58_type 1285 |
366 | #define _gather_57_type 1286 |
367 | #define _tmp_59_type 1287 |
368 | #define _loop1_60_type 1288 |
369 | #define _loop1_61_type 1289 |
370 | #define _tmp_62_type 1290 |
371 | #define _tmp_63_type 1291 |
372 | #define _loop1_64_type 1292 |
373 | #define _loop0_66_type 1293 |
374 | #define _gather_65_type 1294 |
375 | #define _tmp_67_type 1295 |
376 | #define _tmp_68_type 1296 |
377 | #define _tmp_69_type 1297 |
378 | #define _tmp_70_type 1298 |
379 | #define _loop0_72_type 1299 |
380 | #define _gather_71_type 1300 |
381 | #define _loop0_74_type 1301 |
382 | #define _gather_73_type 1302 |
383 | #define _tmp_75_type 1303 |
384 | #define _loop0_77_type 1304 |
385 | #define _gather_76_type 1305 |
386 | #define _loop0_79_type 1306 |
387 | #define _gather_78_type 1307 |
388 | #define _loop1_80_type 1308 |
389 | #define _loop1_81_type 1309 |
390 | #define _loop0_83_type 1310 |
391 | #define _gather_82_type 1311 |
392 | #define _loop1_84_type 1312 |
393 | #define _loop1_85_type 1313 |
394 | #define _loop1_86_type 1314 |
395 | #define _tmp_87_type 1315 |
396 | #define _loop0_89_type 1316 |
397 | #define _gather_88_type 1317 |
398 | #define _tmp_90_type 1318 |
399 | #define _tmp_91_type 1319 |
400 | #define _tmp_92_type 1320 |
401 | #define _tmp_93_type 1321 |
402 | #define _tmp_94_type 1322 |
403 | #define _loop0_95_type 1323 |
404 | #define _loop0_96_type 1324 |
405 | #define _loop0_97_type 1325 |
406 | #define _loop1_98_type 1326 |
407 | #define _loop0_99_type 1327 |
408 | #define _loop1_100_type 1328 |
409 | #define _loop1_101_type 1329 |
410 | #define _loop1_102_type 1330 |
411 | #define _loop0_103_type 1331 |
412 | #define _loop1_104_type 1332 |
413 | #define _loop0_105_type 1333 |
414 | #define _loop1_106_type 1334 |
415 | #define _loop0_107_type 1335 |
416 | #define _loop1_108_type 1336 |
417 | #define _loop1_109_type 1337 |
418 | #define _tmp_110_type 1338 |
419 | #define _loop0_112_type 1339 |
420 | #define _gather_111_type 1340 |
421 | #define _loop1_113_type 1341 |
422 | #define _loop0_114_type 1342 |
423 | #define _loop0_115_type 1343 |
424 | #define _tmp_116_type 1344 |
425 | #define _loop0_118_type 1345 |
426 | #define _gather_117_type 1346 |
427 | #define _tmp_119_type 1347 |
428 | #define _loop0_121_type 1348 |
429 | #define _gather_120_type 1349 |
430 | #define _loop0_123_type 1350 |
431 | #define _gather_122_type 1351 |
432 | #define _loop0_125_type 1352 |
433 | #define _gather_124_type 1353 |
434 | #define _loop0_127_type 1354 |
435 | #define _gather_126_type 1355 |
436 | #define _loop0_128_type 1356 |
437 | #define _loop0_130_type 1357 |
438 | #define _gather_129_type 1358 |
439 | #define _loop1_131_type 1359 |
440 | #define _tmp_132_type 1360 |
441 | #define _loop0_134_type 1361 |
442 | #define _gather_133_type 1362 |
443 | #define _loop0_136_type 1363 |
444 | #define _gather_135_type 1364 |
445 | #define _loop0_138_type 1365 |
446 | #define _gather_137_type 1366 |
447 | #define _loop0_140_type 1367 |
448 | #define _gather_139_type 1368 |
449 | #define _loop0_142_type 1369 |
450 | #define _gather_141_type 1370 |
451 | #define _tmp_143_type 1371 |
452 | #define _tmp_144_type 1372 |
453 | #define _tmp_145_type 1373 |
454 | #define _tmp_146_type 1374 |
455 | #define _tmp_147_type 1375 |
456 | #define _tmp_148_type 1376 |
457 | #define _tmp_149_type 1377 |
458 | #define _tmp_150_type 1378 |
459 | #define _tmp_151_type 1379 |
460 | #define _loop0_152_type 1380 |
461 | #define _loop0_153_type 1381 |
462 | #define _loop0_154_type 1382 |
463 | #define _tmp_155_type 1383 |
464 | #define _tmp_156_type 1384 |
465 | #define _tmp_157_type 1385 |
466 | #define _tmp_158_type 1386 |
467 | #define _loop0_159_type 1387 |
468 | #define _loop0_160_type 1388 |
469 | #define _loop1_161_type 1389 |
470 | #define _tmp_162_type 1390 |
471 | #define _loop0_163_type 1391 |
472 | #define _tmp_164_type 1392 |
473 | #define _loop0_165_type 1393 |
474 | #define _tmp_166_type 1394 |
475 | #define _loop0_167_type 1395 |
476 | #define _loop1_168_type 1396 |
477 | #define _tmp_169_type 1397 |
478 | #define _tmp_170_type 1398 |
479 | #define _tmp_171_type 1399 |
480 | #define _loop0_172_type 1400 |
481 | #define _tmp_173_type 1401 |
482 | #define _tmp_174_type 1402 |
483 | #define _loop1_175_type 1403 |
484 | #define _loop0_176_type 1404 |
485 | #define _loop0_177_type 1405 |
486 | #define _loop0_179_type 1406 |
487 | #define _gather_178_type 1407 |
488 | #define _tmp_180_type 1408 |
489 | #define _loop0_181_type 1409 |
490 | #define _tmp_182_type 1410 |
491 | #define _loop0_183_type 1411 |
492 | #define _tmp_184_type 1412 |
493 | #define _loop0_185_type 1413 |
494 | #define _loop1_186_type 1414 |
495 | #define _loop1_187_type 1415 |
496 | #define _tmp_188_type 1416 |
497 | #define _tmp_189_type 1417 |
498 | #define _loop0_190_type 1418 |
499 | #define _tmp_191_type 1419 |
500 | #define _tmp_192_type 1420 |
501 | #define _tmp_193_type 1421 |
502 | #define _loop0_195_type 1422 |
503 | #define _gather_194_type 1423 |
504 | #define _loop0_197_type 1424 |
505 | #define _gather_196_type 1425 |
506 | #define _loop0_199_type 1426 |
507 | #define _gather_198_type 1427 |
508 | #define _loop0_201_type 1428 |
509 | #define _gather_200_type 1429 |
510 | #define _tmp_202_type 1430 |
511 | #define _loop0_203_type 1431 |
512 | #define _tmp_204_type 1432 |
513 | #define _loop0_205_type 1433 |
514 | #define _tmp_206_type 1434 |
515 | #define _tmp_207_type 1435 |
516 | #define _tmp_208_type 1436 |
517 | #define _tmp_209_type 1437 |
518 | #define _tmp_210_type 1438 |
519 | #define _tmp_211_type 1439 |
520 | #define _tmp_212_type 1440 |
521 | #define _tmp_213_type 1441 |
522 | #define _tmp_214_type 1442 |
523 | #define _loop0_216_type 1443 |
524 | #define _gather_215_type 1444 |
525 | #define _tmp_217_type 1445 |
526 | #define _tmp_218_type 1446 |
527 | #define _tmp_219_type 1447 |
528 | #define _tmp_220_type 1448 |
529 | #define _tmp_221_type 1449 |
530 | #define _tmp_222_type 1450 |
531 | #define _tmp_223_type 1451 |
532 | #define _tmp_224_type 1452 |
533 | #define _tmp_225_type 1453 |
534 | #define _tmp_226_type 1454 |
535 | #define _tmp_227_type 1455 |
536 | #define _tmp_228_type 1456 |
537 | #define _tmp_229_type 1457 |
538 | #define _tmp_230_type 1458 |
539 | #define _tmp_231_type 1459 |
540 | #define _tmp_232_type 1460 |
541 | #define _tmp_233_type 1461 |
542 | #define _tmp_234_type 1462 |
543 | #define _tmp_235_type 1463 |
544 | #define _tmp_236_type 1464 |
545 | #define _tmp_237_type 1465 |
546 | #define _tmp_238_type 1466 |
547 | #define _tmp_239_type 1467 |
548 | #define _tmp_240_type 1468 |
549 | #define _tmp_241_type 1469 |
550 | #define _tmp_242_type 1470 |
551 | #define _tmp_243_type 1471 |
552 | #define _tmp_244_type 1472 |
553 | #define _tmp_245_type 1473 |
554 | #define _tmp_246_type 1474 |
555 | #define _tmp_247_type 1475 |
556 | #define _loop1_248_type 1476 |
557 | #define _loop1_249_type 1477 |
558 | |
559 | static mod_ty file_rule(Parser *p); |
560 | static mod_ty interactive_rule(Parser *p); |
561 | static mod_ty eval_rule(Parser *p); |
562 | static mod_ty func_type_rule(Parser *p); |
563 | static expr_ty fstring_rule(Parser *p); |
564 | static asdl_stmt_seq* statements_rule(Parser *p); |
565 | static asdl_stmt_seq* statement_rule(Parser *p); |
566 | static asdl_stmt_seq* statement_newline_rule(Parser *p); |
567 | static asdl_stmt_seq* simple_stmts_rule(Parser *p); |
568 | static stmt_ty simple_stmt_rule(Parser *p); |
569 | static stmt_ty compound_stmt_rule(Parser *p); |
570 | static stmt_ty assignment_rule(Parser *p); |
571 | static expr_ty annotated_rhs_rule(Parser *p); |
572 | static AugOperator* augassign_rule(Parser *p); |
573 | static stmt_ty return_stmt_rule(Parser *p); |
574 | static stmt_ty raise_stmt_rule(Parser *p); |
575 | static stmt_ty global_stmt_rule(Parser *p); |
576 | static stmt_ty nonlocal_stmt_rule(Parser *p); |
577 | static stmt_ty del_stmt_rule(Parser *p); |
578 | static stmt_ty yield_stmt_rule(Parser *p); |
579 | static stmt_ty assert_stmt_rule(Parser *p); |
580 | static stmt_ty import_stmt_rule(Parser *p); |
581 | static stmt_ty import_name_rule(Parser *p); |
582 | static stmt_ty import_from_rule(Parser *p); |
583 | static asdl_alias_seq* import_from_targets_rule(Parser *p); |
584 | static asdl_alias_seq* import_from_as_names_rule(Parser *p); |
585 | static alias_ty import_from_as_name_rule(Parser *p); |
586 | static asdl_alias_seq* dotted_as_names_rule(Parser *p); |
587 | static alias_ty dotted_as_name_rule(Parser *p); |
588 | static expr_ty dotted_name_rule(Parser *p); |
589 | static asdl_stmt_seq* block_rule(Parser *p); |
590 | static asdl_expr_seq* decorators_rule(Parser *p); |
591 | static stmt_ty class_def_rule(Parser *p); |
592 | static stmt_ty class_def_raw_rule(Parser *p); |
593 | static stmt_ty function_def_rule(Parser *p); |
594 | static stmt_ty function_def_raw_rule(Parser *p); |
595 | static arguments_ty params_rule(Parser *p); |
596 | static arguments_ty parameters_rule(Parser *p); |
597 | static asdl_arg_seq* slash_no_default_rule(Parser *p); |
598 | static SlashWithDefault* slash_with_default_rule(Parser *p); |
599 | static StarEtc* star_etc_rule(Parser *p); |
600 | static arg_ty kwds_rule(Parser *p); |
601 | static arg_ty param_no_default_rule(Parser *p); |
602 | static arg_ty param_no_default_star_annotation_rule(Parser *p); |
603 | static NameDefaultPair* param_with_default_rule(Parser *p); |
604 | static NameDefaultPair* param_maybe_default_rule(Parser *p); |
605 | static arg_ty param_rule(Parser *p); |
606 | static arg_ty param_star_annotation_rule(Parser *p); |
607 | static expr_ty annotation_rule(Parser *p); |
608 | static expr_ty star_annotation_rule(Parser *p); |
609 | static expr_ty default_rule(Parser *p); |
610 | static stmt_ty if_stmt_rule(Parser *p); |
611 | static stmt_ty elif_stmt_rule(Parser *p); |
612 | static asdl_stmt_seq* else_block_rule(Parser *p); |
613 | static stmt_ty while_stmt_rule(Parser *p); |
614 | static stmt_ty for_stmt_rule(Parser *p); |
615 | static stmt_ty with_stmt_rule(Parser *p); |
616 | static withitem_ty with_item_rule(Parser *p); |
617 | static stmt_ty try_stmt_rule(Parser *p); |
618 | static excepthandler_ty except_block_rule(Parser *p); |
619 | static excepthandler_ty except_star_block_rule(Parser *p); |
620 | static asdl_stmt_seq* finally_block_rule(Parser *p); |
621 | static stmt_ty match_stmt_rule(Parser *p); |
622 | static expr_ty subject_expr_rule(Parser *p); |
623 | static match_case_ty case_block_rule(Parser *p); |
624 | static expr_ty guard_rule(Parser *p); |
625 | static pattern_ty patterns_rule(Parser *p); |
626 | static pattern_ty pattern_rule(Parser *p); |
627 | static pattern_ty as_pattern_rule(Parser *p); |
628 | static pattern_ty or_pattern_rule(Parser *p); |
629 | static pattern_ty closed_pattern_rule(Parser *p); |
630 | static pattern_ty literal_pattern_rule(Parser *p); |
631 | static expr_ty literal_expr_rule(Parser *p); |
632 | static expr_ty complex_number_rule(Parser *p); |
633 | static expr_ty signed_number_rule(Parser *p); |
634 | static expr_ty signed_real_number_rule(Parser *p); |
635 | static expr_ty real_number_rule(Parser *p); |
636 | static expr_ty imaginary_number_rule(Parser *p); |
637 | static pattern_ty capture_pattern_rule(Parser *p); |
638 | static expr_ty pattern_capture_target_rule(Parser *p); |
639 | static pattern_ty wildcard_pattern_rule(Parser *p); |
640 | static pattern_ty value_pattern_rule(Parser *p); |
641 | static expr_ty attr_rule(Parser *p); |
642 | static expr_ty name_or_attr_rule(Parser *p); |
643 | static pattern_ty group_pattern_rule(Parser *p); |
644 | static pattern_ty sequence_pattern_rule(Parser *p); |
645 | static asdl_seq* open_sequence_pattern_rule(Parser *p); |
646 | static asdl_seq* maybe_sequence_pattern_rule(Parser *p); |
647 | static pattern_ty maybe_star_pattern_rule(Parser *p); |
648 | static pattern_ty star_pattern_rule(Parser *p); |
649 | static pattern_ty mapping_pattern_rule(Parser *p); |
650 | static asdl_seq* items_pattern_rule(Parser *p); |
651 | static KeyPatternPair* key_value_pattern_rule(Parser *p); |
652 | static expr_ty double_star_pattern_rule(Parser *p); |
653 | static pattern_ty class_pattern_rule(Parser *p); |
654 | static asdl_pattern_seq* positional_patterns_rule(Parser *p); |
655 | static asdl_seq* keyword_patterns_rule(Parser *p); |
656 | static KeyPatternPair* keyword_pattern_rule(Parser *p); |
657 | static expr_ty expressions_rule(Parser *p); |
658 | static expr_ty expression_rule(Parser *p); |
659 | static expr_ty yield_expr_rule(Parser *p); |
660 | static expr_ty star_expressions_rule(Parser *p); |
661 | static expr_ty star_expression_rule(Parser *p); |
662 | static asdl_expr_seq* star_named_expressions_rule(Parser *p); |
663 | static expr_ty star_named_expression_rule(Parser *p); |
664 | static expr_ty assignment_expression_rule(Parser *p); |
665 | static expr_ty named_expression_rule(Parser *p); |
666 | static expr_ty disjunction_rule(Parser *p); |
667 | static expr_ty conjunction_rule(Parser *p); |
668 | static expr_ty inversion_rule(Parser *p); |
669 | static expr_ty comparison_rule(Parser *p); |
670 | static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p); |
671 | static CmpopExprPair* eq_bitwise_or_rule(Parser *p); |
672 | static CmpopExprPair* noteq_bitwise_or_rule(Parser *p); |
673 | static CmpopExprPair* lte_bitwise_or_rule(Parser *p); |
674 | static CmpopExprPair* lt_bitwise_or_rule(Parser *p); |
675 | static CmpopExprPair* gte_bitwise_or_rule(Parser *p); |
676 | static CmpopExprPair* gt_bitwise_or_rule(Parser *p); |
677 | static CmpopExprPair* notin_bitwise_or_rule(Parser *p); |
678 | static CmpopExprPair* in_bitwise_or_rule(Parser *p); |
679 | static CmpopExprPair* isnot_bitwise_or_rule(Parser *p); |
680 | static CmpopExprPair* is_bitwise_or_rule(Parser *p); |
681 | static expr_ty bitwise_or_rule(Parser *p); |
682 | static expr_ty bitwise_xor_rule(Parser *p); |
683 | static expr_ty bitwise_and_rule(Parser *p); |
684 | static expr_ty shift_expr_rule(Parser *p); |
685 | static expr_ty sum_rule(Parser *p); |
686 | static expr_ty term_rule(Parser *p); |
687 | static expr_ty factor_rule(Parser *p); |
688 | static expr_ty power_rule(Parser *p); |
689 | static expr_ty await_primary_rule(Parser *p); |
690 | static expr_ty primary_rule(Parser *p); |
691 | static expr_ty slices_rule(Parser *p); |
692 | static expr_ty slice_rule(Parser *p); |
693 | static expr_ty atom_rule(Parser *p); |
694 | static expr_ty group_rule(Parser *p); |
695 | static expr_ty lambdef_rule(Parser *p); |
696 | static arguments_ty lambda_params_rule(Parser *p); |
697 | static arguments_ty lambda_parameters_rule(Parser *p); |
698 | static asdl_arg_seq* lambda_slash_no_default_rule(Parser *p); |
699 | static SlashWithDefault* lambda_slash_with_default_rule(Parser *p); |
700 | static StarEtc* lambda_star_etc_rule(Parser *p); |
701 | static arg_ty lambda_kwds_rule(Parser *p); |
702 | static arg_ty lambda_param_no_default_rule(Parser *p); |
703 | static NameDefaultPair* lambda_param_with_default_rule(Parser *p); |
704 | static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p); |
705 | static arg_ty lambda_param_rule(Parser *p); |
706 | static expr_ty strings_rule(Parser *p); |
707 | static expr_ty list_rule(Parser *p); |
708 | static expr_ty tuple_rule(Parser *p); |
709 | static expr_ty set_rule(Parser *p); |
710 | static expr_ty dict_rule(Parser *p); |
711 | static asdl_seq* double_starred_kvpairs_rule(Parser *p); |
712 | static KeyValuePair* double_starred_kvpair_rule(Parser *p); |
713 | static KeyValuePair* kvpair_rule(Parser *p); |
714 | static asdl_comprehension_seq* for_if_clauses_rule(Parser *p); |
715 | static comprehension_ty for_if_clause_rule(Parser *p); |
716 | static expr_ty listcomp_rule(Parser *p); |
717 | static expr_ty setcomp_rule(Parser *p); |
718 | static expr_ty genexp_rule(Parser *p); |
719 | static expr_ty dictcomp_rule(Parser *p); |
720 | static expr_ty arguments_rule(Parser *p); |
721 | static expr_ty args_rule(Parser *p); |
722 | static asdl_seq* kwargs_rule(Parser *p); |
723 | static expr_ty starred_expression_rule(Parser *p); |
724 | static KeywordOrStarred* kwarg_or_starred_rule(Parser *p); |
725 | static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p); |
726 | static expr_ty star_targets_rule(Parser *p); |
727 | static asdl_expr_seq* star_targets_list_seq_rule(Parser *p); |
728 | static asdl_expr_seq* star_targets_tuple_seq_rule(Parser *p); |
729 | static expr_ty star_target_rule(Parser *p); |
730 | static expr_ty target_with_star_atom_rule(Parser *p); |
731 | static expr_ty star_atom_rule(Parser *p); |
732 | static expr_ty single_target_rule(Parser *p); |
733 | static expr_ty single_subscript_attribute_target_rule(Parser *p); |
734 | static expr_ty t_primary_rule(Parser *p); |
735 | static void *t_lookahead_rule(Parser *p); |
736 | static asdl_expr_seq* del_targets_rule(Parser *p); |
737 | static expr_ty del_target_rule(Parser *p); |
738 | static expr_ty del_t_atom_rule(Parser *p); |
739 | static asdl_expr_seq* type_expressions_rule(Parser *p); |
740 | static Token* func_type_comment_rule(Parser *p); |
741 | static void *invalid_arguments_rule(Parser *p); |
742 | static void *invalid_kwarg_rule(Parser *p); |
743 | static expr_ty expression_without_invalid_rule(Parser *p); |
744 | static void *invalid_legacy_expression_rule(Parser *p); |
745 | static void *invalid_expression_rule(Parser *p); |
746 | static void *invalid_named_expression_rule(Parser *p); |
747 | static void *invalid_assignment_rule(Parser *p); |
748 | static expr_ty invalid_ann_assign_target_rule(Parser *p); |
749 | static void *invalid_del_stmt_rule(Parser *p); |
750 | static void *invalid_block_rule(Parser *p); |
751 | static void *invalid_comprehension_rule(Parser *p); |
752 | static void *invalid_dict_comprehension_rule(Parser *p); |
753 | static void *invalid_parameters_rule(Parser *p); |
754 | static void *invalid_default_rule(Parser *p); |
755 | static void *invalid_star_etc_rule(Parser *p); |
756 | static void *invalid_kwds_rule(Parser *p); |
757 | static void *invalid_parameters_helper_rule(Parser *p); |
758 | static void *invalid_lambda_parameters_rule(Parser *p); |
759 | static void *invalid_lambda_parameters_helper_rule(Parser *p); |
760 | static void *invalid_lambda_star_etc_rule(Parser *p); |
761 | static void *invalid_lambda_kwds_rule(Parser *p); |
762 | static void *invalid_double_type_comments_rule(Parser *p); |
763 | static void *invalid_with_item_rule(Parser *p); |
764 | static void *invalid_for_target_rule(Parser *p); |
765 | static void *invalid_group_rule(Parser *p); |
766 | static void *invalid_import_from_targets_rule(Parser *p); |
767 | static void *invalid_with_stmt_rule(Parser *p); |
768 | static void *invalid_with_stmt_indent_rule(Parser *p); |
769 | static void *invalid_try_stmt_rule(Parser *p); |
770 | static void *invalid_except_stmt_rule(Parser *p); |
771 | static void *invalid_finally_stmt_rule(Parser *p); |
772 | static void *invalid_except_stmt_indent_rule(Parser *p); |
773 | static void *invalid_except_star_stmt_indent_rule(Parser *p); |
774 | static void *invalid_match_stmt_rule(Parser *p); |
775 | static void *invalid_case_block_rule(Parser *p); |
776 | static void *invalid_as_pattern_rule(Parser *p); |
777 | static void *invalid_class_pattern_rule(Parser *p); |
778 | static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p); |
779 | static void *invalid_if_stmt_rule(Parser *p); |
780 | static void *invalid_elif_stmt_rule(Parser *p); |
781 | static void *invalid_else_stmt_rule(Parser *p); |
782 | static void *invalid_while_stmt_rule(Parser *p); |
783 | static void *invalid_for_stmt_rule(Parser *p); |
784 | static void *invalid_def_raw_rule(Parser *p); |
785 | static void *invalid_class_def_raw_rule(Parser *p); |
786 | static void *invalid_double_starred_kvpairs_rule(Parser *p); |
787 | static void *invalid_kvpair_rule(Parser *p); |
788 | static asdl_seq *_loop0_1_rule(Parser *p); |
789 | static asdl_seq *_loop0_2_rule(Parser *p); |
790 | static asdl_seq *_loop1_3_rule(Parser *p); |
791 | static asdl_seq *_loop0_5_rule(Parser *p); |
792 | static asdl_seq *_gather_4_rule(Parser *p); |
793 | static void *_tmp_6_rule(Parser *p); |
794 | static void *_tmp_7_rule(Parser *p); |
795 | static void *_tmp_8_rule(Parser *p); |
796 | static void *_tmp_9_rule(Parser *p); |
797 | static void *_tmp_10_rule(Parser *p); |
798 | static void *_tmp_11_rule(Parser *p); |
799 | static void *_tmp_12_rule(Parser *p); |
800 | static void *_tmp_13_rule(Parser *p); |
801 | static asdl_seq *_loop1_14_rule(Parser *p); |
802 | static void *_tmp_15_rule(Parser *p); |
803 | static void *_tmp_16_rule(Parser *p); |
804 | static void *_tmp_17_rule(Parser *p); |
805 | static asdl_seq *_loop0_19_rule(Parser *p); |
806 | static asdl_seq *_gather_18_rule(Parser *p); |
807 | static asdl_seq *_loop0_21_rule(Parser *p); |
808 | static asdl_seq *_gather_20_rule(Parser *p); |
809 | static void *_tmp_22_rule(Parser *p); |
810 | static void *_tmp_23_rule(Parser *p); |
811 | static asdl_seq *_loop0_24_rule(Parser *p); |
812 | static asdl_seq *_loop1_25_rule(Parser *p); |
813 | static asdl_seq *_loop0_27_rule(Parser *p); |
814 | static asdl_seq *_gather_26_rule(Parser *p); |
815 | static void *_tmp_28_rule(Parser *p); |
816 | static asdl_seq *_loop0_30_rule(Parser *p); |
817 | static asdl_seq *_gather_29_rule(Parser *p); |
818 | static void *_tmp_31_rule(Parser *p); |
819 | static asdl_seq *_loop1_32_rule(Parser *p); |
820 | static void *_tmp_33_rule(Parser *p); |
821 | static void *_tmp_34_rule(Parser *p); |
822 | static void *_tmp_35_rule(Parser *p); |
823 | static asdl_seq *_loop0_36_rule(Parser *p); |
824 | static asdl_seq *_loop0_37_rule(Parser *p); |
825 | static asdl_seq *_loop0_38_rule(Parser *p); |
826 | static asdl_seq *_loop1_39_rule(Parser *p); |
827 | static asdl_seq *_loop0_40_rule(Parser *p); |
828 | static asdl_seq *_loop1_41_rule(Parser *p); |
829 | static asdl_seq *_loop1_42_rule(Parser *p); |
830 | static asdl_seq *_loop1_43_rule(Parser *p); |
831 | static asdl_seq *_loop0_44_rule(Parser *p); |
832 | static asdl_seq *_loop1_45_rule(Parser *p); |
833 | static asdl_seq *_loop0_46_rule(Parser *p); |
834 | static asdl_seq *_loop1_47_rule(Parser *p); |
835 | static asdl_seq *_loop0_48_rule(Parser *p); |
836 | static asdl_seq *_loop0_49_rule(Parser *p); |
837 | static asdl_seq *_loop1_50_rule(Parser *p); |
838 | static asdl_seq *_loop0_52_rule(Parser *p); |
839 | static asdl_seq *_gather_51_rule(Parser *p); |
840 | static asdl_seq *_loop0_54_rule(Parser *p); |
841 | static asdl_seq *_gather_53_rule(Parser *p); |
842 | static asdl_seq *_loop0_56_rule(Parser *p); |
843 | static asdl_seq *_gather_55_rule(Parser *p); |
844 | static asdl_seq *_loop0_58_rule(Parser *p); |
845 | static asdl_seq *_gather_57_rule(Parser *p); |
846 | static void *_tmp_59_rule(Parser *p); |
847 | static asdl_seq *_loop1_60_rule(Parser *p); |
848 | static asdl_seq *_loop1_61_rule(Parser *p); |
849 | static void *_tmp_62_rule(Parser *p); |
850 | static void *_tmp_63_rule(Parser *p); |
851 | static asdl_seq *_loop1_64_rule(Parser *p); |
852 | static asdl_seq *_loop0_66_rule(Parser *p); |
853 | static asdl_seq *_gather_65_rule(Parser *p); |
854 | static void *_tmp_67_rule(Parser *p); |
855 | static void *_tmp_68_rule(Parser *p); |
856 | static void *_tmp_69_rule(Parser *p); |
857 | static void *_tmp_70_rule(Parser *p); |
858 | static asdl_seq *_loop0_72_rule(Parser *p); |
859 | static asdl_seq *_gather_71_rule(Parser *p); |
860 | static asdl_seq *_loop0_74_rule(Parser *p); |
861 | static asdl_seq *_gather_73_rule(Parser *p); |
862 | static void *_tmp_75_rule(Parser *p); |
863 | static asdl_seq *_loop0_77_rule(Parser *p); |
864 | static asdl_seq *_gather_76_rule(Parser *p); |
865 | static asdl_seq *_loop0_79_rule(Parser *p); |
866 | static asdl_seq *_gather_78_rule(Parser *p); |
867 | static asdl_seq *_loop1_80_rule(Parser *p); |
868 | static asdl_seq *_loop1_81_rule(Parser *p); |
869 | static asdl_seq *_loop0_83_rule(Parser *p); |
870 | static asdl_seq *_gather_82_rule(Parser *p); |
871 | static asdl_seq *_loop1_84_rule(Parser *p); |
872 | static asdl_seq *_loop1_85_rule(Parser *p); |
873 | static asdl_seq *_loop1_86_rule(Parser *p); |
874 | static void *_tmp_87_rule(Parser *p); |
875 | static asdl_seq *_loop0_89_rule(Parser *p); |
876 | static asdl_seq *_gather_88_rule(Parser *p); |
877 | static void *_tmp_90_rule(Parser *p); |
878 | static void *_tmp_91_rule(Parser *p); |
879 | static void *_tmp_92_rule(Parser *p); |
880 | static void *_tmp_93_rule(Parser *p); |
881 | static void *_tmp_94_rule(Parser *p); |
882 | static asdl_seq *_loop0_95_rule(Parser *p); |
883 | static asdl_seq *_loop0_96_rule(Parser *p); |
884 | static asdl_seq *_loop0_97_rule(Parser *p); |
885 | static asdl_seq *_loop1_98_rule(Parser *p); |
886 | static asdl_seq *_loop0_99_rule(Parser *p); |
887 | static asdl_seq *_loop1_100_rule(Parser *p); |
888 | static asdl_seq *_loop1_101_rule(Parser *p); |
889 | static asdl_seq *_loop1_102_rule(Parser *p); |
890 | static asdl_seq *_loop0_103_rule(Parser *p); |
891 | static asdl_seq *_loop1_104_rule(Parser *p); |
892 | static asdl_seq *_loop0_105_rule(Parser *p); |
893 | static asdl_seq *_loop1_106_rule(Parser *p); |
894 | static asdl_seq *_loop0_107_rule(Parser *p); |
895 | static asdl_seq *_loop1_108_rule(Parser *p); |
896 | static asdl_seq *_loop1_109_rule(Parser *p); |
897 | static void *_tmp_110_rule(Parser *p); |
898 | static asdl_seq *_loop0_112_rule(Parser *p); |
899 | static asdl_seq *_gather_111_rule(Parser *p); |
900 | static asdl_seq *_loop1_113_rule(Parser *p); |
901 | static asdl_seq *_loop0_114_rule(Parser *p); |
902 | static asdl_seq *_loop0_115_rule(Parser *p); |
903 | static void *_tmp_116_rule(Parser *p); |
904 | static asdl_seq *_loop0_118_rule(Parser *p); |
905 | static asdl_seq *_gather_117_rule(Parser *p); |
906 | static void *_tmp_119_rule(Parser *p); |
907 | static asdl_seq *_loop0_121_rule(Parser *p); |
908 | static asdl_seq *_gather_120_rule(Parser *p); |
909 | static asdl_seq *_loop0_123_rule(Parser *p); |
910 | static asdl_seq *_gather_122_rule(Parser *p); |
911 | static asdl_seq *_loop0_125_rule(Parser *p); |
912 | static asdl_seq *_gather_124_rule(Parser *p); |
913 | static asdl_seq *_loop0_127_rule(Parser *p); |
914 | static asdl_seq *_gather_126_rule(Parser *p); |
915 | static asdl_seq *_loop0_128_rule(Parser *p); |
916 | static asdl_seq *_loop0_130_rule(Parser *p); |
917 | static asdl_seq *_gather_129_rule(Parser *p); |
918 | static asdl_seq *_loop1_131_rule(Parser *p); |
919 | static void *_tmp_132_rule(Parser *p); |
920 | static asdl_seq *_loop0_134_rule(Parser *p); |
921 | static asdl_seq *_gather_133_rule(Parser *p); |
922 | static asdl_seq *_loop0_136_rule(Parser *p); |
923 | static asdl_seq *_gather_135_rule(Parser *p); |
924 | static asdl_seq *_loop0_138_rule(Parser *p); |
925 | static asdl_seq *_gather_137_rule(Parser *p); |
926 | static asdl_seq *_loop0_140_rule(Parser *p); |
927 | static asdl_seq *_gather_139_rule(Parser *p); |
928 | static asdl_seq *_loop0_142_rule(Parser *p); |
929 | static asdl_seq *_gather_141_rule(Parser *p); |
930 | static void *_tmp_143_rule(Parser *p); |
931 | static void *_tmp_144_rule(Parser *p); |
932 | static void *_tmp_145_rule(Parser *p); |
933 | static void *_tmp_146_rule(Parser *p); |
934 | static void *_tmp_147_rule(Parser *p); |
935 | static void *_tmp_148_rule(Parser *p); |
936 | static void *_tmp_149_rule(Parser *p); |
937 | static void *_tmp_150_rule(Parser *p); |
938 | static void *_tmp_151_rule(Parser *p); |
939 | static asdl_seq *_loop0_152_rule(Parser *p); |
940 | static asdl_seq *_loop0_153_rule(Parser *p); |
941 | static asdl_seq *_loop0_154_rule(Parser *p); |
942 | static void *_tmp_155_rule(Parser *p); |
943 | static void *_tmp_156_rule(Parser *p); |
944 | static void *_tmp_157_rule(Parser *p); |
945 | static void *_tmp_158_rule(Parser *p); |
946 | static asdl_seq *_loop0_159_rule(Parser *p); |
947 | static asdl_seq *_loop0_160_rule(Parser *p); |
948 | static asdl_seq *_loop1_161_rule(Parser *p); |
949 | static void *_tmp_162_rule(Parser *p); |
950 | static asdl_seq *_loop0_163_rule(Parser *p); |
951 | static void *_tmp_164_rule(Parser *p); |
952 | static asdl_seq *_loop0_165_rule(Parser *p); |
953 | static void *_tmp_166_rule(Parser *p); |
954 | static asdl_seq *_loop0_167_rule(Parser *p); |
955 | static asdl_seq *_loop1_168_rule(Parser *p); |
956 | static void *_tmp_169_rule(Parser *p); |
957 | static void *_tmp_170_rule(Parser *p); |
958 | static void *_tmp_171_rule(Parser *p); |
959 | static asdl_seq *_loop0_172_rule(Parser *p); |
960 | static void *_tmp_173_rule(Parser *p); |
961 | static void *_tmp_174_rule(Parser *p); |
962 | static asdl_seq *_loop1_175_rule(Parser *p); |
963 | static asdl_seq *_loop0_176_rule(Parser *p); |
964 | static asdl_seq *_loop0_177_rule(Parser *p); |
965 | static asdl_seq *_loop0_179_rule(Parser *p); |
966 | static asdl_seq *_gather_178_rule(Parser *p); |
967 | static void *_tmp_180_rule(Parser *p); |
968 | static asdl_seq *_loop0_181_rule(Parser *p); |
969 | static void *_tmp_182_rule(Parser *p); |
970 | static asdl_seq *_loop0_183_rule(Parser *p); |
971 | static void *_tmp_184_rule(Parser *p); |
972 | static asdl_seq *_loop0_185_rule(Parser *p); |
973 | static asdl_seq *_loop1_186_rule(Parser *p); |
974 | static asdl_seq *_loop1_187_rule(Parser *p); |
975 | static void *_tmp_188_rule(Parser *p); |
976 | static void *_tmp_189_rule(Parser *p); |
977 | static asdl_seq *_loop0_190_rule(Parser *p); |
978 | static void *_tmp_191_rule(Parser *p); |
979 | static void *_tmp_192_rule(Parser *p); |
980 | static void *_tmp_193_rule(Parser *p); |
981 | static asdl_seq *_loop0_195_rule(Parser *p); |
982 | static asdl_seq *_gather_194_rule(Parser *p); |
983 | static asdl_seq *_loop0_197_rule(Parser *p); |
984 | static asdl_seq *_gather_196_rule(Parser *p); |
985 | static asdl_seq *_loop0_199_rule(Parser *p); |
986 | static asdl_seq *_gather_198_rule(Parser *p); |
987 | static asdl_seq *_loop0_201_rule(Parser *p); |
988 | static asdl_seq *_gather_200_rule(Parser *p); |
989 | static void *_tmp_202_rule(Parser *p); |
990 | static asdl_seq *_loop0_203_rule(Parser *p); |
991 | static void *_tmp_204_rule(Parser *p); |
992 | static asdl_seq *_loop0_205_rule(Parser *p); |
993 | static void *_tmp_206_rule(Parser *p); |
994 | static void *_tmp_207_rule(Parser *p); |
995 | static void *_tmp_208_rule(Parser *p); |
996 | static void *_tmp_209_rule(Parser *p); |
997 | static void *_tmp_210_rule(Parser *p); |
998 | static void *_tmp_211_rule(Parser *p); |
999 | static void *_tmp_212_rule(Parser *p); |
1000 | static void *_tmp_213_rule(Parser *p); |
1001 | static void *_tmp_214_rule(Parser *p); |
1002 | static asdl_seq *_loop0_216_rule(Parser *p); |
1003 | static asdl_seq *_gather_215_rule(Parser *p); |
1004 | static void *_tmp_217_rule(Parser *p); |
1005 | static void *_tmp_218_rule(Parser *p); |
1006 | static void *_tmp_219_rule(Parser *p); |
1007 | static void *_tmp_220_rule(Parser *p); |
1008 | static void *_tmp_221_rule(Parser *p); |
1009 | static void *_tmp_222_rule(Parser *p); |
1010 | static void *_tmp_223_rule(Parser *p); |
1011 | static void *_tmp_224_rule(Parser *p); |
1012 | static void *_tmp_225_rule(Parser *p); |
1013 | static void *_tmp_226_rule(Parser *p); |
1014 | static void *_tmp_227_rule(Parser *p); |
1015 | static void *_tmp_228_rule(Parser *p); |
1016 | static void *_tmp_229_rule(Parser *p); |
1017 | static void *_tmp_230_rule(Parser *p); |
1018 | static void *_tmp_231_rule(Parser *p); |
1019 | static void *_tmp_232_rule(Parser *p); |
1020 | static void *_tmp_233_rule(Parser *p); |
1021 | static void *_tmp_234_rule(Parser *p); |
1022 | static void *_tmp_235_rule(Parser *p); |
1023 | static void *_tmp_236_rule(Parser *p); |
1024 | static void *_tmp_237_rule(Parser *p); |
1025 | static void *_tmp_238_rule(Parser *p); |
1026 | static void *_tmp_239_rule(Parser *p); |
1027 | static void *_tmp_240_rule(Parser *p); |
1028 | static void *_tmp_241_rule(Parser *p); |
1029 | static void *_tmp_242_rule(Parser *p); |
1030 | static void *_tmp_243_rule(Parser *p); |
1031 | static void *_tmp_244_rule(Parser *p); |
1032 | static void *_tmp_245_rule(Parser *p); |
1033 | static void *_tmp_246_rule(Parser *p); |
1034 | static void *_tmp_247_rule(Parser *p); |
1035 | static asdl_seq *_loop1_248_rule(Parser *p); |
1036 | static asdl_seq *_loop1_249_rule(Parser *p); |
1037 | |
1038 | |
1039 | // file: statements? $ |
1040 | static mod_ty |
1041 | file_rule(Parser *p) |
1042 | { |
1043 | if (p->level++ == MAXSTACK) { Branch (1043:9): [True: 0, False: 18.2k]
|
1044 | p->error_indicator = 1; |
1045 | PyErr_NoMemory(); |
1046 | } |
1047 | if (p->error_indicator) { Branch (1047:9): [True: 157, False: 18.0k]
|
1048 | p->level--; |
1049 | return NULL; |
1050 | } |
1051 | mod_ty _res = NULL; |
1052 | int _mark = p->mark; |
1053 | { // statements? $ |
1054 | if (p->error_indicator) { Branch (1054:13): [True: 0, False: 18.0k]
|
1055 | p->level--; |
1056 | return NULL; |
1057 | } |
1058 | D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $")); |
1059 | void *a; |
1060 | Token * endmarker_var; |
1061 | if ( |
1062 | (a = statements_rule(p), !p->error_indicator) // statements? Branch (1062:13): [True: 17.7k, False: 351]
|
1063 | && |
1064 | (endmarker_var = _PyPegen_expect_token(p, 17.7k ENDMARKER17.7k )) // token='ENDMARKER' Branch (1064:13): [True: 16.9k, False: 798]
|
1065 | ) |
1066 | { |
1067 | D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $")); |
1068 | _res = _PyPegen_make_module ( p , a ); |
1069 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1069:17): [True: 0, False: 16.9k]
Branch (1069:33): [True: 0, False: 0]
|
1070 | p->error_indicator = 1; |
1071 | p->level--; |
1072 | return NULL; |
1073 | } |
1074 | goto done; |
1075 | } |
1076 | p->mark = _mark; |
1077 | D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ', |
1078 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $")); |
1079 | } |
1080 | _res = NULL; |
1081 | done: |
1082 | p->level--; |
1083 | return _res; |
1084 | } |
1085 | |
1086 | // interactive: statement_newline |
1087 | static mod_ty |
1088 | interactive_rule(Parser *p) |
1089 | { |
1090 | if (p->level++ == MAXSTACK) { Branch (1090:9): [True: 0, False: 5.01k]
|
1091 | p->error_indicator = 1; |
1092 | PyErr_NoMemory(); |
1093 | } |
1094 | if (p->error_indicator) { Branch (1094:9): [True: 16, False: 4.99k]
|
1095 | p->level--; |
1096 | return NULL; |
1097 | } |
1098 | mod_ty _res = NULL; |
1099 | int _mark = p->mark; |
1100 | { // statement_newline |
1101 | if (p->error_indicator) { Branch (1101:13): [True: 0, False: 4.99k]
|
1102 | p->level--; |
1103 | return NULL; |
1104 | } |
1105 | D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline")); |
1106 | asdl_stmt_seq* a; |
1107 | if ( |
1108 | (a = statement_newline_rule(p)) // statement_newline Branch (1108:13): [True: 4.11k, False: 883]
|
1109 | ) |
1110 | { |
1111 | D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline")); |
1112 | _res = _PyAST_Interactive ( a , p -> arena ); |
1113 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1113:17): [True: 0, False: 4.11k]
Branch (1113:33): [True: 0, False: 0]
|
1114 | p->error_indicator = 1; |
1115 | p->level--; |
1116 | return NULL; |
1117 | } |
1118 | goto done; |
1119 | } |
1120 | p->mark = _mark; |
1121 | D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ', |
1122 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline")); |
1123 | } |
1124 | _res = NULL; |
1125 | done: |
1126 | p->level--; |
1127 | return _res; |
1128 | } |
1129 | |
1130 | // eval: expressions NEWLINE* $ |
1131 | static mod_ty |
1132 | eval_rule(Parser *p) |
1133 | { |
1134 | if (p->level++ == MAXSTACK) { Branch (1134:9): [True: 0, False: 37.4k]
|
1135 | p->error_indicator = 1; |
1136 | PyErr_NoMemory(); |
1137 | } |
1138 | if (p->error_indicator) { Branch (1138:9): [True: 386, False: 37.0k]
|
1139 | p->level--; |
1140 | return NULL; |
1141 | } |
1142 | mod_ty _res = NULL; |
1143 | int _mark = p->mark; |
1144 | { // expressions NEWLINE* $ |
1145 | if (p->error_indicator) { Branch (1145:13): [True: 0, False: 37.0k]
|
1146 | p->level--; |
1147 | return NULL; |
1148 | } |
1149 | D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $")); |
1150 | asdl_seq * _loop0_1_var; |
1151 | expr_ty a; |
1152 | Token * endmarker_var; |
1153 | if ( |
1154 | (a = expressions_rule(p)) // expressions Branch (1154:13): [True: 36.6k, False: 424]
|
1155 | && |
1156 | (_loop0_1_var = _loop0_1_rule(p))36.6k // NEWLINE* Branch (1156:13): [True: 36.6k, False: 0]
|
1157 | && |
1158 | (endmarker_var = _PyPegen_expect_token(p, 36.6k ENDMARKER36.6k )) // token='ENDMARKER' Branch (1158:13): [True: 36.4k, False: 164]
|
1159 | ) |
1160 | { |
1161 | D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $")); |
1162 | _res = _PyAST_Expression ( a , p -> arena ); |
1163 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1163:17): [True: 0, False: 36.4k]
Branch (1163:33): [True: 0, False: 0]
|
1164 | p->error_indicator = 1; |
1165 | p->level--; |
1166 | return NULL; |
1167 | } |
1168 | goto done; |
1169 | } |
1170 | p->mark = _mark; |
1171 | D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ', |
1172 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $")); |
1173 | } |
1174 | _res = NULL; |
1175 | done: |
1176 | p->level--; |
1177 | return _res; |
1178 | } |
1179 | |
1180 | // func_type: '(' type_expressions? ')' '->' expression NEWLINE* $ |
1181 | static mod_ty |
1182 | func_type_rule(Parser *p) |
1183 | { |
1184 | if (p->level++ == MAXSTACK) { Branch (1184:9): [True: 0, False: 18]
|
1185 | p->error_indicator = 1; |
1186 | PyErr_NoMemory(); |
1187 | } |
1188 | if (p->error_indicator) { Branch (1188:9): [True: 0, False: 18]
|
1189 | p->level--; |
1190 | return NULL; |
1191 | } |
1192 | mod_ty _res = NULL; |
1193 | int _mark = p->mark; |
1194 | { // '(' type_expressions? ')' '->' expression NEWLINE* $ |
1195 | if (p->error_indicator) { Branch (1195:13): [True: 0, False: 18]
|
1196 | p->level--; |
1197 | return NULL; |
1198 | } |
1199 | D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $")); |
1200 | Token * _literal; |
1201 | Token * _literal_1; |
1202 | Token * _literal_2; |
1203 | asdl_seq * _loop0_2_var; |
1204 | void *a; |
1205 | expr_ty b; |
1206 | Token * endmarker_var; |
1207 | if ( |
1208 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (1208:13): [True: 18, False: 0]
|
1209 | && |
1210 | (a = type_expressions_rule(p), !p->error_indicator) // type_expressions? Branch (1210:13): [True: 18, False: 0]
|
1211 | && |
1212 | (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' Branch (1212:13): [True: 12, False: 6]
|
1213 | && |
1214 | (_literal_2 = _PyPegen_expect_token(p, 51))12 // token='->' Branch (1214:13): [True: 12, False: 0]
|
1215 | && |
1216 | (b = expression_rule(p))12 // expression Branch (1216:13): [True: 12, False: 0]
|
1217 | && |
1218 | (_loop0_2_var = _loop0_2_rule(p))12 // NEWLINE* Branch (1218:13): [True: 12, False: 0]
|
1219 | && |
1220 | (endmarker_var = _PyPegen_expect_token(p, 12 ENDMARKER12 )) // token='ENDMARKER' Branch (1220:13): [True: 12, False: 0]
|
1221 | ) |
1222 | { |
1223 | D(fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $")); |
1224 | _res = _PyAST_FunctionType ( a , b , p -> arena ); |
1225 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1225:17): [True: 0, False: 12]
Branch (1225:33): [True: 0, False: 0]
|
1226 | p->error_indicator = 1; |
1227 | p->level--; |
1228 | return NULL; |
1229 | } |
1230 | goto done; |
1231 | } |
1232 | p->mark = _mark; |
1233 | D(fprintf(stderr, "%*c%s func_type[%d-%d]: %s failed!\n", p->level, ' ', |
1234 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $")); |
1235 | } |
1236 | _res = NULL; |
1237 | done: |
1238 | p->level--; |
1239 | return _res; |
1240 | } |
1241 | |
1242 | // fstring: star_expressions |
1243 | static expr_ty |
1244 | fstring_rule(Parser *p) |
1245 | { |
1246 | if (p->level++ == MAXSTACK) { Branch (1246:9): [True: 0, False: 73.0k]
|
1247 | p->error_indicator = 1; |
1248 | PyErr_NoMemory(); |
1249 | } |
1250 | if (p->error_indicator) { Branch (1250:9): [True: 4, False: 73.0k]
|
1251 | p->level--; |
1252 | return NULL; |
1253 | } |
1254 | expr_ty _res = NULL; |
1255 | int _mark = p->mark; |
1256 | { // star_expressions |
1257 | if (p->error_indicator) { Branch (1257:13): [True: 0, False: 73.0k]
|
1258 | p->level--; |
1259 | return NULL; |
1260 | } |
1261 | D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
1262 | expr_ty star_expressions_var; |
1263 | if ( |
1264 | (star_expressions_var = star_expressions_rule(p)) // star_expressions Branch (1264:13): [True: 73.0k, False: 26]
|
1265 | ) |
1266 | { |
1267 | D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
1268 | _res = star_expressions_var; |
1269 | goto done; |
1270 | } |
1271 | p->mark = _mark; |
1272 | D(fprintf(stderr, "%*c%s fstring[%d-%d]: %s failed!\n", p->level, ' ', |
1273 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); |
1274 | } |
1275 | _res = NULL; |
1276 | done: |
1277 | p->level--; |
1278 | return _res; |
1279 | } |
1280 | |
1281 | // statements: statement+ |
1282 | static asdl_stmt_seq* |
1283 | statements_rule(Parser *p) |
1284 | { |
1285 | if (p->level++ == MAXSTACK) { Branch (1285:9): [True: 0, False: 98.7k]
|
1286 | p->error_indicator = 1; |
1287 | PyErr_NoMemory(); |
1288 | } |
1289 | if (p->error_indicator) { Branch (1289:9): [True: 0, False: 98.7k]
|
1290 | p->level--; |
1291 | return NULL; |
1292 | } |
1293 | asdl_stmt_seq* _res = NULL; |
1294 | int _mark = p->mark; |
1295 | { // statement+ |
1296 | if (p->error_indicator) { Branch (1296:13): [True: 0, False: 98.7k]
|
1297 | p->level--; |
1298 | return NULL; |
1299 | } |
1300 | D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+")); |
1301 | asdl_seq * a; |
1302 | if ( |
1303 | (a = _loop1_3_rule(p)) // statement+ Branch (1303:13): [True: 97.1k, False: 1.55k]
|
1304 | ) |
1305 | { |
1306 | D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement+")); |
1307 | _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a ); |
1308 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1308:17): [True: 0, False: 97.1k]
Branch (1308:33): [True: 0, False: 0]
|
1309 | p->error_indicator = 1; |
1310 | p->level--; |
1311 | return NULL; |
1312 | } |
1313 | goto done; |
1314 | } |
1315 | p->mark = _mark; |
1316 | D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ', |
1317 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+")); |
1318 | } |
1319 | _res = NULL; |
1320 | done: |
1321 | p->level--; |
1322 | return _res; |
1323 | } |
1324 | |
1325 | // statement: compound_stmt | simple_stmts |
1326 | static asdl_stmt_seq* |
1327 | statement_rule(Parser *p) |
1328 | { |
1329 | if (p->level++ == MAXSTACK) { Branch (1329:9): [True: 0, False: 541k]
|
1330 | p->error_indicator = 1; |
1331 | PyErr_NoMemory(); |
1332 | } |
1333 | if (p->error_indicator) { Branch (1333:9): [True: 0, False: 541k]
|
1334 | p->level--; |
1335 | return NULL; |
1336 | } |
1337 | asdl_stmt_seq* _res = NULL; |
1338 | int _mark = p->mark; |
1339 | { // compound_stmt |
1340 | if (p->error_indicator) { Branch (1340:13): [True: 0, False: 541k]
|
1341 | p->level--; |
1342 | return NULL; |
1343 | } |
1344 | D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt")); |
1345 | stmt_ty a; |
1346 | if ( |
1347 | (a = compound_stmt_rule(p)) // compound_stmt Branch (1347:13): [True: 272k, False: 268k]
|
1348 | ) |
1349 | { |
1350 | D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt")); |
1351 | _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); |
1352 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1352:17): [True: 0, False: 272k]
Branch (1352:33): [True: 0, False: 0]
|
1353 | p->error_indicator = 1; |
1354 | p->level--; |
1355 | return NULL; |
1356 | } |
1357 | goto done; |
1358 | } |
1359 | p->mark = _mark; |
1360 | D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', |
1361 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt")); |
1362 | } |
1363 | { // simple_stmts |
1364 | if (p->error_indicator) { Branch (1364:13): [True: 174, False: 268k]
|
1365 | p->level--; |
1366 | return NULL; |
1367 | } |
1368 | D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts")); |
1369 | asdl_stmt_seq* a; |
1370 | if ( |
1371 | (a = (asdl_stmt_seq*)simple_stmts_rule(p)) // simple_stmts Branch (1371:13): [True: 170k, False: 98.5k]
|
1372 | ) |
1373 | { |
1374 | D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts")); |
1375 | _res = a; |
1376 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1376:17): [True: 0, False: 170k]
Branch (1376:33): [True: 0, False: 0]
|
1377 | p->error_indicator = 1; |
1378 | p->level--; |
1379 | return NULL; |
1380 | } |
1381 | goto done; |
1382 | } |
1383 | p->mark = _mark; |
1384 | D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', |
1385 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); |
1386 | } |
1387 | _res = NULL; |
1388 | done: |
1389 | p->level--; |
1390 | return _res; |
1391 | } |
1392 | |
1393 | // statement_newline: compound_stmt NEWLINE | simple_stmts | NEWLINE | $ |
1394 | static asdl_stmt_seq* |
1395 | statement_newline_rule(Parser *p) |
1396 | { |
1397 | if (p->level++ == MAXSTACK) { Branch (1397:9): [True: 0, False: 4.99k]
|
1398 | p->error_indicator = 1; |
1399 | PyErr_NoMemory(); |
1400 | } |
1401 | if (p->error_indicator) { Branch (1401:9): [True: 0, False: 4.99k]
|
1402 | p->level--; |
1403 | return NULL; |
1404 | } |
1405 | asdl_stmt_seq* _res = NULL; |
1406 | int _mark = p->mark; |
1407 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 04.66k ) { Branch (1407:9): [True: 4.66k, False: 333]
Branch (1407:31): [True: 0, False: 4.66k]
|
1408 | p->error_indicator = 1; |
1409 | p->level--; |
1410 | return NULL; |
1411 | } |
1412 | int _start_lineno = p->tokens[_mark]->lineno; |
1413 | UNUSED(_start_lineno); // Only used by EXTRA macro |
1414 | int _start_col_offset = p->tokens[_mark]->col_offset; |
1415 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
1416 | { // compound_stmt NEWLINE |
1417 | if (p->error_indicator) { Branch (1417:13): [True: 0, False: 4.99k]
|
1418 | p->level--; |
1419 | return NULL; |
1420 | } |
1421 | D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE")); |
1422 | stmt_ty a; |
1423 | Token * newline_var; |
1424 | if ( |
1425 | (a = compound_stmt_rule(p)) // compound_stmt Branch (1425:13): [True: 628, False: 4.36k]
|
1426 | && |
1427 | (newline_var = _PyPegen_expect_token(p, 628 NEWLINE628 )) // token='NEWLINE' Branch (1427:13): [True: 596, False: 32]
|
1428 | ) |
1429 | { |
1430 | D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE")); |
1431 | _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); |
1432 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1432:17): [True: 0, False: 596]
Branch (1432:33): [True: 0, False: 0]
|
1433 | p->error_indicator = 1; |
1434 | p->level--; |
1435 | return NULL; |
1436 | } |
1437 | goto done; |
1438 | } |
1439 | p->mark = _mark; |
1440 | D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', |
1441 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt NEWLINE")); |
1442 | } |
1443 | { // simple_stmts |
1444 | if (p->error_indicator) { Branch (1444:13): [True: 159, False: 4.24k]
|
1445 | p->level--; |
1446 | return NULL; |
1447 | } |
1448 | D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts")); |
1449 | asdl_stmt_seq* simple_stmts_var; |
1450 | if ( |
1451 | (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts Branch (1451:13): [True: 3.51k, False: 724]
|
1452 | ) |
1453 | { |
1454 | D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts")); |
1455 | _res = simple_stmts_var; |
1456 | goto done; |
1457 | } |
1458 | p->mark = _mark; |
1459 | D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', |
1460 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); |
1461 | } |
1462 | { // NEWLINE |
1463 | if (p->error_indicator) { Branch (1463:13): [True: 244, False: 480]
|
1464 | p->level--; |
1465 | return NULL; |
1466 | } |
1467 | D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
1468 | Token * newline_var; |
1469 | if ( |
1470 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (1470:13): [True: 0, False: 480]
|
1471 | ) |
1472 | { |
1473 | D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
1474 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
1475 | if (_token == NULL) { Branch (1475:17): [True: 0, False: 0]
|
1476 | p->level--; |
1477 | return NULL; |
1478 | } |
1479 | int _end_lineno = _token->end_lineno; |
1480 | UNUSED(_end_lineno); // Only used by EXTRA macro |
1481 | int _end_col_offset = _token->end_col_offset; |
1482 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
1483 | _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , CHECK ( stmt_ty , _PyAST_Pass ( EXTRA ) ) ); |
1484 | if (_res == NULL && PyErr_Occurred()) { Branch (1484:17): [True: 0, False: 0]
Branch (1484:33): [True: 0, False: 0]
|
1485 | p->error_indicator = 1; |
1486 | p->level--; |
1487 | return NULL; |
1488 | } |
1489 | goto done; |
1490 | } |
1491 | p->mark = _mark; |
1492 | D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', |
1493 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); |
1494 | } |
1495 | { // $ |
1496 | if (p->error_indicator) { Branch (1496:13): [True: 0, False: 480]
|
1497 | p->level--; |
1498 | return NULL; |
1499 | } |
1500 | D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$")); |
1501 | Token * endmarker_var; |
1502 | if ( |
1503 | (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER' Branch (1503:13): [True: 0, False: 480]
|
1504 | ) |
1505 | { |
1506 | D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "$")); |
1507 | _res = _PyPegen_interactive_exit ( p ); |
1508 | if (_res == NULL && PyErr_Occurred()) { Branch (1508:17): [True: 0, False: 0]
Branch (1508:33): [True: 0, False: 0]
|
1509 | p->error_indicator = 1; |
1510 | p->level--; |
1511 | return NULL; |
1512 | } |
1513 | goto done; |
1514 | } |
1515 | p->mark = _mark; |
1516 | D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', |
1517 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "$")); |
1518 | } |
1519 | _res = NULL; |
1520 | done: |
1521 | p->level--; |
1522 | return _res; |
1523 | } |
1524 | |
1525 | // simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE |
1526 | static asdl_stmt_seq* |
1527 | simple_stmts_rule(Parser *p) |
1528 | { |
1529 | if (p->level++ == MAXSTACK) { Branch (1529:9): [True: 0, False: 478k]
|
1530 | p->error_indicator = 1; |
1531 | PyErr_NoMemory(); |
1532 | } |
1533 | if (p->error_indicator) { Branch (1533:9): [True: 0, False: 478k]
|
1534 | p->level--; |
1535 | return NULL; |
1536 | } |
1537 | asdl_stmt_seq* _res = NULL; |
1538 | int _mark = p->mark; |
1539 | { // simple_stmt !';' NEWLINE |
1540 | if (p->error_indicator) { Branch (1540:13): [True: 0, False: 478k]
|
1541 | p->level--; |
1542 | return NULL; |
1543 | } |
1544 | D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt !';' NEWLINE")); |
1545 | stmt_ty a; |
1546 | Token * newline_var; |
1547 | if ( |
1548 | (a = simple_stmt_rule(p)) // simple_stmt Branch (1548:13): [True: 379k, False: 99.0k]
|
1549 | && |
1550 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13)379k // token=';' Branch (1550:13): [True: 378k, False: 352]
|
1551 | && |
1552 | (newline_var = _PyPegen_expect_token(p, 378k NEWLINE378k )) // token='NEWLINE' Branch (1552:13): [True: 378k, False: 544]
|
1553 | ) |
1554 | { |
1555 | D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt !';' NEWLINE")); |
1556 | _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a ); |
1557 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1557:17): [True: 0, False: 378k]
Branch (1557:33): [True: 0, False: 0]
|
1558 | p->error_indicator = 1; |
1559 | p->level--; |
1560 | return NULL; |
1561 | } |
1562 | goto done; |
1563 | } |
1564 | p->mark = _mark; |
1565 | D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ', |
1566 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt !';' NEWLINE")); |
1567 | } |
1568 | { // ';'.simple_stmt+ ';'? NEWLINE |
1569 | if (p->error_indicator) { Branch (1569:13): [True: 454, False: 99.4k]
|
1570 | p->level--; |
1571 | return NULL; |
1572 | } |
1573 | D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE")); |
1574 | void *_opt_var; |
1575 | UNUSED(_opt_var); // Silence compiler warnings |
1576 | asdl_stmt_seq* a; |
1577 | Token * newline_var; |
1578 | if ( |
1579 | (a = (asdl_stmt_seq*)_gather_4_rule(p)) // ';'.simple_stmt+ Branch (1579:13): [True: 896, False: 98.6k]
|
1580 | && |
1581 | (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator)896 // ';'? Branch (1581:13): [True: 894, False: 2]
|
1582 | && |
1583 | (newline_var = _PyPegen_expect_token(p, 894 NEWLINE894 )) // token='NEWLINE' Branch (1583:13): [True: 342, False: 552]
|
1584 | ) |
1585 | { |
1586 | D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE")); |
1587 | _res = a; |
1588 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1588:17): [True: 0, False: 342]
Branch (1588:33): [True: 0, False: 0]
|
1589 | p->error_indicator = 1; |
1590 | p->level--; |
1591 | return NULL; |
1592 | } |
1593 | goto done; |
1594 | } |
1595 | p->mark = _mark; |
1596 | D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ', |
1597 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE")); |
1598 | } |
1599 | _res = NULL; |
1600 | done: |
1601 | p->level--; |
1602 | return _res; |
1603 | } |
1604 | |
1605 | // simple_stmt: |
1606 | // | assignment |
1607 | // | star_expressions |
1608 | // | &'return' return_stmt |
1609 | // | &('import' | 'from') import_stmt |
1610 | // | &'raise' raise_stmt |
1611 | // | 'pass' |
1612 | // | &'del' del_stmt |
1613 | // | &'yield' yield_stmt |
1614 | // | &'assert' assert_stmt |
1615 | // | 'break' |
1616 | // | 'continue' |
1617 | // | &'global' global_stmt |
1618 | // | &'nonlocal' nonlocal_stmt |
1619 | static stmt_ty |
1620 | simple_stmt_rule(Parser *p) |
1621 | { |
1622 | if (p->level++ == MAXSTACK) { Branch (1622:9): [True: 0, False: 582k]
|
1623 | p->error_indicator = 1; |
1624 | PyErr_NoMemory(); |
1625 | } |
1626 | if (p->error_indicator) { Branch (1626:9): [True: 0, False: 582k]
|
1627 | p->level--; |
1628 | return NULL; |
1629 | } |
1630 | stmt_ty _res = NULL; |
1631 | if (_PyPegen_is_memoized(p, simple_stmt_type, &_res)) { Branch (1631:9): [True: 99.4k, False: 482k]
|
1632 | p->level--; |
1633 | return _res; |
1634 | } |
1635 | int _mark = p->mark; |
1636 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (1636:9): [True: 0, False: 482k]
Branch (1636:31): [True: 0, False: 0]
|
1637 | p->error_indicator = 1; |
1638 | p->level--; |
1639 | return NULL; |
1640 | } |
1641 | int _start_lineno = p->tokens[_mark]->lineno; |
1642 | UNUSED(_start_lineno); // Only used by EXTRA macro |
1643 | int _start_col_offset = p->tokens[_mark]->col_offset; |
1644 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
1645 | { // assignment |
1646 | if (p->error_indicator) { Branch (1646:13): [True: 0, False: 482k]
|
1647 | p->level--; |
1648 | return NULL; |
1649 | } |
1650 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment")); |
1651 | stmt_ty assignment_var; |
1652 | if ( |
1653 | (assignment_var = assignment_rule(p)) // assignment Branch (1653:13): [True: 87.6k, False: 394k]
|
1654 | ) |
1655 | { |
1656 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment")); |
1657 | _res = assignment_var; |
1658 | goto done; |
1659 | } |
1660 | p->mark = _mark; |
1661 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1662 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment")); |
1663 | } |
1664 | { // star_expressions |
1665 | if (p->error_indicator) { Branch (1665:13): [True: 390, False: 394k]
|
1666 | p->level--; |
1667 | return NULL; |
1668 | } |
1669 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
1670 | expr_ty e; |
1671 | if ( |
1672 | (e = star_expressions_rule(p)) // star_expressions Branch (1672:13): [True: 252k, False: 142k]
|
1673 | ) |
1674 | { |
1675 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
1676 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
1677 | if (_token == NULL) { Branch (1677:17): [True: 0, False: 252k]
|
1678 | p->level--; |
1679 | return NULL; |
1680 | } |
1681 | int _end_lineno = _token->end_lineno; |
1682 | UNUSED(_end_lineno); // Only used by EXTRA macro |
1683 | int _end_col_offset = _token->end_col_offset; |
1684 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
1685 | _res = _PyAST_Expr ( e , EXTRA ); |
1686 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1686:17): [True: 0, False: 252k]
Branch (1686:33): [True: 0, False: 0]
|
1687 | p->error_indicator = 1; |
1688 | p->level--; |
1689 | return NULL; |
1690 | } |
1691 | goto done; |
1692 | } |
1693 | p->mark = _mark; |
1694 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1695 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); |
1696 | } |
1697 | { // &'return' return_stmt |
1698 | if (p->error_indicator) { Branch (1698:13): [True: 14, False: 142k]
|
1699 | p->level--; |
1700 | return NULL; |
1701 | } |
1702 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt")); |
1703 | stmt_ty return_stmt_var; |
1704 | if ( |
1705 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 519) // token='return' Branch (1705:13): [True: 20.9k, False: 121k]
|
1706 | && |
1707 | (return_stmt_var = return_stmt_rule(p))20.9k // return_stmt Branch (1707:13): [True: 20.9k, False: 1]
|
1708 | ) |
1709 | { |
1710 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt")); |
1711 | _res = return_stmt_var; |
1712 | goto done; |
1713 | } |
1714 | p->mark = _mark; |
1715 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1716 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt")); |
1717 | } |
1718 | { // &('import' | 'from') import_stmt |
1719 | if (p->error_indicator) { Branch (1719:13): [True: 1, False: 121k]
|
1720 | p->level--; |
1721 | return NULL; |
1722 | } |
1723 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt")); |
1724 | stmt_ty import_stmt_var; |
1725 | if ( |
1726 | _PyPegen_lookahead(1, _tmp_6_rule, p) Branch (1726:13): [True: 6.26k, False: 114k]
|
1727 | && |
1728 | (import_stmt_var = import_stmt_rule(p))6.26k // import_stmt Branch (1728:13): [True: 6.20k, False: 56]
|
1729 | ) |
1730 | { |
1731 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt")); |
1732 | _res = import_stmt_var; |
1733 | goto done; |
1734 | } |
1735 | p->mark = _mark; |
1736 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1737 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from') import_stmt")); |
1738 | } |
1739 | { // &'raise' raise_stmt |
1740 | if (p->error_indicator) { Branch (1740:13): [True: 21, False: 114k]
|
1741 | p->level--; |
1742 | return NULL; |
1743 | } |
1744 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt")); |
1745 | stmt_ty raise_stmt_var; |
1746 | if ( |
1747 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 522) // token='raise' Branch (1747:13): [True: 5.42k, False: 109k]
|
1748 | && |
1749 | (raise_stmt_var = raise_stmt_rule(p))5.42k // raise_stmt Branch (1749:13): [True: 5.42k, False: 0]
|
1750 | ) |
1751 | { |
1752 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt")); |
1753 | _res = raise_stmt_var; |
1754 | goto done; |
1755 | } |
1756 | p->mark = _mark; |
1757 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1758 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt")); |
1759 | } |
1760 | { // 'pass' |
1761 | if (p->error_indicator) { Branch (1761:13): [True: 0, False: 109k]
|
1762 | p->level--; |
1763 | return NULL; |
1764 | } |
1765 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'")); |
1766 | Token * _keyword; |
1767 | if ( |
1768 | (_keyword = _PyPegen_expect_token(p, 504)) // token='pass' Branch (1768:13): [True: 6.55k, False: 102k]
|
1769 | ) |
1770 | { |
1771 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'")); |
1772 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
1773 | if (_token == NULL) { Branch (1773:17): [True: 0, False: 6.55k]
|
1774 | p->level--; |
1775 | return NULL; |
1776 | } |
1777 | int _end_lineno = _token->end_lineno; |
1778 | UNUSED(_end_lineno); // Only used by EXTRA macro |
1779 | int _end_col_offset = _token->end_col_offset; |
1780 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
1781 | _res = _PyAST_Pass ( EXTRA ); |
1782 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1782:17): [True: 0, False: 6.55k]
Branch (1782:33): [True: 0, False: 0]
|
1783 | p->error_indicator = 1; |
1784 | p->level--; |
1785 | return NULL; |
1786 | } |
1787 | goto done; |
1788 | } |
1789 | p->mark = _mark; |
1790 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1791 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'pass'")); |
1792 | } |
1793 | { // &'del' del_stmt |
1794 | if (p->error_indicator) { Branch (1794:13): [True: 0, False: 102k]
|
1795 | p->level--; |
1796 | return NULL; |
1797 | } |
1798 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt")); |
1799 | stmt_ty del_stmt_var; |
1800 | if ( |
1801 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 603) // token='del' Branch (1801:13): [True: 828, False: 102k]
|
1802 | && |
1803 | (del_stmt_var = del_stmt_rule(p))828 // del_stmt Branch (1803:13): [True: 748, False: 80]
|
1804 | ) |
1805 | { |
1806 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt")); |
1807 | _res = del_stmt_var; |
1808 | goto done; |
1809 | } |
1810 | p->mark = _mark; |
1811 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1812 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt")); |
1813 | } |
1814 | { // &'yield' yield_stmt |
1815 | if (p->error_indicator) { Branch (1815:13): [True: 30, False: 102k]
|
1816 | p->level--; |
1817 | return NULL; |
1818 | } |
1819 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt")); |
1820 | stmt_ty yield_stmt_var; |
1821 | if ( |
1822 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 573) // token='yield' Branch (1822:13): [True: 1.01k, False: 101k]
|
1823 | && |
1824 | (yield_stmt_var = yield_stmt_rule(p))1.01k // yield_stmt Branch (1824:13): [True: 1.01k, False: 0]
|
1825 | ) |
1826 | { |
1827 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt")); |
1828 | _res = yield_stmt_var; |
1829 | goto done; |
1830 | } |
1831 | p->mark = _mark; |
1832 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1833 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt")); |
1834 | } |
1835 | { // &'assert' assert_stmt |
1836 | if (p->error_indicator) { Branch (1836:13): [True: 0, False: 101k]
|
1837 | p->level--; |
1838 | return NULL; |
1839 | } |
1840 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt")); |
1841 | stmt_ty assert_stmt_var; |
1842 | if ( |
1843 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 526) // token='assert' Branch (1843:13): [True: 552, False: 100k]
|
1844 | && |
1845 | (assert_stmt_var = assert_stmt_rule(p))552 // assert_stmt Branch (1845:13): [True: 550, False: 2]
|
1846 | ) |
1847 | { |
1848 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt")); |
1849 | _res = assert_stmt_var; |
1850 | goto done; |
1851 | } |
1852 | p->mark = _mark; |
1853 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1854 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt")); |
1855 | } |
1856 | { // 'break' |
1857 | if (p->error_indicator) { Branch (1857:13): [True: 0, False: 100k]
|
1858 | p->level--; |
1859 | return NULL; |
1860 | } |
1861 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'")); |
1862 | Token * _keyword; |
1863 | if ( |
1864 | (_keyword = _PyPegen_expect_token(p, 508)) // token='break' Branch (1864:13): [True: 984, False: 99.6k]
|
1865 | ) |
1866 | { |
1867 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'")); |
1868 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
1869 | if (_token == NULL) { Branch (1869:17): [True: 0, False: 984]
|
1870 | p->level--; |
1871 | return NULL; |
1872 | } |
1873 | int _end_lineno = _token->end_lineno; |
1874 | UNUSED(_end_lineno); // Only used by EXTRA macro |
1875 | int _end_col_offset = _token->end_col_offset; |
1876 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
1877 | _res = _PyAST_Break ( EXTRA ); |
1878 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1878:17): [True: 0, False: 984]
Branch (1878:33): [True: 0, False: 0]
|
1879 | p->error_indicator = 1; |
1880 | p->level--; |
1881 | return NULL; |
1882 | } |
1883 | goto done; |
1884 | } |
1885 | p->mark = _mark; |
1886 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1887 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'break'")); |
1888 | } |
1889 | { // 'continue' |
1890 | if (p->error_indicator) { Branch (1890:13): [True: 0, False: 99.6k]
|
1891 | p->level--; |
1892 | return NULL; |
1893 | } |
1894 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'")); |
1895 | Token * _keyword; |
1896 | if ( |
1897 | (_keyword = _PyPegen_expect_token(p, 509)) // token='continue' Branch (1897:13): [True: 774, False: 98.8k]
|
1898 | ) |
1899 | { |
1900 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'")); |
1901 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
1902 | if (_token == NULL) { Branch (1902:17): [True: 0, False: 774]
|
1903 | p->level--; |
1904 | return NULL; |
1905 | } |
1906 | int _end_lineno = _token->end_lineno; |
1907 | UNUSED(_end_lineno); // Only used by EXTRA macro |
1908 | int _end_col_offset = _token->end_col_offset; |
1909 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
1910 | _res = _PyAST_Continue ( EXTRA ); |
1911 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (1911:17): [True: 0, False: 774]
Branch (1911:33): [True: 0, False: 0]
|
1912 | p->error_indicator = 1; |
1913 | p->level--; |
1914 | return NULL; |
1915 | } |
1916 | goto done; |
1917 | } |
1918 | p->mark = _mark; |
1919 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1920 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'continue'")); |
1921 | } |
1922 | { // &'global' global_stmt |
1923 | if (p->error_indicator) { Branch (1923:13): [True: 0, False: 98.8k]
|
1924 | p->level--; |
1925 | return NULL; |
1926 | } |
1927 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt")); |
1928 | stmt_ty global_stmt_var; |
1929 | if ( |
1930 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 523) // token='global' Branch (1930:13): [True: 168, False: 98.7k]
|
1931 | && |
1932 | (global_stmt_var = global_stmt_rule(p))168 // global_stmt Branch (1932:13): [True: 166, False: 2]
|
1933 | ) |
1934 | { |
1935 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt")); |
1936 | _res = global_stmt_var; |
1937 | goto done; |
1938 | } |
1939 | p->mark = _mark; |
1940 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1941 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt")); |
1942 | } |
1943 | { // &'nonlocal' nonlocal_stmt |
1944 | if (p->error_indicator) { Branch (1944:13): [True: 0, False: 98.7k]
|
1945 | p->level--; |
1946 | return NULL; |
1947 | } |
1948 | D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt")); |
1949 | stmt_ty nonlocal_stmt_var; |
1950 | if ( |
1951 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 524) // token='nonlocal' Branch (1951:13): [True: 112, False: 98.6k]
|
1952 | && |
1953 | (nonlocal_stmt_var = nonlocal_stmt_rule(p))112 // nonlocal_stmt Branch (1953:13): [True: 110, False: 2]
|
1954 | ) |
1955 | { |
1956 | D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt")); |
1957 | _res = nonlocal_stmt_var; |
1958 | goto done; |
1959 | } |
1960 | p->mark = _mark; |
1961 | D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
1962 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'nonlocal' nonlocal_stmt")); |
1963 | } |
1964 | _res = NULL; |
1965 | done: |
1966 | _PyPegen_insert_memo(p, _mark, simple_stmt_type, _res); |
1967 | p->level--; |
1968 | return _res; |
1969 | } |
1970 | |
1971 | // compound_stmt: |
1972 | // | &('def' | '@' | ASYNC) function_def |
1973 | // | &'if' if_stmt |
1974 | // | &('class' | '@') class_def |
1975 | // | &('with' | ASYNC) with_stmt |
1976 | // | &('for' | ASYNC) for_stmt |
1977 | // | &'try' try_stmt |
1978 | // | &'while' while_stmt |
1979 | // | match_stmt |
1980 | static stmt_ty |
1981 | compound_stmt_rule(Parser *p) |
1982 | { |
1983 | if (p->level++ == MAXSTACK) { Branch (1983:9): [True: 0, False: 546k]
|
1984 | p->error_indicator = 1; |
1985 | PyErr_NoMemory(); |
1986 | } |
1987 | if (p->error_indicator) { Branch (1987:9): [True: 0, False: 546k]
|
1988 | p->level--; |
1989 | return NULL; |
1990 | } |
1991 | stmt_ty _res = NULL; |
1992 | int _mark = p->mark; |
1993 | { // &('def' | '@' | ASYNC) function_def |
1994 | if (p->error_indicator) { Branch (1994:13): [True: 0, False: 546k]
|
1995 | p->level--; |
1996 | return NULL; |
1997 | } |
1998 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def")); |
1999 | stmt_ty function_def_var; |
2000 | if ( |
2001 | _PyPegen_lookahead(1, _tmp_7_rule, p) Branch (2001:13): [True: 33.7k, False: 512k]
|
2002 | && |
2003 | (function_def_var = function_def_rule(p))33.7k // function_def Branch (2003:13): [True: 32.9k, False: 799]
|
2004 | ) |
2005 | { |
2006 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def")); |
2007 | _res = function_def_var; |
2008 | goto done; |
2009 | } |
2010 | p->mark = _mark; |
2011 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2012 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('def' | '@' | ASYNC) function_def")); |
2013 | } |
2014 | { // &'if' if_stmt |
2015 | if (p->error_indicator) { Branch (2015:13): [True: 195, False: 512k]
|
2016 | p->level--; |
2017 | return NULL; |
2018 | } |
2019 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt")); |
2020 | stmt_ty if_stmt_var; |
2021 | if ( |
2022 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 634) // token='if' Branch (2022:13): [True: 223k, False: 289k]
|
2023 | && |
2024 | (if_stmt_var = if_stmt_rule(p))223k // if_stmt Branch (2024:13): [True: 223k, False: 87]
|
2025 | ) |
2026 | { |
2027 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt")); |
2028 | _res = if_stmt_var; |
2029 | goto done; |
2030 | } |
2031 | p->mark = _mark; |
2032 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2033 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt")); |
2034 | } |
2035 | { // &('class' | '@') class_def |
2036 | if (p->error_indicator) { Branch (2036:13): [True: 28, False: 289k]
|
2037 | p->level--; |
2038 | return NULL; |
2039 | } |
2040 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def")); |
2041 | stmt_ty class_def_var; |
2042 | if ( |
2043 | _PyPegen_lookahead(1, _tmp_8_rule, p) Branch (2043:13): [True: 4.52k, False: 284k]
|
2044 | && |
2045 | (class_def_var = class_def_rule(p))4.52k // class_def Branch (2045:13): [True: 4.48k, False: 41]
|
2046 | ) |
2047 | { |
2048 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def")); |
2049 | _res = class_def_var; |
2050 | goto done; |
2051 | } |
2052 | p->mark = _mark; |
2053 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2054 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def")); |
2055 | } |
2056 | { // &('with' | ASYNC) with_stmt |
2057 | if (p->error_indicator) { Branch (2057:13): [True: 8, False: 284k]
|
2058 | p->level--; |
2059 | return NULL; |
2060 | } |
2061 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt")); |
2062 | stmt_ty with_stmt_var; |
2063 | if ( |
2064 | _PyPegen_lookahead(1, _tmp_9_rule, p) Branch (2064:13): [True: 2.14k, False: 282k]
|
2065 | && |
2066 | (with_stmt_var = with_stmt_rule(p))2.14k // with_stmt Branch (2066:13): [True: 1.93k, False: 214]
|
2067 | ) |
2068 | { |
2069 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt")); |
2070 | _res = with_stmt_var; |
2071 | goto done; |
2072 | } |
2073 | p->mark = _mark; |
2074 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2075 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('with' | ASYNC) with_stmt")); |
2076 | } |
2077 | { // &('for' | ASYNC) for_stmt |
2078 | if (p->error_indicator) { Branch (2078:13): [True: 27, False: 283k]
|
2079 | p->level--; |
2080 | return NULL; |
2081 | } |
2082 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt")); |
2083 | stmt_ty for_stmt_var; |
2084 | if ( |
2085 | _PyPegen_lookahead(1, _tmp_10_rule, p) Branch (2085:13): [True: 4.46k, False: 278k]
|
2086 | && |
2087 | (for_stmt_var = for_stmt_rule(p))4.46k // for_stmt Branch (2087:13): [True: 4.33k, False: 127]
|
2088 | ) |
2089 | { |
2090 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt")); |
2091 | _res = for_stmt_var; |
2092 | goto done; |
2093 | } |
2094 | p->mark = _mark; |
2095 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2096 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('for' | ASYNC) for_stmt")); |
2097 | } |
2098 | { // &'try' try_stmt |
2099 | if (p->error_indicator) { Branch (2099:13): [True: 17, False: 278k]
|
2100 | p->level--; |
2101 | return NULL; |
2102 | } |
2103 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt")); |
2104 | stmt_ty try_stmt_var; |
2105 | if ( |
2106 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 618) // token='try' Branch (2106:13): [True: 3.79k, False: 274k]
|
2107 | && |
2108 | (try_stmt_var = try_stmt_rule(p))3.79k // try_stmt Branch (2108:13): [True: 3.69k, False: 97]
|
2109 | ) |
2110 | { |
2111 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt")); |
2112 | _res = try_stmt_var; |
2113 | goto done; |
2114 | } |
2115 | p->mark = _mark; |
2116 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2117 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt")); |
2118 | } |
2119 | { // &'while' while_stmt |
2120 | if (p->error_indicator) { Branch (2120:13): [True: 35, False: 274k]
|
2121 | p->level--; |
2122 | return NULL; |
2123 | } |
2124 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt")); |
2125 | stmt_ty while_stmt_var; |
2126 | if ( |
2127 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 639) // token='while' Branch (2127:13): [True: 1.10k, False: 273k]
|
2128 | && |
2129 | (while_stmt_var = while_stmt_rule(p))1.10k // while_stmt Branch (2129:13): [True: 1.05k, False: 48]
|
2130 | ) |
2131 | { |
2132 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt")); |
2133 | _res = while_stmt_var; |
2134 | goto done; |
2135 | } |
2136 | p->mark = _mark; |
2137 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2138 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt")); |
2139 | } |
2140 | { // match_stmt |
2141 | if (p->error_indicator) { Branch (2141:13): [True: 4, False: 273k]
|
2142 | p->level--; |
2143 | return NULL; |
2144 | } |
2145 | D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "match_stmt")); |
2146 | stmt_ty match_stmt_var; |
2147 | if ( |
2148 | (match_stmt_var = match_stmt_rule(p)) // match_stmt Branch (2148:13): [True: 909, False: 272k]
|
2149 | ) |
2150 | { |
2151 | D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "match_stmt")); |
2152 | _res = match_stmt_var; |
2153 | goto done; |
2154 | } |
2155 | p->mark = _mark; |
2156 | D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2157 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "match_stmt")); |
2158 | } |
2159 | _res = NULL; |
2160 | done: |
2161 | p->level--; |
2162 | return _res; |
2163 | } |
2164 | |
2165 | // assignment: |
2166 | // | NAME ':' expression ['=' annotated_rhs] |
2167 | // | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs] |
2168 | // | ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT? |
2169 | // | single_target augassign ~ (yield_expr | star_expressions) |
2170 | // | invalid_assignment |
2171 | static stmt_ty |
2172 | assignment_rule(Parser *p) |
2173 | { |
2174 | if (p->level++ == MAXSTACK) { Branch (2174:9): [True: 0, False: 482k]
|
2175 | p->error_indicator = 1; |
2176 | PyErr_NoMemory(); |
2177 | } |
2178 | if (p->error_indicator) { Branch (2178:9): [True: 0, False: 482k]
|
2179 | p->level--; |
2180 | return NULL; |
2181 | } |
2182 | stmt_ty _res = NULL; |
2183 | int _mark = p->mark; |
2184 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (2184:9): [True: 0, False: 482k]
Branch (2184:31): [True: 0, False: 0]
|
2185 | p->error_indicator = 1; |
2186 | p->level--; |
2187 | return NULL; |
2188 | } |
2189 | int _start_lineno = p->tokens[_mark]->lineno; |
2190 | UNUSED(_start_lineno); // Only used by EXTRA macro |
2191 | int _start_col_offset = p->tokens[_mark]->col_offset; |
2192 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
2193 | { // NAME ':' expression ['=' annotated_rhs] |
2194 | if (p->error_indicator) { Branch (2194:13): [True: 0, False: 482k]
|
2195 | p->level--; |
2196 | return NULL; |
2197 | } |
2198 | D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); |
2199 | Token * _literal; |
2200 | expr_ty a; |
2201 | expr_ty b; |
2202 | void *c; |
2203 | if ( |
2204 | (a = _PyPegen_name_token(p)) // NAME Branch (2204:13): [True: 328k, False: 154k]
|
2205 | && |
2206 | (_literal = _PyPegen_expect_token(p, 11))328k // token=':' Branch (2206:13): [True: 675, False: 327k]
|
2207 | && |
2208 | (b = expression_rule(p))675 // expression Branch (2208:13): [True: 671, False: 4]
|
2209 | && |
2210 | (c = _tmp_11_rule(p), !p->error_indicator)671 // ['=' annotated_rhs] Branch (2210:13): [True: 671, False: 0]
|
2211 | ) |
2212 | { |
2213 | D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); |
2214 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2215 | if (_token == NULL) { Branch (2215:17): [True: 0, False: 671]
|
2216 | p->level--; |
2217 | return NULL; |
2218 | } |
2219 | int _end_lineno = _token->end_lineno; |
2220 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2221 | int _end_col_offset = _token->end_col_offset; |
2222 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2223 | _res = CHECK_VERSION ( stmt_ty , 6 , "Variable annotation syntax is" , _PyAST_AnnAssign ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA ) ); |
2224 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2224:17): [True: 0, False: 671]
Branch (2224:33): [True: 0, False: 0]
|
2225 | p->error_indicator = 1; |
2226 | p->level--; |
2227 | return NULL; |
2228 | } |
2229 | goto done; |
2230 | } |
2231 | p->mark = _mark; |
2232 | D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', |
2233 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); |
2234 | } |
2235 | { // ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs] |
2236 | if (p->error_indicator) { Branch (2236:13): [True: 3, False: 481k]
|
2237 | p->level--; |
2238 | return NULL; |
2239 | } |
2240 | D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); |
2241 | Token * _literal; |
2242 | void *a; |
2243 | expr_ty b; |
2244 | void *c; |
2245 | if ( |
2246 | (a = _tmp_12_rule(p)) // '(' single_target ')' | single_subscript_attribute_target Branch (2246:13): [True: 12.6k, False: 469k]
|
2247 | && |
2248 | (_literal = _PyPegen_expect_token(p, 11))12.6k // token=':' Branch (2248:13): [True: 381, False: 12.2k]
|
2249 | && |
2250 | (b = expression_rule(p))381 // expression Branch (2250:13): [True: 381, False: 0]
|
2251 | && |
2252 | (c = _tmp_13_rule(p), !p->error_indicator)381 // ['=' annotated_rhs] Branch (2252:13): [True: 381, False: 0]
|
2253 | ) |
2254 | { |
2255 | D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); |
2256 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2257 | if (_token == NULL) { Branch (2257:17): [True: 0, False: 381]
|
2258 | p->level--; |
2259 | return NULL; |
2260 | } |
2261 | int _end_lineno = _token->end_lineno; |
2262 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2263 | int _end_col_offset = _token->end_col_offset; |
2264 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2265 | _res = CHECK_VERSION ( stmt_ty , 6 , "Variable annotations syntax is" , _PyAST_AnnAssign ( a , b , c , 0 , EXTRA ) ); |
2266 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2266:17): [True: 0, False: 381]
Branch (2266:33): [True: 0, False: 0]
|
2267 | p->error_indicator = 1; |
2268 | p->level--; |
2269 | return NULL; |
2270 | } |
2271 | goto done; |
2272 | } |
2273 | p->mark = _mark; |
2274 | D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', |
2275 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); |
2276 | } |
2277 | { // ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT? |
2278 | if (p->error_indicator) { Branch (2278:13): [True: 209, False: 481k]
|
2279 | p->level--; |
2280 | return NULL; |
2281 | } |
2282 | D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?")); |
2283 | asdl_expr_seq* a; |
2284 | void *b; |
2285 | void *tc; |
2286 | if ( |
2287 | (a = (asdl_expr_seq*)_loop1_14_rule(p)) // ((star_targets '='))+ Branch (2287:13): [True: 84.4k, False: 396k]
|
2288 | && |
2289 | (b = _tmp_15_rule(p))84.4k // yield_expr | star_expressions Branch (2289:13): [True: 84.4k, False: 16]
|
2290 | && |
2291 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)84.4k // token='=' Branch (2291:13): [True: 84.4k, False: 4]
|
2292 | && |
2293 | (tc = _PyPegen_expect_token(p, 84.4k TYPE_COMMENT84.4k ), !p->error_indicator) // TYPE_COMMENT? Branch (2293:13): [True: 84.4k, False: 0]
|
2294 | ) |
2295 | { |
2296 | D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?")); |
2297 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2298 | if (_token == NULL) { Branch (2298:17): [True: 0, False: 84.4k]
|
2299 | p->level--; |
2300 | return NULL; |
2301 | } |
2302 | int _end_lineno = _token->end_lineno; |
2303 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2304 | int _end_col_offset = _token->end_col_offset; |
2305 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2306 | _res = _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); |
2307 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2307:17): [True: 0, False: 84.4k]
Branch (2307:33): [True: 0, False: 0]
|
2308 | p->error_indicator = 1; |
2309 | p->level--; |
2310 | return NULL; |
2311 | } |
2312 | goto done; |
2313 | } |
2314 | p->mark = _mark; |
2315 | D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', |
2316 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?")); |
2317 | } |
2318 | { // single_target augassign ~ (yield_expr | star_expressions) |
2319 | if (p->error_indicator) { Branch (2319:13): [True: 38, False: 396k]
|
2320 | p->level--; |
2321 | return NULL; |
2322 | } |
2323 | D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)")); |
2324 | int _cut_var = 0; |
2325 | expr_ty a; |
2326 | AugOperator* b; |
2327 | void *c; |
2328 | if ( |
2329 | (a = single_target_rule(p)) // single_target Branch (2329:13): [True: 242k, False: 153k]
|
2330 | && |
2331 | (b = augassign_rule(p))242k // augassign Branch (2331:13): [True: 2.15k, False: 240k]
|
2332 | && |
2333 | (_cut_var = 1)2.15k Branch (2333:13): [True: 2.15k, False: 0]
|
2334 | && |
2335 | (c = _tmp_16_rule(p))2.15k // yield_expr | star_expressions Branch (2335:13): [True: 2.15k, False: 0]
|
2336 | ) |
2337 | { |
2338 | D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)")); |
2339 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2340 | if (_token == NULL) { Branch (2340:17): [True: 0, False: 2.15k]
|
2341 | p->level--; |
2342 | return NULL; |
2343 | } |
2344 | int _end_lineno = _token->end_lineno; |
2345 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2346 | int _end_col_offset = _token->end_col_offset; |
2347 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2348 | _res = _PyAST_AugAssign ( a , b -> kind , c , EXTRA ); |
2349 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2349:17): [True: 0, False: 2.15k]
Branch (2349:33): [True: 0, False: 0]
|
2350 | p->error_indicator = 1; |
2351 | p->level--; |
2352 | return NULL; |
2353 | } |
2354 | goto done; |
2355 | } |
2356 | p->mark = _mark; |
2357 | D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', |
2358 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)")); |
2359 | if (_cut_var) { Branch (2359:13): [True: 0, False: 394k]
|
2360 | p->level--; |
2361 | return NULL; |
2362 | } |
2363 | } |
2364 | if (p->call_invalid_rules) { // invalid_assignment Branch (2364:9): [True: 886, False: 393k]
|
2365 | if (p->error_indicator) { Branch (2365:13): [True: 0, False: 886]
|
2366 | p->level--; |
2367 | return NULL; |
2368 | } |
2369 | D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignment")); |
2370 | void *invalid_assignment_var; |
2371 | if ( |
2372 | (invalid_assignment_var = invalid_assignment_rule(p)) // invalid_assignment Branch (2372:13): [True: 0, False: 886]
|
2373 | ) |
2374 | { |
2375 | D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_assignment")); |
2376 | _res = invalid_assignment_var; |
2377 | goto done; |
2378 | } |
2379 | p->mark = _mark; |
2380 | D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', |
2381 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_assignment")); |
2382 | } |
2383 | _res = NULL; |
2384 | done: |
2385 | p->level--; |
2386 | return _res; |
2387 | } |
2388 | |
2389 | // annotated_rhs: yield_expr | star_expressions |
2390 | static expr_ty |
2391 | annotated_rhs_rule(Parser *p) |
2392 | { |
2393 | if (p->level++ == MAXSTACK) { Branch (2393:9): [True: 0, False: 251]
|
2394 | p->error_indicator = 1; |
2395 | PyErr_NoMemory(); |
2396 | } |
2397 | if (p->error_indicator) { Branch (2397:9): [True: 0, False: 251]
|
2398 | p->level--; |
2399 | return NULL; |
2400 | } |
2401 | expr_ty _res = NULL; |
2402 | int _mark = p->mark; |
2403 | { // yield_expr |
2404 | if (p->error_indicator) { Branch (2404:13): [True: 0, False: 251]
|
2405 | p->level--; |
2406 | return NULL; |
2407 | } |
2408 | D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
2409 | expr_ty yield_expr_var; |
2410 | if ( |
2411 | (yield_expr_var = yield_expr_rule(p)) // yield_expr Branch (2411:13): [True: 1, False: 250]
|
2412 | ) |
2413 | { |
2414 | D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
2415 | _res = yield_expr_var; |
2416 | goto done; |
2417 | } |
2418 | p->mark = _mark; |
2419 | D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', |
2420 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); |
2421 | } |
2422 | { // star_expressions |
2423 | if (p->error_indicator) { Branch (2423:13): [True: 0, False: 250]
|
2424 | p->level--; |
2425 | return NULL; |
2426 | } |
2427 | D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
2428 | expr_ty star_expressions_var; |
2429 | if ( |
2430 | (star_expressions_var = star_expressions_rule(p)) // star_expressions Branch (2430:13): [True: 250, False: 0]
|
2431 | ) |
2432 | { |
2433 | D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
2434 | _res = star_expressions_var; |
2435 | goto done; |
2436 | } |
2437 | p->mark = _mark; |
2438 | D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', |
2439 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); |
2440 | } |
2441 | _res = NULL; |
2442 | done: |
2443 | p->level--; |
2444 | return _res; |
2445 | } |
2446 | |
2447 | // augassign: |
2448 | // | '+=' |
2449 | // | '-=' |
2450 | // | '*=' |
2451 | // | '@=' |
2452 | // | '/=' |
2453 | // | '%=' |
2454 | // | '&=' |
2455 | // | '|=' |
2456 | // | '^=' |
2457 | // | '<<=' |
2458 | // | '>>=' |
2459 | // | '**=' |
2460 | // | '//=' |
2461 | static AugOperator* |
2462 | augassign_rule(Parser *p) |
2463 | { |
2464 | if (p->level++ == MAXSTACK) { Branch (2464:9): [True: 0, False: 243k]
|
2465 | p->error_indicator = 1; |
2466 | PyErr_NoMemory(); |
2467 | } |
2468 | if (p->error_indicator) { Branch (2468:9): [True: 0, False: 243k]
|
2469 | p->level--; |
2470 | return NULL; |
2471 | } |
2472 | AugOperator* _res = NULL; |
2473 | int _mark = p->mark; |
2474 | { // '+=' |
2475 | if (p->error_indicator) { Branch (2475:13): [True: 0, False: 243k]
|
2476 | p->level--; |
2477 | return NULL; |
2478 | } |
2479 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='")); |
2480 | Token * _literal; |
2481 | if ( |
2482 | (_literal = _PyPegen_expect_token(p, 36)) // token='+=' Branch (2482:13): [True: 1.50k, False: 241k]
|
2483 | ) |
2484 | { |
2485 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='")); |
2486 | _res = _PyPegen_augoperator ( p , Add ); |
2487 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2487:17): [True: 0, False: 1.50k]
Branch (2487:33): [True: 0, False: 0]
|
2488 | p->error_indicator = 1; |
2489 | p->level--; |
2490 | return NULL; |
2491 | } |
2492 | goto done; |
2493 | } |
2494 | p->mark = _mark; |
2495 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2496 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='")); |
2497 | } |
2498 | { // '-=' |
2499 | if (p->error_indicator) { Branch (2499:13): [True: 0, False: 241k]
|
2500 | p->level--; |
2501 | return NULL; |
2502 | } |
2503 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='")); |
2504 | Token * _literal; |
2505 | if ( |
2506 | (_literal = _PyPegen_expect_token(p, 37)) // token='-=' Branch (2506:13): [True: 240, False: 241k]
|
2507 | ) |
2508 | { |
2509 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='")); |
2510 | _res = _PyPegen_augoperator ( p , Sub ); |
2511 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2511:17): [True: 0, False: 240]
Branch (2511:33): [True: 0, False: 0]
|
2512 | p->error_indicator = 1; |
2513 | p->level--; |
2514 | return NULL; |
2515 | } |
2516 | goto done; |
2517 | } |
2518 | p->mark = _mark; |
2519 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2520 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='")); |
2521 | } |
2522 | { // '*=' |
2523 | if (p->error_indicator) { Branch (2523:13): [True: 0, False: 241k]
|
2524 | p->level--; |
2525 | return NULL; |
2526 | } |
2527 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='")); |
2528 | Token * _literal; |
2529 | if ( |
2530 | (_literal = _PyPegen_expect_token(p, 38)) // token='*=' Branch (2530:13): [True: 48, False: 241k]
|
2531 | ) |
2532 | { |
2533 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='")); |
2534 | _res = _PyPegen_augoperator ( p , Mult ); |
2535 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2535:17): [True: 0, False: 48]
Branch (2535:33): [True: 0, False: 0]
|
2536 | p->error_indicator = 1; |
2537 | p->level--; |
2538 | return NULL; |
2539 | } |
2540 | goto done; |
2541 | } |
2542 | p->mark = _mark; |
2543 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2544 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='")); |
2545 | } |
2546 | { // '@=' |
2547 | if (p->error_indicator) { Branch (2547:13): [True: 0, False: 241k]
|
2548 | p->level--; |
2549 | return NULL; |
2550 | } |
2551 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='")); |
2552 | Token * _literal; |
2553 | if ( |
2554 | (_literal = _PyPegen_expect_token(p, 50)) // token='@=' Branch (2554:13): [True: 14, False: 241k]
|
2555 | ) |
2556 | { |
2557 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='")); |
2558 | _res = CHECK_VERSION ( AugOperator* , 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) ); |
2559 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2559:17): [True: 0, False: 14]
Branch (2559:33): [True: 0, False: 0]
|
2560 | p->error_indicator = 1; |
2561 | p->level--; |
2562 | return NULL; |
2563 | } |
2564 | goto done; |
2565 | } |
2566 | p->mark = _mark; |
2567 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2568 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='")); |
2569 | } |
2570 | { // '/=' |
2571 | if (p->error_indicator) { Branch (2571:13): [True: 0, False: 241k]
|
2572 | p->level--; |
2573 | return NULL; |
2574 | } |
2575 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='")); |
2576 | Token * _literal; |
2577 | if ( |
2578 | (_literal = _PyPegen_expect_token(p, 39)) // token='/=' Branch (2578:13): [True: 19, False: 241k]
|
2579 | ) |
2580 | { |
2581 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='")); |
2582 | _res = _PyPegen_augoperator ( p , Div ); |
2583 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2583:17): [True: 0, False: 19]
Branch (2583:33): [True: 0, False: 0]
|
2584 | p->error_indicator = 1; |
2585 | p->level--; |
2586 | return NULL; |
2587 | } |
2588 | goto done; |
2589 | } |
2590 | p->mark = _mark; |
2591 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2592 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='")); |
2593 | } |
2594 | { // '%=' |
2595 | if (p->error_indicator) { Branch (2595:13): [True: 0, False: 241k]
|
2596 | p->level--; |
2597 | return NULL; |
2598 | } |
2599 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='")); |
2600 | Token * _literal; |
2601 | if ( |
2602 | (_literal = _PyPegen_expect_token(p, 40)) // token='%=' Branch (2602:13): [True: 16, False: 241k]
|
2603 | ) |
2604 | { |
2605 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='")); |
2606 | _res = _PyPegen_augoperator ( p , Mod ); |
2607 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2607:17): [True: 0, False: 16]
Branch (2607:33): [True: 0, False: 0]
|
2608 | p->error_indicator = 1; |
2609 | p->level--; |
2610 | return NULL; |
2611 | } |
2612 | goto done; |
2613 | } |
2614 | p->mark = _mark; |
2615 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2616 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='")); |
2617 | } |
2618 | { // '&=' |
2619 | if (p->error_indicator) { Branch (2619:13): [True: 0, False: 241k]
|
2620 | p->level--; |
2621 | return NULL; |
2622 | } |
2623 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='")); |
2624 | Token * _literal; |
2625 | if ( |
2626 | (_literal = _PyPegen_expect_token(p, 41)) // token='&=' Branch (2626:13): [True: 40, False: 241k]
|
2627 | ) |
2628 | { |
2629 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='")); |
2630 | _res = _PyPegen_augoperator ( p , BitAnd ); |
2631 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2631:17): [True: 0, False: 40]
Branch (2631:33): [True: 0, False: 0]
|
2632 | p->error_indicator = 1; |
2633 | p->level--; |
2634 | return NULL; |
2635 | } |
2636 | goto done; |
2637 | } |
2638 | p->mark = _mark; |
2639 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2640 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='")); |
2641 | } |
2642 | { // '|=' |
2643 | if (p->error_indicator) { Branch (2643:13): [True: 0, False: 241k]
|
2644 | p->level--; |
2645 | return NULL; |
2646 | } |
2647 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='")); |
2648 | Token * _literal; |
2649 | if ( |
2650 | (_literal = _PyPegen_expect_token(p, 42)) // token='|=' Branch (2650:13): [True: 164, False: 241k]
|
2651 | ) |
2652 | { |
2653 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='")); |
2654 | _res = _PyPegen_augoperator ( p , BitOr ); |
2655 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2655:17): [True: 0, False: 164]
Branch (2655:33): [True: 0, False: 0]
|
2656 | p->error_indicator = 1; |
2657 | p->level--; |
2658 | return NULL; |
2659 | } |
2660 | goto done; |
2661 | } |
2662 | p->mark = _mark; |
2663 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2664 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='")); |
2665 | } |
2666 | { // '^=' |
2667 | if (p->error_indicator) { Branch (2667:13): [True: 0, False: 241k]
|
2668 | p->level--; |
2669 | return NULL; |
2670 | } |
2671 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='")); |
2672 | Token * _literal; |
2673 | if ( |
2674 | (_literal = _PyPegen_expect_token(p, 43)) // token='^=' Branch (2674:13): [True: 36, False: 241k]
|
2675 | ) |
2676 | { |
2677 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='")); |
2678 | _res = _PyPegen_augoperator ( p , BitXor ); |
2679 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2679:17): [True: 0, False: 36]
Branch (2679:33): [True: 0, False: 0]
|
2680 | p->error_indicator = 1; |
2681 | p->level--; |
2682 | return NULL; |
2683 | } |
2684 | goto done; |
2685 | } |
2686 | p->mark = _mark; |
2687 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2688 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='")); |
2689 | } |
2690 | { // '<<=' |
2691 | if (p->error_indicator) { Branch (2691:13): [True: 0, False: 241k]
|
2692 | p->level--; |
2693 | return NULL; |
2694 | } |
2695 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='")); |
2696 | Token * _literal; |
2697 | if ( |
2698 | (_literal = _PyPegen_expect_token(p, 44)) // token='<<=' Branch (2698:13): [True: 25, False: 241k]
|
2699 | ) |
2700 | { |
2701 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='")); |
2702 | _res = _PyPegen_augoperator ( p , LShift ); |
2703 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2703:17): [True: 0, False: 25]
Branch (2703:33): [True: 0, False: 0]
|
2704 | p->error_indicator = 1; |
2705 | p->level--; |
2706 | return NULL; |
2707 | } |
2708 | goto done; |
2709 | } |
2710 | p->mark = _mark; |
2711 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2712 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='")); |
2713 | } |
2714 | { // '>>=' |
2715 | if (p->error_indicator) { Branch (2715:13): [True: 0, False: 241k]
|
2716 | p->level--; |
2717 | return NULL; |
2718 | } |
2719 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='")); |
2720 | Token * _literal; |
2721 | if ( |
2722 | (_literal = _PyPegen_expect_token(p, 45)) // token='>>=' Branch (2722:13): [True: 19, False: 241k]
|
2723 | ) |
2724 | { |
2725 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='")); |
2726 | _res = _PyPegen_augoperator ( p , RShift ); |
2727 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2727:17): [True: 0, False: 19]
Branch (2727:33): [True: 0, False: 0]
|
2728 | p->error_indicator = 1; |
2729 | p->level--; |
2730 | return NULL; |
2731 | } |
2732 | goto done; |
2733 | } |
2734 | p->mark = _mark; |
2735 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2736 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='")); |
2737 | } |
2738 | { // '**=' |
2739 | if (p->error_indicator) { Branch (2739:13): [True: 0, False: 241k]
|
2740 | p->level--; |
2741 | return NULL; |
2742 | } |
2743 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='")); |
2744 | Token * _literal; |
2745 | if ( |
2746 | (_literal = _PyPegen_expect_token(p, 46)) // token='**=' Branch (2746:13): [True: 11, False: 240k]
|
2747 | ) |
2748 | { |
2749 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='")); |
2750 | _res = _PyPegen_augoperator ( p , Pow ); |
2751 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2751:17): [True: 0, False: 11]
Branch (2751:33): [True: 0, False: 0]
|
2752 | p->error_indicator = 1; |
2753 | p->level--; |
2754 | return NULL; |
2755 | } |
2756 | goto done; |
2757 | } |
2758 | p->mark = _mark; |
2759 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2760 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='")); |
2761 | } |
2762 | { // '//=' |
2763 | if (p->error_indicator) { Branch (2763:13): [True: 0, False: 240k]
|
2764 | p->level--; |
2765 | return NULL; |
2766 | } |
2767 | D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='")); |
2768 | Token * _literal; |
2769 | if ( |
2770 | (_literal = _PyPegen_expect_token(p, 48)) // token='//=' Branch (2770:13): [True: 34, False: 240k]
|
2771 | ) |
2772 | { |
2773 | D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='")); |
2774 | _res = _PyPegen_augoperator ( p , FloorDiv ); |
2775 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2775:17): [True: 0, False: 34]
Branch (2775:33): [True: 0, False: 0]
|
2776 | p->error_indicator = 1; |
2777 | p->level--; |
2778 | return NULL; |
2779 | } |
2780 | goto done; |
2781 | } |
2782 | p->mark = _mark; |
2783 | D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', |
2784 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='")); |
2785 | } |
2786 | _res = NULL; |
2787 | done: |
2788 | p->level--; |
2789 | return _res; |
2790 | } |
2791 | |
2792 | // return_stmt: 'return' star_expressions? |
2793 | static stmt_ty |
2794 | return_stmt_rule(Parser *p) |
2795 | { |
2796 | if (p->level++ == MAXSTACK) { Branch (2796:9): [True: 0, False: 20.9k]
|
2797 | p->error_indicator = 1; |
2798 | PyErr_NoMemory(); |
2799 | } |
2800 | if (p->error_indicator) { Branch (2800:9): [True: 0, False: 20.9k]
|
2801 | p->level--; |
2802 | return NULL; |
2803 | } |
2804 | stmt_ty _res = NULL; |
2805 | int _mark = p->mark; |
2806 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (2806:9): [True: 0, False: 20.9k]
Branch (2806:31): [True: 0, False: 0]
|
2807 | p->error_indicator = 1; |
2808 | p->level--; |
2809 | return NULL; |
2810 | } |
2811 | int _start_lineno = p->tokens[_mark]->lineno; |
2812 | UNUSED(_start_lineno); // Only used by EXTRA macro |
2813 | int _start_col_offset = p->tokens[_mark]->col_offset; |
2814 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
2815 | { // 'return' star_expressions? |
2816 | if (p->error_indicator) { Branch (2816:13): [True: 0, False: 20.9k]
|
2817 | p->level--; |
2818 | return NULL; |
2819 | } |
2820 | D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?")); |
2821 | Token * _keyword; |
2822 | void *a; |
2823 | if ( |
2824 | (_keyword = _PyPegen_expect_token(p, 519)) // token='return' Branch (2824:13): [True: 20.9k, False: 0]
|
2825 | && |
2826 | (a = star_expressions_rule(p), !p->error_indicator) // star_expressions? Branch (2826:13): [True: 20.9k, False: 1]
|
2827 | ) |
2828 | { |
2829 | D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?")); |
2830 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2831 | if (_token == NULL) { Branch (2831:17): [True: 0, False: 20.9k]
|
2832 | p->level--; |
2833 | return NULL; |
2834 | } |
2835 | int _end_lineno = _token->end_lineno; |
2836 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2837 | int _end_col_offset = _token->end_col_offset; |
2838 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2839 | _res = _PyAST_Return ( a , EXTRA ); |
2840 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2840:17): [True: 0, False: 20.9k]
Branch (2840:33): [True: 0, False: 0]
|
2841 | p->error_indicator = 1; |
2842 | p->level--; |
2843 | return NULL; |
2844 | } |
2845 | goto done; |
2846 | } |
2847 | p->mark = _mark; |
2848 | D(fprintf(stderr, "%*c%s return_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2849 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'return' star_expressions?")); |
2850 | } |
2851 | _res = NULL; |
2852 | done: |
2853 | p->level--; |
2854 | return _res; |
2855 | } |
2856 | |
2857 | // raise_stmt: 'raise' expression ['from' expression] | 'raise' |
2858 | static stmt_ty |
2859 | raise_stmt_rule(Parser *p) |
2860 | { |
2861 | if (p->level++ == MAXSTACK) { Branch (2861:9): [True: 0, False: 5.42k]
|
2862 | p->error_indicator = 1; |
2863 | PyErr_NoMemory(); |
2864 | } |
2865 | if (p->error_indicator) { Branch (2865:9): [True: 0, False: 5.42k]
|
2866 | p->level--; |
2867 | return NULL; |
2868 | } |
2869 | stmt_ty _res = NULL; |
2870 | int _mark = p->mark; |
2871 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (2871:9): [True: 0, False: 5.42k]
Branch (2871:31): [True: 0, False: 0]
|
2872 | p->error_indicator = 1; |
2873 | p->level--; |
2874 | return NULL; |
2875 | } |
2876 | int _start_lineno = p->tokens[_mark]->lineno; |
2877 | UNUSED(_start_lineno); // Only used by EXTRA macro |
2878 | int _start_col_offset = p->tokens[_mark]->col_offset; |
2879 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
2880 | { // 'raise' expression ['from' expression] |
2881 | if (p->error_indicator) { Branch (2881:13): [True: 0, False: 5.42k]
|
2882 | p->level--; |
2883 | return NULL; |
2884 | } |
2885 | D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]")); |
2886 | Token * _keyword; |
2887 | expr_ty a; |
2888 | void *b; |
2889 | if ( |
2890 | (_keyword = _PyPegen_expect_token(p, 522)) // token='raise' Branch (2890:13): [True: 5.42k, False: 0]
|
2891 | && |
2892 | (a = expression_rule(p)) // expression Branch (2892:13): [True: 5.07k, False: 348]
|
2893 | && |
2894 | (b = _tmp_17_rule(p), !p->error_indicator)5.07k // ['from' expression] Branch (2894:13): [True: 5.07k, False: 0]
|
2895 | ) |
2896 | { |
2897 | D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]")); |
2898 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2899 | if (_token == NULL) { Branch (2899:17): [True: 0, False: 5.07k]
|
2900 | p->level--; |
2901 | return NULL; |
2902 | } |
2903 | int _end_lineno = _token->end_lineno; |
2904 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2905 | int _end_col_offset = _token->end_col_offset; |
2906 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2907 | _res = _PyAST_Raise ( a , b , EXTRA ); |
2908 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2908:17): [True: 0, False: 5.07k]
Branch (2908:33): [True: 0, False: 0]
|
2909 | p->error_indicator = 1; |
2910 | p->level--; |
2911 | return NULL; |
2912 | } |
2913 | goto done; |
2914 | } |
2915 | p->mark = _mark; |
2916 | D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2917 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise' expression ['from' expression]")); |
2918 | } |
2919 | { // 'raise' |
2920 | if (p->error_indicator) { Branch (2920:13): [True: 0, False: 348]
|
2921 | p->level--; |
2922 | return NULL; |
2923 | } |
2924 | D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'")); |
2925 | Token * _keyword; |
2926 | if ( |
2927 | (_keyword = _PyPegen_expect_token(p, 522)) // token='raise' Branch (2927:13): [True: 348, False: 0]
|
2928 | ) |
2929 | { |
2930 | D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'")); |
2931 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2932 | if (_token == NULL) { Branch (2932:17): [True: 0, False: 348]
|
2933 | p->level--; |
2934 | return NULL; |
2935 | } |
2936 | int _end_lineno = _token->end_lineno; |
2937 | UNUSED(_end_lineno); // Only used by EXTRA macro |
2938 | int _end_col_offset = _token->end_col_offset; |
2939 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
2940 | _res = _PyAST_Raise ( NULL , NULL , EXTRA ); |
2941 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (2941:17): [True: 0, False: 348]
Branch (2941:33): [True: 0, False: 0]
|
2942 | p->error_indicator = 1; |
2943 | p->level--; |
2944 | return NULL; |
2945 | } |
2946 | goto done; |
2947 | } |
2948 | p->mark = _mark; |
2949 | D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
2950 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise'")); |
2951 | } |
2952 | _res = NULL; |
2953 | done: |
2954 | p->level--; |
2955 | return _res; |
2956 | } |
2957 | |
2958 | // global_stmt: 'global' ','.NAME+ |
2959 | static stmt_ty |
2960 | global_stmt_rule(Parser *p) |
2961 | { |
2962 | if (p->level++ == MAXSTACK) { Branch (2962:9): [True: 0, False: 168]
|
2963 | p->error_indicator = 1; |
2964 | PyErr_NoMemory(); |
2965 | } |
2966 | if (p->error_indicator) { Branch (2966:9): [True: 0, False: 168]
|
2967 | p->level--; |
2968 | return NULL; |
2969 | } |
2970 | stmt_ty _res = NULL; |
2971 | int _mark = p->mark; |
2972 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (2972:9): [True: 0, False: 168]
Branch (2972:31): [True: 0, False: 0]
|
2973 | p->error_indicator = 1; |
2974 | p->level--; |
2975 | return NULL; |
2976 | } |
2977 | int _start_lineno = p->tokens[_mark]->lineno; |
2978 | UNUSED(_start_lineno); // Only used by EXTRA macro |
2979 | int _start_col_offset = p->tokens[_mark]->col_offset; |
2980 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
2981 | { // 'global' ','.NAME+ |
2982 | if (p->error_indicator) { Branch (2982:13): [True: 0, False: 168]
|
2983 | p->level--; |
2984 | return NULL; |
2985 | } |
2986 | D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+")); |
2987 | Token * _keyword; |
2988 | asdl_expr_seq* a; |
2989 | if ( |
2990 | (_keyword = _PyPegen_expect_token(p, 523)) // token='global' Branch (2990:13): [True: 168, False: 0]
|
2991 | && |
2992 | (a = (asdl_expr_seq*)_gather_18_rule(p)) // ','.NAME+ Branch (2992:13): [True: 166, False: 2]
|
2993 | ) |
2994 | { |
2995 | D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+")); |
2996 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
2997 | if (_token == NULL) { Branch (2997:17): [True: 0, False: 166]
|
2998 | p->level--; |
2999 | return NULL; |
3000 | } |
3001 | int _end_lineno = _token->end_lineno; |
3002 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3003 | int _end_col_offset = _token->end_col_offset; |
3004 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3005 | _res = _PyAST_Global ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA ); |
3006 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3006:17): [True: 0, False: 166]
Branch (3006:33): [True: 0, False: 0]
|
3007 | p->error_indicator = 1; |
3008 | p->level--; |
3009 | return NULL; |
3010 | } |
3011 | goto done; |
3012 | } |
3013 | p->mark = _mark; |
3014 | D(fprintf(stderr, "%*c%s global_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3015 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'global' ','.NAME+")); |
3016 | } |
3017 | _res = NULL; |
3018 | done: |
3019 | p->level--; |
3020 | return _res; |
3021 | } |
3022 | |
3023 | // nonlocal_stmt: 'nonlocal' ','.NAME+ |
3024 | static stmt_ty |
3025 | nonlocal_stmt_rule(Parser *p) |
3026 | { |
3027 | if (p->level++ == MAXSTACK) { Branch (3027:9): [True: 0, False: 112]
|
3028 | p->error_indicator = 1; |
3029 | PyErr_NoMemory(); |
3030 | } |
3031 | if (p->error_indicator) { Branch (3031:9): [True: 0, False: 112]
|
3032 | p->level--; |
3033 | return NULL; |
3034 | } |
3035 | stmt_ty _res = NULL; |
3036 | int _mark = p->mark; |
3037 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (3037:9): [True: 0, False: 112]
Branch (3037:31): [True: 0, False: 0]
|
3038 | p->error_indicator = 1; |
3039 | p->level--; |
3040 | return NULL; |
3041 | } |
3042 | int _start_lineno = p->tokens[_mark]->lineno; |
3043 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3044 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3045 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3046 | { // 'nonlocal' ','.NAME+ |
3047 | if (p->error_indicator) { Branch (3047:13): [True: 0, False: 112]
|
3048 | p->level--; |
3049 | return NULL; |
3050 | } |
3051 | D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+")); |
3052 | Token * _keyword; |
3053 | asdl_expr_seq* a; |
3054 | if ( |
3055 | (_keyword = _PyPegen_expect_token(p, 524)) // token='nonlocal' Branch (3055:13): [True: 112, False: 0]
|
3056 | && |
3057 | (a = (asdl_expr_seq*)_gather_20_rule(p)) // ','.NAME+ Branch (3057:13): [True: 110, False: 2]
|
3058 | ) |
3059 | { |
3060 | D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+")); |
3061 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3062 | if (_token == NULL) { Branch (3062:17): [True: 0, False: 110]
|
3063 | p->level--; |
3064 | return NULL; |
3065 | } |
3066 | int _end_lineno = _token->end_lineno; |
3067 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3068 | int _end_col_offset = _token->end_col_offset; |
3069 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3070 | _res = _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA ); |
3071 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3071:17): [True: 0, False: 110]
Branch (3071:33): [True: 0, False: 0]
|
3072 | p->error_indicator = 1; |
3073 | p->level--; |
3074 | return NULL; |
3075 | } |
3076 | goto done; |
3077 | } |
3078 | p->mark = _mark; |
3079 | D(fprintf(stderr, "%*c%s nonlocal_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3080 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'nonlocal' ','.NAME+")); |
3081 | } |
3082 | _res = NULL; |
3083 | done: |
3084 | p->level--; |
3085 | return _res; |
3086 | } |
3087 | |
3088 | // del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt |
3089 | static stmt_ty |
3090 | del_stmt_rule(Parser *p) |
3091 | { |
3092 | if (p->level++ == MAXSTACK) { Branch (3092:9): [True: 0, False: 828]
|
3093 | p->error_indicator = 1; |
3094 | PyErr_NoMemory(); |
3095 | } |
3096 | if (p->error_indicator) { Branch (3096:9): [True: 0, False: 828]
|
3097 | p->level--; |
3098 | return NULL; |
3099 | } |
3100 | stmt_ty _res = NULL; |
3101 | int _mark = p->mark; |
3102 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (3102:9): [True: 0, False: 828]
Branch (3102:31): [True: 0, False: 0]
|
3103 | p->error_indicator = 1; |
3104 | p->level--; |
3105 | return NULL; |
3106 | } |
3107 | int _start_lineno = p->tokens[_mark]->lineno; |
3108 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3109 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3110 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3111 | { // 'del' del_targets &(';' | NEWLINE) |
3112 | if (p->error_indicator) { Branch (3112:13): [True: 0, False: 828]
|
3113 | p->level--; |
3114 | return NULL; |
3115 | } |
3116 | D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); |
3117 | Token * _keyword; |
3118 | asdl_expr_seq* a; |
3119 | if ( |
3120 | (_keyword = _PyPegen_expect_token(p, 603)) // token='del' Branch (3120:13): [True: 828, False: 0]
|
3121 | && |
3122 | (a = del_targets_rule(p)) // del_targets Branch (3122:13): [True: 782, False: 46]
|
3123 | && |
3124 | _PyPegen_lookahead(1, _tmp_22_rule, p)782 Branch (3124:13): [True: 748, False: 34]
|
3125 | ) |
3126 | { |
3127 | D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); |
3128 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3129 | if (_token == NULL) { Branch (3129:17): [True: 0, False: 748]
|
3130 | p->level--; |
3131 | return NULL; |
3132 | } |
3133 | int _end_lineno = _token->end_lineno; |
3134 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3135 | int _end_col_offset = _token->end_col_offset; |
3136 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3137 | _res = _PyAST_Delete ( a , EXTRA ); |
3138 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3138:17): [True: 0, False: 748]
Branch (3138:33): [True: 0, False: 0]
|
3139 | p->error_indicator = 1; |
3140 | p->level--; |
3141 | return NULL; |
3142 | } |
3143 | goto done; |
3144 | } |
3145 | p->mark = _mark; |
3146 | D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3147 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); |
3148 | } |
3149 | if (p->call_invalid_rules) { // invalid_del_stmt Branch (3149:9): [True: 38, False: 42]
|
3150 | if (p->error_indicator) { Branch (3150:13): [True: 1, False: 37]
|
3151 | p->level--; |
3152 | return NULL; |
3153 | } |
3154 | D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt")); |
3155 | void *invalid_del_stmt_var; |
3156 | if ( |
3157 | (invalid_del_stmt_var = invalid_del_stmt_rule(p)) // invalid_del_stmt Branch (3157:13): [True: 0, False: 37]
|
3158 | ) |
3159 | { |
3160 | D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt")); |
3161 | _res = invalid_del_stmt_var; |
3162 | goto done; |
3163 | } |
3164 | p->mark = _mark; |
3165 | D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3166 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_del_stmt")); |
3167 | } |
3168 | _res = NULL; |
3169 | done: |
3170 | p->level--; |
3171 | return _res; |
3172 | } |
3173 | |
3174 | // yield_stmt: yield_expr |
3175 | static stmt_ty |
3176 | yield_stmt_rule(Parser *p) |
3177 | { |
3178 | if (p->level++ == MAXSTACK) { Branch (3178:9): [True: 0, False: 1.01k]
|
3179 | p->error_indicator = 1; |
3180 | PyErr_NoMemory(); |
3181 | } |
3182 | if (p->error_indicator) { Branch (3182:9): [True: 0, False: 1.01k]
|
3183 | p->level--; |
3184 | return NULL; |
3185 | } |
3186 | stmt_ty _res = NULL; |
3187 | int _mark = p->mark; |
3188 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (3188:9): [True: 0, False: 1.01k]
Branch (3188:31): [True: 0, False: 0]
|
3189 | p->error_indicator = 1; |
3190 | p->level--; |
3191 | return NULL; |
3192 | } |
3193 | int _start_lineno = p->tokens[_mark]->lineno; |
3194 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3195 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3196 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3197 | { // yield_expr |
3198 | if (p->error_indicator) { Branch (3198:13): [True: 0, False: 1.01k]
|
3199 | p->level--; |
3200 | return NULL; |
3201 | } |
3202 | D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
3203 | expr_ty y; |
3204 | if ( |
3205 | (y = yield_expr_rule(p)) // yield_expr Branch (3205:13): [True: 1.01k, False: 0]
|
3206 | ) |
3207 | { |
3208 | D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
3209 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3210 | if (_token == NULL) { Branch (3210:17): [True: 0, False: 1.01k]
|
3211 | p->level--; |
3212 | return NULL; |
3213 | } |
3214 | int _end_lineno = _token->end_lineno; |
3215 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3216 | int _end_col_offset = _token->end_col_offset; |
3217 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3218 | _res = _PyAST_Expr ( y , EXTRA ); |
3219 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3219:17): [True: 0, False: 1.01k]
Branch (3219:33): [True: 0, False: 0]
|
3220 | p->error_indicator = 1; |
3221 | p->level--; |
3222 | return NULL; |
3223 | } |
3224 | goto done; |
3225 | } |
3226 | p->mark = _mark; |
3227 | D(fprintf(stderr, "%*c%s yield_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3228 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); |
3229 | } |
3230 | _res = NULL; |
3231 | done: |
3232 | p->level--; |
3233 | return _res; |
3234 | } |
3235 | |
3236 | // assert_stmt: 'assert' expression [',' expression] |
3237 | static stmt_ty |
3238 | assert_stmt_rule(Parser *p) |
3239 | { |
3240 | if (p->level++ == MAXSTACK) { Branch (3240:9): [True: 0, False: 552]
|
3241 | p->error_indicator = 1; |
3242 | PyErr_NoMemory(); |
3243 | } |
3244 | if (p->error_indicator) { Branch (3244:9): [True: 0, False: 552]
|
3245 | p->level--; |
3246 | return NULL; |
3247 | } |
3248 | stmt_ty _res = NULL; |
3249 | int _mark = p->mark; |
3250 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (3250:9): [True: 0, False: 552]
Branch (3250:31): [True: 0, False: 0]
|
3251 | p->error_indicator = 1; |
3252 | p->level--; |
3253 | return NULL; |
3254 | } |
3255 | int _start_lineno = p->tokens[_mark]->lineno; |
3256 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3257 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3258 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3259 | { // 'assert' expression [',' expression] |
3260 | if (p->error_indicator) { Branch (3260:13): [True: 0, False: 552]
|
3261 | p->level--; |
3262 | return NULL; |
3263 | } |
3264 | D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]")); |
3265 | Token * _keyword; |
3266 | expr_ty a; |
3267 | void *b; |
3268 | if ( |
3269 | (_keyword = _PyPegen_expect_token(p, 526)) // token='assert' Branch (3269:13): [True: 552, False: 0]
|
3270 | && |
3271 | (a = expression_rule(p)) // expression Branch (3271:13): [True: 550, False: 2]
|
3272 | && |
3273 | (b = _tmp_23_rule(p), !p->error_indicator)550 // [',' expression] Branch (3273:13): [True: 550, False: 0]
|
3274 | ) |
3275 | { |
3276 | D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]")); |
3277 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3278 | if (_token == NULL) { Branch (3278:17): [True: 0, False: 550]
|
3279 | p->level--; |
3280 | return NULL; |
3281 | } |
3282 | int _end_lineno = _token->end_lineno; |
3283 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3284 | int _end_col_offset = _token->end_col_offset; |
3285 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3286 | _res = _PyAST_Assert ( a , b , EXTRA ); |
3287 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3287:17): [True: 0, False: 550]
Branch (3287:33): [True: 0, False: 0]
|
3288 | p->error_indicator = 1; |
3289 | p->level--; |
3290 | return NULL; |
3291 | } |
3292 | goto done; |
3293 | } |
3294 | p->mark = _mark; |
3295 | D(fprintf(stderr, "%*c%s assert_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3296 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'assert' expression [',' expression]")); |
3297 | } |
3298 | _res = NULL; |
3299 | done: |
3300 | p->level--; |
3301 | return _res; |
3302 | } |
3303 | |
3304 | // import_stmt: import_name | import_from |
3305 | static stmt_ty |
3306 | import_stmt_rule(Parser *p) |
3307 | { |
3308 | if (p->level++ == MAXSTACK) { Branch (3308:9): [True: 0, False: 6.26k]
|
3309 | p->error_indicator = 1; |
3310 | PyErr_NoMemory(); |
3311 | } |
3312 | if (p->error_indicator) { Branch (3312:9): [True: 0, False: 6.26k]
|
3313 | p->level--; |
3314 | return NULL; |
3315 | } |
3316 | stmt_ty _res = NULL; |
3317 | int _mark = p->mark; |
3318 | { // import_name |
3319 | if (p->error_indicator) { Branch (3319:13): [True: 0, False: 6.26k]
|
3320 | p->level--; |
3321 | return NULL; |
3322 | } |
3323 | D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name")); |
3324 | stmt_ty import_name_var; |
3325 | if ( |
3326 | (import_name_var = import_name_rule(p)) // import_name Branch (3326:13): [True: 4.16k, False: 2.09k]
|
3327 | ) |
3328 | { |
3329 | D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_name")); |
3330 | _res = import_name_var; |
3331 | goto done; |
3332 | } |
3333 | p->mark = _mark; |
3334 | D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3335 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name")); |
3336 | } |
3337 | { // import_from |
3338 | if (p->error_indicator) { Branch (3338:13): [True: 2, False: 2.09k]
|
3339 | p->level--; |
3340 | return NULL; |
3341 | } |
3342 | D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from")); |
3343 | stmt_ty import_from_var; |
3344 | if ( |
3345 | (import_from_var = import_from_rule(p)) // import_from Branch (3345:13): [True: 2.04k, False: 54]
|
3346 | ) |
3347 | { |
3348 | D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from")); |
3349 | _res = import_from_var; |
3350 | goto done; |
3351 | } |
3352 | p->mark = _mark; |
3353 | D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
3354 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from")); |
3355 | } |
3356 | _res = NULL; |
3357 | done: |
3358 | p->level--; |
3359 | return _res; |
3360 | } |
3361 | |
3362 | // import_name: 'import' dotted_as_names |
3363 | static stmt_ty |
3364 | import_name_rule(Parser *p) |
3365 | { |
3366 | if (p->level++ == MAXSTACK) { Branch (3366:9): [True: 0, False: 6.26k]
|
3367 | p->error_indicator = 1; |
3368 | PyErr_NoMemory(); |
3369 | } |
3370 | if (p->error_indicator) { Branch (3370:9): [True: 0, False: 6.26k]
|
3371 | p->level--; |
3372 | return NULL; |
3373 | } |
3374 | stmt_ty _res = NULL; |
3375 | int _mark = p->mark; |
3376 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (3376:9): [True: 0, False: 6.26k]
Branch (3376:31): [True: 0, False: 0]
|
3377 | p->error_indicator = 1; |
3378 | p->level--; |
3379 | return NULL; |
3380 | } |
3381 | int _start_lineno = p->tokens[_mark]->lineno; |
3382 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3383 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3384 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3385 | { // 'import' dotted_as_names |
3386 | if (p->error_indicator) { Branch (3386:13): [True: 0, False: 6.26k]
|
3387 | p->level--; |
3388 | return NULL; |
3389 | } |
3390 | D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names")); |
3391 | Token * _keyword; |
3392 | asdl_alias_seq* a; |
3393 | if ( |
3394 | (_keyword = _PyPegen_expect_token(p, 531)) // token='import' Branch (3394:13): [True: 4.18k, False: 2.07k]
|
3395 | && |
3396 | (a = dotted_as_names_rule(p))4.18k // dotted_as_names Branch (3396:13): [True: 4.16k, False: 18]
|
3397 | ) |
3398 | { |
3399 | D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names")); |
3400 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3401 | if (_token == NULL) { Branch (3401:17): [True: 0, False: 4.16k]
|
3402 | p->level--; |
3403 | return NULL; |
3404 | } |
3405 | int _end_lineno = _token->end_lineno; |
3406 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3407 | int _end_col_offset = _token->end_col_offset; |
3408 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3409 | _res = _PyAST_Import ( a , EXTRA ); |
3410 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3410:17): [True: 0, False: 4.16k]
Branch (3410:33): [True: 0, False: 0]
|
3411 | p->error_indicator = 1; |
3412 | p->level--; |
3413 | return NULL; |
3414 | } |
3415 | goto done; |
3416 | } |
3417 | p->mark = _mark; |
3418 | D(fprintf(stderr, "%*c%s import_name[%d-%d]: %s failed!\n", p->level, ' ', |
3419 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' dotted_as_names")); |
3420 | } |
3421 | _res = NULL; |
3422 | done: |
3423 | p->level--; |
3424 | return _res; |
3425 | } |
3426 | |
3427 | // import_from: |
3428 | // | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets |
3429 | // | 'from' (('.' | '...'))+ 'import' import_from_targets |
3430 | static stmt_ty |
3431 | import_from_rule(Parser *p) |
3432 | { |
3433 | if (p->level++ == MAXSTACK) { Branch (3433:9): [True: 0, False: 2.09k]
|
3434 | p->error_indicator = 1; |
3435 | PyErr_NoMemory(); |
3436 | } |
3437 | if (p->error_indicator) { Branch (3437:9): [True: 0, False: 2.09k]
|
3438 | p->level--; |
3439 | return NULL; |
3440 | } |
3441 | stmt_ty _res = NULL; |
3442 | int _mark = p->mark; |
3443 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (3443:9): [True: 0, False: 2.09k]
Branch (3443:31): [True: 0, False: 0]
|
3444 | p->error_indicator = 1; |
3445 | p->level--; |
3446 | return NULL; |
3447 | } |
3448 | int _start_lineno = p->tokens[_mark]->lineno; |
3449 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3450 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3451 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3452 | { // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets |
3453 | if (p->error_indicator) { Branch (3453:13): [True: 0, False: 2.09k]
|
3454 | p->level--; |
3455 | return NULL; |
3456 | } |
3457 | D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets")); |
3458 | Token * _keyword; |
3459 | Token * _keyword_1; |
3460 | asdl_seq * a; |
3461 | expr_ty b; |
3462 | asdl_alias_seq* c; |
3463 | if ( |
3464 | (_keyword = _PyPegen_expect_token(p, 572)) // token='from' Branch (3464:13): [True: 2.07k, False: 16]
|
3465 | && |
3466 | (a = _loop0_24_rule(p))2.07k // (('.' | '...'))* Branch (3466:13): [True: 2.07k, False: 0]
|
3467 | && |
3468 | (b = dotted_name_rule(p))2.07k // dotted_name Branch (3468:13): [True: 2.02k, False: 56]
|
3469 | && |
3470 | (_keyword_1 = _PyPegen_expect_token(p, 531))2.02k // token='import' Branch (3470:13): [True: 2.02k, False: 0]
|
3471 | && |
3472 | (c = import_from_targets_rule(p))2.02k // import_from_targets Branch (3472:13): [True: 1.98k, False: 34]
|
3473 | ) |
3474 | { |
3475 | D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets")); |
3476 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3477 | if (_token == NULL) { Branch (3477:17): [True: 0, False: 1.98k]
|
3478 | p->level--; |
3479 | return NULL; |
3480 | } |
3481 | int _end_lineno = _token->end_lineno; |
3482 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3483 | int _end_col_offset = _token->end_col_offset; |
3484 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3485 | _res = _PyAST_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA ); |
3486 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3486:17): [True: 0, False: 1.98k]
Branch (3486:33): [True: 0, False: 0]
|
3487 | p->error_indicator = 1; |
3488 | p->level--; |
3489 | return NULL; |
3490 | } |
3491 | goto done; |
3492 | } |
3493 | p->mark = _mark; |
3494 | D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ', |
3495 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets")); |
3496 | } |
3497 | { // 'from' (('.' | '...'))+ 'import' import_from_targets |
3498 | if (p->error_indicator) { Branch (3498:13): [True: 19, False: 87]
|
3499 | p->level--; |
3500 | return NULL; |
3501 | } |
3502 | D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets")); |
3503 | Token * _keyword; |
3504 | Token * _keyword_1; |
3505 | asdl_seq * a; |
3506 | asdl_alias_seq* b; |
3507 | if ( |
3508 | (_keyword = _PyPegen_expect_token(p, 572)) // token='from' Branch (3508:13): [True: 71, False: 16]
|
3509 | && |
3510 | (a = _loop1_25_rule(p))71 // (('.' | '...'))+ Branch (3510:13): [True: 52, False: 19]
|
3511 | && |
3512 | (_keyword_1 = _PyPegen_expect_token(p, 531))52 // token='import' Branch (3512:13): [True: 52, False: 0]
|
3513 | && |
3514 | (b = import_from_targets_rule(p))52 // import_from_targets Branch (3514:13): [True: 52, False: 0]
|
3515 | ) |
3516 | { |
3517 | D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets")); |
3518 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3519 | if (_token == NULL) { Branch (3519:17): [True: 0, False: 52]
|
3520 | p->level--; |
3521 | return NULL; |
3522 | } |
3523 | int _end_lineno = _token->end_lineno; |
3524 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3525 | int _end_col_offset = _token->end_col_offset; |
3526 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3527 | _res = _PyAST_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA ); |
3528 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3528:17): [True: 0, False: 52]
Branch (3528:33): [True: 0, False: 0]
|
3529 | p->error_indicator = 1; |
3530 | p->level--; |
3531 | return NULL; |
3532 | } |
3533 | goto done; |
3534 | } |
3535 | p->mark = _mark; |
3536 | D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ', |
3537 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets")); |
3538 | } |
3539 | _res = NULL; |
3540 | done: |
3541 | p->level--; |
3542 | return _res; |
3543 | } |
3544 | |
3545 | // import_from_targets: |
3546 | // | '(' import_from_as_names ','? ')' |
3547 | // | import_from_as_names !',' |
3548 | // | '*' |
3549 | // | invalid_import_from_targets |
3550 | static asdl_alias_seq* |
3551 | import_from_targets_rule(Parser *p) |
3552 | { |
3553 | if (p->level++ == MAXSTACK) { Branch (3553:9): [True: 0, False: 2.07k]
|
3554 | p->error_indicator = 1; |
3555 | PyErr_NoMemory(); |
3556 | } |
3557 | if (p->error_indicator) { Branch (3557:9): [True: 0, False: 2.07k]
|
3558 | p->level--; |
3559 | return NULL; |
3560 | } |
3561 | asdl_alias_seq* _res = NULL; |
3562 | int _mark = p->mark; |
3563 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 02.05k ) { Branch (3563:9): [True: 2.05k, False: 18]
Branch (3563:31): [True: 0, False: 2.05k]
|
3564 | p->error_indicator = 1; |
3565 | p->level--; |
3566 | return NULL; |
3567 | } |
3568 | int _start_lineno = p->tokens[_mark]->lineno; |
3569 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3570 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3571 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3572 | { // '(' import_from_as_names ','? ')' |
3573 | if (p->error_indicator) { Branch (3573:13): [True: 0, False: 2.07k]
|
3574 | p->level--; |
3575 | return NULL; |
3576 | } |
3577 | D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'")); |
3578 | Token * _literal; |
3579 | Token * _literal_1; |
3580 | void *_opt_var; |
3581 | UNUSED(_opt_var); // Silence compiler warnings |
3582 | asdl_alias_seq* a; |
3583 | if ( |
3584 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (3584:13): [True: 92, False: 1.98k]
|
3585 | && |
3586 | (a = import_from_as_names_rule(p))92 // import_from_as_names Branch (3586:13): [True: 84, False: 8]
|
3587 | && |
3588 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)84 // ','? Branch (3588:13): [True: 78, False: 6]
|
3589 | && |
3590 | (_literal_1 = _PyPegen_expect_token(p, 8))78 // token=')' Branch (3590:13): [True: 76, False: 2]
|
3591 | ) |
3592 | { |
3593 | D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'")); |
3594 | _res = a; |
3595 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3595:17): [True: 0, False: 76]
Branch (3595:33): [True: 0, False: 0]
|
3596 | p->error_indicator = 1; |
3597 | p->level--; |
3598 | return NULL; |
3599 | } |
3600 | goto done; |
3601 | } |
3602 | p->mark = _mark; |
3603 | D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', |
3604 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' import_from_as_names ','? ')'")); |
3605 | } |
3606 | { // import_from_as_names !',' |
3607 | if (p->error_indicator) { Branch (3607:13): [True: 12, False: 1.98k]
|
3608 | p->level--; |
3609 | return NULL; |
3610 | } |
3611 | D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','")); |
3612 | asdl_alias_seq* import_from_as_names_var; |
3613 | if ( |
3614 | (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names Branch (3614:13): [True: 1.56k, False: 419]
|
3615 | && |
3616 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)1.56k // token=',' Branch (3616:13): [True: 1.55k, False: 12]
|
3617 | ) |
3618 | { |
3619 | D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','")); |
3620 | _res = import_from_as_names_var; |
3621 | goto done; |
3622 | } |
3623 | p->mark = _mark; |
3624 | D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', |
3625 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names !','")); |
3626 | } |
3627 | { // '*' |
3628 | if (p->error_indicator) { Branch (3628:13): [True: 2, False: 429]
|
3629 | p->level--; |
3630 | return NULL; |
3631 | } |
3632 | D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); |
3633 | Token * _literal; |
3634 | if ( |
3635 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (3635:13): [True: 409, False: 20]
|
3636 | ) |
3637 | { |
3638 | D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); |
3639 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3640 | if (_token == NULL) { Branch (3640:17): [True: 0, False: 409]
|
3641 | p->level--; |
3642 | return NULL; |
3643 | } |
3644 | int _end_lineno = _token->end_lineno; |
3645 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3646 | int _end_col_offset = _token->end_col_offset; |
3647 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3648 | _res = ( asdl_alias_seq* ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star ( p , EXTRA ) ) ); |
3649 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3649:17): [True: 0, False: 409]
Branch (3649:33): [True: 0, False: 0]
|
3650 | p->error_indicator = 1; |
3651 | p->level--; |
3652 | return NULL; |
3653 | } |
3654 | goto done; |
3655 | } |
3656 | p->mark = _mark; |
3657 | D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', |
3658 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); |
3659 | } |
3660 | if (p->call_invalid_rules) { // invalid_import_from_targets Branch (3660:9): [True: 10, False: 10]
|
3661 | if (p->error_indicator) { Branch (3661:13): [True: 0, False: 10]
|
3662 | p->level--; |
3663 | return NULL; |
3664 | } |
3665 | D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets")); |
3666 | void *invalid_import_from_targets_var; |
3667 | if ( |
3668 | (invalid_import_from_targets_var = invalid_import_from_targets_rule(p)) // invalid_import_from_targets Branch (3668:13): [True: 0, False: 10]
|
3669 | ) |
3670 | { |
3671 | D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets")); |
3672 | _res = invalid_import_from_targets_var; |
3673 | goto done; |
3674 | } |
3675 | p->mark = _mark; |
3676 | D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', |
3677 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import_from_targets")); |
3678 | } |
3679 | _res = NULL; |
3680 | done: |
3681 | p->level--; |
3682 | return _res; |
3683 | } |
3684 | |
3685 | // import_from_as_names: ','.import_from_as_name+ |
3686 | static asdl_alias_seq* |
3687 | import_from_as_names_rule(Parser *p) |
3688 | { |
3689 | if (p->level++ == MAXSTACK) { Branch (3689:9): [True: 0, False: 2.08k]
|
3690 | p->error_indicator = 1; |
3691 | PyErr_NoMemory(); |
3692 | } |
3693 | if (p->error_indicator) { Branch (3693:9): [True: 0, False: 2.08k]
|
3694 | p->level--; |
3695 | return NULL; |
3696 | } |
3697 | asdl_alias_seq* _res = NULL; |
3698 | int _mark = p->mark; |
3699 | { // ','.import_from_as_name+ |
3700 | if (p->error_indicator) { Branch (3700:13): [True: 0, False: 2.08k]
|
3701 | p->level--; |
3702 | return NULL; |
3703 | } |
3704 | D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+")); |
3705 | asdl_alias_seq* a; |
3706 | if ( |
3707 | (a = (asdl_alias_seq*)_gather_26_rule(p)) // ','.import_from_as_name+ Branch (3707:13): [True: 1.65k, False: 431]
|
3708 | ) |
3709 | { |
3710 | D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+")); |
3711 | _res = a; |
3712 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3712:17): [True: 0, False: 1.65k]
Branch (3712:33): [True: 0, False: 0]
|
3713 | p->error_indicator = 1; |
3714 | p->level--; |
3715 | return NULL; |
3716 | } |
3717 | goto done; |
3718 | } |
3719 | p->mark = _mark; |
3720 | D(fprintf(stderr, "%*c%s import_from_as_names[%d-%d]: %s failed!\n", p->level, ' ', |
3721 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.import_from_as_name+")); |
3722 | } |
3723 | _res = NULL; |
3724 | done: |
3725 | p->level--; |
3726 | return _res; |
3727 | } |
3728 | |
3729 | // import_from_as_name: NAME ['as' NAME] |
3730 | static alias_ty |
3731 | import_from_as_name_rule(Parser *p) |
3732 | { |
3733 | if (p->level++ == MAXSTACK) { Branch (3733:9): [True: 0, False: 2.88k]
|
3734 | p->error_indicator = 1; |
3735 | PyErr_NoMemory(); |
3736 | } |
3737 | if (p->error_indicator) { Branch (3737:9): [True: 0, False: 2.88k]
|
3738 | p->level--; |
3739 | return NULL; |
3740 | } |
3741 | alias_ty _res = NULL; |
3742 | int _mark = p->mark; |
3743 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0869 ) { Branch (3743:9): [True: 869, False: 2.02k]
Branch (3743:31): [True: 6, False: 863]
|
3744 | p->error_indicator = 1; |
3745 | p->level--; |
3746 | return NULL; |
3747 | } |
3748 | int _start_lineno = p->tokens[_mark]->lineno; |
3749 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3750 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3751 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3752 | { // NAME ['as' NAME] |
3753 | if (p->error_indicator) { Branch (3753:13): [True: 0, False: 2.88k]
|
3754 | p->level--; |
3755 | return NULL; |
3756 | } |
3757 | D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]")); |
3758 | expr_ty a; |
3759 | void *b; |
3760 | if ( |
3761 | (a = _PyPegen_name_token(p)) // NAME Branch (3761:13): [True: 2.43k, False: 451]
|
3762 | && |
3763 | (b = _tmp_28_rule(p), !p->error_indicator)2.43k // ['as' NAME] Branch (3763:13): [True: 2.42k, False: 8]
|
3764 | ) |
3765 | { |
3766 | D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]")); |
3767 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3768 | if (_token == NULL) { Branch (3768:17): [True: 0, False: 2.42k]
|
3769 | p->level--; |
3770 | return NULL; |
3771 | } |
3772 | int _end_lineno = _token->end_lineno; |
3773 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3774 | int _end_col_offset = _token->end_col_offset; |
3775 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3776 | _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id251 : NULL , EXTRA ); Branch (3776:56): [True: 251, False: 2.17k]
|
3777 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3777:17): [True: 0, False: 2.42k]
Branch (3777:33): [True: 0, False: 0]
|
3778 | p->error_indicator = 1; |
3779 | p->level--; |
3780 | return NULL; |
3781 | } |
3782 | goto done; |
3783 | } |
3784 | p->mark = _mark; |
3785 | D(fprintf(stderr, "%*c%s import_from_as_name[%d-%d]: %s failed!\n", p->level, ' ', |
3786 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ['as' NAME]")); |
3787 | } |
3788 | _res = NULL; |
3789 | done: |
3790 | p->level--; |
3791 | return _res; |
3792 | } |
3793 | |
3794 | // dotted_as_names: ','.dotted_as_name+ |
3795 | static asdl_alias_seq* |
3796 | dotted_as_names_rule(Parser *p) |
3797 | { |
3798 | if (p->level++ == MAXSTACK) { Branch (3798:9): [True: 0, False: 4.18k]
|
3799 | p->error_indicator = 1; |
3800 | PyErr_NoMemory(); |
3801 | } |
3802 | if (p->error_indicator) { Branch (3802:9): [True: 0, False: 4.18k]
|
3803 | p->level--; |
3804 | return NULL; |
3805 | } |
3806 | asdl_alias_seq* _res = NULL; |
3807 | int _mark = p->mark; |
3808 | { // ','.dotted_as_name+ |
3809 | if (p->error_indicator) { Branch (3809:13): [True: 0, False: 4.18k]
|
3810 | p->level--; |
3811 | return NULL; |
3812 | } |
3813 | D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+")); |
3814 | asdl_alias_seq* a; |
3815 | if ( |
3816 | (a = (asdl_alias_seq*)_gather_29_rule(p)) // ','.dotted_as_name+ Branch (3816:13): [True: 4.16k, False: 18]
|
3817 | ) |
3818 | { |
3819 | D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+")); |
3820 | _res = a; |
3821 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3821:17): [True: 0, False: 4.16k]
Branch (3821:33): [True: 0, False: 0]
|
3822 | p->error_indicator = 1; |
3823 | p->level--; |
3824 | return NULL; |
3825 | } |
3826 | goto done; |
3827 | } |
3828 | p->mark = _mark; |
3829 | D(fprintf(stderr, "%*c%s dotted_as_names[%d-%d]: %s failed!\n", p->level, ' ', |
3830 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.dotted_as_name+")); |
3831 | } |
3832 | _res = NULL; |
3833 | done: |
3834 | p->level--; |
3835 | return _res; |
3836 | } |
3837 | |
3838 | // dotted_as_name: dotted_name ['as' NAME] |
3839 | static alias_ty |
3840 | dotted_as_name_rule(Parser *p) |
3841 | { |
3842 | if (p->level++ == MAXSTACK) { Branch (3842:9): [True: 0, False: 4.30k]
|
3843 | p->error_indicator = 1; |
3844 | PyErr_NoMemory(); |
3845 | } |
3846 | if (p->error_indicator) { Branch (3846:9): [True: 0, False: 4.30k]
|
3847 | p->level--; |
3848 | return NULL; |
3849 | } |
3850 | alias_ty _res = NULL; |
3851 | int _mark = p->mark; |
3852 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 04.29k ) { Branch (3852:9): [True: 4.29k, False: 14]
Branch (3852:31): [True: 0, False: 4.29k]
|
3853 | p->error_indicator = 1; |
3854 | p->level--; |
3855 | return NULL; |
3856 | } |
3857 | int _start_lineno = p->tokens[_mark]->lineno; |
3858 | UNUSED(_start_lineno); // Only used by EXTRA macro |
3859 | int _start_col_offset = p->tokens[_mark]->col_offset; |
3860 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
3861 | { // dotted_name ['as' NAME] |
3862 | if (p->error_indicator) { Branch (3862:13): [True: 0, False: 4.30k]
|
3863 | p->level--; |
3864 | return NULL; |
3865 | } |
3866 | D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]")); |
3867 | expr_ty a; |
3868 | void *b; |
3869 | if ( |
3870 | (a = dotted_name_rule(p)) // dotted_name Branch (3870:13): [True: 4.28k, False: 18]
|
3871 | && |
3872 | (b = _tmp_31_rule(p), !p->error_indicator)4.28k // ['as' NAME] Branch (3872:13): [True: 4.28k, False: 0]
|
3873 | ) |
3874 | { |
3875 | D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]")); |
3876 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
3877 | if (_token == NULL) { Branch (3877:17): [True: 0, False: 4.28k]
|
3878 | p->level--; |
3879 | return NULL; |
3880 | } |
3881 | int _end_lineno = _token->end_lineno; |
3882 | UNUSED(_end_lineno); // Only used by EXTRA macro |
3883 | int _end_col_offset = _token->end_col_offset; |
3884 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
3885 | _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id140 : NULL , EXTRA ); Branch (3885:56): [True: 140, False: 4.14k]
|
3886 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3886:17): [True: 0, False: 4.28k]
Branch (3886:33): [True: 0, False: 0]
|
3887 | p->error_indicator = 1; |
3888 | p->level--; |
3889 | return NULL; |
3890 | } |
3891 | goto done; |
3892 | } |
3893 | p->mark = _mark; |
3894 | D(fprintf(stderr, "%*c%s dotted_as_name[%d-%d]: %s failed!\n", p->level, ' ', |
3895 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name ['as' NAME]")); |
3896 | } |
3897 | _res = NULL; |
3898 | done: |
3899 | p->level--; |
3900 | return _res; |
3901 | } |
3902 | |
3903 | // Left-recursive |
3904 | // dotted_name: dotted_name '.' NAME | NAME |
3905 | static expr_ty dotted_name_raw(Parser *); |
3906 | static expr_ty |
3907 | dotted_name_rule(Parser *p) |
3908 | { |
3909 | if (p->level++ == MAXSTACK) { Branch (3909:9): [True: 0, False: 20.0k]
|
3910 | p->error_indicator = 1; |
3911 | PyErr_NoMemory(); |
3912 | } |
3913 | expr_ty _res = NULL; |
3914 | if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) { Branch (3914:9): [True: 13.7k, False: 6.38k]
|
3915 | p->level--; |
3916 | return _res; |
3917 | } |
3918 | int _mark = p->mark; |
3919 | int _resmark = p->mark; |
3920 | while (1) { Branch (3920:12): [Folded - Ignored]
|
3921 | int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res); |
3922 | if (tmpvar_0) { Branch (3922:13): [True: 0, False: 13.7k]
|
3923 | p->level--; |
3924 | return _res; |
3925 | } |
3926 | p->mark = _mark; |
3927 | void *_raw = dotted_name_raw(p); |
3928 | if (p->error_indicator) { Branch (3928:13): [True: 2, False: 13.7k]
|
3929 | p->level--; |
3930 | return NULL; |
3931 | } |
3932 | if (_raw == NULL || p->mark <= _resmark13.6k ) Branch (3932:13): [True: 72, False: 13.6k]
Branch (3932:29): [True: 6.30k, False: 7.32k]
|
3933 | break; |
3934 | _resmark = p->mark; |
3935 | _res = _raw; |
3936 | } |
3937 | p->mark = _resmark; |
3938 | p->level--; |
3939 | return _res; |
3940 | } |
3941 | static expr_ty |
3942 | dotted_name_raw(Parser *p) |
3943 | { |
3944 | if (p->level++ == MAXSTACK) { Branch (3944:9): [True: 0, False: 13.7k]
|
3945 | p->error_indicator = 1; |
3946 | PyErr_NoMemory(); |
3947 | } |
3948 | if (p->error_indicator) { Branch (3948:9): [True: 0, False: 13.7k]
|
3949 | p->level--; |
3950 | return NULL; |
3951 | } |
3952 | expr_ty _res = NULL; |
3953 | int _mark = p->mark; |
3954 | { // dotted_name '.' NAME |
3955 | if (p->error_indicator) { Branch (3955:13): [True: 0, False: 13.7k]
|
3956 | p->level--; |
3957 | return NULL; |
3958 | } |
3959 | D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME")); |
3960 | Token * _literal; |
3961 | expr_ty a; |
3962 | expr_ty b; |
3963 | if ( |
3964 | (a = dotted_name_rule(p)) // dotted_name Branch (3964:13): [True: 7.32k, False: 6.38k]
|
3965 | && |
3966 | (_literal = _PyPegen_expect_token(p, 23))7.32k // token='.' Branch (3966:13): [True: 1.01k, False: 6.31k]
|
3967 | && |
3968 | (b = _PyPegen_name_token(p))1.01k // NAME Branch (3968:13): [True: 1.01k, False: 0]
|
3969 | ) |
3970 | { |
3971 | D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME")); |
3972 | _res = _PyPegen_join_names_with_dot ( p , a , b ); |
3973 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (3973:17): [True: 0, False: 1.01k]
Branch (3973:33): [True: 0, False: 0]
|
3974 | p->error_indicator = 1; |
3975 | p->level--; |
3976 | return NULL; |
3977 | } |
3978 | goto done; |
3979 | } |
3980 | p->mark = _mark; |
3981 | D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ', |
3982 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name '.' NAME")); |
3983 | } |
3984 | { // NAME |
3985 | if (p->error_indicator) { Branch (3985:13): [True: 2, False: 12.6k]
|
3986 | p->level--; |
3987 | return NULL; |
3988 | } |
3989 | D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
3990 | expr_ty name_var; |
3991 | if ( |
3992 | (name_var = _PyPegen_name_token(p)) // NAME Branch (3992:13): [True: 12.6k, False: 72]
|
3993 | ) |
3994 | { |
3995 | D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
3996 | _res = name_var; |
3997 | goto done; |
3998 | } |
3999 | p->mark = _mark; |
4000 | D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ', |
4001 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
4002 | } |
4003 | _res = NULL; |
4004 | done: |
4005 | p->level--; |
4006 | return _res; |
4007 | } |
4008 | |
4009 | // block: NEWLINE INDENT statements DEDENT | simple_stmts | invalid_block |
4010 | static asdl_stmt_seq* |
4011 | block_rule(Parser *p) |
4012 | { |
4013 | if (p->level++ == MAXSTACK) { Branch (4013:9): [True: 0, False: 512k]
|
4014 | p->error_indicator = 1; |
4015 | PyErr_NoMemory(); |
4016 | } |
4017 | if (p->error_indicator) { Branch (4017:9): [True: 0, False: 512k]
|
4018 | p->level--; |
4019 | return NULL; |
4020 | } |
4021 | asdl_stmt_seq* _res = NULL; |
4022 | if (_PyPegen_is_memoized(p, block_type, &_res)) { Branch (4022:9): [True: 226k, False: 285k]
|
4023 | p->level--; |
4024 | return _res; |
4025 | } |
4026 | int _mark = p->mark; |
4027 | { // NEWLINE INDENT statements DEDENT |
4028 | if (p->error_indicator) { Branch (4028:13): [True: 0, False: 285k]
|
4029 | p->level--; |
4030 | return NULL; |
4031 | } |
4032 | D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT")); |
4033 | asdl_stmt_seq* a; |
4034 | Token * dedent_var; |
4035 | Token * indent_var; |
4036 | Token * newline_var; |
4037 | if ( |
4038 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (4038:13): [True: 80.7k, False: 205k]
|
4039 | && |
4040 | (indent_var = _PyPegen_expect_token(p, 80.7k INDENT80.7k )) // token='INDENT' Branch (4040:13): [True: 80.6k, False: 89]
|
4041 | && |
4042 | (a = statements_rule(p))80.6k // statements Branch (4042:13): [True: 80.5k, False: 121]
|
4043 | && |
4044 | (dedent_var = _PyPegen_expect_token(p, 80.5k DEDENT80.5k )) // token='DEDENT' Branch (4044:13): [True: 80.4k, False: 24]
|
4045 | ) |
4046 | { |
4047 | D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT")); |
4048 | _res = a; |
4049 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4049:17): [True: 0, False: 80.4k]
Branch (4049:33): [True: 0, False: 0]
|
4050 | p->error_indicator = 1; |
4051 | p->level--; |
4052 | return NULL; |
4053 | } |
4054 | goto done; |
4055 | } |
4056 | p->mark = _mark; |
4057 | D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', |
4058 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT")); |
4059 | } |
4060 | { // simple_stmts |
4061 | if (p->error_indicator) { Branch (4061:13): [True: 27, False: 205k]
|
4062 | p->level--; |
4063 | return NULL; |
4064 | } |
4065 | D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts")); |
4066 | asdl_stmt_seq* simple_stmts_var; |
4067 | if ( |
4068 | (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts Branch (4068:13): [True: 204k, False: 347]
|
4069 | ) |
4070 | { |
4071 | D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts")); |
4072 | _res = simple_stmts_var; |
4073 | goto done; |
4074 | } |
4075 | p->mark = _mark; |
4076 | D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', |
4077 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); |
4078 | } |
4079 | if (p->call_invalid_rules) { // invalid_block Branch (4079:9): [True: 142, False: 205]
|
4080 | if (p->error_indicator) { Branch (4080:13): [True: 7, False: 135]
|
4081 | p->level--; |
4082 | return NULL; |
4083 | } |
4084 | D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block")); |
4085 | void *invalid_block_var; |
4086 | if ( |
4087 | (invalid_block_var = invalid_block_rule(p)) // invalid_block Branch (4087:13): [True: 0, False: 135]
|
4088 | ) |
4089 | { |
4090 | D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_block")); |
4091 | _res = invalid_block_var; |
4092 | goto done; |
4093 | } |
4094 | p->mark = _mark; |
4095 | D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', |
4096 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block")); |
4097 | } |
4098 | _res = NULL; |
4099 | done: |
4100 | _PyPegen_insert_memo(p, _mark, block_type, _res); |
4101 | p->level--; |
4102 | return _res; |
4103 | } |
4104 | |
4105 | // decorators: (('@' named_expression NEWLINE))+ |
4106 | static asdl_expr_seq* |
4107 | decorators_rule(Parser *p) |
4108 | { |
4109 | if (p->level++ == MAXSTACK) { Branch (4109:9): [True: 0, False: 38.2k]
|
4110 | p->error_indicator = 1; |
4111 | PyErr_NoMemory(); |
4112 | } |
4113 | if (p->error_indicator) { Branch (4113:9): [True: 0, False: 38.2k]
|
4114 | p->level--; |
4115 | return NULL; |
4116 | } |
4117 | asdl_expr_seq* _res = NULL; |
4118 | int _mark = p->mark; |
4119 | { // (('@' named_expression NEWLINE))+ |
4120 | if (p->error_indicator) { Branch (4120:13): [True: 0, False: 38.2k]
|
4121 | p->level--; |
4122 | return NULL; |
4123 | } |
4124 | D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+")); |
4125 | asdl_expr_seq* a; |
4126 | if ( |
4127 | (a = (asdl_expr_seq*)_loop1_32_rule(p)) // (('@' named_expression NEWLINE))+ Branch (4127:13): [True: 2.57k, False: 35.6k]
|
4128 | ) |
4129 | { |
4130 | D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+")); |
4131 | _res = a; |
4132 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4132:17): [True: 0, False: 2.57k]
Branch (4132:33): [True: 0, False: 0]
|
4133 | p->error_indicator = 1; |
4134 | p->level--; |
4135 | return NULL; |
4136 | } |
4137 | goto done; |
4138 | } |
4139 | p->mark = _mark; |
4140 | D(fprintf(stderr, "%*c%s decorators[%d-%d]: %s failed!\n", p->level, ' ', |
4141 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(('@' named_expression NEWLINE))+")); |
4142 | } |
4143 | _res = NULL; |
4144 | done: |
4145 | p->level--; |
4146 | return _res; |
4147 | } |
4148 | |
4149 | // class_def: decorators class_def_raw | class_def_raw |
4150 | static stmt_ty |
4151 | class_def_rule(Parser *p) |
4152 | { |
4153 | if (p->level++ == MAXSTACK) { Branch (4153:9): [True: 0, False: 4.52k]
|
4154 | p->error_indicator = 1; |
4155 | PyErr_NoMemory(); |
4156 | } |
4157 | if (p->error_indicator) { Branch (4157:9): [True: 0, False: 4.52k]
|
4158 | p->level--; |
4159 | return NULL; |
4160 | } |
4161 | stmt_ty _res = NULL; |
4162 | int _mark = p->mark; |
4163 | { // decorators class_def_raw |
4164 | if (p->error_indicator) { Branch (4164:13): [True: 0, False: 4.52k]
|
4165 | p->level--; |
4166 | return NULL; |
4167 | } |
4168 | D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw")); |
4169 | asdl_expr_seq* a; |
4170 | stmt_ty b; |
4171 | if ( |
4172 | (a = decorators_rule(p)) // decorators Branch (4172:13): [True: 208, False: 4.31k]
|
4173 | && |
4174 | (b = class_def_raw_rule(p))208 // class_def_raw Branch (4174:13): [True: 208, False: 0]
|
4175 | ) |
4176 | { |
4177 | D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw")); |
4178 | _res = _PyPegen_class_def_decorators ( p , a , b ); |
4179 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4179:17): [True: 0, False: 208]
Branch (4179:33): [True: 0, False: 0]
|
4180 | p->error_indicator = 1; |
4181 | p->level--; |
4182 | return NULL; |
4183 | } |
4184 | goto done; |
4185 | } |
4186 | p->mark = _mark; |
4187 | D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', |
4188 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators class_def_raw")); |
4189 | } |
4190 | { // class_def_raw |
4191 | if (p->error_indicator) { Branch (4191:13): [True: 0, False: 4.31k]
|
4192 | p->level--; |
4193 | return NULL; |
4194 | } |
4195 | D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw")); |
4196 | stmt_ty class_def_raw_var; |
4197 | if ( |
4198 | (class_def_raw_var = class_def_raw_rule(p)) // class_def_raw Branch (4198:13): [True: 4.27k, False: 41]
|
4199 | ) |
4200 | { |
4201 | D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_def_raw")); |
4202 | _res = class_def_raw_var; |
4203 | goto done; |
4204 | } |
4205 | p->mark = _mark; |
4206 | D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', |
4207 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw")); |
4208 | } |
4209 | _res = NULL; |
4210 | done: |
4211 | p->level--; |
4212 | return _res; |
4213 | } |
4214 | |
4215 | // class_def_raw: invalid_class_def_raw | 'class' NAME ['(' arguments? ')'] ':' block |
4216 | static stmt_ty |
4217 | class_def_raw_rule(Parser *p) |
4218 | { |
4219 | if (p->level++ == MAXSTACK) { Branch (4219:9): [True: 0, False: 4.52k]
|
4220 | p->error_indicator = 1; |
4221 | PyErr_NoMemory(); |
4222 | } |
4223 | if (p->error_indicator) { Branch (4223:9): [True: 0, False: 4.52k]
|
4224 | p->level--; |
4225 | return NULL; |
4226 | } |
4227 | stmt_ty _res = NULL; |
4228 | int _mark = p->mark; |
4229 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (4229:9): [True: 0, False: 4.52k]
Branch (4229:31): [True: 0, False: 0]
|
4230 | p->error_indicator = 1; |
4231 | p->level--; |
4232 | return NULL; |
4233 | } |
4234 | int _start_lineno = p->tokens[_mark]->lineno; |
4235 | UNUSED(_start_lineno); // Only used by EXTRA macro |
4236 | int _start_col_offset = p->tokens[_mark]->col_offset; |
4237 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
4238 | if (p->call_invalid_rules) { // invalid_class_def_raw Branch (4238:9): [True: 15, False: 4.50k]
|
4239 | if (p->error_indicator) { Branch (4239:13): [True: 0, False: 15]
|
4240 | p->level--; |
4241 | return NULL; |
4242 | } |
4243 | D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class_def_raw")); |
4244 | void *invalid_class_def_raw_var; |
4245 | if ( |
4246 | (invalid_class_def_raw_var = invalid_class_def_raw_rule(p)) // invalid_class_def_raw Branch (4246:13): [True: 0, False: 15]
|
4247 | ) |
4248 | { |
4249 | D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_class_def_raw")); |
4250 | _res = invalid_class_def_raw_var; |
4251 | goto done; |
4252 | } |
4253 | p->mark = _mark; |
4254 | D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
4255 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_def_raw")); |
4256 | } |
4257 | { // 'class' NAME ['(' arguments? ')'] ':' block |
4258 | if (p->error_indicator) { Branch (4258:13): [True: 2, False: 4.52k]
|
4259 | p->level--; |
4260 | return NULL; |
4261 | } |
4262 | D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block")); |
4263 | Token * _keyword; |
4264 | Token * _literal; |
4265 | expr_ty a; |
4266 | void *b; |
4267 | asdl_stmt_seq* c; |
4268 | if ( |
4269 | (_keyword = _PyPegen_expect_token(p, 646)) // token='class' Branch (4269:13): [True: 4.51k, False: 9]
|
4270 | && |
4271 | (a = _PyPegen_name_token(p))4.51k // NAME Branch (4271:13): [True: 4.50k, False: 10]
|
4272 | && |
4273 | (b = _tmp_33_rule(p), !p->error_indicator)4.50k // ['(' arguments? ')'] Branch (4273:13): [True: 4.49k, False: 6]
|
4274 | && |
4275 | (_literal = _PyPegen_expect_token(p, 11))4.49k // token=':' Branch (4275:13): [True: 4.49k, False: 5]
|
4276 | && |
4277 | (c = block_rule(p))4.49k // block Branch (4277:13): [True: 4.48k, False: 9]
|
4278 | ) |
4279 | { |
4280 | D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block")); |
4281 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
4282 | if (_token == NULL) { Branch (4282:17): [True: 0, False: 4.48k]
|
4283 | p->level--; |
4284 | return NULL; |
4285 | } |
4286 | int _end_lineno = _token->end_lineno; |
4287 | UNUSED(_end_lineno); // Only used by EXTRA macro |
4288 | int _end_col_offset = _token->end_col_offset; |
4289 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
4290 | _res = _PyAST_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args2.44k : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords2.44k : NULL , c , NULL , EXTRA ); Branch (4290:59): [True: 2.44k, False: 2.03k]
Branch (4290:113): [True: 2.44k, False: 2.03k]
|
4291 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4291:17): [True: 0, False: 4.48k]
Branch (4291:33): [True: 0, False: 0]
|
4292 | p->error_indicator = 1; |
4293 | p->level--; |
4294 | return NULL; |
4295 | } |
4296 | goto done; |
4297 | } |
4298 | p->mark = _mark; |
4299 | D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
4300 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block")); |
4301 | } |
4302 | _res = NULL; |
4303 | done: |
4304 | p->level--; |
4305 | return _res; |
4306 | } |
4307 | |
4308 | // function_def: decorators function_def_raw | function_def_raw |
4309 | static stmt_ty |
4310 | function_def_rule(Parser *p) |
4311 | { |
4312 | if (p->level++ == MAXSTACK) { Branch (4312:9): [True: 0, False: 33.7k]
|
4313 | p->error_indicator = 1; |
4314 | PyErr_NoMemory(); |
4315 | } |
4316 | if (p->error_indicator) { Branch (4316:9): [True: 0, False: 33.7k]
|
4317 | p->level--; |
4318 | return NULL; |
4319 | } |
4320 | stmt_ty _res = NULL; |
4321 | int _mark = p->mark; |
4322 | { // decorators function_def_raw |
4323 | if (p->error_indicator) { Branch (4323:13): [True: 0, False: 33.7k]
|
4324 | p->level--; |
4325 | return NULL; |
4326 | } |
4327 | D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw")); |
4328 | asdl_expr_seq* d; |
4329 | stmt_ty f; |
4330 | if ( |
4331 | (d = decorators_rule(p)) // decorators Branch (4331:13): [True: 2.37k, False: 31.3k]
|
4332 | && |
4333 | (f = function_def_raw_rule(p))2.37k // function_def_raw Branch (4333:13): [True: 2.16k, False: 208]
|
4334 | ) |
4335 | { |
4336 | D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw")); |
4337 | _res = _PyPegen_function_def_decorators ( p , d , f ); |
4338 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4338:17): [True: 0, False: 2.16k]
Branch (4338:33): [True: 0, False: 0]
|
4339 | p->error_indicator = 1; |
4340 | p->level--; |
4341 | return NULL; |
4342 | } |
4343 | goto done; |
4344 | } |
4345 | p->mark = _mark; |
4346 | D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', |
4347 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators function_def_raw")); |
4348 | } |
4349 | { // function_def_raw |
4350 | if (p->error_indicator) { Branch (4350:13): [True: 11, False: 31.5k]
|
4351 | p->level--; |
4352 | return NULL; |
4353 | } |
4354 | D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_raw")); |
4355 | stmt_ty function_def_raw_var; |
4356 | if ( |
4357 | (function_def_raw_var = function_def_raw_rule(p)) // function_def_raw Branch (4357:13): [True: 30.7k, False: 788]
|
4358 | ) |
4359 | { |
4360 | D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "function_def_raw")); |
4361 | _res = function_def_raw_var; |
4362 | goto done; |
4363 | } |
4364 | p->mark = _mark; |
4365 | D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', |
4366 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw")); |
4367 | } |
4368 | _res = NULL; |
4369 | done: |
4370 | p->level--; |
4371 | return _res; |
4372 | } |
4373 | |
4374 | // function_def_raw: |
4375 | // | invalid_def_raw |
4376 | // | 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block |
4377 | // | ASYNC 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block |
4378 | static stmt_ty |
4379 | function_def_raw_rule(Parser *p) |
4380 | { |
4381 | if (p->level++ == MAXSTACK) { Branch (4381:9): [True: 0, False: 33.9k]
|
4382 | p->error_indicator = 1; |
4383 | PyErr_NoMemory(); |
4384 | } |
4385 | if (p->error_indicator) { Branch (4385:9): [True: 0, False: 33.9k]
|
4386 | p->level--; |
4387 | return NULL; |
4388 | } |
4389 | stmt_ty _res = NULL; |
4390 | int _mark = p->mark; |
4391 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (4391:9): [True: 0, False: 33.9k]
Branch (4391:31): [True: 0, False: 0]
|
4392 | p->error_indicator = 1; |
4393 | p->level--; |
4394 | return NULL; |
4395 | } |
4396 | int _start_lineno = p->tokens[_mark]->lineno; |
4397 | UNUSED(_start_lineno); // Only used by EXTRA macro |
4398 | int _start_col_offset = p->tokens[_mark]->col_offset; |
4399 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
4400 | if (p->call_invalid_rules) { // invalid_def_raw Branch (4400:9): [True: 216, False: 33.7k]
|
4401 | if (p->error_indicator) { Branch (4401:13): [True: 0, False: 216]
|
4402 | p->level--; |
4403 | return NULL; |
4404 | } |
4405 | D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_def_raw")); |
4406 | void *invalid_def_raw_var; |
4407 | if ( |
4408 | (invalid_def_raw_var = invalid_def_raw_rule(p)) // invalid_def_raw Branch (4408:13): [True: 0, False: 216]
|
4409 | ) |
4410 | { |
4411 | D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_def_raw")); |
4412 | _res = invalid_def_raw_var; |
4413 | goto done; |
4414 | } |
4415 | p->mark = _mark; |
4416 | D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
4417 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_def_raw")); |
4418 | } |
4419 | { // 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block |
4420 | if (p->error_indicator) { Branch (4420:13): [True: 72, False: 33.8k]
|
4421 | p->level--; |
4422 | return NULL; |
4423 | } |
4424 | D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block")); |
4425 | Token * _keyword; |
4426 | Token * _literal; |
4427 | Token * _literal_1; |
4428 | Token * _literal_2; |
4429 | void *a; |
4430 | asdl_stmt_seq* b; |
4431 | expr_ty n; |
4432 | void *params; |
4433 | void *tc; |
4434 | if ( |
4435 | (_keyword = _PyPegen_expect_token(p, 644)) // token='def' Branch (4435:13): [True: 32.5k, False: 1.32k]
|
4436 | && |
4437 | (n = _PyPegen_name_token(p))32.5k // NAME Branch (4437:13): [True: 32.5k, False: 18]
|
4438 | && |
4439 | (_literal = _PyPegen_expect_forced_token(p, 7, "("))32.5k // forced_token='(' Branch (4439:13): [True: 32.5k, False: 4]
|
4440 | && |
4441 | (params = params_rule(p), !p->error_indicator)32.5k // params? Branch (4441:13): [True: 32.4k, False: 13]
|
4442 | && |
4443 | (_literal_1 = _PyPegen_expect_token(p, 8))32.4k // token=')' Branch (4443:13): [True: 32.3k, False: 150]
|
4444 | && |
4445 | (a = _tmp_34_rule(p), !p->error_indicator)32.3k // ['->' expression] Branch (4445:13): [True: 32.3k, False: 0]
|
4446 | && |
4447 | (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":"))32.3k // forced_token=':' Branch (4447:13): [True: 32.3k, False: 1]
|
4448 | && |
4449 | (tc = func_type_comment_rule(p), !p->error_indicator)32.3k // func_type_comment? Branch (4449:13): [True: 32.3k, False: 9]
|
4450 | && |
4451 | (b = block_rule(p))32.3k // block Branch (4451:13): [True: 32.2k, False: 75]
|
4452 | ) |
4453 | { |
4454 | D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block")); |
4455 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
4456 | if (_token == NULL) { Branch (4456:17): [True: 0, False: 32.2k]
|
4457 | p->level--; |
4458 | return NULL; |
4459 | } |
4460 | int _end_lineno = _token->end_lineno; |
4461 | UNUSED(_end_lineno); // Only used by EXTRA macro |
4462 | int _end_col_offset = _token->end_col_offset; |
4463 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
4464 | _res = _PyAST_FunctionDef ( n -> v . Name . id , ( params ) ? params27.4k : CHECK4.81k ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); Branch (4464:62): [True: 27.4k, False: 4.81k]
|
4465 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4465:17): [True: 0, False: 32.2k]
Branch (4465:33): [True: 0, False: 0]
|
4466 | p->error_indicator = 1; |
4467 | p->level--; |
4468 | return NULL; |
4469 | } |
4470 | goto done; |
4471 | } |
4472 | p->mark = _mark; |
4473 | D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
4474 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block")); |
4475 | } |
4476 | { // ASYNC 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block |
4477 | if (p->error_indicator) { Branch (4477:13): [True: 38, False: 1.55k]
|
4478 | p->level--; |
4479 | return NULL; |
4480 | } |
4481 | D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block")); |
4482 | Token * _keyword; |
4483 | Token * _literal; |
4484 | Token * _literal_1; |
4485 | Token * _literal_2; |
4486 | void *a; |
4487 | Token * async_var; |
4488 | asdl_stmt_seq* b; |
4489 | expr_ty n; |
4490 | void *params; |
4491 | void *tc; |
4492 | if ( |
4493 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (4493:13): [True: 895, False: 657]
|
4494 | && |
4495 | (_keyword = _PyPegen_expect_token(p, 644))895 // token='def' Branch (4495:13): [True: 725, False: 170]
|
4496 | && |
4497 | (n = _PyPegen_name_token(p))725 // NAME Branch (4497:13): [True: 725, False: 0]
|
4498 | && |
4499 | (_literal = _PyPegen_expect_forced_token(p, 7, "("))725 // forced_token='(' Branch (4499:13): [True: 724, False: 1]
|
4500 | && |
4501 | (params = params_rule(p), !p->error_indicator)724 // params? Branch (4501:13): [True: 724, False: 0]
|
4502 | && |
4503 | (_literal_1 = _PyPegen_expect_token(p, 8))724 // token=')' Branch (4503:13): [True: 701, False: 23]
|
4504 | && |
4505 | (a = _tmp_35_rule(p), !p->error_indicator)701 // ['->' expression] Branch (4505:13): [True: 701, False: 0]
|
4506 | && |
4507 | (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":"))701 // forced_token=':' Branch (4507:13): [True: 701, False: 0]
|
4508 | && |
4509 | (tc = func_type_comment_rule(p), !p->error_indicator)701 // func_type_comment? Branch (4509:13): [True: 701, False: 0]
|
4510 | && |
4511 | (b = block_rule(p))701 // block Branch (4511:13): [True: 666, False: 35]
|
4512 | ) |
4513 | { |
4514 | D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block")); |
4515 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
4516 | if (_token == NULL) { Branch (4516:17): [True: 0, False: 666]
|
4517 | p->level--; |
4518 | return NULL; |
4519 | } |
4520 | int _end_lineno = _token->end_lineno; |
4521 | UNUSED(_end_lineno); // Only used by EXTRA macro |
4522 | int _end_col_offset = _token->end_col_offset; |
4523 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
4524 | _res = CHECK_VERSION ( stmt_ty , 5 , "Async functions are" , _PyAST_AsyncFunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); |
4525 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4525:17): [True: 0, False: 666]
Branch (4525:33): [True: 0, False: 0]
|
4526 | p->error_indicator = 1; |
4527 | p->level--; |
4528 | return NULL; |
4529 | } |
4530 | goto done; |
4531 | } |
4532 | p->mark = _mark; |
4533 | D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
4534 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block")); |
4535 | } |
4536 | _res = NULL; |
4537 | done: |
4538 | p->level--; |
4539 | return _res; |
4540 | } |
4541 | |
4542 | // params: invalid_parameters | parameters |
4543 | static arguments_ty |
4544 | params_rule(Parser *p) |
4545 | { |
4546 | if (p->level++ == MAXSTACK) { Branch (4546:9): [True: 0, False: 33.4k]
|
4547 | p->error_indicator = 1; |
4548 | PyErr_NoMemory(); |
4549 | } |
4550 | if (p->error_indicator) { Branch (4550:9): [True: 0, False: 33.4k]
|
4551 | p->level--; |
4552 | return NULL; |
4553 | } |
4554 | arguments_ty _res = NULL; |
4555 | int _mark = p->mark; |
4556 | if (p->call_invalid_rules) { // invalid_parameters Branch (4556:9): [True: 300, False: 33.1k]
|
4557 | if (p->error_indicator) { Branch (4557:13): [True: 0, False: 300]
|
4558 | p->level--; |
4559 | return NULL; |
4560 | } |
4561 | D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters")); |
4562 | void *invalid_parameters_var; |
4563 | if ( |
4564 | (invalid_parameters_var = invalid_parameters_rule(p)) // invalid_parameters Branch (4564:13): [True: 0, False: 300]
|
4565 | ) |
4566 | { |
4567 | D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_parameters")); |
4568 | _res = invalid_parameters_var; |
4569 | goto done; |
4570 | } |
4571 | p->mark = _mark; |
4572 | D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ', |
4573 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_parameters")); |
4574 | } |
4575 | { // parameters |
4576 | if (p->error_indicator) { Branch (4576:13): [True: 50, False: 33.3k]
|
4577 | p->level--; |
4578 | return NULL; |
4579 | } |
4580 | D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters")); |
4581 | arguments_ty parameters_var; |
4582 | if ( |
4583 | (parameters_var = parameters_rule(p)) // parameters Branch (4583:13): [True: 27.8k, False: 5.52k]
|
4584 | ) |
4585 | { |
4586 | D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameters")); |
4587 | _res = parameters_var; |
4588 | goto done; |
4589 | } |
4590 | p->mark = _mark; |
4591 | D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ', |
4592 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters")); |
4593 | } |
4594 | _res = NULL; |
4595 | done: |
4596 | p->level--; |
4597 | return _res; |
4598 | } |
4599 | |
4600 | // parameters: |
4601 | // | slash_no_default param_no_default* param_with_default* star_etc? |
4602 | // | slash_with_default param_with_default* star_etc? |
4603 | // | param_no_default+ param_with_default* star_etc? |
4604 | // | param_with_default+ star_etc? |
4605 | // | star_etc |
4606 | static arguments_ty |
4607 | parameters_rule(Parser *p) |
4608 | { |
4609 | if (p->level++ == MAXSTACK) { Branch (4609:9): [True: 0, False: 33.3k]
|
4610 | p->error_indicator = 1; |
4611 | PyErr_NoMemory(); |
4612 | } |
4613 | if (p->error_indicator) { Branch (4613:9): [True: 0, False: 33.3k]
|
4614 | p->level--; |
4615 | return NULL; |
4616 | } |
4617 | arguments_ty _res = NULL; |
4618 | int _mark = p->mark; |
4619 | { // slash_no_default param_no_default* param_with_default* star_etc? |
4620 | if (p->error_indicator) { Branch (4620:13): [True: 0, False: 33.3k]
|
4621 | p->level--; |
4622 | return NULL; |
4623 | } |
4624 | D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?")); |
4625 | asdl_arg_seq* a; |
4626 | asdl_arg_seq* b; |
4627 | asdl_seq * c; |
4628 | void *d; |
4629 | if ( |
4630 | (a = slash_no_default_rule(p)) // slash_no_default Branch (4630:13): [True: 380, False: 32.9k]
|
4631 | && |
4632 | (b = (asdl_arg_seq*)_loop0_36_rule(p))380 // param_no_default* Branch (4632:13): [True: 380, False: 0]
|
4633 | && |
4634 | (c = _loop0_37_rule(p))380 // param_with_default* Branch (4634:13): [True: 380, False: 0]
|
4635 | && |
4636 | (d = star_etc_rule(p), !p->error_indicator)380 // star_etc? Branch (4636:13): [True: 378, False: 2]
|
4637 | ) |
4638 | { |
4639 | D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?")); |
4640 | _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d ); |
4641 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4641:17): [True: 0, False: 378]
Branch (4641:33): [True: 0, False: 0]
|
4642 | p->error_indicator = 1; |
4643 | p->level--; |
4644 | return NULL; |
4645 | } |
4646 | goto done; |
4647 | } |
4648 | p->mark = _mark; |
4649 | D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', |
4650 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?")); |
4651 | } |
4652 | { // slash_with_default param_with_default* star_etc? |
4653 | if (p->error_indicator) { Branch (4653:13): [True: 15, False: 32.9k]
|
4654 | p->level--; |
4655 | return NULL; |
4656 | } |
4657 | D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?")); |
4658 | SlashWithDefault* a; |
4659 | asdl_seq * b; |
4660 | void *c; |
4661 | if ( |
4662 | (a = slash_with_default_rule(p)) // slash_with_default Branch (4662:13): [True: 125, False: 32.8k]
|
4663 | && |
4664 | (b = _loop0_38_rule(p))125 // param_with_default* Branch (4664:13): [True: 125, False: 0]
|
4665 | && |
4666 | (c = star_etc_rule(p), !p->error_indicator)125 // star_etc? Branch (4666:13): [True: 124, False: 1]
|
4667 | ) |
4668 | { |
4669 | D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?")); |
4670 | _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ); |
4671 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4671:17): [True: 0, False: 124]
Branch (4671:33): [True: 0, False: 0]
|
4672 | p->error_indicator = 1; |
4673 | p->level--; |
4674 | return NULL; |
4675 | } |
4676 | goto done; |
4677 | } |
4678 | p->mark = _mark; |
4679 | D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', |
4680 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default param_with_default* star_etc?")); |
4681 | } |
4682 | { // param_no_default+ param_with_default* star_etc? |
4683 | if (p->error_indicator) { Branch (4683:13): [True: 1, False: 32.8k]
|
4684 | p->level--; |
4685 | return NULL; |
4686 | } |
4687 | D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?")); |
4688 | asdl_arg_seq* a; |
4689 | asdl_seq * b; |
4690 | void *c; |
4691 | if ( |
4692 | (a = (asdl_arg_seq*)_loop1_39_rule(p)) // param_no_default+ Branch (4692:13): [True: 26.1k, False: 6.74k]
|
4693 | && |
4694 | (b = _loop0_40_rule(p))26.1k // param_with_default* Branch (4694:13): [True: 26.1k, False: 0]
|
4695 | && |
4696 | (c = star_etc_rule(p), !p->error_indicator)26.1k // star_etc? Branch (4696:13): [True: 26.0k, False: 11]
|
4697 | ) |
4698 | { |
4699 | D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?")); |
4700 | _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); |
4701 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4701:17): [True: 0, False: 26.0k]
Branch (4701:33): [True: 0, False: 0]
|
4702 | p->error_indicator = 1; |
4703 | p->level--; |
4704 | return NULL; |
4705 | } |
4706 | goto done; |
4707 | } |
4708 | p->mark = _mark; |
4709 | D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', |
4710 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ param_with_default* star_etc?")); |
4711 | } |
4712 | { // param_with_default+ star_etc? |
4713 | if (p->error_indicator) { Branch (4713:13): [True: 11, False: 6.74k]
|
4714 | p->level--; |
4715 | return NULL; |
4716 | } |
4717 | D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?")); |
4718 | asdl_seq * a; |
4719 | void *b; |
4720 | if ( |
4721 | (a = _loop1_41_rule(p)) // param_with_default+ Branch (4721:13): [True: 325, False: 6.42k]
|
4722 | && |
4723 | (b = star_etc_rule(p), !p->error_indicator)325 // star_etc? Branch (4723:13): [True: 325, False: 0]
|
4724 | ) |
4725 | { |
4726 | D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?")); |
4727 | _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b ); |
4728 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4728:17): [True: 0, False: 325]
Branch (4728:33): [True: 0, False: 0]
|
4729 | p->error_indicator = 1; |
4730 | p->level--; |
4731 | return NULL; |
4732 | } |
4733 | goto done; |
4734 | } |
4735 | p->mark = _mark; |
4736 | D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', |
4737 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+ star_etc?")); |
4738 | } |
4739 | { // star_etc |
4740 | if (p->error_indicator) { Branch (4740:13): [True: 0, False: 6.42k]
|
4741 | p->level--; |
4742 | return NULL; |
4743 | } |
4744 | D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc")); |
4745 | StarEtc* a; |
4746 | if ( |
4747 | (a = star_etc_rule(p)) // star_etc Branch (4747:13): [True: 919, False: 5.50k]
|
4748 | ) |
4749 | { |
4750 | D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_etc")); |
4751 | _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a ); |
4752 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4752:17): [True: 0, False: 919]
Branch (4752:33): [True: 0, False: 0]
|
4753 | p->error_indicator = 1; |
4754 | p->level--; |
4755 | return NULL; |
4756 | } |
4757 | goto done; |
4758 | } |
4759 | p->mark = _mark; |
4760 | D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', |
4761 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_etc")); |
4762 | } |
4763 | _res = NULL; |
4764 | done: |
4765 | p->level--; |
4766 | return _res; |
4767 | } |
4768 | |
4769 | // slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')' |
4770 | static asdl_arg_seq* |
4771 | slash_no_default_rule(Parser *p) |
4772 | { |
4773 | if (p->level++ == MAXSTACK) { Branch (4773:9): [True: 0, False: 33.9k]
|
4774 | p->error_indicator = 1; |
4775 | PyErr_NoMemory(); |
4776 | } |
4777 | if (p->error_indicator) { Branch (4777:9): [True: 0, False: 33.9k]
|
4778 | p->level--; |
4779 | return NULL; |
4780 | } |
4781 | asdl_arg_seq* _res = NULL; |
4782 | int _mark = p->mark; |
4783 | { // param_no_default+ '/' ',' |
4784 | if (p->error_indicator) { Branch (4784:13): [True: 0, False: 33.9k]
|
4785 | p->level--; |
4786 | return NULL; |
4787 | } |
4788 | D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','")); |
4789 | Token * _literal; |
4790 | Token * _literal_1; |
4791 | asdl_arg_seq* a; |
4792 | if ( |
4793 | (a = (asdl_arg_seq*)_loop1_42_rule(p)) // param_no_default+ Branch (4793:13): [True: 26.6k, False: 7.25k]
|
4794 | && |
4795 | (_literal = _PyPegen_expect_token(p, 17))26.6k // token='/' Branch (4795:13): [True: 395, False: 26.2k]
|
4796 | && |
4797 | (_literal_1 = _PyPegen_expect_token(p, 12))395 // token=',' Branch (4797:13): [True: 339, False: 56]
|
4798 | ) |
4799 | { |
4800 | D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','")); |
4801 | _res = a; |
4802 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4802:17): [True: 0, False: 339]
Branch (4802:33): [True: 0, False: 0]
|
4803 | p->error_indicator = 1; |
4804 | p->level--; |
4805 | return NULL; |
4806 | } |
4807 | goto done; |
4808 | } |
4809 | p->mark = _mark; |
4810 | D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
4811 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' ','")); |
4812 | } |
4813 | { // param_no_default+ '/' &')' |
4814 | if (p->error_indicator) { Branch (4814:13): [True: 13, False: 33.5k]
|
4815 | p->level--; |
4816 | return NULL; |
4817 | } |
4818 | D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'")); |
4819 | Token * _literal; |
4820 | asdl_arg_seq* a; |
4821 | if ( |
4822 | (a = (asdl_arg_seq*)_loop1_43_rule(p)) // param_no_default+ Branch (4822:13): [True: 26.3k, False: 7.24k]
|
4823 | && |
4824 | (_literal = _PyPegen_expect_token(p, 17))26.3k // token='/' Branch (4824:13): [True: 56, False: 26.2k]
|
4825 | && |
4826 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)56 // token=')' Branch (4826:13): [True: 56, False: 0]
|
4827 | ) |
4828 | { |
4829 | D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'")); |
4830 | _res = a; |
4831 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4831:17): [True: 0, False: 56]
Branch (4831:33): [True: 0, False: 0]
|
4832 | p->error_indicator = 1; |
4833 | p->level--; |
4834 | return NULL; |
4835 | } |
4836 | goto done; |
4837 | } |
4838 | p->mark = _mark; |
4839 | D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
4840 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' &')'")); |
4841 | } |
4842 | _res = NULL; |
4843 | done: |
4844 | p->level--; |
4845 | return _res; |
4846 | } |
4847 | |
4848 | // slash_with_default: |
4849 | // | param_no_default* param_with_default+ '/' ',' |
4850 | // | param_no_default* param_with_default+ '/' &')' |
4851 | static SlashWithDefault* |
4852 | slash_with_default_rule(Parser *p) |
4853 | { |
4854 | if (p->level++ == MAXSTACK) { Branch (4854:9): [True: 0, False: 33.7k]
|
4855 | p->error_indicator = 1; |
4856 | PyErr_NoMemory(); |
4857 | } |
4858 | if (p->error_indicator) { Branch (4858:9): [True: 0, False: 33.7k]
|
4859 | p->level--; |
4860 | return NULL; |
4861 | } |
4862 | SlashWithDefault* _res = NULL; |
4863 | int _mark = p->mark; |
4864 | { // param_no_default* param_with_default+ '/' ',' |
4865 | if (p->error_indicator) { Branch (4865:13): [True: 0, False: 33.7k]
|
4866 | p->level--; |
4867 | return NULL; |
4868 | } |
4869 | D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','")); |
4870 | Token * _literal; |
4871 | Token * _literal_1; |
4872 | asdl_seq * a; |
4873 | asdl_seq * b; |
4874 | if ( |
4875 | (a = _loop0_44_rule(p)) // param_no_default* Branch (4875:13): [True: 33.7k, False: 0]
|
4876 | && |
4877 | (b = _loop1_45_rule(p)) // param_with_default+ Branch (4877:13): [True: 3.00k, False: 30.7k]
|
4878 | && |
4879 | (_literal = _PyPegen_expect_token(p, 17))3.00k // token='/' Branch (4879:13): [True: 138, False: 2.86k]
|
4880 | && |
4881 | (_literal_1 = _PyPegen_expect_token(p, 12))138 // token=',' Branch (4881:13): [True: 121, False: 17]
|
4882 | ) |
4883 | { |
4884 | D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','")); |
4885 | _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); |
4886 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4886:17): [True: 0, False: 121]
Branch (4886:33): [True: 0, False: 0]
|
4887 | p->error_indicator = 1; |
4888 | p->level--; |
4889 | return NULL; |
4890 | } |
4891 | goto done; |
4892 | } |
4893 | p->mark = _mark; |
4894 | D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
4895 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' ','")); |
4896 | } |
4897 | { // param_no_default* param_with_default+ '/' &')' |
4898 | if (p->error_indicator) { Branch (4898:13): [True: 3, False: 33.6k]
|
4899 | p->level--; |
4900 | return NULL; |
4901 | } |
4902 | D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'")); |
4903 | Token * _literal; |
4904 | asdl_seq * a; |
4905 | asdl_seq * b; |
4906 | if ( |
4907 | (a = _loop0_46_rule(p)) // param_no_default* Branch (4907:13): [True: 33.6k, False: 0]
|
4908 | && |
4909 | (b = _loop1_47_rule(p)) // param_with_default+ Branch (4909:13): [True: 2.88k, False: 30.7k]
|
4910 | && |
4911 | (_literal = _PyPegen_expect_token(p, 17))2.88k // token='/' Branch (4911:13): [True: 17, False: 2.86k]
|
4912 | && |
4913 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)17 // token=')' Branch (4913:13): [True: 13, False: 4]
|
4914 | ) |
4915 | { |
4916 | D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'")); |
4917 | _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); |
4918 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4918:17): [True: 0, False: 13]
Branch (4918:33): [True: 0, False: 0]
|
4919 | p->error_indicator = 1; |
4920 | p->level--; |
4921 | return NULL; |
4922 | } |
4923 | goto done; |
4924 | } |
4925 | p->mark = _mark; |
4926 | D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
4927 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' &')'")); |
4928 | } |
4929 | _res = NULL; |
4930 | done: |
4931 | p->level--; |
4932 | return _res; |
4933 | } |
4934 | |
4935 | // star_etc: |
4936 | // | invalid_star_etc |
4937 | // | '*' param_no_default param_maybe_default* kwds? |
4938 | // | '*' param_no_default_star_annotation param_maybe_default* kwds? |
4939 | // | '*' ',' param_maybe_default+ kwds? |
4940 | // | kwds |
4941 | static StarEtc* |
4942 | star_etc_rule(Parser *p) |
4943 | { |
4944 | if (p->level++ == MAXSTACK) { Branch (4944:9): [True: 0, False: 33.3k]
|
4945 | p->error_indicator = 1; |
4946 | PyErr_NoMemory(); |
4947 | } |
4948 | if (p->error_indicator) { Branch (4948:9): [True: 0, False: 33.3k]
|
4949 | p->level--; |
4950 | return NULL; |
4951 | } |
4952 | StarEtc* _res = NULL; |
4953 | int _mark = p->mark; |
4954 | if (p->call_invalid_rules) { // invalid_star_etc Branch (4954:9): [True: 250, False: 33.1k]
|
4955 | if (p->error_indicator) { Branch (4955:13): [True: 0, False: 250]
|
4956 | p->level--; |
4957 | return NULL; |
4958 | } |
4959 | D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc")); |
4960 | void *invalid_star_etc_var; |
4961 | if ( |
4962 | (invalid_star_etc_var = invalid_star_etc_rule(p)) // invalid_star_etc Branch (4962:13): [True: 0, False: 250]
|
4963 | ) |
4964 | { |
4965 | D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_star_etc")); |
4966 | _res = invalid_star_etc_var; |
4967 | goto done; |
4968 | } |
4969 | p->mark = _mark; |
4970 | D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
4971 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc")); |
4972 | } |
4973 | { // '*' param_no_default param_maybe_default* kwds? |
4974 | if (p->error_indicator) { Branch (4974:13): [True: 10, False: 33.3k]
|
4975 | p->level--; |
4976 | return NULL; |
4977 | } |
4978 | D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?")); |
4979 | Token * _literal; |
4980 | arg_ty a; |
4981 | asdl_seq * b; |
4982 | void *c; |
4983 | if ( |
4984 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (4984:13): [True: 3.18k, False: 30.1k]
|
4985 | && |
4986 | (a = param_no_default_rule(p))3.18k // param_no_default Branch (4986:13): [True: 2.06k, False: 1.11k]
|
4987 | && |
4988 | (b = _loop0_48_rule(p))2.06k // param_maybe_default* Branch (4988:13): [True: 2.06k, False: 0]
|
4989 | && |
4990 | (c = kwds_rule(p), !p->error_indicator)2.06k // kwds? Branch (4990:13): [True: 2.06k, False: 4]
|
4991 | ) |
4992 | { |
4993 | D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?")); |
4994 | _res = _PyPegen_star_etc ( p , a , b , c ); |
4995 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (4995:17): [True: 0, False: 2.06k]
Branch (4995:33): [True: 0, False: 0]
|
4996 | p->error_indicator = 1; |
4997 | p->level--; |
4998 | return NULL; |
4999 | } |
5000 | goto done; |
5001 | } |
5002 | p->mark = _mark; |
5003 | D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
5004 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?")); |
5005 | } |
5006 | { // '*' param_no_default_star_annotation param_maybe_default* kwds? |
5007 | if (p->error_indicator) { Branch (5007:13): [True: 4, False: 31.2k]
|
5008 | p->level--; |
5009 | return NULL; |
5010 | } |
5011 | D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?")); |
5012 | Token * _literal; |
5013 | arg_ty a; |
5014 | asdl_seq * b; |
5015 | void *c; |
5016 | if ( |
5017 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (5017:13): [True: 1.11k, False: 30.1k]
|
5018 | && |
5019 | (a = param_no_default_star_annotation_rule(p))1.11k // param_no_default_star_annotation Branch (5019:13): [True: 20, False: 1.09k]
|
5020 | && |
5021 | (b = _loop0_49_rule(p))20 // param_maybe_default* Branch (5021:13): [True: 20, False: 0]
|
5022 | && |
5023 | (c = kwds_rule(p), !p->error_indicator)20 // kwds? Branch (5023:13): [True: 20, False: 0]
|
5024 | ) |
5025 | { |
5026 | D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?")); |
5027 | _res = _PyPegen_star_etc ( p , a , b , c ); |
5028 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5028:17): [True: 0, False: 20]
Branch (5028:33): [True: 0, False: 0]
|
5029 | p->error_indicator = 1; |
5030 | p->level--; |
5031 | return NULL; |
5032 | } |
5033 | goto done; |
5034 | } |
5035 | p->mark = _mark; |
5036 | D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
5037 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?")); |
5038 | } |
5039 | { // '*' ',' param_maybe_default+ kwds? |
5040 | if (p->error_indicator) { Branch (5040:13): [True: 0, False: 31.2k]
|
5041 | p->level--; |
5042 | return NULL; |
5043 | } |
5044 | D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); |
5045 | Token * _literal; |
5046 | Token * _literal_1; |
5047 | asdl_seq * b; |
5048 | void *c; |
5049 | if ( |
5050 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (5050:13): [True: 1.09k, False: 30.1k]
|
5051 | && |
5052 | (_literal_1 = _PyPegen_expect_token(p, 12))1.09k // token=',' Branch (5052:13): [True: 1.08k, False: 10]
|
5053 | && |
5054 | (b = _loop1_50_rule(p))1.08k // param_maybe_default+ Branch (5054:13): [True: 1.06k, False: 13]
|
5055 | && |
5056 | (c = kwds_rule(p), !p->error_indicator)1.06k // kwds? Branch (5056:13): [True: 1.06k, False: 0]
|
5057 | ) |
5058 | { |
5059 | D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); |
5060 | _res = _PyPegen_star_etc ( p , NULL , b , c ); |
5061 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5061:17): [True: 0, False: 1.06k]
Branch (5061:33): [True: 0, False: 0]
|
5062 | p->error_indicator = 1; |
5063 | p->level--; |
5064 | return NULL; |
5065 | } |
5066 | goto done; |
5067 | } |
5068 | p->mark = _mark; |
5069 | D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
5070 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); |
5071 | } |
5072 | { // kwds |
5073 | if (p->error_indicator) { Branch (5073:13): [True: 0, False: 30.1k]
|
5074 | p->level--; |
5075 | return NULL; |
5076 | } |
5077 | D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds")); |
5078 | arg_ty a; |
5079 | if ( |
5080 | (a = kwds_rule(p)) // kwds Branch (5080:13): [True: 230, False: 29.9k]
|
5081 | ) |
5082 | { |
5083 | D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds")); |
5084 | _res = _PyPegen_star_etc ( p , NULL , NULL , a ); |
5085 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5085:17): [True: 0, False: 230]
Branch (5085:33): [True: 0, False: 0]
|
5086 | p->error_indicator = 1; |
5087 | p->level--; |
5088 | return NULL; |
5089 | } |
5090 | goto done; |
5091 | } |
5092 | p->mark = _mark; |
5093 | D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
5094 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwds")); |
5095 | } |
5096 | _res = NULL; |
5097 | done: |
5098 | p->level--; |
5099 | return _res; |
5100 | } |
5101 | |
5102 | // kwds: invalid_kwds | '**' param_no_default |
5103 | static arg_ty |
5104 | kwds_rule(Parser *p) |
5105 | { |
5106 | if (p->level++ == MAXSTACK) { Branch (5106:9): [True: 0, False: 33.3k]
|
5107 | p->error_indicator = 1; |
5108 | PyErr_NoMemory(); |
5109 | } |
5110 | if (p->error_indicator) { Branch (5110:9): [True: 0, False: 33.3k]
|
5111 | p->level--; |
5112 | return NULL; |
5113 | } |
5114 | arg_ty _res = NULL; |
5115 | int _mark = p->mark; |
5116 | if (p->call_invalid_rules) { // invalid_kwds Branch (5116:9): [True: 240, False: 33.1k]
|
5117 | if (p->error_indicator) { Branch (5117:13): [True: 0, False: 240]
|
5118 | p->level--; |
5119 | return NULL; |
5120 | } |
5121 | D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwds")); |
5122 | void *invalid_kwds_var; |
5123 | if ( |
5124 | (invalid_kwds_var = invalid_kwds_rule(p)) // invalid_kwds Branch (5124:13): [True: 0, False: 240]
|
5125 | ) |
5126 | { |
5127 | D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwds")); |
5128 | _res = invalid_kwds_var; |
5129 | goto done; |
5130 | } |
5131 | p->mark = _mark; |
5132 | D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ', |
5133 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwds")); |
5134 | } |
5135 | { // '**' param_no_default |
5136 | if (p->error_indicator) { Branch (5136:13): [True: 9, False: 33.3k]
|
5137 | p->level--; |
5138 | return NULL; |
5139 | } |
5140 | D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default")); |
5141 | Token * _literal; |
5142 | arg_ty a; |
5143 | if ( |
5144 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (5144:13): [True: 1.79k, False: 31.5k]
|
5145 | && |
5146 | (a = param_no_default_rule(p))1.79k // param_no_default Branch (5146:13): [True: 1.78k, False: 8]
|
5147 | ) |
5148 | { |
5149 | D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_no_default")); |
5150 | _res = a; |
5151 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5151:17): [True: 0, False: 1.78k]
Branch (5151:33): [True: 0, False: 0]
|
5152 | p->error_indicator = 1; |
5153 | p->level--; |
5154 | return NULL; |
5155 | } |
5156 | goto done; |
5157 | } |
5158 | p->mark = _mark; |
5159 | D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ', |
5160 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param_no_default")); |
5161 | } |
5162 | _res = NULL; |
5163 | done: |
5164 | p->level--; |
5165 | return _res; |
5166 | } |
5167 | |
5168 | // param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')' |
5169 | static arg_ty |
5170 | param_no_default_rule(Parser *p) |
5171 | { |
5172 | if (p->level++ == MAXSTACK) { Branch (5172:9): [True: 0, False: 386k]
|
5173 | p->error_indicator = 1; |
5174 | PyErr_NoMemory(); |
5175 | } |
5176 | if (p->error_indicator) { Branch (5176:9): [True: 0, False: 386k]
|
5177 | p->level--; |
5178 | return NULL; |
5179 | } |
5180 | arg_ty _res = NULL; |
5181 | int _mark = p->mark; |
5182 | { // param ',' TYPE_COMMENT? |
5183 | if (p->error_indicator) { Branch (5183:13): [True: 0, False: 386k]
|
5184 | p->level--; |
5185 | return NULL; |
5186 | } |
5187 | D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?")); |
5188 | Token * _literal; |
5189 | arg_ty a; |
5190 | void *tc; |
5191 | if ( |
5192 | (a = param_rule(p)) // param Branch (5192:13): [True: 232k, False: 153k]
|
5193 | && |
5194 | (_literal = _PyPegen_expect_token(p, 12))232k // token=',' Branch (5194:13): [True: 105k, False: 126k]
|
5195 | && |
5196 | (tc = _PyPegen_expect_token(p, 105k TYPE_COMMENT105k ), !p->error_indicator) // TYPE_COMMENT? Branch (5196:13): [True: 105k, False: 4]
|
5197 | ) |
5198 | { |
5199 | D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?")); |
5200 | _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); |
5201 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5201:17): [True: 0, False: 105k]
Branch (5201:33): [True: 0, False: 0]
|
5202 | p->error_indicator = 1; |
5203 | p->level--; |
5204 | return NULL; |
5205 | } |
5206 | goto done; |
5207 | } |
5208 | p->mark = _mark; |
5209 | D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
5210 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param ',' TYPE_COMMENT?")); |
5211 | } |
5212 | { // param TYPE_COMMENT? &')' |
5213 | if (p->error_indicator) { Branch (5213:13): [True: 18, False: 280k]
|
5214 | p->level--; |
5215 | return NULL; |
5216 | } |
5217 | D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'")); |
5218 | arg_ty a; |
5219 | void *tc; |
5220 | if ( |
5221 | (a = param_rule(p)) // param Branch (5221:13): [True: 126k, False: 153k]
|
5222 | && |
5223 | (tc = _PyPegen_expect_token(p, 126k TYPE_COMMENT126k ), !p->error_indicator) // TYPE_COMMENT? Branch (5223:13): [True: 126k, False: 0]
|
5224 | && |
5225 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)126k // token=')' Branch (5225:13): [True: 110k, False: 16.0k]
|
5226 | ) |
5227 | { |
5228 | D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'")); |
5229 | _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); |
5230 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5230:17): [True: 0, False: 110k]
Branch (5230:33): [True: 0, False: 0]
|
5231 | p->error_indicator = 1; |
5232 | p->level--; |
5233 | return NULL; |
5234 | } |
5235 | goto done; |
5236 | } |
5237 | p->mark = _mark; |
5238 | D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
5239 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param TYPE_COMMENT? &')'")); |
5240 | } |
5241 | _res = NULL; |
5242 | done: |
5243 | p->level--; |
5244 | return _res; |
5245 | } |
5246 | |
5247 | // param_no_default_star_annotation: |
5248 | // | param_star_annotation ',' TYPE_COMMENT? |
5249 | // | param_star_annotation TYPE_COMMENT? &')' |
5250 | static arg_ty |
5251 | param_no_default_star_annotation_rule(Parser *p) |
5252 | { |
5253 | if (p->level++ == MAXSTACK) { Branch (5253:9): [True: 0, False: 1.11k]
|
5254 | p->error_indicator = 1; |
5255 | PyErr_NoMemory(); |
5256 | } |
5257 | if (p->error_indicator) { Branch (5257:9): [True: 0, False: 1.11k]
|
5258 | p->level--; |
5259 | return NULL; |
5260 | } |
5261 | arg_ty _res = NULL; |
5262 | int _mark = p->mark; |
5263 | { // param_star_annotation ',' TYPE_COMMENT? |
5264 | if (p->error_indicator) { Branch (5264:13): [True: 0, False: 1.11k]
|
5265 | p->level--; |
5266 | return NULL; |
5267 | } |
5268 | D(fprintf(stderr, "%*c> param_no_default_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?")); |
5269 | Token * _literal; |
5270 | arg_ty a; |
5271 | void *tc; |
5272 | if ( |
5273 | (a = param_star_annotation_rule(p)) // param_star_annotation Branch (5273:13): [True: 24, False: 1.08k]
|
5274 | && |
5275 | (_literal = _PyPegen_expect_token(p, 12))24 // token=',' Branch (5275:13): [True: 3, False: 21]
|
5276 | && |
5277 | (tc = _PyPegen_expect_token(p, 3 TYPE_COMMENT3 ), !p->error_indicator) // TYPE_COMMENT? Branch (5277:13): [True: 3, False: 0]
|
5278 | ) |
5279 | { |
5280 | D(fprintf(stderr, "%*c+ param_no_default_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?")); |
5281 | _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); |
5282 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5282:17): [True: 0, False: 3]
Branch (5282:33): [True: 0, False: 0]
|
5283 | p->error_indicator = 1; |
5284 | p->level--; |
5285 | return NULL; |
5286 | } |
5287 | goto done; |
5288 | } |
5289 | p->mark = _mark; |
5290 | D(fprintf(stderr, "%*c%s param_no_default_star_annotation[%d-%d]: %s failed!\n", p->level, ' ', |
5291 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?")); |
5292 | } |
5293 | { // param_star_annotation TYPE_COMMENT? &')' |
5294 | if (p->error_indicator) { Branch (5294:13): [True: 0, False: 1.10k]
|
5295 | p->level--; |
5296 | return NULL; |
5297 | } |
5298 | D(fprintf(stderr, "%*c> param_no_default_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'")); |
5299 | arg_ty a; |
5300 | void *tc; |
5301 | if ( |
5302 | (a = param_star_annotation_rule(p)) // param_star_annotation Branch (5302:13): [True: 21, False: 1.08k]
|
5303 | && |
5304 | (tc = _PyPegen_expect_token(p, 21 TYPE_COMMENT21 ), !p->error_indicator) // TYPE_COMMENT? Branch (5304:13): [True: 21, False: 0]
|
5305 | && |
5306 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)21 // token=')' Branch (5306:13): [True: 17, False: 4]
|
5307 | ) |
5308 | { |
5309 | D(fprintf(stderr, "%*c+ param_no_default_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'")); |
5310 | _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); |
5311 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5311:17): [True: 0, False: 17]
Branch (5311:33): [True: 0, False: 0]
|
5312 | p->error_indicator = 1; |
5313 | p->level--; |
5314 | return NULL; |
5315 | } |
5316 | goto done; |
5317 | } |
5318 | p->mark = _mark; |
5319 | D(fprintf(stderr, "%*c%s param_no_default_star_annotation[%d-%d]: %s failed!\n", p->level, ' ', |
5320 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'")); |
5321 | } |
5322 | _res = NULL; |
5323 | done: |
5324 | p->level--; |
5325 | return _res; |
5326 | } |
5327 | |
5328 | // param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')' |
5329 | static NameDefaultPair* |
5330 | param_with_default_rule(Parser *p) |
5331 | { |
5332 | if (p->level++ == MAXSTACK) { Branch (5332:9): [True: 0, False: 116k]
|
5333 | p->error_indicator = 1; |
5334 | PyErr_NoMemory(); |
5335 | } |
5336 | if (p->error_indicator) { Branch (5336:9): [True: 0, False: 116k]
|
5337 | p->level--; |
5338 | return NULL; |
5339 | } |
5340 | NameDefaultPair* _res = NULL; |
5341 | int _mark = p->mark; |
5342 | { // param default ',' TYPE_COMMENT? |
5343 | if (p->error_indicator) { Branch (5343:13): [True: 0, False: 116k]
|
5344 | p->level--; |
5345 | return NULL; |
5346 | } |
5347 | D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?")); |
5348 | Token * _literal; |
5349 | arg_ty a; |
5350 | expr_ty c; |
5351 | void *tc; |
5352 | if ( |
5353 | (a = param_rule(p)) // param Branch (5353:13): [True: 16.1k, False: 100k]
|
5354 | && |
5355 | (c = default_rule(p))16.1k // default Branch (5355:13): [True: 15.4k, False: 780]
|
5356 | && |
5357 | (_literal = _PyPegen_expect_token(p, 12))15.4k // token=',' Branch (5357:13): [True: 7.68k, False: 7.72k]
|
5358 | && |
5359 | (tc = _PyPegen_expect_token(p, 7.68k TYPE_COMMENT7.68k ), !p->error_indicator) // TYPE_COMMENT? Branch (5359:13): [True: 7.68k, False: 0]
|
5360 | ) |
5361 | { |
5362 | D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?")); |
5363 | _res = _PyPegen_name_default_pair ( p , a , c , tc ); |
5364 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5364:17): [True: 0, False: 7.68k]
Branch (5364:33): [True: 0, False: 0]
|
5365 | p->error_indicator = 1; |
5366 | p->level--; |
5367 | return NULL; |
5368 | } |
5369 | goto done; |
5370 | } |
5371 | p->mark = _mark; |
5372 | D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
5373 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default ',' TYPE_COMMENT?")); |
5374 | } |
5375 | { // param default TYPE_COMMENT? &')' |
5376 | if (p->error_indicator) { Branch (5376:13): [True: 3, False: 108k]
|
5377 | p->level--; |
5378 | return NULL; |
5379 | } |
5380 | D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'")); |
5381 | arg_ty a; |
5382 | expr_ty c; |
5383 | void *tc; |
5384 | if ( |
5385 | (a = param_rule(p)) // param Branch (5385:13): [True: 8.50k, False: 100k]
|
5386 | && |
5387 | (c = default_rule(p))8.50k // default Branch (5387:13): [True: 7.72k, False: 777]
|
5388 | && |
5389 | (tc = _PyPegen_expect_token(p, 7.72k TYPE_COMMENT7.72k ), !p->error_indicator) // TYPE_COMMENT? Branch (5389:13): [True: 7.72k, False: 0]
|
5390 | && |
5391 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)7.72k // token=')' Branch (5391:13): [True: 7.70k, False: 23]
|
5392 | ) |
5393 | { |
5394 | D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'")); |
5395 | _res = _PyPegen_name_default_pair ( p , a , c , tc ); |
5396 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5396:17): [True: 0, False: 7.70k]
Branch (5396:33): [True: 0, False: 0]
|
5397 | p->error_indicator = 1; |
5398 | p->level--; |
5399 | return NULL; |
5400 | } |
5401 | goto done; |
5402 | } |
5403 | p->mark = _mark; |
5404 | D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
5405 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default TYPE_COMMENT? &')'")); |
5406 | } |
5407 | _res = NULL; |
5408 | done: |
5409 | p->level--; |
5410 | return _res; |
5411 | } |
5412 | |
5413 | // param_maybe_default: |
5414 | // | param default? ',' TYPE_COMMENT? |
5415 | // | param default? TYPE_COMMENT? &')' |
5416 | static NameDefaultPair* |
5417 | param_maybe_default_rule(Parser *p) |
5418 | { |
5419 | if (p->level++ == MAXSTACK) { Branch (5419:9): [True: 0, False: 7.74k]
|
5420 | p->error_indicator = 1; |
5421 | PyErr_NoMemory(); |
5422 | } |
5423 | if (p->error_indicator) { Branch (5423:9): [True: 0, False: 7.74k]
|
5424 | p->level--; |
5425 | return NULL; |
5426 | } |
5427 | NameDefaultPair* _res = NULL; |
5428 | int _mark = p->mark; |
5429 | { // param default? ',' TYPE_COMMENT? |
5430 | if (p->error_indicator) { Branch (5430:13): [True: 0, False: 7.74k]
|
5431 | p->level--; |
5432 | return NULL; |
5433 | } |
5434 | D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?")); |
5435 | Token * _literal; |
5436 | arg_ty a; |
5437 | void *c; |
5438 | void *tc; |
5439 | if ( |
5440 | (a = param_rule(p)) // param Branch (5440:13): [True: 4.12k, False: 3.62k]
|
5441 | && |
5442 | (c = default_rule(p), !p->error_indicator)4.12k // default? Branch (5442:13): [True: 4.12k, False: 0]
|
5443 | && |
5444 | (_literal = _PyPegen_expect_token(p, 12))4.12k // token=',' Branch (5444:13): [True: 2.91k, False: 1.21k]
|
5445 | && |
5446 | (tc = _PyPegen_expect_token(p, 2.91k TYPE_COMMENT2.91k ), !p->error_indicator) // TYPE_COMMENT? Branch (5446:13): [True: 2.91k, False: 0]
|
5447 | ) |
5448 | { |
5449 | D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?")); |
5450 | _res = _PyPegen_name_default_pair ( p , a , c , tc ); |
5451 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5451:17): [True: 0, False: 2.91k]
Branch (5451:33): [True: 0, False: 0]
|
5452 | p->error_indicator = 1; |
5453 | p->level--; |
5454 | return NULL; |
5455 | } |
5456 | goto done; |
5457 | } |
5458 | p->mark = _mark; |
5459 | D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', |
5460 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? ',' TYPE_COMMENT?")); |
5461 | } |
5462 | { // param default? TYPE_COMMENT? &')' |
5463 | if (p->error_indicator) { Branch (5463:13): [True: 0, False: 4.83k]
|
5464 | p->level--; |
5465 | return NULL; |
5466 | } |
5467 | D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'")); |
5468 | arg_ty a; |
5469 | void *c; |
5470 | void *tc; |
5471 | if ( |
5472 | (a = param_rule(p)) // param Branch (5472:13): [True: 1.21k, False: 3.62k]
|
5473 | && |
5474 | (c = default_rule(p), !p->error_indicator)1.21k // default? Branch (5474:13): [True: 1.21k, False: 0]
|
5475 | && |
5476 | (tc = _PyPegen_expect_token(p, 1.21k TYPE_COMMENT1.21k ), !p->error_indicator) // TYPE_COMMENT? Branch (5476:13): [True: 1.21k, False: 0]
|
5477 | && |
5478 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)1.21k // token=')' Branch (5478:13): [True: 1.08k, False: 128]
|
5479 | ) |
5480 | { |
5481 | D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'")); |
5482 | _res = _PyPegen_name_default_pair ( p , a , c , tc ); |
5483 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5483:17): [True: 0, False: 1.08k]
Branch (5483:33): [True: 0, False: 0]
|
5484 | p->error_indicator = 1; |
5485 | p->level--; |
5486 | return NULL; |
5487 | } |
5488 | goto done; |
5489 | } |
5490 | p->mark = _mark; |
5491 | D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', |
5492 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? TYPE_COMMENT? &')'")); |
5493 | } |
5494 | _res = NULL; |
5495 | done: |
5496 | p->level--; |
5497 | return _res; |
5498 | } |
5499 | |
5500 | // param: NAME annotation? |
5501 | static arg_ty |
5502 | param_rule(Parser *p) |
5503 | { |
5504 | if (p->level++ == MAXSTACK) { Branch (5504:9): [True: 0, False: 904k]
|
5505 | p->error_indicator = 1; |
5506 | PyErr_NoMemory(); |
5507 | } |
5508 | if (p->error_indicator) { Branch (5508:9): [True: 0, False: 904k]
|
5509 | p->level--; |
5510 | return NULL; |
5511 | } |
5512 | arg_ty _res = NULL; |
5513 | int _mark = p->mark; |
5514 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 039.7k ) { Branch (5514:9): [True: 39.7k, False: 864k]
Branch (5514:31): [True: 5, False: 39.7k]
|
5515 | p->error_indicator = 1; |
5516 | p->level--; |
5517 | return NULL; |
5518 | } |
5519 | int _start_lineno = p->tokens[_mark]->lineno; |
5520 | UNUSED(_start_lineno); // Only used by EXTRA macro |
5521 | int _start_col_offset = p->tokens[_mark]->col_offset; |
5522 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
5523 | { // NAME annotation? |
5524 | if (p->error_indicator) { Branch (5524:13): [True: 0, False: 904k]
|
5525 | p->level--; |
5526 | return NULL; |
5527 | } |
5528 | D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?")); |
5529 | expr_ty a; |
5530 | void *b; |
5531 | if ( |
5532 | (a = _PyPegen_name_token(p)) // NAME Branch (5532:13): [True: 389k, False: 515k]
|
5533 | && |
5534 | (b = annotation_rule(p), !p->error_indicator)389k // annotation? Branch (5534:13): [True: 389k, False: 9]
|
5535 | ) |
5536 | { |
5537 | D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?")); |
5538 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
5539 | if (_token == NULL) { Branch (5539:17): [True: 0, False: 389k]
|
5540 | p->level--; |
5541 | return NULL; |
5542 | } |
5543 | int _end_lineno = _token->end_lineno; |
5544 | UNUSED(_end_lineno); // Only used by EXTRA macro |
5545 | int _end_col_offset = _token->end_col_offset; |
5546 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
5547 | _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA ); |
5548 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5548:17): [True: 0, False: 389k]
Branch (5548:33): [True: 0, False: 0]
|
5549 | p->error_indicator = 1; |
5550 | p->level--; |
5551 | return NULL; |
5552 | } |
5553 | goto done; |
5554 | } |
5555 | p->mark = _mark; |
5556 | D(fprintf(stderr, "%*c%s param[%d-%d]: %s failed!\n", p->level, ' ', |
5557 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME annotation?")); |
5558 | } |
5559 | _res = NULL; |
5560 | done: |
5561 | p->level--; |
5562 | return _res; |
5563 | } |
5564 | |
5565 | // param_star_annotation: NAME star_annotation |
5566 | static arg_ty |
5567 | param_star_annotation_rule(Parser *p) |
5568 | { |
5569 | if (p->level++ == MAXSTACK) { Branch (5569:9): [True: 0, False: 2.22k]
|
5570 | p->error_indicator = 1; |
5571 | PyErr_NoMemory(); |
5572 | } |
5573 | if (p->error_indicator) { Branch (5573:9): [True: 0, False: 2.22k]
|
5574 | p->level--; |
5575 | return NULL; |
5576 | } |
5577 | arg_ty _res = NULL; |
5578 | int _mark = p->mark; |
5579 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (5579:9): [True: 0, False: 2.22k]
Branch (5579:31): [True: 0, False: 0]
|
5580 | p->error_indicator = 1; |
5581 | p->level--; |
5582 | return NULL; |
5583 | } |
5584 | int _start_lineno = p->tokens[_mark]->lineno; |
5585 | UNUSED(_start_lineno); // Only used by EXTRA macro |
5586 | int _start_col_offset = p->tokens[_mark]->col_offset; |
5587 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
5588 | { // NAME star_annotation |
5589 | if (p->error_indicator) { Branch (5589:13): [True: 0, False: 2.22k]
|
5590 | p->level--; |
5591 | return NULL; |
5592 | } |
5593 | D(fprintf(stderr, "%*c> param_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME star_annotation")); |
5594 | expr_ty a; |
5595 | expr_ty b; |
5596 | if ( |
5597 | (a = _PyPegen_name_token(p)) // NAME Branch (5597:13): [True: 47, False: 2.17k]
|
5598 | && |
5599 | (b = star_annotation_rule(p))47 // star_annotation Branch (5599:13): [True: 45, False: 2]
|
5600 | ) |
5601 | { |
5602 | D(fprintf(stderr, "%*c+ param_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME star_annotation")); |
5603 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
5604 | if (_token == NULL) { Branch (5604:17): [True: 0, False: 45]
|
5605 | p->level--; |
5606 | return NULL; |
5607 | } |
5608 | int _end_lineno = _token->end_lineno; |
5609 | UNUSED(_end_lineno); // Only used by EXTRA macro |
5610 | int _end_col_offset = _token->end_col_offset; |
5611 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
5612 | _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA ); |
5613 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5613:17): [True: 0, False: 45]
Branch (5613:33): [True: 0, False: 0]
|
5614 | p->error_indicator = 1; |
5615 | p->level--; |
5616 | return NULL; |
5617 | } |
5618 | goto done; |
5619 | } |
5620 | p->mark = _mark; |
5621 | D(fprintf(stderr, "%*c%s param_star_annotation[%d-%d]: %s failed!\n", p->level, ' ', |
5622 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME star_annotation")); |
5623 | } |
5624 | _res = NULL; |
5625 | done: |
5626 | p->level--; |
5627 | return _res; |
5628 | } |
5629 | |
5630 | // annotation: ':' expression |
5631 | static expr_ty |
5632 | annotation_rule(Parser *p) |
5633 | { |
5634 | if (p->level++ == MAXSTACK) { Branch (5634:9): [True: 0, False: 389k]
|
5635 | p->error_indicator = 1; |
5636 | PyErr_NoMemory(); |
5637 | } |
5638 | if (p->error_indicator) { Branch (5638:9): [True: 0, False: 389k]
|
5639 | p->level--; |
5640 | return NULL; |
5641 | } |
5642 | expr_ty _res = NULL; |
5643 | int _mark = p->mark; |
5644 | { // ':' expression |
5645 | if (p->error_indicator) { Branch (5645:13): [True: 0, False: 389k]
|
5646 | p->level--; |
5647 | return NULL; |
5648 | } |
5649 | D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression")); |
5650 | Token * _literal; |
5651 | expr_ty a; |
5652 | if ( |
5653 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' Branch (5653:13): [True: 18.3k, False: 370k]
|
5654 | && |
5655 | (a = expression_rule(p))18.3k // expression Branch (5655:13): [True: 17.9k, False: 337]
|
5656 | ) |
5657 | { |
5658 | D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression")); |
5659 | _res = a; |
5660 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5660:17): [True: 0, False: 17.9k]
Branch (5660:33): [True: 0, False: 0]
|
5661 | p->error_indicator = 1; |
5662 | p->level--; |
5663 | return NULL; |
5664 | } |
5665 | goto done; |
5666 | } |
5667 | p->mark = _mark; |
5668 | D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ', |
5669 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression")); |
5670 | } |
5671 | _res = NULL; |
5672 | done: |
5673 | p->level--; |
5674 | return _res; |
5675 | } |
5676 | |
5677 | // star_annotation: ':' star_expression |
5678 | static expr_ty |
5679 | star_annotation_rule(Parser *p) |
5680 | { |
5681 | if (p->level++ == MAXSTACK) { Branch (5681:9): [True: 0, False: 47]
|
5682 | p->error_indicator = 1; |
5683 | PyErr_NoMemory(); |
5684 | } |
5685 | if (p->error_indicator) { Branch (5685:9): [True: 0, False: 47]
|
5686 | p->level--; |
5687 | return NULL; |
5688 | } |
5689 | expr_ty _res = NULL; |
5690 | int _mark = p->mark; |
5691 | { // ':' star_expression |
5692 | if (p->error_indicator) { Branch (5692:13): [True: 0, False: 47]
|
5693 | p->level--; |
5694 | return NULL; |
5695 | } |
5696 | D(fprintf(stderr, "%*c> star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' star_expression")); |
5697 | Token * _literal; |
5698 | expr_ty a; |
5699 | if ( |
5700 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' Branch (5700:13): [True: 45, False: 2]
|
5701 | && |
5702 | (a = star_expression_rule(p))45 // star_expression Branch (5702:13): [True: 45, False: 0]
|
5703 | ) |
5704 | { |
5705 | D(fprintf(stderr, "%*c+ star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' star_expression")); |
5706 | _res = a; |
5707 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5707:17): [True: 0, False: 45]
Branch (5707:33): [True: 0, False: 0]
|
5708 | p->error_indicator = 1; |
5709 | p->level--; |
5710 | return NULL; |
5711 | } |
5712 | goto done; |
5713 | } |
5714 | p->mark = _mark; |
5715 | D(fprintf(stderr, "%*c%s star_annotation[%d-%d]: %s failed!\n", p->level, ' ', |
5716 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' star_expression")); |
5717 | } |
5718 | _res = NULL; |
5719 | done: |
5720 | p->level--; |
5721 | return _res; |
5722 | } |
5723 | |
5724 | // default: '=' expression | invalid_default |
5725 | static expr_ty |
5726 | default_rule(Parser *p) |
5727 | { |
5728 | if (p->level++ == MAXSTACK) { Branch (5728:9): [True: 0, False: 31.1k]
|
5729 | p->error_indicator = 1; |
5730 | PyErr_NoMemory(); |
5731 | } |
5732 | if (p->error_indicator) { Branch (5732:9): [True: 0, False: 31.1k]
|
5733 | p->level--; |
5734 | return NULL; |
5735 | } |
5736 | expr_ty _res = NULL; |
5737 | int _mark = p->mark; |
5738 | { // '=' expression |
5739 | if (p->error_indicator) { Branch (5739:13): [True: 0, False: 31.1k]
|
5740 | p->level--; |
5741 | return NULL; |
5742 | } |
5743 | D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression")); |
5744 | Token * _literal; |
5745 | expr_ty a; |
5746 | if ( |
5747 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' Branch (5747:13): [True: 26.0k, False: 5.16k]
|
5748 | && |
5749 | (a = expression_rule(p))26.0k // expression Branch (5749:13): [True: 25.7k, False: 305]
|
5750 | ) |
5751 | { |
5752 | D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression")); |
5753 | _res = a; |
5754 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5754:17): [True: 0, False: 25.7k]
Branch (5754:33): [True: 0, False: 0]
|
5755 | p->error_indicator = 1; |
5756 | p->level--; |
5757 | return NULL; |
5758 | } |
5759 | goto done; |
5760 | } |
5761 | p->mark = _mark; |
5762 | D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ', |
5763 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression")); |
5764 | } |
5765 | if (p->call_invalid_rules) { // invalid_default Branch (5765:9): [True: 1.77k, False: 3.69k]
|
5766 | if (p->error_indicator) { Branch (5766:13): [True: 0, False: 1.77k]
|
5767 | p->level--; |
5768 | return NULL; |
5769 | } |
5770 | D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_default")); |
5771 | void *invalid_default_var; |
5772 | if ( |
5773 | (invalid_default_var = invalid_default_rule(p)) // invalid_default Branch (5773:13): [True: 0, False: 1.77k]
|
5774 | ) |
5775 | { |
5776 | D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_default")); |
5777 | _res = invalid_default_var; |
5778 | goto done; |
5779 | } |
5780 | p->mark = _mark; |
5781 | D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ', |
5782 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_default")); |
5783 | } |
5784 | _res = NULL; |
5785 | done: |
5786 | p->level--; |
5787 | return _res; |
5788 | } |
5789 | |
5790 | // if_stmt: |
5791 | // | invalid_if_stmt |
5792 | // | 'if' named_expression ':' block elif_stmt |
5793 | // | 'if' named_expression ':' block else_block? |
5794 | static stmt_ty |
5795 | if_stmt_rule(Parser *p) |
5796 | { |
5797 | if (p->level++ == MAXSTACK) { Branch (5797:9): [True: 0, False: 223k]
|
5798 | p->error_indicator = 1; |
5799 | PyErr_NoMemory(); |
5800 | } |
5801 | if (p->error_indicator) { Branch (5801:9): [True: 0, False: 223k]
|
5802 | p->level--; |
5803 | return NULL; |
5804 | } |
5805 | stmt_ty _res = NULL; |
5806 | int _mark = p->mark; |
5807 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (5807:9): [True: 0, False: 223k]
Branch (5807:31): [True: 0, False: 0]
|
5808 | p->error_indicator = 1; |
5809 | p->level--; |
5810 | return NULL; |
5811 | } |
5812 | int _start_lineno = p->tokens[_mark]->lineno; |
5813 | UNUSED(_start_lineno); // Only used by EXTRA macro |
5814 | int _start_col_offset = p->tokens[_mark]->col_offset; |
5815 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
5816 | if (p->call_invalid_rules) { // invalid_if_stmt Branch (5816:9): [True: 37, False: 223k]
|
5817 | if (p->error_indicator) { Branch (5817:13): [True: 0, False: 37]
|
5818 | p->level--; |
5819 | return NULL; |
5820 | } |
5821 | D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt")); |
5822 | void *invalid_if_stmt_var; |
5823 | if ( |
5824 | (invalid_if_stmt_var = invalid_if_stmt_rule(p)) // invalid_if_stmt Branch (5824:13): [True: 0, False: 37]
|
5825 | ) |
5826 | { |
5827 | D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt")); |
5828 | _res = invalid_if_stmt_var; |
5829 | goto done; |
5830 | } |
5831 | p->mark = _mark; |
5832 | D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
5833 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_stmt")); |
5834 | } |
5835 | { // 'if' named_expression ':' block elif_stmt |
5836 | if (p->error_indicator) { Branch (5836:13): [True: 6, False: 223k]
|
5837 | p->level--; |
5838 | return NULL; |
5839 | } |
5840 | D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt")); |
5841 | Token * _keyword; |
5842 | Token * _literal; |
5843 | expr_ty a; |
5844 | asdl_stmt_seq* b; |
5845 | stmt_ty c; |
5846 | if ( |
5847 | (_keyword = _PyPegen_expect_token(p, 634)) // token='if' Branch (5847:13): [True: 223k, False: 0]
|
5848 | && |
5849 | (a = named_expression_rule(p)) // named_expression Branch (5849:13): [True: 223k, False: 6]
|
5850 | && |
5851 | (_literal = _PyPegen_expect_token(p, 11))223k // token=':' Branch (5851:13): [True: 223k, False: 3]
|
5852 | && |
5853 | (b = block_rule(p))223k // block Branch (5853:13): [True: 223k, False: 65]
|
5854 | && |
5855 | (c = elif_stmt_rule(p))223k // elif_stmt Branch (5855:13): [True: 1.68k, False: 221k]
|
5856 | ) |
5857 | { |
5858 | D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt")); |
5859 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
5860 | if (_token == NULL) { Branch (5860:17): [True: 0, False: 1.68k]
|
5861 | p->level--; |
5862 | return NULL; |
5863 | } |
5864 | int _end_lineno = _token->end_lineno; |
5865 | UNUSED(_end_lineno); // Only used by EXTRA macro |
5866 | int _end_col_offset = _token->end_col_offset; |
5867 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
5868 | _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); |
5869 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5869:17): [True: 0, False: 1.68k]
Branch (5869:33): [True: 0, False: 0]
|
5870 | p->error_indicator = 1; |
5871 | p->level--; |
5872 | return NULL; |
5873 | } |
5874 | goto done; |
5875 | } |
5876 | p->mark = _mark; |
5877 | D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
5878 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block elif_stmt")); |
5879 | } |
5880 | { // 'if' named_expression ':' block else_block? |
5881 | if (p->error_indicator) { Branch (5881:13): [True: 22, False: 221k]
|
5882 | p->level--; |
5883 | return NULL; |
5884 | } |
5885 | D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?")); |
5886 | Token * _keyword; |
5887 | Token * _literal; |
5888 | expr_ty a; |
5889 | asdl_stmt_seq* b; |
5890 | void *c; |
5891 | if ( |
5892 | (_keyword = _PyPegen_expect_token(p, 634)) // token='if' Branch (5892:13): [True: 221k, False: 0]
|
5893 | && |
5894 | (a = named_expression_rule(p)) // named_expression Branch (5894:13): [True: 221k, False: 6]
|
5895 | && |
5896 | (_literal = _PyPegen_expect_token(p, 11))221k // token=':' Branch (5896:13): [True: 221k, False: 3]
|
5897 | && |
5898 | (b = block_rule(p))221k // block Branch (5898:13): [True: 221k, False: 50]
|
5899 | && |
5900 | (c = else_block_rule(p), !p->error_indicator)221k // else_block? Branch (5900:13): [True: 221k, False: 0]
|
5901 | ) |
5902 | { |
5903 | D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?")); |
5904 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
5905 | if (_token == NULL) { Branch (5905:17): [True: 0, False: 221k]
|
5906 | p->level--; |
5907 | return NULL; |
5908 | } |
5909 | int _end_lineno = _token->end_lineno; |
5910 | UNUSED(_end_lineno); // Only used by EXTRA macro |
5911 | int _end_col_offset = _token->end_col_offset; |
5912 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
5913 | _res = _PyAST_If ( a , b , c , EXTRA ); |
5914 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (5914:17): [True: 0, False: 221k]
Branch (5914:33): [True: 0, False: 0]
|
5915 | p->error_indicator = 1; |
5916 | p->level--; |
5917 | return NULL; |
5918 | } |
5919 | goto done; |
5920 | } |
5921 | p->mark = _mark; |
5922 | D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
5923 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block else_block?")); |
5924 | } |
5925 | _res = NULL; |
5926 | done: |
5927 | p->level--; |
5928 | return _res; |
5929 | } |
5930 | |
5931 | // elif_stmt: |
5932 | // | invalid_elif_stmt |
5933 | // | 'elif' named_expression ':' block elif_stmt |
5934 | // | 'elif' named_expression ':' block else_block? |
5935 | static stmt_ty |
5936 | elif_stmt_rule(Parser *p) |
5937 | { |
5938 | if (p->level++ == MAXSTACK) { Branch (5938:9): [True: 0, False: 226k]
|
5939 | p->error_indicator = 1; |
5940 | PyErr_NoMemory(); |
5941 | } |
5942 | if (p->error_indicator) { Branch (5942:9): [True: 0, False: 226k]
|
5943 | p->level--; |
5944 | return NULL; |
5945 | } |
5946 | stmt_ty _res = NULL; |
5947 | int _mark = p->mark; |
5948 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0226k ) { Branch (5948:9): [True: 226k, False: 8]
Branch (5948:31): [True: 0, False: 226k]
|
5949 | p->error_indicator = 1; |
5950 | p->level--; |
5951 | return NULL; |
5952 | } |
5953 | int _start_lineno = p->tokens[_mark]->lineno; |
5954 | UNUSED(_start_lineno); // Only used by EXTRA macro |
5955 | int _start_col_offset = p->tokens[_mark]->col_offset; |
5956 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
5957 | if (p->call_invalid_rules) { // invalid_elif_stmt Branch (5957:9): [True: 8, False: 226k]
|
5958 | if (p->error_indicator) { Branch (5958:13): [True: 0, False: 8]
|
5959 | p->level--; |
5960 | return NULL; |
5961 | } |
5962 | D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt")); |
5963 | void *invalid_elif_stmt_var; |
5964 | if ( |
5965 | (invalid_elif_stmt_var = invalid_elif_stmt_rule(p)) // invalid_elif_stmt Branch (5965:13): [True: 0, False: 8]
|
5966 | ) |
5967 | { |
5968 | D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt")); |
5969 | _res = invalid_elif_stmt_var; |
5970 | goto done; |
5971 | } |
5972 | p->mark = _mark; |
5973 | D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
5974 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_elif_stmt")); |
5975 | } |
5976 | { // 'elif' named_expression ':' block elif_stmt |
5977 | if (p->error_indicator) { Branch (5977:13): [True: 2, False: 226k]
|
5978 | p->level--; |
5979 | return NULL; |
5980 | } |
5981 | D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt")); |
5982 | Token * _keyword; |
5983 | Token * _literal; |
5984 | expr_ty a; |
5985 | asdl_stmt_seq* b; |
5986 | stmt_ty c; |
5987 | if ( |
5988 | (_keyword = _PyPegen_expect_token(p, 636)) // token='elif' Branch (5988:13): [True: 2.85k, False: 223k]
|
5989 | && |
5990 | (a = named_expression_rule(p))2.85k // named_expression Branch (5990:13): [True: 2.85k, False: 0]
|
5991 | && |
5992 | (_literal = _PyPegen_expect_token(p, 11))2.85k // token=':' Branch (5992:13): [True: 2.85k, False: 1]
|
5993 | && |
5994 | (b = block_rule(p))2.85k // block Branch (5994:13): [True: 2.84k, False: 7]
|
5995 | && |
5996 | (c = elif_stmt_rule(p))2.84k // elif_stmt Branch (5996:13): [True: 1.15k, False: 1.69k]
|
5997 | ) |
5998 | { |
5999 | D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt")); |
6000 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6001 | if (_token == NULL) { Branch (6001:17): [True: 0, False: 1.15k]
|
6002 | p->level--; |
6003 | return NULL; |
6004 | } |
6005 | int _end_lineno = _token->end_lineno; |
6006 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6007 | int _end_col_offset = _token->end_col_offset; |
6008 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6009 | _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); |
6010 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6010:17): [True: 0, False: 1.15k]
Branch (6010:33): [True: 0, False: 0]
|
6011 | p->error_indicator = 1; |
6012 | p->level--; |
6013 | return NULL; |
6014 | } |
6015 | goto done; |
6016 | } |
6017 | p->mark = _mark; |
6018 | D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6019 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block elif_stmt")); |
6020 | } |
6021 | { // 'elif' named_expression ':' block else_block? |
6022 | if (p->error_indicator) { Branch (6022:13): [True: 2, False: 225k]
|
6023 | p->level--; |
6024 | return NULL; |
6025 | } |
6026 | D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?")); |
6027 | Token * _keyword; |
6028 | Token * _literal; |
6029 | expr_ty a; |
6030 | asdl_stmt_seq* b; |
6031 | void *c; |
6032 | if ( |
6033 | (_keyword = _PyPegen_expect_token(p, 636)) // token='elif' Branch (6033:13): [True: 1.69k, False: 223k]
|
6034 | && |
6035 | (a = named_expression_rule(p))1.69k // named_expression Branch (6035:13): [True: 1.69k, False: 0]
|
6036 | && |
6037 | (_literal = _PyPegen_expect_token(p, 11))1.69k // token=':' Branch (6037:13): [True: 1.69k, False: 1]
|
6038 | && |
6039 | (b = block_rule(p))1.69k // block Branch (6039:13): [True: 1.69k, False: 5]
|
6040 | && |
6041 | (c = else_block_rule(p), !p->error_indicator)1.69k // else_block? Branch (6041:13): [True: 1.68k, False: 3]
|
6042 | ) |
6043 | { |
6044 | D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?")); |
6045 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6046 | if (_token == NULL) { Branch (6046:17): [True: 0, False: 1.68k]
|
6047 | p->level--; |
6048 | return NULL; |
6049 | } |
6050 | int _end_lineno = _token->end_lineno; |
6051 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6052 | int _end_col_offset = _token->end_col_offset; |
6053 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6054 | _res = _PyAST_If ( a , b , c , EXTRA ); |
6055 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6055:17): [True: 0, False: 1.68k]
Branch (6055:33): [True: 0, False: 0]
|
6056 | p->error_indicator = 1; |
6057 | p->level--; |
6058 | return NULL; |
6059 | } |
6060 | goto done; |
6061 | } |
6062 | p->mark = _mark; |
6063 | D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6064 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block else_block?")); |
6065 | } |
6066 | _res = NULL; |
6067 | done: |
6068 | p->level--; |
6069 | return _res; |
6070 | } |
6071 | |
6072 | // else_block: invalid_else_stmt | 'else' &&':' block |
6073 | static asdl_stmt_seq* |
6074 | else_block_rule(Parser *p) |
6075 | { |
6076 | if (p->level++ == MAXSTACK) { Branch (6076:9): [True: 0, False: 232k]
|
6077 | p->error_indicator = 1; |
6078 | PyErr_NoMemory(); |
6079 | } |
6080 | if (p->error_indicator) { Branch (6080:9): [True: 0, False: 232k]
|
6081 | p->level--; |
6082 | return NULL; |
6083 | } |
6084 | asdl_stmt_seq* _res = NULL; |
6085 | int _mark = p->mark; |
6086 | if (p->call_invalid_rules) { // invalid_else_stmt Branch (6086:9): [True: 6, False: 232k]
|
6087 | if (p->error_indicator) { Branch (6087:13): [True: 0, False: 6]
|
6088 | p->level--; |
6089 | return NULL; |
6090 | } |
6091 | D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_else_stmt")); |
6092 | void *invalid_else_stmt_var; |
6093 | if ( |
6094 | (invalid_else_stmt_var = invalid_else_stmt_rule(p)) // invalid_else_stmt Branch (6094:13): [True: 0, False: 6]
|
6095 | ) |
6096 | { |
6097 | D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_else_stmt")); |
6098 | _res = invalid_else_stmt_var; |
6099 | goto done; |
6100 | } |
6101 | p->mark = _mark; |
6102 | D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ', |
6103 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_else_stmt")); |
6104 | } |
6105 | { // 'else' &&':' block |
6106 | if (p->error_indicator) { Branch (6106:13): [True: 3, False: 232k]
|
6107 | p->level--; |
6108 | return NULL; |
6109 | } |
6110 | D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' &&':' block")); |
6111 | Token * _keyword; |
6112 | Token * _literal; |
6113 | asdl_stmt_seq* b; |
6114 | if ( |
6115 | (_keyword = _PyPegen_expect_token(p, 637)) // token='else' Branch (6115:13): [True: 5.31k, False: 226k]
|
6116 | && |
6117 | (_literal = _PyPegen_expect_forced_token(p, 11, ":"))5.31k // forced_token=':' Branch (6117:13): [True: 5.31k, False: 1]
|
6118 | && |
6119 | (b = block_rule(p))5.31k // block Branch (6119:13): [True: 5.29k, False: 21]
|
6120 | ) |
6121 | { |
6122 | D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' &&':' block")); |
6123 | _res = b; |
6124 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6124:17): [True: 0, False: 5.29k]
Branch (6124:33): [True: 0, False: 0]
|
6125 | p->error_indicator = 1; |
6126 | p->level--; |
6127 | return NULL; |
6128 | } |
6129 | goto done; |
6130 | } |
6131 | p->mark = _mark; |
6132 | D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ', |
6133 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' &&':' block")); |
6134 | } |
6135 | _res = NULL; |
6136 | done: |
6137 | p->level--; |
6138 | return _res; |
6139 | } |
6140 | |
6141 | // while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block? |
6142 | static stmt_ty |
6143 | while_stmt_rule(Parser *p) |
6144 | { |
6145 | if (p->level++ == MAXSTACK) { Branch (6145:9): [True: 0, False: 1.10k]
|
6146 | p->error_indicator = 1; |
6147 | PyErr_NoMemory(); |
6148 | } |
6149 | if (p->error_indicator) { Branch (6149:9): [True: 0, False: 1.10k]
|
6150 | p->level--; |
6151 | return NULL; |
6152 | } |
6153 | stmt_ty _res = NULL; |
6154 | int _mark = p->mark; |
6155 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (6155:9): [True: 0, False: 1.10k]
Branch (6155:31): [True: 0, False: 0]
|
6156 | p->error_indicator = 1; |
6157 | p->level--; |
6158 | return NULL; |
6159 | } |
6160 | int _start_lineno = p->tokens[_mark]->lineno; |
6161 | UNUSED(_start_lineno); // Only used by EXTRA macro |
6162 | int _start_col_offset = p->tokens[_mark]->col_offset; |
6163 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
6164 | if (p->call_invalid_rules) { // invalid_while_stmt Branch (6164:9): [True: 23, False: 1.08k]
|
6165 | if (p->error_indicator) { Branch (6165:13): [True: 0, False: 23]
|
6166 | p->level--; |
6167 | return NULL; |
6168 | } |
6169 | D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_while_stmt")); |
6170 | void *invalid_while_stmt_var; |
6171 | if ( |
6172 | (invalid_while_stmt_var = invalid_while_stmt_rule(p)) // invalid_while_stmt Branch (6172:13): [True: 0, False: 23]
|
6173 | ) |
6174 | { |
6175 | D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_while_stmt")); |
6176 | _res = invalid_while_stmt_var; |
6177 | goto done; |
6178 | } |
6179 | p->mark = _mark; |
6180 | D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6181 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_while_stmt")); |
6182 | } |
6183 | { // 'while' named_expression ':' block else_block? |
6184 | if (p->error_indicator) { Branch (6184:13): [True: 4, False: 1.10k]
|
6185 | p->level--; |
6186 | return NULL; |
6187 | } |
6188 | D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?")); |
6189 | Token * _keyword; |
6190 | Token * _literal; |
6191 | expr_ty a; |
6192 | asdl_stmt_seq* b; |
6193 | void *c; |
6194 | if ( |
6195 | (_keyword = _PyPegen_expect_token(p, 639)) // token='while' Branch (6195:13): [True: 1.10k, False: 0]
|
6196 | && |
6197 | (a = named_expression_rule(p)) // named_expression Branch (6197:13): [True: 1.10k, False: 2]
|
6198 | && |
6199 | (_literal = _PyPegen_expect_token(p, 11))1.10k // token=':' Branch (6199:13): [True: 1.09k, False: 3]
|
6200 | && |
6201 | (b = block_rule(p))1.09k // block Branch (6201:13): [True: 1.05k, False: 39]
|
6202 | && |
6203 | (c = else_block_rule(p), !p->error_indicator)1.05k // else_block? Branch (6203:13): [True: 1.05k, False: 0]
|
6204 | ) |
6205 | { |
6206 | D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?")); |
6207 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6208 | if (_token == NULL) { Branch (6208:17): [True: 0, False: 1.05k]
|
6209 | p->level--; |
6210 | return NULL; |
6211 | } |
6212 | int _end_lineno = _token->end_lineno; |
6213 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6214 | int _end_col_offset = _token->end_col_offset; |
6215 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6216 | _res = _PyAST_While ( a , b , c , EXTRA ); |
6217 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6217:17): [True: 0, False: 1.05k]
Branch (6217:33): [True: 0, False: 0]
|
6218 | p->error_indicator = 1; |
6219 | p->level--; |
6220 | return NULL; |
6221 | } |
6222 | goto done; |
6223 | } |
6224 | p->mark = _mark; |
6225 | D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6226 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' block else_block?")); |
6227 | } |
6228 | _res = NULL; |
6229 | done: |
6230 | p->level--; |
6231 | return _res; |
6232 | } |
6233 | |
6234 | // for_stmt: |
6235 | // | invalid_for_stmt |
6236 | // | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? |
6237 | // | ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? |
6238 | // | invalid_for_target |
6239 | static stmt_ty |
6240 | for_stmt_rule(Parser *p) |
6241 | { |
6242 | if (p->level++ == MAXSTACK) { Branch (6242:9): [True: 0, False: 4.46k]
|
6243 | p->error_indicator = 1; |
6244 | PyErr_NoMemory(); |
6245 | } |
6246 | if (p->error_indicator) { Branch (6246:9): [True: 0, False: 4.46k]
|
6247 | p->level--; |
6248 | return NULL; |
6249 | } |
6250 | stmt_ty _res = NULL; |
6251 | int _mark = p->mark; |
6252 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (6252:9): [True: 0, False: 4.46k]
Branch (6252:31): [True: 0, False: 0]
|
6253 | p->error_indicator = 1; |
6254 | p->level--; |
6255 | return NULL; |
6256 | } |
6257 | int _start_lineno = p->tokens[_mark]->lineno; |
6258 | UNUSED(_start_lineno); // Only used by EXTRA macro |
6259 | int _start_col_offset = p->tokens[_mark]->col_offset; |
6260 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
6261 | if (p->call_invalid_rules) { // invalid_for_stmt Branch (6261:9): [True: 54, False: 4.41k]
|
6262 | if (p->error_indicator) { Branch (6262:13): [True: 0, False: 54]
|
6263 | p->level--; |
6264 | return NULL; |
6265 | } |
6266 | D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt")); |
6267 | void *invalid_for_stmt_var; |
6268 | if ( |
6269 | (invalid_for_stmt_var = invalid_for_stmt_rule(p)) // invalid_for_stmt Branch (6269:13): [True: 0, False: 54]
|
6270 | ) |
6271 | { |
6272 | D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt")); |
6273 | _res = invalid_for_stmt_var; |
6274 | goto done; |
6275 | } |
6276 | p->mark = _mark; |
6277 | D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6278 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_stmt")); |
6279 | } |
6280 | { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? |
6281 | if (p->error_indicator) { Branch (6281:13): [True: 3, False: 4.46k]
|
6282 | p->level--; |
6283 | return NULL; |
6284 | } |
6285 | D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); |
6286 | int _cut_var = 0; |
6287 | Token * _keyword; |
6288 | Token * _keyword_1; |
6289 | Token * _literal; |
6290 | asdl_stmt_seq* b; |
6291 | void *el; |
6292 | expr_ty ex; |
6293 | expr_ty t; |
6294 | void *tc; |
6295 | if ( |
6296 | (_keyword = _PyPegen_expect_token(p, 642)) // token='for' Branch (6296:13): [True: 4.30k, False: 154]
|
6297 | && |
6298 | (t = star_targets_rule(p))4.30k // star_targets Branch (6298:13): [True: 4.28k, False: 18]
|
6299 | && |
6300 | (_keyword_1 = _PyPegen_expect_token(p, 643))4.28k // token='in' Branch (6300:13): [True: 4.27k, False: 12]
|
6301 | && |
6302 | (_cut_var = 1)4.27k Branch (6302:13): [True: 4.27k, False: 0]
|
6303 | && |
6304 | (ex = star_expressions_rule(p))4.27k // star_expressions Branch (6304:13): [True: 4.27k, False: 0]
|
6305 | && |
6306 | (_literal = _PyPegen_expect_token(p, 11))4.27k // token=':' Branch (6306:13): [True: 4.27k, False: 3]
|
6307 | && |
6308 | (tc = _PyPegen_expect_token(p, 4.27k TYPE_COMMENT4.27k ), !p->error_indicator) // TYPE_COMMENT? Branch (6308:13): [True: 4.27k, False: 0]
|
6309 | && |
6310 | (b = block_rule(p))4.27k // block Branch (6310:13): [True: 4.26k, False: 6]
|
6311 | && |
6312 | (el = else_block_rule(p), !p->error_indicator)4.26k // else_block? Branch (6312:13): [True: 4.26k, False: 1]
|
6313 | ) |
6314 | { |
6315 | D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); |
6316 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6317 | if (_token == NULL) { Branch (6317:17): [True: 0, False: 4.26k]
|
6318 | p->level--; |
6319 | return NULL; |
6320 | } |
6321 | int _end_lineno = _token->end_lineno; |
6322 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6323 | int _end_col_offset = _token->end_col_offset; |
6324 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6325 | _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); |
6326 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6326:17): [True: 0, False: 4.26k]
Branch (6326:33): [True: 0, False: 0]
|
6327 | p->error_indicator = 1; |
6328 | p->level--; |
6329 | return NULL; |
6330 | } |
6331 | goto done; |
6332 | } |
6333 | p->mark = _mark; |
6334 | D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6335 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); |
6336 | if (_cut_var) { Branch (6336:13): [True: 10, False: 184]
|
6337 | p->level--; |
6338 | return NULL; |
6339 | } |
6340 | } |
6341 | { // ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? |
6342 | if (p->error_indicator) { Branch (6342:13): [True: 0, False: 184]
|
6343 | p->level--; |
6344 | return NULL; |
6345 | } |
6346 | D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); |
6347 | int _cut_var = 0; |
6348 | Token * _keyword; |
6349 | Token * _keyword_1; |
6350 | Token * _literal; |
6351 | Token * async_var; |
6352 | asdl_stmt_seq* b; |
6353 | void *el; |
6354 | expr_ty ex; |
6355 | expr_ty t; |
6356 | void *tc; |
6357 | if ( |
6358 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (6358:13): [True: 154, False: 30]
|
6359 | && |
6360 | (_keyword = _PyPegen_expect_token(p, 642))154 // token='for' Branch (6360:13): [True: 72, False: 82]
|
6361 | && |
6362 | (t = star_targets_rule(p))72 // star_targets Branch (6362:13): [True: 72, False: 0]
|
6363 | && |
6364 | (_keyword_1 = _PyPegen_expect_token(p, 643))72 // token='in' Branch (6364:13): [True: 72, False: 0]
|
6365 | && |
6366 | (_cut_var = 1)72 Branch (6366:13): [True: 72, False: 0]
|
6367 | && |
6368 | (ex = star_expressions_rule(p))72 // star_expressions Branch (6368:13): [True: 72, False: 0]
|
6369 | && |
6370 | (_literal = _PyPegen_expect_token(p, 11))72 // token=':' Branch (6370:13): [True: 72, False: 0]
|
6371 | && |
6372 | (tc = _PyPegen_expect_token(p, 72 TYPE_COMMENT72 ), !p->error_indicator) // TYPE_COMMENT? Branch (6372:13): [True: 72, False: 0]
|
6373 | && |
6374 | (b = block_rule(p))72 // block Branch (6374:13): [True: 71, False: 1]
|
6375 | && |
6376 | (el = else_block_rule(p), !p->error_indicator)71 // else_block? Branch (6376:13): [True: 70, False: 1]
|
6377 | ) |
6378 | { |
6379 | D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); |
6380 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6381 | if (_token == NULL) { Branch (6381:17): [True: 0, False: 70]
|
6382 | p->level--; |
6383 | return NULL; |
6384 | } |
6385 | int _end_lineno = _token->end_lineno; |
6386 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6387 | int _end_col_offset = _token->end_col_offset; |
6388 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6389 | _res = CHECK_VERSION ( stmt_ty , 5 , "Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); |
6390 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6390:17): [True: 0, False: 70]
Branch (6390:33): [True: 0, False: 0]
|
6391 | p->error_indicator = 1; |
6392 | p->level--; |
6393 | return NULL; |
6394 | } |
6395 | goto done; |
6396 | } |
6397 | p->mark = _mark; |
6398 | D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6399 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); |
6400 | if (_cut_var) { Branch (6400:13): [True: 2, False: 112]
|
6401 | p->level--; |
6402 | return NULL; |
6403 | } |
6404 | } |
6405 | if (p->call_invalid_rules) { // invalid_for_target Branch (6405:9): [True: 47, False: 65]
|
6406 | if (p->error_indicator) { Branch (6406:13): [True: 0, False: 47]
|
6407 | p->level--; |
6408 | return NULL; |
6409 | } |
6410 | D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); |
6411 | void *invalid_for_target_var; |
6412 | if ( |
6413 | (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target Branch (6413:13): [True: 0, False: 47]
|
6414 | ) |
6415 | { |
6416 | D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); |
6417 | _res = invalid_for_target_var; |
6418 | goto done; |
6419 | } |
6420 | p->mark = _mark; |
6421 | D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6422 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); |
6423 | } |
6424 | _res = NULL; |
6425 | done: |
6426 | p->level--; |
6427 | return _res; |
6428 | } |
6429 | |
6430 | // with_stmt: |
6431 | // | invalid_with_stmt_indent |
6432 | // | 'with' '(' ','.with_item+ ','? ')' ':' block |
6433 | // | 'with' ','.with_item+ ':' TYPE_COMMENT? block |
6434 | // | ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block |
6435 | // | ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block |
6436 | // | invalid_with_stmt |
6437 | static stmt_ty |
6438 | with_stmt_rule(Parser *p) |
6439 | { |
6440 | if (p->level++ == MAXSTACK) { Branch (6440:9): [True: 0, False: 2.14k]
|
6441 | p->error_indicator = 1; |
6442 | PyErr_NoMemory(); |
6443 | } |
6444 | if (p->error_indicator) { Branch (6444:9): [True: 0, False: 2.14k]
|
6445 | p->level--; |
6446 | return NULL; |
6447 | } |
6448 | stmt_ty _res = NULL; |
6449 | int _mark = p->mark; |
6450 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (6450:9): [True: 0, False: 2.14k]
Branch (6450:31): [True: 0, False: 0]
|
6451 | p->error_indicator = 1; |
6452 | p->level--; |
6453 | return NULL; |
6454 | } |
6455 | int _start_lineno = p->tokens[_mark]->lineno; |
6456 | UNUSED(_start_lineno); // Only used by EXTRA macro |
6457 | int _start_col_offset = p->tokens[_mark]->col_offset; |
6458 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
6459 | if (p->call_invalid_rules) { // invalid_with_stmt_indent Branch (6459:9): [True: 63, False: 2.08k]
|
6460 | if (p->error_indicator) { Branch (6460:13): [True: 0, False: 63]
|
6461 | p->level--; |
6462 | return NULL; |
6463 | } |
6464 | D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt_indent")); |
6465 | void *invalid_with_stmt_indent_var; |
6466 | if ( |
6467 | (invalid_with_stmt_indent_var = invalid_with_stmt_indent_rule(p)) // invalid_with_stmt_indent Branch (6467:13): [True: 0, False: 63]
|
6468 | ) |
6469 | { |
6470 | D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt_indent")); |
6471 | _res = invalid_with_stmt_indent_var; |
6472 | goto done; |
6473 | } |
6474 | p->mark = _mark; |
6475 | D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6476 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt_indent")); |
6477 | } |
6478 | { // 'with' '(' ','.with_item+ ','? ')' ':' block |
6479 | if (p->error_indicator) { Branch (6479:13): [True: 7, False: 2.13k]
|
6480 | p->level--; |
6481 | return NULL; |
6482 | } |
6483 | D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block")); |
6484 | Token * _keyword; |
6485 | Token * _literal; |
6486 | Token * _literal_1; |
6487 | Token * _literal_2; |
6488 | void *_opt_var; |
6489 | UNUSED(_opt_var); // Silence compiler warnings |
6490 | asdl_withitem_seq* a; |
6491 | asdl_stmt_seq* b; |
6492 | if ( |
6493 | (_keyword = _PyPegen_expect_token(p, 612)) // token='with' Branch (6493:13): [True: 1.91k, False: 222]
|
6494 | && |
6495 | (_literal = _PyPegen_expect_token(p, 7))1.91k // token='(' Branch (6495:13): [True: 27, False: 1.88k]
|
6496 | && |
6497 | (a = (asdl_withitem_seq*)_gather_51_rule(p))27 // ','.with_item+ Branch (6497:13): [True: 26, False: 1]
|
6498 | && |
6499 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)26 // ','? Branch (6499:13): [True: 26, False: 0]
|
6500 | && |
6501 | (_literal_1 = _PyPegen_expect_token(p, 8))26 // token=')' Branch (6501:13): [True: 26, False: 0]
|
6502 | && |
6503 | (_literal_2 = _PyPegen_expect_token(p, 11))26 // token=':' Branch (6503:13): [True: 17, False: 9]
|
6504 | && |
6505 | (b = block_rule(p))17 // block Branch (6505:13): [True: 16, False: 1]
|
6506 | ) |
6507 | { |
6508 | D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block")); |
6509 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6510 | if (_token == NULL) { Branch (6510:17): [True: 0, False: 16]
|
6511 | p->level--; |
6512 | return NULL; |
6513 | } |
6514 | int _end_lineno = _token->end_lineno; |
6515 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6516 | int _end_col_offset = _token->end_col_offset; |
6517 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6518 | _res = _PyAST_With ( a , b , NULL , EXTRA ); |
6519 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6519:17): [True: 0, False: 16]
Branch (6519:33): [True: 0, False: 0]
|
6520 | p->error_indicator = 1; |
6521 | p->level--; |
6522 | return NULL; |
6523 | } |
6524 | goto done; |
6525 | } |
6526 | p->mark = _mark; |
6527 | D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6528 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block")); |
6529 | } |
6530 | { // 'with' ','.with_item+ ':' TYPE_COMMENT? block |
6531 | if (p->error_indicator) { Branch (6531:13): [True: 0, False: 2.12k]
|
6532 | p->level--; |
6533 | return NULL; |
6534 | } |
6535 | D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block")); |
6536 | Token * _keyword; |
6537 | Token * _literal; |
6538 | asdl_withitem_seq* a; |
6539 | asdl_stmt_seq* b; |
6540 | void *tc; |
6541 | if ( |
6542 | (_keyword = _PyPegen_expect_token(p, 612)) // token='with' Branch (6542:13): [True: 1.89k, False: 222]
|
6543 | && |
6544 | (a = (asdl_withitem_seq*)_gather_53_rule(p))1.89k // ','.with_item+ Branch (6544:13): [True: 1.87k, False: 20]
|
6545 | && |
6546 | (_literal = _PyPegen_expect_token(p, 11))1.87k // token=':' Branch (6546:13): [True: 1.85k, False: 26]
|
6547 | && |
6548 | (tc = _PyPegen_expect_token(p, 1.85k TYPE_COMMENT1.85k ), !p->error_indicator) // TYPE_COMMENT? Branch (6548:13): [True: 1.85k, False: 0]
|
6549 | && |
6550 | (b = block_rule(p))1.85k // block Branch (6550:13): [True: 1.84k, False: 6]
|
6551 | ) |
6552 | { |
6553 | D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block")); |
6554 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6555 | if (_token == NULL) { Branch (6555:17): [True: 0, False: 1.84k]
|
6556 | p->level--; |
6557 | return NULL; |
6558 | } |
6559 | int _end_lineno = _token->end_lineno; |
6560 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6561 | int _end_col_offset = _token->end_col_offset; |
6562 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6563 | _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); |
6564 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6564:17): [True: 0, False: 1.84k]
Branch (6564:33): [True: 0, False: 0]
|
6565 | p->error_indicator = 1; |
6566 | p->level--; |
6567 | return NULL; |
6568 | } |
6569 | goto done; |
6570 | } |
6571 | p->mark = _mark; |
6572 | D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6573 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block")); |
6574 | } |
6575 | { // ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block |
6576 | if (p->error_indicator) { Branch (6576:13): [True: 11, False: 263]
|
6577 | p->level--; |
6578 | return NULL; |
6579 | } |
6580 | D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block")); |
6581 | Token * _keyword; |
6582 | Token * _literal; |
6583 | Token * _literal_1; |
6584 | Token * _literal_2; |
6585 | void *_opt_var; |
6586 | UNUSED(_opt_var); // Silence compiler warnings |
6587 | asdl_withitem_seq* a; |
6588 | Token * async_var; |
6589 | asdl_stmt_seq* b; |
6590 | if ( |
6591 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (6591:13): [True: 222, False: 41]
|
6592 | && |
6593 | (_keyword = _PyPegen_expect_token(p, 612))222 // token='with' Branch (6593:13): [True: 70, False: 152]
|
6594 | && |
6595 | (_literal = _PyPegen_expect_token(p, 7))70 // token='(' Branch (6595:13): [True: 1, False: 69]
|
6596 | && |
6597 | (a = (asdl_withitem_seq*)_gather_55_rule(p))1 // ','.with_item+ Branch (6597:13): [True: 1, False: 0]
|
6598 | && |
6599 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)1 // ','? Branch (6599:13): [True: 1, False: 0]
|
6600 | && |
6601 | (_literal_1 = _PyPegen_expect_token(p, 8))1 // token=')' Branch (6601:13): [True: 1, False: 0]
|
6602 | && |
6603 | (_literal_2 = _PyPegen_expect_token(p, 11))1 // token=':' Branch (6603:13): [True: 1, False: 0]
|
6604 | && |
6605 | (b = block_rule(p))1 // block Branch (6605:13): [True: 0, False: 1]
|
6606 | ) |
6607 | { |
6608 | D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block")); |
6609 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6610 | if (_token == NULL) { Branch (6610:17): [True: 0, False: 0]
|
6611 | p->level--; |
6612 | return NULL; |
6613 | } |
6614 | int _end_lineno = _token->end_lineno; |
6615 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6616 | int _end_col_offset = _token->end_col_offset; |
6617 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6618 | _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NULL , EXTRA ) ); |
6619 | if (_res == NULL && PyErr_Occurred()) { Branch (6619:17): [True: 0, False: 0]
Branch (6619:33): [True: 0, False: 0]
|
6620 | p->error_indicator = 1; |
6621 | p->level--; |
6622 | return NULL; |
6623 | } |
6624 | goto done; |
6625 | } |
6626 | p->mark = _mark; |
6627 | D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6628 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block")); |
6629 | } |
6630 | { // ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block |
6631 | if (p->error_indicator) { Branch (6631:13): [True: 0, False: 263]
|
6632 | p->level--; |
6633 | return NULL; |
6634 | } |
6635 | D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block")); |
6636 | Token * _keyword; |
6637 | Token * _literal; |
6638 | asdl_withitem_seq* a; |
6639 | Token * async_var; |
6640 | asdl_stmt_seq* b; |
6641 | void *tc; |
6642 | if ( |
6643 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (6643:13): [True: 222, False: 41]
|
6644 | && |
6645 | (_keyword = _PyPegen_expect_token(p, 612))222 // token='with' Branch (6645:13): [True: 70, False: 152]
|
6646 | && |
6647 | (a = (asdl_withitem_seq*)_gather_57_rule(p))70 // ','.with_item+ Branch (6647:13): [True: 69, False: 1]
|
6648 | && |
6649 | (_literal = _PyPegen_expect_token(p, 11))69 // token=':' Branch (6649:13): [True: 69, False: 0]
|
6650 | && |
6651 | (tc = _PyPegen_expect_token(p, 69 TYPE_COMMENT69 ), !p->error_indicator) // TYPE_COMMENT? Branch (6651:13): [True: 69, False: 0]
|
6652 | && |
6653 | (b = block_rule(p))69 // block Branch (6653:13): [True: 67, False: 2]
|
6654 | ) |
6655 | { |
6656 | D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block")); |
6657 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6658 | if (_token == NULL) { Branch (6658:17): [True: 0, False: 67]
|
6659 | p->level--; |
6660 | return NULL; |
6661 | } |
6662 | int _end_lineno = _token->end_lineno; |
6663 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6664 | int _end_col_offset = _token->end_col_offset; |
6665 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6666 | _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); |
6667 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6667:17): [True: 0, False: 67]
Branch (6667:33): [True: 0, False: 0]
|
6668 | p->error_indicator = 1; |
6669 | p->level--; |
6670 | return NULL; |
6671 | } |
6672 | goto done; |
6673 | } |
6674 | p->mark = _mark; |
6675 | D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6676 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block")); |
6677 | } |
6678 | if (p->call_invalid_rules) { // invalid_with_stmt Branch (6678:9): [True: 45, False: 151]
|
6679 | if (p->error_indicator) { Branch (6679:13): [True: 0, False: 45]
|
6680 | p->level--; |
6681 | return NULL; |
6682 | } |
6683 | D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt")); |
6684 | void *invalid_with_stmt_var; |
6685 | if ( |
6686 | (invalid_with_stmt_var = invalid_with_stmt_rule(p)) // invalid_with_stmt Branch (6686:13): [True: 0, False: 45]
|
6687 | ) |
6688 | { |
6689 | D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt")); |
6690 | _res = invalid_with_stmt_var; |
6691 | goto done; |
6692 | } |
6693 | p->mark = _mark; |
6694 | D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6695 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt")); |
6696 | } |
6697 | _res = NULL; |
6698 | done: |
6699 | p->level--; |
6700 | return _res; |
6701 | } |
6702 | |
6703 | // with_item: |
6704 | // | expression 'as' star_target &(',' | ')' | ':') |
6705 | // | invalid_with_item |
6706 | // | expression |
6707 | static withitem_ty |
6708 | with_item_rule(Parser *p) |
6709 | { |
6710 | if (p->level++ == MAXSTACK) { Branch (6710:9): [True: 0, False: 2.11k]
|
6711 | p->error_indicator = 1; |
6712 | PyErr_NoMemory(); |
6713 | } |
6714 | if (p->error_indicator) { Branch (6714:9): [True: 0, False: 2.11k]
|
6715 | p->level--; |
6716 | return NULL; |
6717 | } |
6718 | withitem_ty _res = NULL; |
6719 | int _mark = p->mark; |
6720 | { // expression 'as' star_target &(',' | ')' | ':') |
6721 | if (p->error_indicator) { Branch (6721:13): [True: 0, False: 2.11k]
|
6722 | p->level--; |
6723 | return NULL; |
6724 | } |
6725 | D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')")); |
6726 | Token * _keyword; |
6727 | expr_ty e; |
6728 | expr_ty t; |
6729 | if ( |
6730 | (e = expression_rule(p)) // expression Branch (6730:13): [True: 2.09k, False: 18]
|
6731 | && |
6732 | (_keyword = _PyPegen_expect_token(p, 632))2.09k // token='as' Branch (6732:13): [True: 1.00k, False: 1.09k]
|
6733 | && |
6734 | (t = star_target_rule(p))1.00k // star_target Branch (6734:13): [True: 987, False: 18]
|
6735 | && |
6736 | _PyPegen_lookahead(1, _tmp_59_rule, p)987 Branch (6736:13): [True: 977, False: 10]
|
6737 | ) |
6738 | { |
6739 | D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')")); |
6740 | _res = _PyAST_withitem ( e , t , p -> arena ); |
6741 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6741:17): [True: 0, False: 977]
Branch (6741:33): [True: 0, False: 0]
|
6742 | p->error_indicator = 1; |
6743 | p->level--; |
6744 | return NULL; |
6745 | } |
6746 | goto done; |
6747 | } |
6748 | p->mark = _mark; |
6749 | D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', |
6750 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')")); |
6751 | } |
6752 | if (p->call_invalid_rules) { // invalid_with_item Branch (6752:9): [True: 28, False: 1.11k]
|
6753 | if (p->error_indicator) { Branch (6753:13): [True: 0, False: 28]
|
6754 | p->level--; |
6755 | return NULL; |
6756 | } |
6757 | D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item")); |
6758 | void *invalid_with_item_var; |
6759 | if ( |
6760 | (invalid_with_item_var = invalid_with_item_rule(p)) // invalid_with_item Branch (6760:13): [True: 0, False: 28]
|
6761 | ) |
6762 | { |
6763 | D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_item")); |
6764 | _res = invalid_with_item_var; |
6765 | goto done; |
6766 | } |
6767 | p->mark = _mark; |
6768 | D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', |
6769 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_item")); |
6770 | } |
6771 | { // expression |
6772 | if (p->error_indicator) { Branch (6772:13): [True: 11, False: 1.12k]
|
6773 | p->level--; |
6774 | return NULL; |
6775 | } |
6776 | D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); |
6777 | expr_ty e; |
6778 | if ( |
6779 | (e = expression_rule(p)) // expression Branch (6779:13): [True: 1.10k, False: 18]
|
6780 | ) |
6781 | { |
6782 | D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); |
6783 | _res = _PyAST_withitem ( e , NULL , p -> arena ); |
6784 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6784:17): [True: 0, False: 1.10k]
Branch (6784:33): [True: 0, False: 0]
|
6785 | p->error_indicator = 1; |
6786 | p->level--; |
6787 | return NULL; |
6788 | } |
6789 | goto done; |
6790 | } |
6791 | p->mark = _mark; |
6792 | D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', |
6793 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); |
6794 | } |
6795 | _res = NULL; |
6796 | done: |
6797 | p->level--; |
6798 | return _res; |
6799 | } |
6800 | |
6801 | // try_stmt: |
6802 | // | invalid_try_stmt |
6803 | // | 'try' &&':' block finally_block |
6804 | // | 'try' &&':' block except_block+ else_block? finally_block? |
6805 | // | 'try' &&':' block except_star_block+ else_block? finally_block? |
6806 | static stmt_ty |
6807 | try_stmt_rule(Parser *p) |
6808 | { |
6809 | if (p->level++ == MAXSTACK) { Branch (6809:9): [True: 0, False: 3.79k]
|
6810 | p->error_indicator = 1; |
6811 | PyErr_NoMemory(); |
6812 | } |
6813 | if (p->error_indicator) { Branch (6813:9): [True: 0, False: 3.79k]
|
6814 | p->level--; |
6815 | return NULL; |
6816 | } |
6817 | stmt_ty _res = NULL; |
6818 | int _mark = p->mark; |
6819 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (6819:9): [True: 0, False: 3.79k]
Branch (6819:31): [True: 0, False: 0]
|
6820 | p->error_indicator = 1; |
6821 | p->level--; |
6822 | return NULL; |
6823 | } |
6824 | int _start_lineno = p->tokens[_mark]->lineno; |
6825 | UNUSED(_start_lineno); // Only used by EXTRA macro |
6826 | int _start_col_offset = p->tokens[_mark]->col_offset; |
6827 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
6828 | if (p->call_invalid_rules) { // invalid_try_stmt Branch (6828:9): [True: 51, False: 3.74k]
|
6829 | if (p->error_indicator) { Branch (6829:13): [True: 0, False: 51]
|
6830 | p->level--; |
6831 | return NULL; |
6832 | } |
6833 | D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt")); |
6834 | void *invalid_try_stmt_var; |
6835 | if ( |
6836 | (invalid_try_stmt_var = invalid_try_stmt_rule(p)) // invalid_try_stmt Branch (6836:13): [True: 0, False: 51]
|
6837 | ) |
6838 | { |
6839 | D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt")); |
6840 | _res = invalid_try_stmt_var; |
6841 | goto done; |
6842 | } |
6843 | p->mark = _mark; |
6844 | D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6845 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_try_stmt")); |
6846 | } |
6847 | { // 'try' &&':' block finally_block |
6848 | if (p->error_indicator) { Branch (6848:13): [True: 29, False: 3.76k]
|
6849 | p->level--; |
6850 | return NULL; |
6851 | } |
6852 | D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block finally_block")); |
6853 | Token * _keyword; |
6854 | Token * _literal; |
6855 | asdl_stmt_seq* b; |
6856 | asdl_stmt_seq* f; |
6857 | if ( |
6858 | (_keyword = _PyPegen_expect_token(p, 618)) // token='try' Branch (6858:13): [True: 3.76k, False: 0]
|
6859 | && |
6860 | (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' Branch (6860:13): [True: 3.76k, False: 3]
|
6861 | && |
6862 | (b = block_rule(p))3.76k // block Branch (6862:13): [True: 3.74k, False: 22]
|
6863 | && |
6864 | (f = finally_block_rule(p))3.74k // finally_block Branch (6864:13): [True: 493, False: 3.24k]
|
6865 | ) |
6866 | { |
6867 | D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block finally_block")); |
6868 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6869 | if (_token == NULL) { Branch (6869:17): [True: 0, False: 493]
|
6870 | p->level--; |
6871 | return NULL; |
6872 | } |
6873 | int _end_lineno = _token->end_lineno; |
6874 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6875 | int _end_col_offset = _token->end_col_offset; |
6876 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6877 | _res = _PyAST_Try ( b , NULL , NULL , f , EXTRA ); |
6878 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6878:17): [True: 0, False: 493]
Branch (6878:33): [True: 0, False: 0]
|
6879 | p->error_indicator = 1; |
6880 | p->level--; |
6881 | return NULL; |
6882 | } |
6883 | goto done; |
6884 | } |
6885 | p->mark = _mark; |
6886 | D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6887 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block finally_block")); |
6888 | } |
6889 | { // 'try' &&':' block except_block+ else_block? finally_block? |
6890 | if (p->error_indicator) { Branch (6890:13): [True: 4, False: 3.27k]
|
6891 | p->level--; |
6892 | return NULL; |
6893 | } |
6894 | D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_block+ else_block? finally_block?")); |
6895 | Token * _keyword; |
6896 | Token * _literal; |
6897 | asdl_stmt_seq* b; |
6898 | void *el; |
6899 | asdl_excepthandler_seq* ex; |
6900 | void *f; |
6901 | if ( |
6902 | (_keyword = _PyPegen_expect_token(p, 618)) // token='try' Branch (6902:13): [True: 3.27k, False: 0]
|
6903 | && |
6904 | (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' Branch (6904:13): [True: 3.27k, False: 0]
|
6905 | && |
6906 | (b = block_rule(p)) // block Branch (6906:13): [True: 3.24k, False: 21]
|
6907 | && |
6908 | (ex = (asdl_excepthandler_seq*)_loop1_60_rule(p))3.24k // except_block+ Branch (6908:13): [True: 3.14k, False: 104]
|
6909 | && |
6910 | (el = else_block_rule(p), !p->error_indicator)3.14k // else_block? Branch (6910:13): [True: 3.14k, False: 0]
|
6911 | && |
6912 | (f = finally_block_rule(p), !p->error_indicator)3.14k // finally_block? Branch (6912:13): [True: 3.14k, False: 1]
|
6913 | ) |
6914 | { |
6915 | D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_block+ else_block? finally_block?")); |
6916 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6917 | if (_token == NULL) { Branch (6917:17): [True: 0, False: 3.14k]
|
6918 | p->level--; |
6919 | return NULL; |
6920 | } |
6921 | int _end_lineno = _token->end_lineno; |
6922 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6923 | int _end_col_offset = _token->end_col_offset; |
6924 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6925 | _res = _PyAST_Try ( b , ex , el , f , EXTRA ); |
6926 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6926:17): [True: 0, False: 3.14k]
Branch (6926:33): [True: 0, False: 0]
|
6927 | p->error_indicator = 1; |
6928 | p->level--; |
6929 | return NULL; |
6930 | } |
6931 | goto done; |
6932 | } |
6933 | p->mark = _mark; |
6934 | D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6935 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_block+ else_block? finally_block?")); |
6936 | } |
6937 | { // 'try' &&':' block except_star_block+ else_block? finally_block? |
6938 | if (p->error_indicator) { Branch (6938:13): [True: 1, False: 125]
|
6939 | p->level--; |
6940 | return NULL; |
6941 | } |
6942 | D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_star_block+ else_block? finally_block?")); |
6943 | Token * _keyword; |
6944 | Token * _literal; |
6945 | asdl_stmt_seq* b; |
6946 | void *el; |
6947 | asdl_excepthandler_seq* ex; |
6948 | void *f; |
6949 | if ( |
6950 | (_keyword = _PyPegen_expect_token(p, 618)) // token='try' Branch (6950:13): [True: 125, False: 0]
|
6951 | && |
6952 | (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' Branch (6952:13): [True: 125, False: 0]
|
6953 | && |
6954 | (b = block_rule(p)) // block Branch (6954:13): [True: 104, False: 21]
|
6955 | && |
6956 | (ex = (asdl_excepthandler_seq*)_loop1_61_rule(p))104 // except_star_block+ Branch (6956:13): [True: 63, False: 41]
|
6957 | && |
6958 | (el = else_block_rule(p), !p->error_indicator)63 // else_block? Branch (6958:13): [True: 63, False: 0]
|
6959 | && |
6960 | (f = finally_block_rule(p), !p->error_indicator)63 // finally_block? Branch (6960:13): [True: 62, False: 1]
|
6961 | ) |
6962 | { |
6963 | D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_star_block+ else_block? finally_block?")); |
6964 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
6965 | if (_token == NULL) { Branch (6965:17): [True: 0, False: 62]
|
6966 | p->level--; |
6967 | return NULL; |
6968 | } |
6969 | int _end_lineno = _token->end_lineno; |
6970 | UNUSED(_end_lineno); // Only used by EXTRA macro |
6971 | int _end_col_offset = _token->end_col_offset; |
6972 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
6973 | _res = _PyAST_TryStar ( b , ex , el , f , EXTRA ); |
6974 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (6974:17): [True: 0, False: 62]
Branch (6974:33): [True: 0, False: 0]
|
6975 | p->error_indicator = 1; |
6976 | p->level--; |
6977 | return NULL; |
6978 | } |
6979 | goto done; |
6980 | } |
6981 | p->mark = _mark; |
6982 | D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
6983 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_star_block+ else_block? finally_block?")); |
6984 | } |
6985 | _res = NULL; |
6986 | done: |
6987 | p->level--; |
6988 | return _res; |
6989 | } |
6990 | |
6991 | // except_block: |
6992 | // | invalid_except_stmt_indent |
6993 | // | 'except' expression ['as' NAME] ':' block |
6994 | // | 'except' ':' block |
6995 | // | invalid_except_stmt |
6996 | static excepthandler_ty |
6997 | except_block_rule(Parser *p) |
6998 | { |
6999 | if (p->level++ == MAXSTACK) { Branch (6999:9): [True: 0, False: 6.64k]
|
7000 | p->error_indicator = 1; |
7001 | PyErr_NoMemory(); |
7002 | } |
7003 | if (p->error_indicator) { Branch (7003:9): [True: 0, False: 6.64k]
|
7004 | p->level--; |
7005 | return NULL; |
7006 | } |
7007 | excepthandler_ty _res = NULL; |
7008 | int _mark = p->mark; |
7009 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 03.32k ) { Branch (7009:9): [True: 3.32k, False: 3.31k]
Branch (7009:31): [True: 0, False: 3.32k]
|
7010 | p->error_indicator = 1; |
7011 | p->level--; |
7012 | return NULL; |
7013 | } |
7014 | int _start_lineno = p->tokens[_mark]->lineno; |
7015 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7016 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7017 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7018 | if (p->call_invalid_rules) { // invalid_except_stmt_indent Branch (7018:9): [True: 78, False: 6.56k]
|
7019 | if (p->error_indicator) { Branch (7019:13): [True: 0, False: 78]
|
7020 | p->level--; |
7021 | return NULL; |
7022 | } |
7023 | D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt_indent")); |
7024 | void *invalid_except_stmt_indent_var; |
7025 | if ( |
7026 | (invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p)) // invalid_except_stmt_indent Branch (7026:13): [True: 0, False: 78]
|
7027 | ) |
7028 | { |
7029 | D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt_indent")); |
7030 | _res = invalid_except_stmt_indent_var; |
7031 | goto done; |
7032 | } |
7033 | p->mark = _mark; |
7034 | D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', |
7035 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt_indent")); |
7036 | } |
7037 | { // 'except' expression ['as' NAME] ':' block |
7038 | if (p->error_indicator) { Branch (7038:13): [True: 2, False: 6.63k]
|
7039 | p->level--; |
7040 | return NULL; |
7041 | } |
7042 | D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block")); |
7043 | Token * _keyword; |
7044 | Token * _literal; |
7045 | asdl_stmt_seq* b; |
7046 | expr_ty e; |
7047 | void *t; |
7048 | if ( |
7049 | (_keyword = _PyPegen_expect_token(p, 629)) // token='except' Branch (7049:13): [True: 3.45k, False: 3.18k]
|
7050 | && |
7051 | (e = expression_rule(p))3.45k // expression Branch (7051:13): [True: 3.12k, False: 331]
|
7052 | && |
7053 | (t = _tmp_62_rule(p), !p->error_indicator)3.12k // ['as' NAME] Branch (7053:13): [True: 3.12k, False: 0]
|
7054 | && |
7055 | (_literal = _PyPegen_expect_token(p, 11))3.12k // token=':' Branch (7055:13): [True: 3.11k, False: 11]
|
7056 | && |
7057 | (b = block_rule(p))3.11k // block Branch (7057:13): [True: 3.11k, False: 1]
|
7058 | ) |
7059 | { |
7060 | D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block")); |
7061 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7062 | if (_token == NULL) { Branch (7062:17): [True: 0, False: 3.11k]
|
7063 | p->level--; |
7064 | return NULL; |
7065 | } |
7066 | int _end_lineno = _token->end_lineno; |
7067 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7068 | int _end_col_offset = _token->end_col_offset; |
7069 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7070 | _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id526 : NULL , b , EXTRA ); Branch (7070:47): [True: 526, False: 2.59k]
|
7071 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7071:17): [True: 0, False: 3.11k]
Branch (7071:33): [True: 0, False: 0]
|
7072 | p->error_indicator = 1; |
7073 | p->level--; |
7074 | return NULL; |
7075 | } |
7076 | goto done; |
7077 | } |
7078 | p->mark = _mark; |
7079 | D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', |
7080 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' block")); |
7081 | } |
7082 | { // 'except' ':' block |
7083 | if (p->error_indicator) { Branch (7083:13): [True: 0, False: 3.52k]
|
7084 | p->level--; |
7085 | return NULL; |
7086 | } |
7087 | D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' block")); |
7088 | Token * _keyword; |
7089 | Token * _literal; |
7090 | asdl_stmt_seq* b; |
7091 | if ( |
7092 | (_keyword = _PyPegen_expect_token(p, 629)) // token='except' Branch (7092:13): [True: 343, False: 3.18k]
|
7093 | && |
7094 | (_literal = _PyPegen_expect_token(p, 11))343 // token=':' Branch (7094:13): [True: 229, False: 114]
|
7095 | && |
7096 | (b = block_rule(p))229 // block Branch (7096:13): [True: 226, False: 3]
|
7097 | ) |
7098 | { |
7099 | D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block")); |
7100 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7101 | if (_token == NULL) { Branch (7101:17): [True: 0, False: 226]
|
7102 | p->level--; |
7103 | return NULL; |
7104 | } |
7105 | int _end_lineno = _token->end_lineno; |
7106 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7107 | int _end_col_offset = _token->end_col_offset; |
7108 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7109 | _res = _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA ); |
7110 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7110:17): [True: 0, False: 226]
Branch (7110:33): [True: 0, False: 0]
|
7111 | p->error_indicator = 1; |
7112 | p->level--; |
7113 | return NULL; |
7114 | } |
7115 | goto done; |
7116 | } |
7117 | p->mark = _mark; |
7118 | D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', |
7119 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' block")); |
7120 | } |
7121 | if (p->call_invalid_rules) { // invalid_except_stmt Branch (7121:9): [True: 61, False: 3.23k]
|
7122 | if (p->error_indicator) { Branch (7122:13): [True: 0, False: 61]
|
7123 | p->level--; |
7124 | return NULL; |
7125 | } |
7126 | D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt")); |
7127 | void *invalid_except_stmt_var; |
7128 | if ( |
7129 | (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt Branch (7129:13): [True: 0, False: 61]
|
7130 | ) |
7131 | { |
7132 | D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt")); |
7133 | _res = invalid_except_stmt_var; |
7134 | goto done; |
7135 | } |
7136 | p->mark = _mark; |
7137 | D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', |
7138 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt")); |
7139 | } |
7140 | _res = NULL; |
7141 | done: |
7142 | p->level--; |
7143 | return _res; |
7144 | } |
7145 | |
7146 | // except_star_block: |
7147 | // | invalid_except_star_stmt_indent |
7148 | // | 'except' '*' expression ['as' NAME] ':' block |
7149 | // | invalid_except_stmt |
7150 | static excepthandler_ty |
7151 | except_star_block_rule(Parser *p) |
7152 | { |
7153 | if (p->level++ == MAXSTACK) { Branch (7153:9): [True: 0, False: 218]
|
7154 | p->error_indicator = 1; |
7155 | PyErr_NoMemory(); |
7156 | } |
7157 | if (p->error_indicator) { Branch (7157:9): [True: 0, False: 218]
|
7158 | p->level--; |
7159 | return NULL; |
7160 | } |
7161 | excepthandler_ty _res = NULL; |
7162 | int _mark = p->mark; |
7163 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 068 ) { Branch (7163:9): [True: 68, False: 150]
Branch (7163:31): [True: 0, False: 68]
|
7164 | p->error_indicator = 1; |
7165 | p->level--; |
7166 | return NULL; |
7167 | } |
7168 | int _start_lineno = p->tokens[_mark]->lineno; |
7169 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7170 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7171 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7172 | if (p->call_invalid_rules) { // invalid_except_star_stmt_indent Branch (7172:9): [True: 58, False: 160]
|
7173 | if (p->error_indicator) { Branch (7173:13): [True: 0, False: 58]
|
7174 | p->level--; |
7175 | return NULL; |
7176 | } |
7177 | D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_star_stmt_indent")); |
7178 | void *invalid_except_star_stmt_indent_var; |
7179 | if ( |
7180 | (invalid_except_star_stmt_indent_var = invalid_except_star_stmt_indent_rule(p)) // invalid_except_star_stmt_indent Branch (7180:13): [True: 0, False: 58]
|
7181 | ) |
7182 | { |
7183 | D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_star_stmt_indent")); |
7184 | _res = invalid_except_star_stmt_indent_var; |
7185 | goto done; |
7186 | } |
7187 | p->mark = _mark; |
7188 | D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ', |
7189 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_star_stmt_indent")); |
7190 | } |
7191 | { // 'except' '*' expression ['as' NAME] ':' block |
7192 | if (p->error_indicator) { Branch (7192:13): [True: 1, False: 217]
|
7193 | p->level--; |
7194 | return NULL; |
7195 | } |
7196 | D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' block")); |
7197 | Token * _keyword; |
7198 | Token * _literal; |
7199 | Token * _literal_1; |
7200 | asdl_stmt_seq* b; |
7201 | expr_ty e; |
7202 | void *t; |
7203 | if ( |
7204 | (_keyword = _PyPegen_expect_token(p, 629)) // token='except' Branch (7204:13): [True: 120, False: 97]
|
7205 | && |
7206 | (_literal = _PyPegen_expect_token(p, 16))120 // token='*' Branch (7206:13): [True: 95, False: 25]
|
7207 | && |
7208 | (e = expression_rule(p))95 // expression Branch (7208:13): [True: 91, False: 4]
|
7209 | && |
7210 | (t = _tmp_63_rule(p), !p->error_indicator)91 // ['as' NAME] Branch (7210:13): [True: 91, False: 0]
|
7211 | && |
7212 | (_literal_1 = _PyPegen_expect_token(p, 11))91 // token=':' Branch (7212:13): [True: 84, False: 7]
|
7213 | && |
7214 | (b = block_rule(p))84 // block Branch (7214:13): [True: 83, False: 1]
|
7215 | ) |
7216 | { |
7217 | D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' block")); |
7218 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7219 | if (_token == NULL) { Branch (7219:17): [True: 0, False: 83]
|
7220 | p->level--; |
7221 | return NULL; |
7222 | } |
7223 | int _end_lineno = _token->end_lineno; |
7224 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7225 | int _end_col_offset = _token->end_col_offset; |
7226 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7227 | _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id28 : NULL , b , EXTRA ); Branch (7227:47): [True: 28, False: 55]
|
7228 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7228:17): [True: 0, False: 83]
Branch (7228:33): [True: 0, False: 0]
|
7229 | p->error_indicator = 1; |
7230 | p->level--; |
7231 | return NULL; |
7232 | } |
7233 | goto done; |
7234 | } |
7235 | p->mark = _mark; |
7236 | D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ', |
7237 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' expression ['as' NAME] ':' block")); |
7238 | } |
7239 | if (p->call_invalid_rules) { // invalid_except_stmt Branch (7239:9): [True: 42, False: 92]
|
7240 | if (p->error_indicator) { Branch (7240:13): [True: 0, False: 42]
|
7241 | p->level--; |
7242 | return NULL; |
7243 | } |
7244 | D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt")); |
7245 | void *invalid_except_stmt_var; |
7246 | if ( |
7247 | (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt Branch (7247:13): [True: 0, False: 42]
|
7248 | ) |
7249 | { |
7250 | D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt")); |
7251 | _res = invalid_except_stmt_var; |
7252 | goto done; |
7253 | } |
7254 | p->mark = _mark; |
7255 | D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ', |
7256 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt")); |
7257 | } |
7258 | _res = NULL; |
7259 | done: |
7260 | p->level--; |
7261 | return _res; |
7262 | } |
7263 | |
7264 | // finally_block: invalid_finally_stmt | 'finally' &&':' block |
7265 | static asdl_stmt_seq* |
7266 | finally_block_rule(Parser *p) |
7267 | { |
7268 | if (p->level++ == MAXSTACK) { Branch (7268:9): [True: 0, False: 6.95k]
|
7269 | p->error_indicator = 1; |
7270 | PyErr_NoMemory(); |
7271 | } |
7272 | if (p->error_indicator) { Branch (7272:9): [True: 0, False: 6.95k]
|
7273 | p->level--; |
7274 | return NULL; |
7275 | } |
7276 | asdl_stmt_seq* _res = NULL; |
7277 | int _mark = p->mark; |
7278 | if (p->call_invalid_rules) { // invalid_finally_stmt Branch (7278:9): [True: 15, False: 6.93k]
|
7279 | if (p->error_indicator) { Branch (7279:13): [True: 0, False: 15]
|
7280 | p->level--; |
7281 | return NULL; |
7282 | } |
7283 | D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_finally_stmt")); |
7284 | void *invalid_finally_stmt_var; |
7285 | if ( |
7286 | (invalid_finally_stmt_var = invalid_finally_stmt_rule(p)) // invalid_finally_stmt Branch (7286:13): [True: 0, False: 15]
|
7287 | ) |
7288 | { |
7289 | D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_finally_stmt")); |
7290 | _res = invalid_finally_stmt_var; |
7291 | goto done; |
7292 | } |
7293 | p->mark = _mark; |
7294 | D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ', |
7295 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_finally_stmt")); |
7296 | } |
7297 | { // 'finally' &&':' block |
7298 | if (p->error_indicator) { Branch (7298:13): [True: 2, False: 6.94k]
|
7299 | p->level--; |
7300 | return NULL; |
7301 | } |
7302 | D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' &&':' block")); |
7303 | Token * _keyword; |
7304 | Token * _literal; |
7305 | asdl_stmt_seq* a; |
7306 | if ( |
7307 | (_keyword = _PyPegen_expect_token(p, 625)) // token='finally' Branch (7307:13): [True: 563, False: 6.38k]
|
7308 | && |
7309 | (_literal = _PyPegen_expect_forced_token(p, 11, ":"))563 // forced_token=':' Branch (7309:13): [True: 563, False: 0]
|
7310 | && |
7311 | (a = block_rule(p))563 // block Branch (7311:13): [True: 539, False: 24]
|
7312 | ) |
7313 | { |
7314 | D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' &&':' block")); |
7315 | _res = a; |
7316 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7316:17): [True: 0, False: 539]
Branch (7316:33): [True: 0, False: 0]
|
7317 | p->error_indicator = 1; |
7318 | p->level--; |
7319 | return NULL; |
7320 | } |
7321 | goto done; |
7322 | } |
7323 | p->mark = _mark; |
7324 | D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ', |
7325 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' &&':' block")); |
7326 | } |
7327 | _res = NULL; |
7328 | done: |
7329 | p->level--; |
7330 | return _res; |
7331 | } |
7332 | |
7333 | // match_stmt: |
7334 | // | "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT |
7335 | // | invalid_match_stmt |
7336 | static stmt_ty |
7337 | match_stmt_rule(Parser *p) |
7338 | { |
7339 | if (p->level++ == MAXSTACK) { Branch (7339:9): [True: 0, False: 273k]
|
7340 | p->error_indicator = 1; |
7341 | PyErr_NoMemory(); |
7342 | } |
7343 | if (p->error_indicator) { Branch (7343:9): [True: 0, False: 273k]
|
7344 | p->level--; |
7345 | return NULL; |
7346 | } |
7347 | stmt_ty _res = NULL; |
7348 | int _mark = p->mark; |
7349 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (7349:9): [True: 0, False: 273k]
Branch (7349:31): [True: 0, False: 0]
|
7350 | p->error_indicator = 1; |
7351 | p->level--; |
7352 | return NULL; |
7353 | } |
7354 | int _start_lineno = p->tokens[_mark]->lineno; |
7355 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7356 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7357 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7358 | { // "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT |
7359 | if (p->error_indicator) { Branch (7359:13): [True: 0, False: 273k]
|
7360 | p->level--; |
7361 | return NULL; |
7362 | } |
7363 | D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT case_block+ DEDENT")); |
7364 | expr_ty _keyword; |
7365 | Token * _literal; |
7366 | asdl_match_case_seq* cases; |
7367 | Token * dedent_var; |
7368 | Token * indent_var; |
7369 | Token * newline_var; |
7370 | expr_ty subject; |
7371 | if ( |
7372 | (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' Branch (7372:13): [True: 1.02k, False: 272k]
|
7373 | && |
7374 | (subject = subject_expr_rule(p))1.02k // subject_expr Branch (7374:13): [True: 962, False: 65]
|
7375 | && |
7376 | (_literal = _PyPegen_expect_token(p, 11))962 // token=':' Branch (7376:13): [True: 957, False: 5]
|
7377 | && |
7378 | (newline_var = _PyPegen_expect_token(p, 957 NEWLINE957 )) // token='NEWLINE' Branch (7378:13): [True: 957, False: 0]
|
7379 | && |
7380 | (indent_var = _PyPegen_expect_token(p, 957 INDENT957 )) // token='INDENT' Branch (7380:13): [True: 955, False: 2]
|
7381 | && |
7382 | (cases = (asdl_match_case_seq*)_loop1_64_rule(p))955 // case_block+ Branch (7382:13): [True: 910, False: 45]
|
7383 | && |
7384 | (dedent_var = _PyPegen_expect_token(p, 910 DEDENT910 )) // token='DEDENT' Branch (7384:13): [True: 909, False: 1]
|
7385 | ) |
7386 | { |
7387 | D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT case_block+ DEDENT")); |
7388 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7389 | if (_token == NULL) { Branch (7389:17): [True: 0, False: 909]
|
7390 | p->level--; |
7391 | return NULL; |
7392 | } |
7393 | int _end_lineno = _token->end_lineno; |
7394 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7395 | int _end_col_offset = _token->end_col_offset; |
7396 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7397 | _res = CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) ); |
7398 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7398:17): [True: 0, False: 909]
Branch (7398:33): [True: 0, False: 0]
|
7399 | p->error_indicator = 1; |
7400 | p->level--; |
7401 | return NULL; |
7402 | } |
7403 | goto done; |
7404 | } |
7405 | p->mark = _mark; |
7406 | D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
7407 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT case_block+ DEDENT")); |
7408 | } |
7409 | if (p->call_invalid_rules) { // invalid_match_stmt Branch (7409:9): [True: 826, False: 272k]
|
7410 | if (p->error_indicator) { Branch (7410:13): [True: 11, False: 815]
|
7411 | p->level--; |
7412 | return NULL; |
7413 | } |
7414 | D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_match_stmt")); |
7415 | void *invalid_match_stmt_var; |
7416 | if ( |
7417 | (invalid_match_stmt_var = invalid_match_stmt_rule(p)) // invalid_match_stmt Branch (7417:13): [True: 0, False: 815]
|
7418 | ) |
7419 | { |
7420 | D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_match_stmt")); |
7421 | _res = invalid_match_stmt_var; |
7422 | goto done; |
7423 | } |
7424 | p->mark = _mark; |
7425 | D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
7426 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_match_stmt")); |
7427 | } |
7428 | _res = NULL; |
7429 | done: |
7430 | p->level--; |
7431 | return _res; |
7432 | } |
7433 | |
7434 | // subject_expr: star_named_expression ',' star_named_expressions? | named_expression |
7435 | static expr_ty |
7436 | subject_expr_rule(Parser *p) |
7437 | { |
7438 | if (p->level++ == MAXSTACK) { Branch (7438:9): [True: 0, False: 1.05k]
|
7439 | p->error_indicator = 1; |
7440 | PyErr_NoMemory(); |
7441 | } |
7442 | if (p->error_indicator) { Branch (7442:9): [True: 0, False: 1.05k]
|
7443 | p->level--; |
7444 | return NULL; |
7445 | } |
7446 | expr_ty _res = NULL; |
7447 | int _mark = p->mark; |
7448 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 01.00k ) { Branch (7448:9): [True: 1.00k, False: 46]
Branch (7448:31): [True: 0, False: 1.00k]
|
7449 | p->error_indicator = 1; |
7450 | p->level--; |
7451 | return NULL; |
7452 | } |
7453 | int _start_lineno = p->tokens[_mark]->lineno; |
7454 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7455 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7456 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7457 | { // star_named_expression ',' star_named_expressions? |
7458 | if (p->error_indicator) { Branch (7458:13): [True: 0, False: 1.05k]
|
7459 | p->level--; |
7460 | return NULL; |
7461 | } |
7462 | D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); |
7463 | Token * _literal; |
7464 | expr_ty value; |
7465 | void *values; |
7466 | if ( |
7467 | (value = star_named_expression_rule(p)) // star_named_expression Branch (7467:13): [True: 985, False: 65]
|
7468 | && |
7469 | (_literal = _PyPegen_expect_token(p, 12))985 // token=',' Branch (7469:13): [True: 8, False: 977]
|
7470 | && |
7471 | (values = star_named_expressions_rule(p), !p->error_indicator)8 // star_named_expressions? Branch (7471:13): [True: 8, False: 0]
|
7472 | ) |
7473 | { |
7474 | D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); |
7475 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7476 | if (_token == NULL) { Branch (7476:17): [True: 0, False: 8]
|
7477 | p->level--; |
7478 | return NULL; |
7479 | } |
7480 | int _end_lineno = _token->end_lineno; |
7481 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7482 | int _end_col_offset = _token->end_col_offset; |
7483 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7484 | _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , value , values ) ) , Load , EXTRA ); |
7485 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7485:17): [True: 0, False: 8]
Branch (7485:33): [True: 0, False: 0]
|
7486 | p->error_indicator = 1; |
7487 | p->level--; |
7488 | return NULL; |
7489 | } |
7490 | goto done; |
7491 | } |
7492 | p->mark = _mark; |
7493 | D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ', |
7494 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); |
7495 | } |
7496 | { // named_expression |
7497 | if (p->error_indicator) { Branch (7497:13): [True: 0, False: 1.04k]
|
7498 | p->level--; |
7499 | return NULL; |
7500 | } |
7501 | D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); |
7502 | expr_ty named_expression_var; |
7503 | if ( |
7504 | (named_expression_var = named_expression_rule(p)) // named_expression Branch (7504:13): [True: 977, False: 65]
|
7505 | ) |
7506 | { |
7507 | D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); |
7508 | _res = named_expression_var; |
7509 | goto done; |
7510 | } |
7511 | p->mark = _mark; |
7512 | D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ', |
7513 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); |
7514 | } |
7515 | _res = NULL; |
7516 | done: |
7517 | p->level--; |
7518 | return _res; |
7519 | } |
7520 | |
7521 | // case_block: invalid_case_block | "case" patterns guard? ':' block |
7522 | static match_case_ty |
7523 | case_block_rule(Parser *p) |
7524 | { |
7525 | if (p->level++ == MAXSTACK) { Branch (7525:9): [True: 0, False: 2.23k]
|
7526 | p->error_indicator = 1; |
7527 | PyErr_NoMemory(); |
7528 | } |
7529 | if (p->error_indicator) { Branch (7529:9): [True: 0, False: 2.23k]
|
7530 | p->level--; |
7531 | return NULL; |
7532 | } |
7533 | match_case_ty _res = NULL; |
7534 | int _mark = p->mark; |
7535 | if (p->call_invalid_rules) { // invalid_case_block Branch (7535:9): [True: 21, False: 2.21k]
|
7536 | if (p->error_indicator) { Branch (7536:13): [True: 0, False: 21]
|
7537 | p->level--; |
7538 | return NULL; |
7539 | } |
7540 | D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_case_block")); |
7541 | void *invalid_case_block_var; |
7542 | if ( |
7543 | (invalid_case_block_var = invalid_case_block_rule(p)) // invalid_case_block Branch (7543:13): [True: 0, False: 21]
|
7544 | ) |
7545 | { |
7546 | D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_case_block")); |
7547 | _res = invalid_case_block_var; |
7548 | goto done; |
7549 | } |
7550 | p->mark = _mark; |
7551 | D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ', |
7552 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_case_block")); |
7553 | } |
7554 | { // "case" patterns guard? ':' block |
7555 | if (p->error_indicator) { Branch (7555:13): [True: 11, False: 2.22k]
|
7556 | p->level--; |
7557 | return NULL; |
7558 | } |
7559 | D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' block")); |
7560 | expr_ty _keyword; |
7561 | Token * _literal; |
7562 | asdl_stmt_seq* body; |
7563 | void *guard; |
7564 | pattern_ty pattern; |
7565 | if ( |
7566 | (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' Branch (7566:13): [True: 1.31k, False: 911]
|
7567 | && |
7568 | (pattern = patterns_rule(p))1.31k // patterns Branch (7568:13): [True: 1.29k, False: 24]
|
7569 | && |
7570 | (guard = guard_rule(p), !p->error_indicator)1.29k // guard? Branch (7570:13): [True: 1.29k, False: 0]
|
7571 | && |
7572 | (_literal = _PyPegen_expect_token(p, 11))1.29k // token=':' Branch (7572:13): [True: 1.28k, False: 5]
|
7573 | && |
7574 | (body = block_rule(p))1.28k // block Branch (7574:13): [True: 1.28k, False: 4]
|
7575 | ) |
7576 | { |
7577 | D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' block")); |
7578 | _res = _PyAST_match_case ( pattern , guard , body , p -> arena ); |
7579 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7579:17): [True: 0, False: 1.28k]
Branch (7579:33): [True: 0, False: 0]
|
7580 | p->error_indicator = 1; |
7581 | p->level--; |
7582 | return NULL; |
7583 | } |
7584 | goto done; |
7585 | } |
7586 | p->mark = _mark; |
7587 | D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ', |
7588 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' block")); |
7589 | } |
7590 | _res = NULL; |
7591 | done: |
7592 | p->level--; |
7593 | return _res; |
7594 | } |
7595 | |
7596 | // guard: 'if' named_expression |
7597 | static expr_ty |
7598 | guard_rule(Parser *p) |
7599 | { |
7600 | if (p->level++ == MAXSTACK) { Branch (7600:9): [True: 0, False: 1.30k]
|
7601 | p->error_indicator = 1; |
7602 | PyErr_NoMemory(); |
7603 | } |
7604 | if (p->error_indicator) { Branch (7604:9): [True: 0, False: 1.30k]
|
7605 | p->level--; |
7606 | return NULL; |
7607 | } |
7608 | expr_ty _res = NULL; |
7609 | int _mark = p->mark; |
7610 | { // 'if' named_expression |
7611 | if (p->error_indicator) { Branch (7611:13): [True: 0, False: 1.30k]
|
7612 | p->level--; |
7613 | return NULL; |
7614 | } |
7615 | D(fprintf(stderr, "%*c> guard[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression")); |
7616 | Token * _keyword; |
7617 | expr_ty guard; |
7618 | if ( |
7619 | (_keyword = _PyPegen_expect_token(p, 634)) // token='if' Branch (7619:13): [True: 146, False: 1.15k]
|
7620 | && |
7621 | (guard = named_expression_rule(p))146 // named_expression Branch (7621:13): [True: 146, False: 0]
|
7622 | ) |
7623 | { |
7624 | D(fprintf(stderr, "%*c+ guard[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression")); |
7625 | _res = guard; |
7626 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7626:17): [True: 0, False: 146]
Branch (7626:33): [True: 0, False: 0]
|
7627 | p->error_indicator = 1; |
7628 | p->level--; |
7629 | return NULL; |
7630 | } |
7631 | goto done; |
7632 | } |
7633 | p->mark = _mark; |
7634 | D(fprintf(stderr, "%*c%s guard[%d-%d]: %s failed!\n", p->level, ' ', |
7635 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression")); |
7636 | } |
7637 | _res = NULL; |
7638 | done: |
7639 | p->level--; |
7640 | return _res; |
7641 | } |
7642 | |
7643 | // patterns: open_sequence_pattern | pattern |
7644 | static pattern_ty |
7645 | patterns_rule(Parser *p) |
7646 | { |
7647 | if (p->level++ == MAXSTACK) { Branch (7647:9): [True: 0, False: 1.34k]
|
7648 | p->error_indicator = 1; |
7649 | PyErr_NoMemory(); |
7650 | } |
7651 | if (p->error_indicator) { Branch (7651:9): [True: 0, False: 1.34k]
|
7652 | p->level--; |
7653 | return NULL; |
7654 | } |
7655 | pattern_ty _res = NULL; |
7656 | int _mark = p->mark; |
7657 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 01.30k ) { Branch (7657:9): [True: 1.30k, False: 40]
Branch (7657:31): [True: 0, False: 1.30k]
|
7658 | p->error_indicator = 1; |
7659 | p->level--; |
7660 | return NULL; |
7661 | } |
7662 | int _start_lineno = p->tokens[_mark]->lineno; |
7663 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7664 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7665 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7666 | { // open_sequence_pattern |
7667 | if (p->error_indicator) { Branch (7667:13): [True: 0, False: 1.34k]
|
7668 | p->level--; |
7669 | return NULL; |
7670 | } |
7671 | D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern")); |
7672 | asdl_pattern_seq* patterns; |
7673 | if ( |
7674 | (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern Branch (7674:13): [True: 61, False: 1.28k]
|
7675 | ) |
7676 | { |
7677 | D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern")); |
7678 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7679 | if (_token == NULL) { Branch (7679:17): [True: 0, False: 61]
|
7680 | p->level--; |
7681 | return NULL; |
7682 | } |
7683 | int _end_lineno = _token->end_lineno; |
7684 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7685 | int _end_col_offset = _token->end_col_offset; |
7686 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7687 | _res = _PyAST_MatchSequence ( patterns , EXTRA ); |
7688 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7688:17): [True: 0, False: 61]
Branch (7688:33): [True: 0, False: 0]
|
7689 | p->error_indicator = 1; |
7690 | p->level--; |
7691 | return NULL; |
7692 | } |
7693 | goto done; |
7694 | } |
7695 | p->mark = _mark; |
7696 | D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ', |
7697 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "open_sequence_pattern")); |
7698 | } |
7699 | { // pattern |
7700 | if (p->error_indicator) { Branch (7700:13): [True: 13, False: 1.27k]
|
7701 | p->level--; |
7702 | return NULL; |
7703 | } |
7704 | D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern")); |
7705 | pattern_ty pattern_var; |
7706 | if ( |
7707 | (pattern_var = pattern_rule(p)) // pattern Branch (7707:13): [True: 1.24k, False: 32]
|
7708 | ) |
7709 | { |
7710 | D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern")); |
7711 | _res = pattern_var; |
7712 | goto done; |
7713 | } |
7714 | p->mark = _mark; |
7715 | D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ', |
7716 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern")); |
7717 | } |
7718 | _res = NULL; |
7719 | done: |
7720 | p->level--; |
7721 | return _res; |
7722 | } |
7723 | |
7724 | // pattern: as_pattern | or_pattern |
7725 | static pattern_ty |
7726 | pattern_rule(Parser *p) |
7727 | { |
7728 | if (p->level++ == MAXSTACK) { Branch (7728:9): [True: 0, False: 5.14k]
|
7729 | p->error_indicator = 1; |
7730 | PyErr_NoMemory(); |
7731 | } |
7732 | if (p->error_indicator) { Branch (7732:9): [True: 0, False: 5.14k]
|
7733 | p->level--; |
7734 | return NULL; |
7735 | } |
7736 | pattern_ty _res = NULL; |
7737 | int _mark = p->mark; |
7738 | { // as_pattern |
7739 | if (p->error_indicator) { Branch (7739:13): [True: 0, False: 5.14k]
|
7740 | p->level--; |
7741 | return NULL; |
7742 | } |
7743 | D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "as_pattern")); |
7744 | pattern_ty as_pattern_var; |
7745 | if ( |
7746 | (as_pattern_var = as_pattern_rule(p)) // as_pattern Branch (7746:13): [True: 174, False: 4.96k]
|
7747 | ) |
7748 | { |
7749 | D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "as_pattern")); |
7750 | _res = as_pattern_var; |
7751 | goto done; |
7752 | } |
7753 | p->mark = _mark; |
7754 | D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7755 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "as_pattern")); |
7756 | } |
7757 | { // or_pattern |
7758 | if (p->error_indicator) { Branch (7758:13): [True: 13, False: 4.95k]
|
7759 | p->level--; |
7760 | return NULL; |
7761 | } |
7762 | D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern")); |
7763 | pattern_ty or_pattern_var; |
7764 | if ( |
7765 | (or_pattern_var = or_pattern_rule(p)) // or_pattern Branch (7765:13): [True: 4.64k, False: 306]
|
7766 | ) |
7767 | { |
7768 | D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern")); |
7769 | _res = or_pattern_var; |
7770 | goto done; |
7771 | } |
7772 | p->mark = _mark; |
7773 | D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7774 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern")); |
7775 | } |
7776 | _res = NULL; |
7777 | done: |
7778 | p->level--; |
7779 | return _res; |
7780 | } |
7781 | |
7782 | // as_pattern: or_pattern 'as' pattern_capture_target | invalid_as_pattern |
7783 | static pattern_ty |
7784 | as_pattern_rule(Parser *p) |
7785 | { |
7786 | if (p->level++ == MAXSTACK) { Branch (7786:9): [True: 0, False: 5.14k]
|
7787 | p->error_indicator = 1; |
7788 | PyErr_NoMemory(); |
7789 | } |
7790 | if (p->error_indicator) { Branch (7790:9): [True: 0, False: 5.14k]
|
7791 | p->level--; |
7792 | return NULL; |
7793 | } |
7794 | pattern_ty _res = NULL; |
7795 | int _mark = p->mark; |
7796 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0807 ) { Branch (7796:9): [True: 807, False: 4.33k]
Branch (7796:31): [True: 0, False: 807]
|
7797 | p->error_indicator = 1; |
7798 | p->level--; |
7799 | return NULL; |
7800 | } |
7801 | int _start_lineno = p->tokens[_mark]->lineno; |
7802 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7803 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7804 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7805 | { // or_pattern 'as' pattern_capture_target |
7806 | if (p->error_indicator) { Branch (7806:13): [True: 0, False: 5.14k]
|
7807 | p->level--; |
7808 | return NULL; |
7809 | } |
7810 | D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' pattern_capture_target")); |
7811 | Token * _keyword; |
7812 | pattern_ty pattern; |
7813 | expr_ty target; |
7814 | if ( |
7815 | (pattern = or_pattern_rule(p)) // or_pattern Branch (7815:13): [True: 4.82k, False: 316]
|
7816 | && |
7817 | (_keyword = _PyPegen_expect_token(p, 632))4.82k // token='as' Branch (7817:13): [True: 183, False: 4.64k]
|
7818 | && |
7819 | (target = pattern_capture_target_rule(p))183 // pattern_capture_target Branch (7819:13): [True: 174, False: 9]
|
7820 | ) |
7821 | { |
7822 | D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' pattern_capture_target")); |
7823 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7824 | if (_token == NULL) { Branch (7824:17): [True: 0, False: 174]
|
7825 | p->level--; |
7826 | return NULL; |
7827 | } |
7828 | int _end_lineno = _token->end_lineno; |
7829 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7830 | int _end_col_offset = _token->end_col_offset; |
7831 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7832 | _res = _PyAST_MatchAs ( pattern , target -> v . Name . id , EXTRA ); |
7833 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7833:17): [True: 0, False: 174]
Branch (7833:33): [True: 0, False: 0]
|
7834 | p->error_indicator = 1; |
7835 | p->level--; |
7836 | return NULL; |
7837 | } |
7838 | goto done; |
7839 | } |
7840 | p->mark = _mark; |
7841 | D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7842 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' pattern_capture_target")); |
7843 | } |
7844 | if (p->call_invalid_rules) { // invalid_as_pattern Branch (7844:9): [True: 111, False: 4.85k]
|
7845 | if (p->error_indicator) { Branch (7845:13): [True: 4, False: 107]
|
7846 | p->level--; |
7847 | return NULL; |
7848 | } |
7849 | D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_as_pattern")); |
7850 | void *invalid_as_pattern_var; |
7851 | if ( |
7852 | (invalid_as_pattern_var = invalid_as_pattern_rule(p)) // invalid_as_pattern Branch (7852:13): [True: 0, False: 107]
|
7853 | ) |
7854 | { |
7855 | D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_as_pattern")); |
7856 | _res = invalid_as_pattern_var; |
7857 | goto done; |
7858 | } |
7859 | p->mark = _mark; |
7860 | D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7861 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_as_pattern")); |
7862 | } |
7863 | _res = NULL; |
7864 | done: |
7865 | p->level--; |
7866 | return _res; |
7867 | } |
7868 | |
7869 | // or_pattern: '|'.closed_pattern+ |
7870 | static pattern_ty |
7871 | or_pattern_rule(Parser *p) |
7872 | { |
7873 | if (p->level++ == MAXSTACK) { Branch (7873:9): [True: 0, False: 10.3k]
|
7874 | p->error_indicator = 1; |
7875 | PyErr_NoMemory(); |
7876 | } |
7877 | if (p->error_indicator) { Branch (7877:9): [True: 0, False: 10.3k]
|
7878 | p->level--; |
7879 | return NULL; |
7880 | } |
7881 | pattern_ty _res = NULL; |
7882 | int _mark = p->mark; |
7883 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (7883:9): [True: 0, False: 10.3k]
Branch (7883:31): [True: 0, False: 0]
|
7884 | p->error_indicator = 1; |
7885 | p->level--; |
7886 | return NULL; |
7887 | } |
7888 | int _start_lineno = p->tokens[_mark]->lineno; |
7889 | UNUSED(_start_lineno); // Only used by EXTRA macro |
7890 | int _start_col_offset = p->tokens[_mark]->col_offset; |
7891 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
7892 | { // '|'.closed_pattern+ |
7893 | if (p->error_indicator) { Branch (7893:13): [True: 0, False: 10.3k]
|
7894 | p->level--; |
7895 | return NULL; |
7896 | } |
7897 | D(fprintf(stderr, "%*c> or_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+")); |
7898 | asdl_pattern_seq* patterns; |
7899 | if ( |
7900 | (patterns = (asdl_pattern_seq*)_gather_65_rule(p)) // '|'.closed_pattern+ Branch (7900:13): [True: 9.57k, False: 738]
|
7901 | ) |
7902 | { |
7903 | D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+")); |
7904 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
7905 | if (_token == NULL) { Branch (7905:17): [True: 0, False: 9.57k]
|
7906 | p->level--; |
7907 | return NULL; |
7908 | } |
7909 | int _end_lineno = _token->end_lineno; |
7910 | UNUSED(_end_lineno); // Only used by EXTRA macro |
7911 | int _end_col_offset = _token->end_col_offset; |
7912 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
7913 | _res = asdl_seq_LEN ( patterns ) == 1 ? asdl_seq_GET ( patterns , 0 ) : _PyAST_MatchOr ( patterns , 529 EXTRA529 ); Branch (7913:20): [True: 9.04k, False: 529]
|
7914 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (7914:17): [True: 0, False: 9.57k]
Branch (7914:33): [True: 0, False: 0]
|
7915 | p->error_indicator = 1; |
7916 | p->level--; |
7917 | return NULL; |
7918 | } |
7919 | goto done; |
7920 | } |
7921 | p->mark = _mark; |
7922 | D(fprintf(stderr, "%*c%s or_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7923 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|'.closed_pattern+")); |
7924 | } |
7925 | _res = NULL; |
7926 | done: |
7927 | p->level--; |
7928 | return _res; |
7929 | } |
7930 | |
7931 | // closed_pattern: |
7932 | // | literal_pattern |
7933 | // | capture_pattern |
7934 | // | wildcard_pattern |
7935 | // | value_pattern |
7936 | // | group_pattern |
7937 | // | sequence_pattern |
7938 | // | mapping_pattern |
7939 | // | class_pattern |
7940 | static pattern_ty |
7941 | closed_pattern_rule(Parser *p) |
7942 | { |
7943 | if (p->level++ == MAXSTACK) { Branch (7943:9): [True: 0, False: 11.2k]
|
7944 | p->error_indicator = 1; |
7945 | PyErr_NoMemory(); |
7946 | } |
7947 | if (p->error_indicator) { Branch (7947:9): [True: 0, False: 11.2k]
|
7948 | p->level--; |
7949 | return NULL; |
7950 | } |
7951 | pattern_ty _res = NULL; |
7952 | if (_PyPegen_is_memoized(p, closed_pattern_type, &_res)) { Branch (7952:9): [True: 7.58k, False: 3.66k]
|
7953 | p->level--; |
7954 | return _res; |
7955 | } |
7956 | int _mark = p->mark; |
7957 | { // literal_pattern |
7958 | if (p->error_indicator) { Branch (7958:13): [True: 0, False: 3.66k]
|
7959 | p->level--; |
7960 | return NULL; |
7961 | } |
7962 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_pattern")); |
7963 | pattern_ty literal_pattern_var; |
7964 | if ( |
7965 | (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern Branch (7965:13): [True: 1.15k, False: 2.50k]
|
7966 | ) |
7967 | { |
7968 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_pattern")); |
7969 | _res = literal_pattern_var; |
7970 | goto done; |
7971 | } |
7972 | p->mark = _mark; |
7973 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7974 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern")); |
7975 | } |
7976 | { // capture_pattern |
7977 | if (p->error_indicator) { Branch (7977:13): [True: 3, False: 2.50k]
|
7978 | p->level--; |
7979 | return NULL; |
7980 | } |
7981 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_pattern")); |
7982 | pattern_ty capture_pattern_var; |
7983 | if ( |
7984 | (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern Branch (7984:13): [True: 748, False: 1.75k]
|
7985 | ) |
7986 | { |
7987 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "capture_pattern")); |
7988 | _res = capture_pattern_var; |
7989 | goto done; |
7990 | } |
7991 | p->mark = _mark; |
7992 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
7993 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern")); |
7994 | } |
7995 | { // wildcard_pattern |
7996 | if (p->error_indicator) { Branch (7996:13): [True: 0, False: 1.75k]
|
7997 | p->level--; |
7998 | return NULL; |
7999 | } |
8000 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pattern")); |
8001 | pattern_ty wildcard_pattern_var; |
8002 | if ( |
8003 | (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern Branch (8003:13): [True: 207, False: 1.55k]
|
8004 | ) |
8005 | { |
8006 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "wildcard_pattern")); |
8007 | _res = wildcard_pattern_var; |
8008 | goto done; |
8009 | } |
8010 | p->mark = _mark; |
8011 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8012 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern")); |
8013 | } |
8014 | { // value_pattern |
8015 | if (p->error_indicator) { Branch (8015:13): [True: 0, False: 1.55k]
|
8016 | p->level--; |
8017 | return NULL; |
8018 | } |
8019 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_pattern")); |
8020 | pattern_ty value_pattern_var; |
8021 | if ( |
8022 | (value_pattern_var = value_pattern_rule(p)) // value_pattern Branch (8022:13): [True: 45, False: 1.50k]
|
8023 | ) |
8024 | { |
8025 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "value_pattern")); |
8026 | _res = value_pattern_var; |
8027 | goto done; |
8028 | } |
8029 | p->mark = _mark; |
8030 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8031 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern")); |
8032 | } |
8033 | { // group_pattern |
8034 | if (p->error_indicator) { Branch (8034:13): [True: 0, False: 1.50k]
|
8035 | p->level--; |
8036 | return NULL; |
8037 | } |
8038 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group_pattern")); |
8039 | pattern_ty group_pattern_var; |
8040 | if ( |
8041 | (group_pattern_var = group_pattern_rule(p)) // group_pattern Branch (8041:13): [True: 214, False: 1.29k]
|
8042 | ) |
8043 | { |
8044 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group_pattern")); |
8045 | _res = group_pattern_var; |
8046 | goto done; |
8047 | } |
8048 | p->mark = _mark; |
8049 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8050 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group_pattern")); |
8051 | } |
8052 | { // sequence_pattern |
8053 | if (p->error_indicator) { Branch (8053:13): [True: 0, False: 1.29k]
|
8054 | p->level--; |
8055 | return NULL; |
8056 | } |
8057 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sequence_pattern")); |
8058 | pattern_ty sequence_pattern_var; |
8059 | if ( |
8060 | (sequence_pattern_var = sequence_pattern_rule(p)) // sequence_pattern Branch (8060:13): [True: 541, False: 750]
|
8061 | ) |
8062 | { |
8063 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sequence_pattern")); |
8064 | _res = sequence_pattern_var; |
8065 | goto done; |
8066 | } |
8067 | p->mark = _mark; |
8068 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8069 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sequence_pattern")); |
8070 | } |
8071 | { // mapping_pattern |
8072 | if (p->error_indicator) { Branch (8072:13): [True: 0, False: 750]
|
8073 | p->level--; |
8074 | return NULL; |
8075 | } |
8076 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "mapping_pattern")); |
8077 | pattern_ty mapping_pattern_var; |
8078 | if ( |
8079 | (mapping_pattern_var = mapping_pattern_rule(p)) // mapping_pattern Branch (8079:13): [True: 351, False: 399]
|
8080 | ) |
8081 | { |
8082 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "mapping_pattern")); |
8083 | _res = mapping_pattern_var; |
8084 | goto done; |
8085 | } |
8086 | p->mark = _mark; |
8087 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8088 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "mapping_pattern")); |
8089 | } |
8090 | { // class_pattern |
8091 | if (p->error_indicator) { Branch (8091:13): [True: 3, False: 396]
|
8092 | p->level--; |
8093 | return NULL; |
8094 | } |
8095 | D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_pattern")); |
8096 | pattern_ty class_pattern_var; |
8097 | if ( |
8098 | (class_pattern_var = class_pattern_rule(p)) // class_pattern Branch (8098:13): [True: 186, False: 210]
|
8099 | ) |
8100 | { |
8101 | D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_pattern")); |
8102 | _res = class_pattern_var; |
8103 | goto done; |
8104 | } |
8105 | p->mark = _mark; |
8106 | D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8107 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_pattern")); |
8108 | } |
8109 | _res = NULL; |
8110 | done: |
8111 | _PyPegen_insert_memo(p, _mark, closed_pattern_type, _res); |
8112 | p->level--; |
8113 | return _res; |
8114 | } |
8115 | |
8116 | // literal_pattern: |
8117 | // | signed_number !('+' | '-') |
8118 | // | complex_number |
8119 | // | strings |
8120 | // | 'None' |
8121 | // | 'True' |
8122 | // | 'False' |
8123 | static pattern_ty |
8124 | literal_pattern_rule(Parser *p) |
8125 | { |
8126 | if (p->level++ == MAXSTACK) { Branch (8126:9): [True: 0, False: 3.66k]
|
8127 | p->error_indicator = 1; |
8128 | PyErr_NoMemory(); |
8129 | } |
8130 | if (p->error_indicator) { Branch (8130:9): [True: 0, False: 3.66k]
|
8131 | p->level--; |
8132 | return NULL; |
8133 | } |
8134 | pattern_ty _res = NULL; |
8135 | int _mark = p->mark; |
8136 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (8136:9): [True: 0, False: 3.66k]
Branch (8136:31): [True: 0, False: 0]
|
8137 | p->error_indicator = 1; |
8138 | p->level--; |
8139 | return NULL; |
8140 | } |
8141 | int _start_lineno = p->tokens[_mark]->lineno; |
8142 | UNUSED(_start_lineno); // Only used by EXTRA macro |
8143 | int _start_col_offset = p->tokens[_mark]->col_offset; |
8144 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
8145 | { // signed_number !('+' | '-') |
8146 | if (p->error_indicator) { Branch (8146:13): [True: 0, False: 3.66k]
|
8147 | p->level--; |
8148 | return NULL; |
8149 | } |
8150 | D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); |
8151 | expr_ty value; |
8152 | if ( |
8153 | (value = signed_number_rule(p)) // signed_number Branch (8153:13): [True: 1.02k, False: 2.64k]
|
8154 | && |
8155 | _PyPegen_lookahead(0, _tmp_67_rule, p)1.02k Branch (8155:13): [True: 987, False: 33]
|
8156 | ) |
8157 | { |
8158 | D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); |
8159 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8160 | if (_token == NULL) { Branch (8160:17): [True: 0, False: 987]
|
8161 | p->level--; |
8162 | return NULL; |
8163 | } |
8164 | int _end_lineno = _token->end_lineno; |
8165 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8166 | int _end_col_offset = _token->end_col_offset; |
8167 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8168 | _res = _PyAST_MatchValue ( value , EXTRA ); |
8169 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8169:17): [True: 0, False: 987]
Branch (8169:33): [True: 0, False: 0]
|
8170 | p->error_indicator = 1; |
8171 | p->level--; |
8172 | return NULL; |
8173 | } |
8174 | goto done; |
8175 | } |
8176 | p->mark = _mark; |
8177 | D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8178 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); |
8179 | } |
8180 | { // complex_number |
8181 | if (p->error_indicator) { Branch (8181:13): [True: 0, False: 2.67k]
|
8182 | p->level--; |
8183 | return NULL; |
8184 | } |
8185 | D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number")); |
8186 | expr_ty value; |
8187 | if ( |
8188 | (value = complex_number_rule(p)) // complex_number Branch (8188:13): [True: 30, False: 2.64k]
|
8189 | ) |
8190 | { |
8191 | D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number")); |
8192 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8193 | if (_token == NULL) { Branch (8193:17): [True: 0, False: 30]
|
8194 | p->level--; |
8195 | return NULL; |
8196 | } |
8197 | int _end_lineno = _token->end_lineno; |
8198 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8199 | int _end_col_offset = _token->end_col_offset; |
8200 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8201 | _res = _PyAST_MatchValue ( value , EXTRA ); |
8202 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8202:17): [True: 0, False: 30]
Branch (8202:33): [True: 0, False: 0]
|
8203 | p->error_indicator = 1; |
8204 | p->level--; |
8205 | return NULL; |
8206 | } |
8207 | goto done; |
8208 | } |
8209 | p->mark = _mark; |
8210 | D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8211 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); |
8212 | } |
8213 | { // strings |
8214 | if (p->error_indicator) { Branch (8214:13): [True: 3, False: 2.64k]
|
8215 | p->level--; |
8216 | return NULL; |
8217 | } |
8218 | D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); |
8219 | expr_ty value; |
8220 | if ( |
8221 | (value = strings_rule(p)) // strings Branch (8221:13): [True: 100, False: 2.54k]
|
8222 | ) |
8223 | { |
8224 | D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings")); |
8225 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8226 | if (_token == NULL) { Branch (8226:17): [True: 0, False: 100]
|
8227 | p->level--; |
8228 | return NULL; |
8229 | } |
8230 | int _end_lineno = _token->end_lineno; |
8231 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8232 | int _end_col_offset = _token->end_col_offset; |
8233 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8234 | _res = _PyAST_MatchValue ( value , EXTRA ); |
8235 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8235:17): [True: 0, False: 100]
Branch (8235:33): [True: 0, False: 0]
|
8236 | p->error_indicator = 1; |
8237 | p->level--; |
8238 | return NULL; |
8239 | } |
8240 | goto done; |
8241 | } |
8242 | p->mark = _mark; |
8243 | D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8244 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); |
8245 | } |
8246 | { // 'None' |
8247 | if (p->error_indicator) { Branch (8247:13): [True: 0, False: 2.54k]
|
8248 | p->level--; |
8249 | return NULL; |
8250 | } |
8251 | D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); |
8252 | Token * _keyword; |
8253 | if ( |
8254 | (_keyword = _PyPegen_expect_token(p, 601)) // token='None' Branch (8254:13): [True: 14, False: 2.52k]
|
8255 | ) |
8256 | { |
8257 | D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); |
8258 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8259 | if (_token == NULL) { Branch (8259:17): [True: 0, False: 14]
|
8260 | p->level--; |
8261 | return NULL; |
8262 | } |
8263 | int _end_lineno = _token->end_lineno; |
8264 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8265 | int _end_col_offset = _token->end_col_offset; |
8266 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8267 | _res = _PyAST_MatchSingleton ( Py_None , EXTRA ); |
8268 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8268:17): [True: 0, False: 14]
Branch (8268:33): [True: 0, False: 0]
|
8269 | p->error_indicator = 1; |
8270 | p->level--; |
8271 | return NULL; |
8272 | } |
8273 | goto done; |
8274 | } |
8275 | p->mark = _mark; |
8276 | D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8277 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); |
8278 | } |
8279 | { // 'True' |
8280 | if (p->error_indicator) { Branch (8280:13): [True: 0, False: 2.52k]
|
8281 | p->level--; |
8282 | return NULL; |
8283 | } |
8284 | D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); |
8285 | Token * _keyword; |
8286 | if ( |
8287 | (_keyword = _PyPegen_expect_token(p, 600)) // token='True' Branch (8287:13): [True: 10, False: 2.51k]
|
8288 | ) |
8289 | { |
8290 | D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); |
8291 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8292 | if (_token == NULL) { Branch (8292:17): [True: 0, False: 10]
|
8293 | p->level--; |
8294 | return NULL; |
8295 | } |
8296 | int _end_lineno = _token->end_lineno; |
8297 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8298 | int _end_col_offset = _token->end_col_offset; |
8299 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8300 | _res = _PyAST_MatchSingleton ( Py_True , EXTRA ); |
8301 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8301:17): [True: 0, False: 10]
Branch (8301:33): [True: 0, False: 0]
|
8302 | p->error_indicator = 1; |
8303 | p->level--; |
8304 | return NULL; |
8305 | } |
8306 | goto done; |
8307 | } |
8308 | p->mark = _mark; |
8309 | D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8310 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); |
8311 | } |
8312 | { // 'False' |
8313 | if (p->error_indicator) { Branch (8313:13): [True: 0, False: 2.51k]
|
8314 | p->level--; |
8315 | return NULL; |
8316 | } |
8317 | D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); |
8318 | Token * _keyword; |
8319 | if ( |
8320 | (_keyword = _PyPegen_expect_token(p, 602)) // token='False' Branch (8320:13): [True: 13, False: 2.50k]
|
8321 | ) |
8322 | { |
8323 | D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); |
8324 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8325 | if (_token == NULL) { Branch (8325:17): [True: 0, False: 13]
|
8326 | p->level--; |
8327 | return NULL; |
8328 | } |
8329 | int _end_lineno = _token->end_lineno; |
8330 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8331 | int _end_col_offset = _token->end_col_offset; |
8332 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8333 | _res = _PyAST_MatchSingleton ( Py_False , EXTRA ); |
8334 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8334:17): [True: 0, False: 13]
Branch (8334:33): [True: 0, False: 0]
|
8335 | p->error_indicator = 1; |
8336 | p->level--; |
8337 | return NULL; |
8338 | } |
8339 | goto done; |
8340 | } |
8341 | p->mark = _mark; |
8342 | D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8343 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); |
8344 | } |
8345 | _res = NULL; |
8346 | done: |
8347 | p->level--; |
8348 | return _res; |
8349 | } |
8350 | |
8351 | // literal_expr: |
8352 | // | signed_number !('+' | '-') |
8353 | // | complex_number |
8354 | // | strings |
8355 | // | 'None' |
8356 | // | 'True' |
8357 | // | 'False' |
8358 | static expr_ty |
8359 | literal_expr_rule(Parser *p) |
8360 | { |
8361 | if (p->level++ == MAXSTACK) { Branch (8361:9): [True: 0, False: 683]
|
8362 | p->error_indicator = 1; |
8363 | PyErr_NoMemory(); |
8364 | } |
8365 | if (p->error_indicator) { Branch (8365:9): [True: 0, False: 683]
|
8366 | p->level--; |
8367 | return NULL; |
8368 | } |
8369 | expr_ty _res = NULL; |
8370 | int _mark = p->mark; |
8371 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 077 ) { Branch (8371:9): [True: 77, False: 606]
Branch (8371:31): [True: 0, False: 77]
|
8372 | p->error_indicator = 1; |
8373 | p->level--; |
8374 | return NULL; |
8375 | } |
8376 | int _start_lineno = p->tokens[_mark]->lineno; |
8377 | UNUSED(_start_lineno); // Only used by EXTRA macro |
8378 | int _start_col_offset = p->tokens[_mark]->col_offset; |
8379 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
8380 | { // signed_number !('+' | '-') |
8381 | if (p->error_indicator) { Branch (8381:13): [True: 0, False: 683]
|
8382 | p->level--; |
8383 | return NULL; |
8384 | } |
8385 | D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); |
8386 | expr_ty signed_number_var; |
8387 | if ( |
8388 | (signed_number_var = signed_number_rule(p)) // signed_number Branch (8388:13): [True: 490, False: 193]
|
8389 | && |
8390 | _PyPegen_lookahead(0, _tmp_68_rule, p)490 Branch (8390:13): [True: 481, False: 9]
|
8391 | ) |
8392 | { |
8393 | D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')")); |
8394 | _res = signed_number_var; |
8395 | goto done; |
8396 | } |
8397 | p->mark = _mark; |
8398 | D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', |
8399 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); |
8400 | } |
8401 | { // complex_number |
8402 | if (p->error_indicator) { Branch (8402:13): [True: 0, False: 202]
|
8403 | p->level--; |
8404 | return NULL; |
8405 | } |
8406 | D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number")); |
8407 | expr_ty complex_number_var; |
8408 | if ( |
8409 | (complex_number_var = complex_number_rule(p)) // complex_number Branch (8409:13): [True: 6, False: 196]
|
8410 | ) |
8411 | { |
8412 | D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number")); |
8413 | _res = complex_number_var; |
8414 | goto done; |
8415 | } |
8416 | p->mark = _mark; |
8417 | D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', |
8418 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); |
8419 | } |
8420 | { // strings |
8421 | if (p->error_indicator) { Branch (8421:13): [True: 3, False: 193]
|
8422 | p->level--; |
8423 | return NULL; |
8424 | } |
8425 | D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings")); |
8426 | expr_ty strings_var; |
8427 | if ( |
8428 | (strings_var = strings_rule(p)) // strings Branch (8428:13): [True: 146, False: 47]
|
8429 | ) |
8430 | { |
8431 | D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings")); |
8432 | _res = strings_var; |
8433 | goto done; |
8434 | } |
8435 | p->mark = _mark; |
8436 | D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', |
8437 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); |
8438 | } |
8439 | { // 'None' |
8440 | if (p->error_indicator) { Branch (8440:13): [True: 0, False: 47]
|
8441 | p->level--; |
8442 | return NULL; |
8443 | } |
8444 | D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); |
8445 | Token * _keyword; |
8446 | if ( |
8447 | (_keyword = _PyPegen_expect_token(p, 601)) // token='None' Branch (8447:13): [True: 0, False: 47]
|
8448 | ) |
8449 | { |
8450 | D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); |
8451 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8452 | if (_token == NULL) { Branch (8452:17): [True: 0, False: 0]
|
8453 | p->level--; |
8454 | return NULL; |
8455 | } |
8456 | int _end_lineno = _token->end_lineno; |
8457 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8458 | int _end_col_offset = _token->end_col_offset; |
8459 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8460 | _res = _PyAST_Constant ( Py_None , NULL , EXTRA ); |
8461 | if (_res == NULL && PyErr_Occurred()) { Branch (8461:17): [True: 0, False: 0]
Branch (8461:33): [True: 0, False: 0]
|
8462 | p->error_indicator = 1; |
8463 | p->level--; |
8464 | return NULL; |
8465 | } |
8466 | goto done; |
8467 | } |
8468 | p->mark = _mark; |
8469 | D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', |
8470 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); |
8471 | } |
8472 | { // 'True' |
8473 | if (p->error_indicator) { Branch (8473:13): [True: 0, False: 47]
|
8474 | p->level--; |
8475 | return NULL; |
8476 | } |
8477 | D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); |
8478 | Token * _keyword; |
8479 | if ( |
8480 | (_keyword = _PyPegen_expect_token(p, 600)) // token='True' Branch (8480:13): [True: 0, False: 47]
|
8481 | ) |
8482 | { |
8483 | D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); |
8484 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8485 | if (_token == NULL) { Branch (8485:17): [True: 0, False: 0]
|
8486 | p->level--; |
8487 | return NULL; |
8488 | } |
8489 | int _end_lineno = _token->end_lineno; |
8490 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8491 | int _end_col_offset = _token->end_col_offset; |
8492 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8493 | _res = _PyAST_Constant ( Py_True , NULL , EXTRA ); |
8494 | if (_res == NULL && PyErr_Occurred()) { Branch (8494:17): [True: 0, False: 0]
Branch (8494:33): [True: 0, False: 0]
|
8495 | p->error_indicator = 1; |
8496 | p->level--; |
8497 | return NULL; |
8498 | } |
8499 | goto done; |
8500 | } |
8501 | p->mark = _mark; |
8502 | D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', |
8503 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); |
8504 | } |
8505 | { // 'False' |
8506 | if (p->error_indicator) { Branch (8506:13): [True: 0, False: 47]
|
8507 | p->level--; |
8508 | return NULL; |
8509 | } |
8510 | D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); |
8511 | Token * _keyword; |
8512 | if ( |
8513 | (_keyword = _PyPegen_expect_token(p, 602)) // token='False' Branch (8513:13): [True: 2, False: 45]
|
8514 | ) |
8515 | { |
8516 | D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); |
8517 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8518 | if (_token == NULL) { Branch (8518:17): [True: 0, False: 2]
|
8519 | p->level--; |
8520 | return NULL; |
8521 | } |
8522 | int _end_lineno = _token->end_lineno; |
8523 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8524 | int _end_col_offset = _token->end_col_offset; |
8525 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8526 | _res = _PyAST_Constant ( Py_False , NULL , EXTRA ); |
8527 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8527:17): [True: 0, False: 2]
Branch (8527:33): [True: 0, False: 0]
|
8528 | p->error_indicator = 1; |
8529 | p->level--; |
8530 | return NULL; |
8531 | } |
8532 | goto done; |
8533 | } |
8534 | p->mark = _mark; |
8535 | D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', |
8536 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); |
8537 | } |
8538 | _res = NULL; |
8539 | done: |
8540 | p->level--; |
8541 | return _res; |
8542 | } |
8543 | |
8544 | // complex_number: |
8545 | // | signed_real_number '+' imaginary_number |
8546 | // | signed_real_number '-' imaginary_number |
8547 | static expr_ty |
8548 | complex_number_rule(Parser *p) |
8549 | { |
8550 | if (p->level++ == MAXSTACK) { Branch (8550:9): [True: 0, False: 2.87k]
|
8551 | p->error_indicator = 1; |
8552 | PyErr_NoMemory(); |
8553 | } |
8554 | if (p->error_indicator) { Branch (8554:9): [True: 0, False: 2.87k]
|
8555 | p->level--; |
8556 | return NULL; |
8557 | } |
8558 | expr_ty _res = NULL; |
8559 | int _mark = p->mark; |
8560 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (8560:9): [True: 0, False: 2.87k]
Branch (8560:31): [True: 0, False: 0]
|
8561 | p->error_indicator = 1; |
8562 | p->level--; |
8563 | return NULL; |
8564 | } |
8565 | int _start_lineno = p->tokens[_mark]->lineno; |
8566 | UNUSED(_start_lineno); // Only used by EXTRA macro |
8567 | int _start_col_offset = p->tokens[_mark]->col_offset; |
8568 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
8569 | { // signed_real_number '+' imaginary_number |
8570 | if (p->error_indicator) { Branch (8570:13): [True: 0, False: 2.87k]
|
8571 | p->level--; |
8572 | return NULL; |
8573 | } |
8574 | D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_number '+' imaginary_number")); |
8575 | Token * _literal; |
8576 | expr_ty imag; |
8577 | expr_ty real; |
8578 | if ( |
8579 | (real = signed_real_number_rule(p)) // signed_real_number Branch (8579:13): [True: 38, False: 2.83k]
|
8580 | && |
8581 | (_literal = _PyPegen_expect_token(p, 14))38 // token='+' Branch (8581:13): [True: 17, False: 21]
|
8582 | && |
8583 | (imag = imaginary_number_rule(p))17 // imaginary_number Branch (8583:13): [True: 15, False: 2]
|
8584 | ) |
8585 | { |
8586 | D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_real_number '+' imaginary_number")); |
8587 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8588 | if (_token == NULL) { Branch (8588:17): [True: 0, False: 15]
|
8589 | p->level--; |
8590 | return NULL; |
8591 | } |
8592 | int _end_lineno = _token->end_lineno; |
8593 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8594 | int _end_col_offset = _token->end_col_offset; |
8595 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8596 | _res = _PyAST_BinOp ( real , Add , imag , EXTRA ); |
8597 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8597:17): [True: 0, False: 15]
Branch (8597:33): [True: 0, False: 0]
|
8598 | p->error_indicator = 1; |
8599 | p->level--; |
8600 | return NULL; |
8601 | } |
8602 | goto done; |
8603 | } |
8604 | p->mark = _mark; |
8605 | D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ', |
8606 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '+' imaginary_number")); |
8607 | } |
8608 | { // signed_real_number '-' imaginary_number |
8609 | if (p->error_indicator) { Branch (8609:13): [True: 6, False: 2.85k]
|
8610 | p->level--; |
8611 | return NULL; |
8612 | } |
8613 | D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_number '-' imaginary_number")); |
8614 | Token * _literal; |
8615 | expr_ty imag; |
8616 | expr_ty real; |
8617 | if ( |
8618 | (real = signed_real_number_rule(p)) // signed_real_number Branch (8618:13): [True: 21, False: 2.83k]
|
8619 | && |
8620 | (_literal = _PyPegen_expect_token(p, 15))21 // token='-' Branch (8620:13): [True: 21, False: 0]
|
8621 | && |
8622 | (imag = imaginary_number_rule(p))21 // imaginary_number Branch (8622:13): [True: 21, False: 0]
|
8623 | ) |
8624 | { |
8625 | D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_real_number '-' imaginary_number")); |
8626 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8627 | if (_token == NULL) { Branch (8627:17): [True: 0, False: 21]
|
8628 | p->level--; |
8629 | return NULL; |
8630 | } |
8631 | int _end_lineno = _token->end_lineno; |
8632 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8633 | int _end_col_offset = _token->end_col_offset; |
8634 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8635 | _res = _PyAST_BinOp ( real , Sub , imag , EXTRA ); |
8636 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8636:17): [True: 0, False: 21]
Branch (8636:33): [True: 0, False: 0]
|
8637 | p->error_indicator = 1; |
8638 | p->level--; |
8639 | return NULL; |
8640 | } |
8641 | goto done; |
8642 | } |
8643 | p->mark = _mark; |
8644 | D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ', |
8645 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '-' imaginary_number")); |
8646 | } |
8647 | _res = NULL; |
8648 | done: |
8649 | p->level--; |
8650 | return _res; |
8651 | } |
8652 | |
8653 | // signed_number: NUMBER | '-' NUMBER |
8654 | static expr_ty |
8655 | signed_number_rule(Parser *p) |
8656 | { |
8657 | if (p->level++ == MAXSTACK) { Branch (8657:9): [True: 0, False: 4.34k]
|
8658 | p->error_indicator = 1; |
8659 | PyErr_NoMemory(); |
8660 | } |
8661 | if (p->error_indicator) { Branch (8661:9): [True: 0, False: 4.34k]
|
8662 | p->level--; |
8663 | return NULL; |
8664 | } |
8665 | expr_ty _res = NULL; |
8666 | int _mark = p->mark; |
8667 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (8667:9): [True: 0, False: 4.34k]
Branch (8667:31): [True: 0, False: 0]
|
8668 | p->error_indicator = 1; |
8669 | p->level--; |
8670 | return NULL; |
8671 | } |
8672 | int _start_lineno = p->tokens[_mark]->lineno; |
8673 | UNUSED(_start_lineno); // Only used by EXTRA macro |
8674 | int _start_col_offset = p->tokens[_mark]->col_offset; |
8675 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
8676 | { // NUMBER |
8677 | if (p->error_indicator) { Branch (8677:13): [True: 0, False: 4.34k]
|
8678 | p->level--; |
8679 | return NULL; |
8680 | } |
8681 | D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
8682 | expr_ty number_var; |
8683 | if ( |
8684 | (number_var = _PyPegen_number_token(p)) // NUMBER Branch (8684:13): [True: 1.45k, False: 2.89k]
|
8685 | ) |
8686 | { |
8687 | D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
8688 | _res = number_var; |
8689 | goto done; |
8690 | } |
8691 | p->mark = _mark; |
8692 | D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', |
8693 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); |
8694 | } |
8695 | { // '-' NUMBER |
8696 | if (p->error_indicator) { Branch (8696:13): [True: 0, False: 2.89k]
|
8697 | p->level--; |
8698 | return NULL; |
8699 | } |
8700 | D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' NUMBER")); |
8701 | Token * _literal; |
8702 | expr_ty number; |
8703 | if ( |
8704 | (_literal = _PyPegen_expect_token(p, 15)) // token='-' Branch (8704:13): [True: 59, False: 2.83k]
|
8705 | && |
8706 | (number = _PyPegen_number_token(p))59 // NUMBER Branch (8706:13): [True: 59, False: 0]
|
8707 | ) |
8708 | { |
8709 | D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' NUMBER")); |
8710 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8711 | if (_token == NULL) { Branch (8711:17): [True: 0, False: 59]
|
8712 | p->level--; |
8713 | return NULL; |
8714 | } |
8715 | int _end_lineno = _token->end_lineno; |
8716 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8717 | int _end_col_offset = _token->end_col_offset; |
8718 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8719 | _res = _PyAST_UnaryOp ( USub , number , EXTRA ); |
8720 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8720:17): [True: 0, False: 59]
Branch (8720:33): [True: 0, False: 0]
|
8721 | p->error_indicator = 1; |
8722 | p->level--; |
8723 | return NULL; |
8724 | } |
8725 | goto done; |
8726 | } |
8727 | p->mark = _mark; |
8728 | D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', |
8729 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' NUMBER")); |
8730 | } |
8731 | _res = NULL; |
8732 | done: |
8733 | p->level--; |
8734 | return _res; |
8735 | } |
8736 | |
8737 | // signed_real_number: real_number | '-' real_number |
8738 | static expr_ty |
8739 | signed_real_number_rule(Parser *p) |
8740 | { |
8741 | if (p->level++ == MAXSTACK) { Branch (8741:9): [True: 0, False: 5.73k]
|
8742 | p->error_indicator = 1; |
8743 | PyErr_NoMemory(); |
8744 | } |
8745 | if (p->error_indicator) { Branch (8745:9): [True: 0, False: 5.73k]
|
8746 | p->level--; |
8747 | return NULL; |
8748 | } |
8749 | expr_ty _res = NULL; |
8750 | int _mark = p->mark; |
8751 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (8751:9): [True: 0, False: 5.73k]
Branch (8751:31): [True: 0, False: 0]
|
8752 | p->error_indicator = 1; |
8753 | p->level--; |
8754 | return NULL; |
8755 | } |
8756 | int _start_lineno = p->tokens[_mark]->lineno; |
8757 | UNUSED(_start_lineno); // Only used by EXTRA macro |
8758 | int _start_col_offset = p->tokens[_mark]->col_offset; |
8759 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
8760 | { // real_number |
8761 | if (p->error_indicator) { Branch (8761:13): [True: 0, False: 5.73k]
|
8762 | p->level--; |
8763 | return NULL; |
8764 | } |
8765 | D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "real_number")); |
8766 | expr_ty real_number_var; |
8767 | if ( |
8768 | (real_number_var = real_number_rule(p)) // real_number Branch (8768:13): [True: 29, False: 5.70k]
|
8769 | ) |
8770 | { |
8771 | D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "real_number")); |
8772 | _res = real_number_var; |
8773 | goto done; |
8774 | } |
8775 | p->mark = _mark; |
8776 | D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', |
8777 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "real_number")); |
8778 | } |
8779 | { // '-' real_number |
8780 | if (p->error_indicator) { Branch (8780:13): [True: 4, False: 5.70k]
|
8781 | p->level--; |
8782 | return NULL; |
8783 | } |
8784 | D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' real_number")); |
8785 | Token * _literal; |
8786 | expr_ty real; |
8787 | if ( |
8788 | (_literal = _PyPegen_expect_token(p, 15)) // token='-' Branch (8788:13): [True: 30, False: 5.67k]
|
8789 | && |
8790 | (real = real_number_rule(p))30 // real_number Branch (8790:13): [True: 30, False: 0]
|
8791 | ) |
8792 | { |
8793 | D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' real_number")); |
8794 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8795 | if (_token == NULL) { Branch (8795:17): [True: 0, False: 30]
|
8796 | p->level--; |
8797 | return NULL; |
8798 | } |
8799 | int _end_lineno = _token->end_lineno; |
8800 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8801 | int _end_col_offset = _token->end_col_offset; |
8802 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8803 | _res = _PyAST_UnaryOp ( USub , real , EXTRA ); |
8804 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8804:17): [True: 0, False: 30]
Branch (8804:33): [True: 0, False: 0]
|
8805 | p->error_indicator = 1; |
8806 | p->level--; |
8807 | return NULL; |
8808 | } |
8809 | goto done; |
8810 | } |
8811 | p->mark = _mark; |
8812 | D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', |
8813 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' real_number")); |
8814 | } |
8815 | _res = NULL; |
8816 | done: |
8817 | p->level--; |
8818 | return _res; |
8819 | } |
8820 | |
8821 | // real_number: NUMBER |
8822 | static expr_ty |
8823 | real_number_rule(Parser *p) |
8824 | { |
8825 | if (p->level++ == MAXSTACK) { Branch (8825:9): [True: 0, False: 5.76k]
|
8826 | p->error_indicator = 1; |
8827 | PyErr_NoMemory(); |
8828 | } |
8829 | if (p->error_indicator) { Branch (8829:9): [True: 0, False: 5.76k]
|
8830 | p->level--; |
8831 | return NULL; |
8832 | } |
8833 | expr_ty _res = NULL; |
8834 | int _mark = p->mark; |
8835 | { // NUMBER |
8836 | if (p->error_indicator) { Branch (8836:13): [True: 0, False: 5.76k]
|
8837 | p->level--; |
8838 | return NULL; |
8839 | } |
8840 | D(fprintf(stderr, "%*c> real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
8841 | expr_ty real; |
8842 | if ( |
8843 | (real = _PyPegen_number_token(p)) // NUMBER Branch (8843:13): [True: 63, False: 5.70k]
|
8844 | ) |
8845 | { |
8846 | D(fprintf(stderr, "%*c+ real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
8847 | _res = _PyPegen_ensure_real ( p , real ); |
8848 | if (_res == NULL && PyErr_Occurred()4 ) { Branch (8848:17): [True: 4, False: 59]
Branch (8848:33): [True: 4, False: 0]
|
8849 | p->error_indicator = 1; |
8850 | p->level--; |
8851 | return NULL; |
8852 | } |
8853 | goto done; |
8854 | } |
8855 | p->mark = _mark; |
8856 | D(fprintf(stderr, "%*c%s real_number[%d-%d]: %s failed!\n", p->level, ' ', |
8857 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); |
8858 | } |
8859 | _res = NULL; |
8860 | done: |
8861 | p->level--; |
8862 | return _res; |
8863 | } |
8864 | |
8865 | // imaginary_number: NUMBER |
8866 | static expr_ty |
8867 | imaginary_number_rule(Parser *p) |
8868 | { |
8869 | if (p->level++ == MAXSTACK) { Branch (8869:9): [True: 0, False: 38]
|
8870 | p->error_indicator = 1; |
8871 | PyErr_NoMemory(); |
8872 | } |
8873 | if (p->error_indicator) { Branch (8873:9): [True: 0, False: 38]
|
8874 | p->level--; |
8875 | return NULL; |
8876 | } |
8877 | expr_ty _res = NULL; |
8878 | int _mark = p->mark; |
8879 | { // NUMBER |
8880 | if (p->error_indicator) { Branch (8880:13): [True: 0, False: 38]
|
8881 | p->level--; |
8882 | return NULL; |
8883 | } |
8884 | D(fprintf(stderr, "%*c> imaginary_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
8885 | expr_ty imag; |
8886 | if ( |
8887 | (imag = _PyPegen_number_token(p)) // NUMBER Branch (8887:13): [True: 38, False: 0]
|
8888 | ) |
8889 | { |
8890 | D(fprintf(stderr, "%*c+ imaginary_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
8891 | _res = _PyPegen_ensure_imaginary ( p , imag ); |
8892 | if (_res == NULL && PyErr_Occurred()2 ) { Branch (8892:17): [True: 2, False: 36]
Branch (8892:33): [True: 2, False: 0]
|
8893 | p->error_indicator = 1; |
8894 | p->level--; |
8895 | return NULL; |
8896 | } |
8897 | goto done; |
8898 | } |
8899 | p->mark = _mark; |
8900 | D(fprintf(stderr, "%*c%s imaginary_number[%d-%d]: %s failed!\n", p->level, ' ', |
8901 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); |
8902 | } |
8903 | _res = NULL; |
8904 | done: |
8905 | p->level--; |
8906 | return _res; |
8907 | } |
8908 | |
8909 | // capture_pattern: pattern_capture_target |
8910 | static pattern_ty |
8911 | capture_pattern_rule(Parser *p) |
8912 | { |
8913 | if (p->level++ == MAXSTACK) { Branch (8913:9): [True: 0, False: 2.50k]
|
8914 | p->error_indicator = 1; |
8915 | PyErr_NoMemory(); |
8916 | } |
8917 | if (p->error_indicator) { Branch (8917:9): [True: 0, False: 2.50k]
|
8918 | p->level--; |
8919 | return NULL; |
8920 | } |
8921 | pattern_ty _res = NULL; |
8922 | int _mark = p->mark; |
8923 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (8923:9): [True: 0, False: 2.50k]
Branch (8923:31): [True: 0, False: 0]
|
8924 | p->error_indicator = 1; |
8925 | p->level--; |
8926 | return NULL; |
8927 | } |
8928 | int _start_lineno = p->tokens[_mark]->lineno; |
8929 | UNUSED(_start_lineno); // Only used by EXTRA macro |
8930 | int _start_col_offset = p->tokens[_mark]->col_offset; |
8931 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
8932 | { // pattern_capture_target |
8933 | if (p->error_indicator) { Branch (8933:13): [True: 0, False: 2.50k]
|
8934 | p->level--; |
8935 | return NULL; |
8936 | } |
8937 | D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern_capture_target")); |
8938 | expr_ty target; |
8939 | if ( |
8940 | (target = pattern_capture_target_rule(p)) // pattern_capture_target Branch (8940:13): [True: 748, False: 1.75k]
|
8941 | ) |
8942 | { |
8943 | D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern_capture_target")); |
8944 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
8945 | if (_token == NULL) { Branch (8945:17): [True: 0, False: 748]
|
8946 | p->level--; |
8947 | return NULL; |
8948 | } |
8949 | int _end_lineno = _token->end_lineno; |
8950 | UNUSED(_end_lineno); // Only used by EXTRA macro |
8951 | int _end_col_offset = _token->end_col_offset; |
8952 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
8953 | _res = _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA ); |
8954 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (8954:17): [True: 0, False: 748]
Branch (8954:33): [True: 0, False: 0]
|
8955 | p->error_indicator = 1; |
8956 | p->level--; |
8957 | return NULL; |
8958 | } |
8959 | goto done; |
8960 | } |
8961 | p->mark = _mark; |
8962 | D(fprintf(stderr, "%*c%s capture_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
8963 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern_capture_target")); |
8964 | } |
8965 | _res = NULL; |
8966 | done: |
8967 | p->level--; |
8968 | return _res; |
8969 | } |
8970 | |
8971 | // pattern_capture_target: !"_" NAME !('.' | '(' | '=') |
8972 | static expr_ty |
8973 | pattern_capture_target_rule(Parser *p) |
8974 | { |
8975 | if (p->level++ == MAXSTACK) { Branch (8975:9): [True: 0, False: 2.86k]
|
8976 | p->error_indicator = 1; |
8977 | PyErr_NoMemory(); |
8978 | } |
8979 | if (p->error_indicator) { Branch (8979:9): [True: 0, False: 2.86k]
|
8980 | p->level--; |
8981 | return NULL; |
8982 | } |
8983 | expr_ty _res = NULL; |
8984 | int _mark = p->mark; |
8985 | { // !"_" NAME !('.' | '(' | '=') |
8986 | if (p->error_indicator) { Branch (8986:13): [True: 0, False: 2.86k]
|
8987 | p->level--; |
8988 | return NULL; |
8989 | } |
8990 | D(fprintf(stderr, "%*c> pattern_capture_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); |
8991 | expr_ty name; |
8992 | if ( |
8993 | _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_") Branch (8993:13): [True: 2.59k, False: 262]
|
8994 | && |
8995 | (name = _PyPegen_name_token(p))2.59k // NAME Branch (8995:13): [True: 1.34k, False: 1.25k]
|
8996 | && |
8997 | _PyPegen_lookahead(0, _tmp_69_rule, p)1.34k Branch (8997:13): [True: 1.04k, False: 303]
|
8998 | ) |
8999 | { |
9000 | D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); |
9001 | _res = _PyPegen_set_expr_context ( p , name , Store ); |
9002 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9002:17): [True: 0, False: 1.04k]
Branch (9002:33): [True: 0, False: 0]
|
9003 | p->error_indicator = 1; |
9004 | p->level--; |
9005 | return NULL; |
9006 | } |
9007 | goto done; |
9008 | } |
9009 | p->mark = _mark; |
9010 | D(fprintf(stderr, "%*c%s pattern_capture_target[%d-%d]: %s failed!\n", p->level, ' ', |
9011 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')")); |
9012 | } |
9013 | _res = NULL; |
9014 | done: |
9015 | p->level--; |
9016 | return _res; |
9017 | } |
9018 | |
9019 | // wildcard_pattern: "_" |
9020 | static pattern_ty |
9021 | wildcard_pattern_rule(Parser *p) |
9022 | { |
9023 | if (p->level++ == MAXSTACK) { Branch (9023:9): [True: 0, False: 1.80k]
|
9024 | p->error_indicator = 1; |
9025 | PyErr_NoMemory(); |
9026 | } |
9027 | if (p->error_indicator) { Branch (9027:9): [True: 0, False: 1.80k]
|
9028 | p->level--; |
9029 | return NULL; |
9030 | } |
9031 | pattern_ty _res = NULL; |
9032 | int _mark = p->mark; |
9033 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (9033:9): [True: 0, False: 1.80k]
Branch (9033:31): [True: 0, False: 0]
|
9034 | p->error_indicator = 1; |
9035 | p->level--; |
9036 | return NULL; |
9037 | } |
9038 | int _start_lineno = p->tokens[_mark]->lineno; |
9039 | UNUSED(_start_lineno); // Only used by EXTRA macro |
9040 | int _start_col_offset = p->tokens[_mark]->col_offset; |
9041 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
9042 | { // "_" |
9043 | if (p->error_indicator) { Branch (9043:13): [True: 0, False: 1.80k]
|
9044 | p->level--; |
9045 | return NULL; |
9046 | } |
9047 | D(fprintf(stderr, "%*c> wildcard_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"_\"")); |
9048 | expr_ty _keyword; |
9049 | if ( |
9050 | (_keyword = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' Branch (9050:13): [True: 252, False: 1.55k]
|
9051 | ) |
9052 | { |
9053 | D(fprintf(stderr, "%*c+ wildcard_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"_\"")); |
9054 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9055 | if (_token == NULL) { Branch (9055:17): [True: 0, False: 252]
|
9056 | p->level--; |
9057 | return NULL; |
9058 | } |
9059 | int _end_lineno = _token->end_lineno; |
9060 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9061 | int _end_col_offset = _token->end_col_offset; |
9062 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9063 | _res = _PyAST_MatchAs ( NULL , NULL , EXTRA ); |
9064 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9064:17): [True: 0, False: 252]
Branch (9064:33): [True: 0, False: 0]
|
9065 | p->error_indicator = 1; |
9066 | p->level--; |
9067 | return NULL; |
9068 | } |
9069 | goto done; |
9070 | } |
9071 | p->mark = _mark; |
9072 | D(fprintf(stderr, "%*c%s wildcard_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9073 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"_\"")); |
9074 | } |
9075 | _res = NULL; |
9076 | done: |
9077 | p->level--; |
9078 | return _res; |
9079 | } |
9080 | |
9081 | // value_pattern: attr !('.' | '(' | '=') |
9082 | static pattern_ty |
9083 | value_pattern_rule(Parser *p) |
9084 | { |
9085 | if (p->level++ == MAXSTACK) { Branch (9085:9): [True: 0, False: 1.55k]
|
9086 | p->error_indicator = 1; |
9087 | PyErr_NoMemory(); |
9088 | } |
9089 | if (p->error_indicator) { Branch (9089:9): [True: 0, False: 1.55k]
|
9090 | p->level--; |
9091 | return NULL; |
9092 | } |
9093 | pattern_ty _res = NULL; |
9094 | int _mark = p->mark; |
9095 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (9095:9): [True: 0, False: 1.55k]
Branch (9095:31): [True: 0, False: 0]
|
9096 | p->error_indicator = 1; |
9097 | p->level--; |
9098 | return NULL; |
9099 | } |
9100 | int _start_lineno = p->tokens[_mark]->lineno; |
9101 | UNUSED(_start_lineno); // Only used by EXTRA macro |
9102 | int _start_col_offset = p->tokens[_mark]->col_offset; |
9103 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
9104 | { // attr !('.' | '(' | '=') |
9105 | if (p->error_indicator) { Branch (9105:13): [True: 0, False: 1.55k]
|
9106 | p->level--; |
9107 | return NULL; |
9108 | } |
9109 | D(fprintf(stderr, "%*c> value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')")); |
9110 | expr_ty attr; |
9111 | if ( |
9112 | (attr = attr_rule(p)) // attr Branch (9112:13): [True: 54, False: 1.49k]
|
9113 | && |
9114 | _PyPegen_lookahead(0, _tmp_70_rule, p)54 Branch (9114:13): [True: 45, False: 9]
|
9115 | ) |
9116 | { |
9117 | D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')")); |
9118 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9119 | if (_token == NULL) { Branch (9119:17): [True: 0, False: 45]
|
9120 | p->level--; |
9121 | return NULL; |
9122 | } |
9123 | int _end_lineno = _token->end_lineno; |
9124 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9125 | int _end_col_offset = _token->end_col_offset; |
9126 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9127 | _res = _PyAST_MatchValue ( attr , EXTRA ); |
9128 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9128:17): [True: 0, False: 45]
Branch (9128:33): [True: 0, False: 0]
|
9129 | p->error_indicator = 1; |
9130 | p->level--; |
9131 | return NULL; |
9132 | } |
9133 | goto done; |
9134 | } |
9135 | p->mark = _mark; |
9136 | D(fprintf(stderr, "%*c%s value_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9137 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr !('.' | '(' | '=')")); |
9138 | } |
9139 | _res = NULL; |
9140 | done: |
9141 | p->level--; |
9142 | return _res; |
9143 | } |
9144 | |
9145 | // Left-recursive |
9146 | // attr: name_or_attr '.' NAME |
9147 | static expr_ty attr_raw(Parser *); |
9148 | static expr_ty |
9149 | attr_rule(Parser *p) |
9150 | { |
9151 | if (p->level++ == MAXSTACK) { Branch (9151:9): [True: 0, False: 4.56k]
|
9152 | p->error_indicator = 1; |
9153 | PyErr_NoMemory(); |
9154 | } |
9155 | expr_ty _res = NULL; |
9156 | if (_PyPegen_is_memoized(p, attr_type, &_res)) { Branch (9156:9): [True: 2.98k, False: 1.58k]
|
9157 | p->level--; |
9158 | return _res; |
9159 | } |
9160 | int _mark = p->mark; |
9161 | int _resmark = p->mark; |
9162 | while (1) { Branch (9162:12): [Folded - Ignored]
|
9163 | int tmpvar_1 = _PyPegen_update_memo(p, _mark, attr_type, _res); |
9164 | if (tmpvar_1) { Branch (9164:13): [True: 0, False: 1.66k]
|
9165 | p->level--; |
9166 | return _res; |
9167 | } |
9168 | p->mark = _mark; |
9169 | void *_raw = attr_raw(p); |
9170 | if (p->error_indicator) { Branch (9170:13): [True: 0, False: 1.66k]
|
9171 | p->level--; |
9172 | return NULL; |
9173 | } |
9174 | if (_raw == NULL || p->mark <= _resmark84 ) Branch (9174:13): [True: 1.58k, False: 84]
Branch (9174:29): [True: 0, False: 84]
|
9175 | break; |
9176 | _resmark = p->mark; |
9177 | _res = _raw; |
9178 | } |
9179 | p->mark = _resmark; |
9180 | p->level--; |
9181 | return _res; |
9182 | } |
9183 | static expr_ty |
9184 | attr_raw(Parser *p) |
9185 | { |
9186 | if (p->level++ == MAXSTACK) { Branch (9186:9): [True: 0, False: 1.66k]
|
9187 | p->error_indicator = 1; |
9188 | PyErr_NoMemory(); |
9189 | } |
9190 | if (p->error_indicator) { Branch (9190:9): [True: 0, False: 1.66k]
|
9191 | p->level--; |
9192 | return NULL; |
9193 | } |
9194 | expr_ty _res = NULL; |
9195 | int _mark = p->mark; |
9196 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (9196:9): [True: 0, False: 1.66k]
Branch (9196:31): [True: 0, False: 0]
|
9197 | p->error_indicator = 1; |
9198 | p->level--; |
9199 | return NULL; |
9200 | } |
9201 | int _start_lineno = p->tokens[_mark]->lineno; |
9202 | UNUSED(_start_lineno); // Only used by EXTRA macro |
9203 | int _start_col_offset = p->tokens[_mark]->col_offset; |
9204 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
9205 | { // name_or_attr '.' NAME |
9206 | if (p->error_indicator) { Branch (9206:13): [True: 0, False: 1.66k]
|
9207 | p->level--; |
9208 | return NULL; |
9209 | } |
9210 | D(fprintf(stderr, "%*c> attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME")); |
9211 | Token * _literal; |
9212 | expr_ty attr; |
9213 | expr_ty value; |
9214 | if ( |
9215 | (value = name_or_attr_rule(p)) // name_or_attr Branch (9215:13): [True: 390, False: 1.27k]
|
9216 | && |
9217 | (_literal = _PyPegen_expect_token(p, 23))390 // token='.' Branch (9217:13): [True: 84, False: 306]
|
9218 | && |
9219 | (attr = _PyPegen_name_token(p))84 // NAME Branch (9219:13): [True: 84, False: 0]
|
9220 | ) |
9221 | { |
9222 | D(fprintf(stderr, "%*c+ attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME")); |
9223 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9224 | if (_token == NULL) { Branch (9224:17): [True: 0, False: 84]
|
9225 | p->level--; |
9226 | return NULL; |
9227 | } |
9228 | int _end_lineno = _token->end_lineno; |
9229 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9230 | int _end_col_offset = _token->end_col_offset; |
9231 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9232 | _res = _PyAST_Attribute ( value , attr -> v . Name . id , Load , EXTRA ); |
9233 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9233:17): [True: 0, False: 84]
Branch (9233:33): [True: 0, False: 0]
|
9234 | p->error_indicator = 1; |
9235 | p->level--; |
9236 | return NULL; |
9237 | } |
9238 | goto done; |
9239 | } |
9240 | p->mark = _mark; |
9241 | D(fprintf(stderr, "%*c%s attr[%d-%d]: %s failed!\n", p->level, ' ', |
9242 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '.' NAME")); |
9243 | } |
9244 | _res = NULL; |
9245 | done: |
9246 | p->level--; |
9247 | return _res; |
9248 | } |
9249 | |
9250 | // Left-recursive |
9251 | // name_or_attr: attr | NAME |
9252 | static expr_ty |
9253 | name_or_attr_rule(Parser *p) |
9254 | { |
9255 | if (p->level++ == MAXSTACK) { Branch (9255:9): [True: 0, False: 2.97k]
|
9256 | p->error_indicator = 1; |
9257 | PyErr_NoMemory(); |
9258 | } |
9259 | if (p->error_indicator) { Branch (9259:9): [True: 0, False: 2.97k]
|
9260 | p->level--; |
9261 | return NULL; |
9262 | } |
9263 | expr_ty _res = NULL; |
9264 | int _mark = p->mark; |
9265 | { // attr |
9266 | if (p->error_indicator) { Branch (9266:13): [True: 0, False: 2.97k]
|
9267 | p->level--; |
9268 | return NULL; |
9269 | } |
9270 | D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); |
9271 | expr_ty attr_var; |
9272 | if ( |
9273 | (attr_var = attr_rule(p)) // attr Branch (9273:13): [True: 96, False: 2.87k]
|
9274 | ) |
9275 | { |
9276 | D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr")); |
9277 | _res = attr_var; |
9278 | goto done; |
9279 | } |
9280 | p->mark = _mark; |
9281 | D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ', |
9282 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); |
9283 | } |
9284 | { // NAME |
9285 | if (p->error_indicator) { Branch (9285:13): [True: 0, False: 2.87k]
|
9286 | p->level--; |
9287 | return NULL; |
9288 | } |
9289 | D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
9290 | expr_ty name_var; |
9291 | if ( |
9292 | (name_var = _PyPegen_name_token(p)) // NAME Branch (9292:13): [True: 1.04k, False: 1.83k]
|
9293 | ) |
9294 | { |
9295 | D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
9296 | _res = name_var; |
9297 | goto done; |
9298 | } |
9299 | p->mark = _mark; |
9300 | D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ', |
9301 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
9302 | } |
9303 | _res = NULL; |
9304 | done: |
9305 | p->level--; |
9306 | return _res; |
9307 | } |
9308 | |
9309 | // group_pattern: '(' pattern ')' |
9310 | static pattern_ty |
9311 | group_pattern_rule(Parser *p) |
9312 | { |
9313 | if (p->level++ == MAXSTACK) { Branch (9313:9): [True: 0, False: 1.50k]
|
9314 | p->error_indicator = 1; |
9315 | PyErr_NoMemory(); |
9316 | } |
9317 | if (p->error_indicator) { Branch (9317:9): [True: 0, False: 1.50k]
|
9318 | p->level--; |
9319 | return NULL; |
9320 | } |
9321 | pattern_ty _res = NULL; |
9322 | int _mark = p->mark; |
9323 | { // '(' pattern ')' |
9324 | if (p->error_indicator) { Branch (9324:13): [True: 0, False: 1.50k]
|
9325 | p->level--; |
9326 | return NULL; |
9327 | } |
9328 | D(fprintf(stderr, "%*c> group_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' pattern ')'")); |
9329 | Token * _literal; |
9330 | Token * _literal_1; |
9331 | pattern_ty pattern; |
9332 | if ( |
9333 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (9333:13): [True: 271, False: 1.23k]
|
9334 | && |
9335 | (pattern = pattern_rule(p))271 // pattern Branch (9335:13): [True: 260, False: 11]
|
9336 | && |
9337 | (_literal_1 = _PyPegen_expect_token(p, 8))260 // token=')' Branch (9337:13): [True: 214, False: 46]
|
9338 | ) |
9339 | { |
9340 | D(fprintf(stderr, "%*c+ group_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' pattern ')'")); |
9341 | _res = pattern; |
9342 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9342:17): [True: 0, False: 214]
Branch (9342:33): [True: 0, False: 0]
|
9343 | p->error_indicator = 1; |
9344 | p->level--; |
9345 | return NULL; |
9346 | } |
9347 | goto done; |
9348 | } |
9349 | p->mark = _mark; |
9350 | D(fprintf(stderr, "%*c%s group_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9351 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' pattern ')'")); |
9352 | } |
9353 | _res = NULL; |
9354 | done: |
9355 | p->level--; |
9356 | return _res; |
9357 | } |
9358 | |
9359 | // sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')' |
9360 | static pattern_ty |
9361 | sequence_pattern_rule(Parser *p) |
9362 | { |
9363 | if (p->level++ == MAXSTACK) { Branch (9363:9): [True: 0, False: 1.29k]
|
9364 | p->error_indicator = 1; |
9365 | PyErr_NoMemory(); |
9366 | } |
9367 | if (p->error_indicator) { Branch (9367:9): [True: 0, False: 1.29k]
|
9368 | p->level--; |
9369 | return NULL; |
9370 | } |
9371 | pattern_ty _res = NULL; |
9372 | int _mark = p->mark; |
9373 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (9373:9): [True: 0, False: 1.29k]
Branch (9373:31): [True: 0, False: 0]
|
9374 | p->error_indicator = 1; |
9375 | p->level--; |
9376 | return NULL; |
9377 | } |
9378 | int _start_lineno = p->tokens[_mark]->lineno; |
9379 | UNUSED(_start_lineno); // Only used by EXTRA macro |
9380 | int _start_col_offset = p->tokens[_mark]->col_offset; |
9381 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
9382 | { // '[' maybe_sequence_pattern? ']' |
9383 | if (p->error_indicator) { Branch (9383:13): [True: 0, False: 1.29k]
|
9384 | p->level--; |
9385 | return NULL; |
9386 | } |
9387 | D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'")); |
9388 | Token * _literal; |
9389 | Token * _literal_1; |
9390 | void *patterns; |
9391 | if ( |
9392 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (9392:13): [True: 484, False: 807]
|
9393 | && |
9394 | (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator)484 // maybe_sequence_pattern? Branch (9394:13): [True: 484, False: 0]
|
9395 | && |
9396 | (_literal_1 = _PyPegen_expect_token(p, 10))484 // token=']' Branch (9396:13): [True: 484, False: 0]
|
9397 | ) |
9398 | { |
9399 | D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'")); |
9400 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9401 | if (_token == NULL) { Branch (9401:17): [True: 0, False: 484]
|
9402 | p->level--; |
9403 | return NULL; |
9404 | } |
9405 | int _end_lineno = _token->end_lineno; |
9406 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9407 | int _end_col_offset = _token->end_col_offset; |
9408 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9409 | _res = _PyAST_MatchSequence ( patterns , EXTRA ); |
9410 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9410:17): [True: 0, False: 484]
Branch (9410:33): [True: 0, False: 0]
|
9411 | p->error_indicator = 1; |
9412 | p->level--; |
9413 | return NULL; |
9414 | } |
9415 | goto done; |
9416 | } |
9417 | p->mark = _mark; |
9418 | D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9419 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' maybe_sequence_pattern? ']'")); |
9420 | } |
9421 | { // '(' open_sequence_pattern? ')' |
9422 | if (p->error_indicator) { Branch (9422:13): [True: 0, False: 807]
|
9423 | p->level--; |
9424 | return NULL; |
9425 | } |
9426 | D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' open_sequence_pattern? ')'")); |
9427 | Token * _literal; |
9428 | Token * _literal_1; |
9429 | void *patterns; |
9430 | if ( |
9431 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (9431:13): [True: 57, False: 750]
|
9432 | && |
9433 | (patterns = open_sequence_pattern_rule(p), !p->error_indicator)57 // open_sequence_pattern? Branch (9433:13): [True: 57, False: 0]
|
9434 | && |
9435 | (_literal_1 = _PyPegen_expect_token(p, 8))57 // token=')' Branch (9435:13): [True: 57, False: 0]
|
9436 | ) |
9437 | { |
9438 | D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' open_sequence_pattern? ')'")); |
9439 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9440 | if (_token == NULL) { Branch (9440:17): [True: 0, False: 57]
|
9441 | p->level--; |
9442 | return NULL; |
9443 | } |
9444 | int _end_lineno = _token->end_lineno; |
9445 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9446 | int _end_col_offset = _token->end_col_offset; |
9447 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9448 | _res = _PyAST_MatchSequence ( patterns , EXTRA ); |
9449 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9449:17): [True: 0, False: 57]
Branch (9449:33): [True: 0, False: 0]
|
9450 | p->error_indicator = 1; |
9451 | p->level--; |
9452 | return NULL; |
9453 | } |
9454 | goto done; |
9455 | } |
9456 | p->mark = _mark; |
9457 | D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9458 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' open_sequence_pattern? ')'")); |
9459 | } |
9460 | _res = NULL; |
9461 | done: |
9462 | p->level--; |
9463 | return _res; |
9464 | } |
9465 | |
9466 | // open_sequence_pattern: maybe_star_pattern ',' maybe_sequence_pattern? |
9467 | static asdl_seq* |
9468 | open_sequence_pattern_rule(Parser *p) |
9469 | { |
9470 | if (p->level++ == MAXSTACK) { Branch (9470:9): [True: 0, False: 1.40k]
|
9471 | p->error_indicator = 1; |
9472 | PyErr_NoMemory(); |
9473 | } |
9474 | if (p->error_indicator) { Branch (9474:9): [True: 0, False: 1.40k]
|
9475 | p->level--; |
9476 | return NULL; |
9477 | } |
9478 | asdl_seq* _res = NULL; |
9479 | int _mark = p->mark; |
9480 | { // maybe_star_pattern ',' maybe_sequence_pattern? |
9481 | if (p->error_indicator) { Branch (9481:13): [True: 0, False: 1.40k]
|
9482 | p->level--; |
9483 | return NULL; |
9484 | } |
9485 | D(fprintf(stderr, "%*c> open_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?")); |
9486 | Token * _literal; |
9487 | pattern_ty pattern; |
9488 | void *patterns; |
9489 | if ( |
9490 | (pattern = maybe_star_pattern_rule(p)) // maybe_star_pattern Branch (9490:13): [True: 1.35k, False: 52]
|
9491 | && |
9492 | (_literal = _PyPegen_expect_token(p, 12))1.35k // token=',' Branch (9492:13): [True: 111, False: 1.24k]
|
9493 | && |
9494 | (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator)111 // maybe_sequence_pattern? Branch (9494:13): [True: 111, False: 0]
|
9495 | ) |
9496 | { |
9497 | D(fprintf(stderr, "%*c+ open_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?")); |
9498 | _res = _PyPegen_seq_insert_in_front ( p , pattern , patterns ); |
9499 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9499:17): [True: 0, False: 111]
Branch (9499:33): [True: 0, False: 0]
|
9500 | p->error_indicator = 1; |
9501 | p->level--; |
9502 | return NULL; |
9503 | } |
9504 | goto done; |
9505 | } |
9506 | p->mark = _mark; |
9507 | D(fprintf(stderr, "%*c%s open_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9508 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?")); |
9509 | } |
9510 | _res = NULL; |
9511 | done: |
9512 | p->level--; |
9513 | return _res; |
9514 | } |
9515 | |
9516 | // maybe_sequence_pattern: ','.maybe_star_pattern+ ','? |
9517 | static asdl_seq* |
9518 | maybe_sequence_pattern_rule(Parser *p) |
9519 | { |
9520 | if (p->level++ == MAXSTACK) { Branch (9520:9): [True: 0, False: 595]
|
9521 | p->error_indicator = 1; |
9522 | PyErr_NoMemory(); |
9523 | } |
9524 | if (p->error_indicator) { Branch (9524:9): [True: 0, False: 595]
|
9525 | p->level--; |
9526 | return NULL; |
9527 | } |
9528 | asdl_seq* _res = NULL; |
9529 | int _mark = p->mark; |
9530 | { // ','.maybe_star_pattern+ ','? |
9531 | if (p->error_indicator) { Branch (9531:13): [True: 0, False: 595]
|
9532 | p->level--; |
9533 | return NULL; |
9534 | } |
9535 | D(fprintf(stderr, "%*c> maybe_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?")); |
9536 | void *_opt_var; |
9537 | UNUSED(_opt_var); // Silence compiler warnings |
9538 | asdl_seq * patterns; |
9539 | if ( |
9540 | (patterns = _gather_71_rule(p)) // ','.maybe_star_pattern+ Branch (9540:13): [True: 500, False: 95]
|
9541 | && |
9542 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)500 // ','? Branch (9542:13): [True: 500, False: 0]
|
9543 | ) |
9544 | { |
9545 | D(fprintf(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?")); |
9546 | _res = patterns; |
9547 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9547:17): [True: 0, False: 500]
Branch (9547:33): [True: 0, False: 0]
|
9548 | p->error_indicator = 1; |
9549 | p->level--; |
9550 | return NULL; |
9551 | } |
9552 | goto done; |
9553 | } |
9554 | p->mark = _mark; |
9555 | D(fprintf(stderr, "%*c%s maybe_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9556 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.maybe_star_pattern+ ','?")); |
9557 | } |
9558 | _res = NULL; |
9559 | done: |
9560 | p->level--; |
9561 | return _res; |
9562 | } |
9563 | |
9564 | // maybe_star_pattern: star_pattern | pattern |
9565 | static pattern_ty |
9566 | maybe_star_pattern_rule(Parser *p) |
9567 | { |
9568 | if (p->level++ == MAXSTACK) { Branch (9568:9): [True: 0, False: 2.59k]
|
9569 | p->error_indicator = 1; |
9570 | PyErr_NoMemory(); |
9571 | } |
9572 | if (p->error_indicator) { Branch (9572:9): [True: 0, False: 2.59k]
|
9573 | p->level--; |
9574 | return NULL; |
9575 | } |
9576 | pattern_ty _res = NULL; |
9577 | int _mark = p->mark; |
9578 | { // star_pattern |
9579 | if (p->error_indicator) { Branch (9579:13): [True: 0, False: 2.59k]
|
9580 | p->level--; |
9581 | return NULL; |
9582 | } |
9583 | D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_pattern")); |
9584 | pattern_ty star_pattern_var; |
9585 | if ( |
9586 | (star_pattern_var = star_pattern_rule(p)) // star_pattern Branch (9586:13): [True: 137, False: 2.45k]
|
9587 | ) |
9588 | { |
9589 | D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_pattern")); |
9590 | _res = star_pattern_var; |
9591 | goto done; |
9592 | } |
9593 | p->mark = _mark; |
9594 | D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9595 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_pattern")); |
9596 | } |
9597 | { // pattern |
9598 | if (p->error_indicator) { Branch (9598:13): [True: 0, False: 2.45k]
|
9599 | p->level--; |
9600 | return NULL; |
9601 | } |
9602 | D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern")); |
9603 | pattern_ty pattern_var; |
9604 | if ( |
9605 | (pattern_var = pattern_rule(p)) // pattern Branch (9605:13): [True: 2.29k, False: 165]
|
9606 | ) |
9607 | { |
9608 | D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern")); |
9609 | _res = pattern_var; |
9610 | goto done; |
9611 | } |
9612 | p->mark = _mark; |
9613 | D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9614 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern")); |
9615 | } |
9616 | _res = NULL; |
9617 | done: |
9618 | p->level--; |
9619 | return _res; |
9620 | } |
9621 | |
9622 | // star_pattern: '*' pattern_capture_target | '*' wildcard_pattern |
9623 | static pattern_ty |
9624 | star_pattern_rule(Parser *p) |
9625 | { |
9626 | if (p->level++ == MAXSTACK) { Branch (9626:9): [True: 0, False: 2.59k]
|
9627 | p->error_indicator = 1; |
9628 | PyErr_NoMemory(); |
9629 | } |
9630 | if (p->error_indicator) { Branch (9630:9): [True: 0, False: 2.59k]
|
9631 | p->level--; |
9632 | return NULL; |
9633 | } |
9634 | pattern_ty _res = NULL; |
9635 | if (_PyPegen_is_memoized(p, star_pattern_type, &_res)) { Branch (9635:9): [True: 20, False: 2.57k]
|
9636 | p->level--; |
9637 | return _res; |
9638 | } |
9639 | int _mark = p->mark; |
9640 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (9640:9): [True: 0, False: 2.57k]
Branch (9640:31): [True: 0, False: 0]
|
9641 | p->error_indicator = 1; |
9642 | p->level--; |
9643 | return NULL; |
9644 | } |
9645 | int _start_lineno = p->tokens[_mark]->lineno; |
9646 | UNUSED(_start_lineno); // Only used by EXTRA macro |
9647 | int _start_col_offset = p->tokens[_mark]->col_offset; |
9648 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
9649 | { // '*' pattern_capture_target |
9650 | if (p->error_indicator) { Branch (9650:13): [True: 0, False: 2.57k]
|
9651 | p->level--; |
9652 | return NULL; |
9653 | } |
9654 | D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target")); |
9655 | Token * _literal; |
9656 | expr_ty target; |
9657 | if ( |
9658 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (9658:13): [True: 137, False: 2.43k]
|
9659 | && |
9660 | (target = pattern_capture_target_rule(p))137 // pattern_capture_target Branch (9660:13): [True: 92, False: 45]
|
9661 | ) |
9662 | { |
9663 | D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target")); |
9664 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9665 | if (_token == NULL) { Branch (9665:17): [True: 0, False: 92]
|
9666 | p->level--; |
9667 | return NULL; |
9668 | } |
9669 | int _end_lineno = _token->end_lineno; |
9670 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9671 | int _end_col_offset = _token->end_col_offset; |
9672 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9673 | _res = _PyAST_MatchStar ( target -> v . Name . id , EXTRA ); |
9674 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9674:17): [True: 0, False: 92]
Branch (9674:33): [True: 0, False: 0]
|
9675 | p->error_indicator = 1; |
9676 | p->level--; |
9677 | return NULL; |
9678 | } |
9679 | goto done; |
9680 | } |
9681 | p->mark = _mark; |
9682 | D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9683 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' pattern_capture_target")); |
9684 | } |
9685 | { // '*' wildcard_pattern |
9686 | if (p->error_indicator) { Branch (9686:13): [True: 0, False: 2.48k]
|
9687 | p->level--; |
9688 | return NULL; |
9689 | } |
9690 | D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern")); |
9691 | Token * _literal; |
9692 | pattern_ty wildcard_pattern_var; |
9693 | if ( |
9694 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (9694:13): [True: 45, False: 2.43k]
|
9695 | && |
9696 | (wildcard_pattern_var = wildcard_pattern_rule(p))45 // wildcard_pattern Branch (9696:13): [True: 45, False: 0]
|
9697 | ) |
9698 | { |
9699 | D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern")); |
9700 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9701 | if (_token == NULL) { Branch (9701:17): [True: 0, False: 45]
|
9702 | p->level--; |
9703 | return NULL; |
9704 | } |
9705 | int _end_lineno = _token->end_lineno; |
9706 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9707 | int _end_col_offset = _token->end_col_offset; |
9708 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9709 | _res = _PyAST_MatchStar ( NULL , EXTRA ); |
9710 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9710:17): [True: 0, False: 45]
Branch (9710:33): [True: 0, False: 0]
|
9711 | p->error_indicator = 1; |
9712 | p->level--; |
9713 | return NULL; |
9714 | } |
9715 | goto done; |
9716 | } |
9717 | p->mark = _mark; |
9718 | D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9719 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' wildcard_pattern")); |
9720 | } |
9721 | _res = NULL; |
9722 | done: |
9723 | _PyPegen_insert_memo(p, _mark, star_pattern_type, _res); |
9724 | p->level--; |
9725 | return _res; |
9726 | } |
9727 | |
9728 | // mapping_pattern: |
9729 | // | '{' '}' |
9730 | // | '{' double_star_pattern ','? '}' |
9731 | // | '{' items_pattern ',' double_star_pattern ','? '}' |
9732 | // | '{' items_pattern ','? '}' |
9733 | static pattern_ty |
9734 | mapping_pattern_rule(Parser *p) |
9735 | { |
9736 | if (p->level++ == MAXSTACK) { Branch (9736:9): [True: 0, False: 750]
|
9737 | p->error_indicator = 1; |
9738 | PyErr_NoMemory(); |
9739 | } |
9740 | if (p->error_indicator) { Branch (9740:9): [True: 0, False: 750]
|
9741 | p->level--; |
9742 | return NULL; |
9743 | } |
9744 | pattern_ty _res = NULL; |
9745 | int _mark = p->mark; |
9746 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (9746:9): [True: 0, False: 750]
Branch (9746:31): [True: 0, False: 0]
|
9747 | p->error_indicator = 1; |
9748 | p->level--; |
9749 | return NULL; |
9750 | } |
9751 | int _start_lineno = p->tokens[_mark]->lineno; |
9752 | UNUSED(_start_lineno); // Only used by EXTRA macro |
9753 | int _start_col_offset = p->tokens[_mark]->col_offset; |
9754 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
9755 | { // '{' '}' |
9756 | if (p->error_indicator) { Branch (9756:13): [True: 0, False: 750]
|
9757 | p->level--; |
9758 | return NULL; |
9759 | } |
9760 | D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'")); |
9761 | Token * _literal; |
9762 | Token * _literal_1; |
9763 | if ( |
9764 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (9764:13): [True: 366, False: 384]
|
9765 | && |
9766 | (_literal_1 = _PyPegen_expect_token(p, 26))366 // token='}' Branch (9766:13): [True: 74, False: 292]
|
9767 | ) |
9768 | { |
9769 | D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'")); |
9770 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9771 | if (_token == NULL) { Branch (9771:17): [True: 0, False: 74]
|
9772 | p->level--; |
9773 | return NULL; |
9774 | } |
9775 | int _end_lineno = _token->end_lineno; |
9776 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9777 | int _end_col_offset = _token->end_col_offset; |
9778 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9779 | _res = _PyAST_MatchMapping ( NULL , NULL , NULL , EXTRA ); |
9780 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9780:17): [True: 0, False: 74]
Branch (9780:33): [True: 0, False: 0]
|
9781 | p->error_indicator = 1; |
9782 | p->level--; |
9783 | return NULL; |
9784 | } |
9785 | goto done; |
9786 | } |
9787 | p->mark = _mark; |
9788 | D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9789 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'")); |
9790 | } |
9791 | { // '{' double_star_pattern ','? '}' |
9792 | if (p->error_indicator) { Branch (9792:13): [True: 0, False: 676]
|
9793 | p->level--; |
9794 | return NULL; |
9795 | } |
9796 | D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'")); |
9797 | Token * _literal; |
9798 | Token * _literal_1; |
9799 | void *_opt_var; |
9800 | UNUSED(_opt_var); // Silence compiler warnings |
9801 | expr_ty rest; |
9802 | if ( |
9803 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (9803:13): [True: 292, False: 384]
|
9804 | && |
9805 | (rest = double_star_pattern_rule(p))292 // double_star_pattern Branch (9805:13): [True: 15, False: 277]
|
9806 | && |
9807 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)15 // ','? Branch (9807:13): [True: 15, False: 0]
|
9808 | && |
9809 | (_literal_1 = _PyPegen_expect_token(p, 26))15 // token='}' Branch (9809:13): [True: 9, False: 6]
|
9810 | ) |
9811 | { |
9812 | D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'")); |
9813 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9814 | if (_token == NULL) { Branch (9814:17): [True: 0, False: 9]
|
9815 | p->level--; |
9816 | return NULL; |
9817 | } |
9818 | int _end_lineno = _token->end_lineno; |
9819 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9820 | int _end_col_offset = _token->end_col_offset; |
9821 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9822 | _res = _PyAST_MatchMapping ( NULL , NULL , rest -> v . Name . id , EXTRA ); |
9823 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9823:17): [True: 0, False: 9]
Branch (9823:33): [True: 0, False: 0]
|
9824 | p->error_indicator = 1; |
9825 | p->level--; |
9826 | return NULL; |
9827 | } |
9828 | goto done; |
9829 | } |
9830 | p->mark = _mark; |
9831 | D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9832 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_star_pattern ','? '}'")); |
9833 | } |
9834 | { // '{' items_pattern ',' double_star_pattern ','? '}' |
9835 | if (p->error_indicator) { Branch (9835:13): [True: 0, False: 667]
|
9836 | p->level--; |
9837 | return NULL; |
9838 | } |
9839 | D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'")); |
9840 | Token * _literal; |
9841 | Token * _literal_1; |
9842 | Token * _literal_2; |
9843 | void *_opt_var; |
9844 | UNUSED(_opt_var); // Silence compiler warnings |
9845 | asdl_seq* items; |
9846 | expr_ty rest; |
9847 | if ( |
9848 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (9848:13): [True: 283, False: 384]
|
9849 | && |
9850 | (items = items_pattern_rule(p))283 // items_pattern Branch (9850:13): [True: 270, False: 13]
|
9851 | && |
9852 | (_literal_1 = _PyPegen_expect_token(p, 12))270 // token=',' Branch (9852:13): [True: 17, False: 253]
|
9853 | && |
9854 | (rest = double_star_pattern_rule(p))17 // double_star_pattern Branch (9854:13): [True: 17, False: 0]
|
9855 | && |
9856 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)17 // ','? Branch (9856:13): [True: 17, False: 0]
|
9857 | && |
9858 | (_literal_2 = _PyPegen_expect_token(p, 26))17 // token='}' Branch (9858:13): [True: 15, False: 2]
|
9859 | ) |
9860 | { |
9861 | D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'")); |
9862 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9863 | if (_token == NULL) { Branch (9863:17): [True: 0, False: 15]
|
9864 | p->level--; |
9865 | return NULL; |
9866 | } |
9867 | int _end_lineno = _token->end_lineno; |
9868 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9869 | int _end_col_offset = _token->end_col_offset; |
9870 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9871 | _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 ); |
9872 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9872:17): [True: 0, False: 15]
Branch (9872:33): [True: 0, False: 0]
|
9873 | p->error_indicator = 1; |
9874 | p->level--; |
9875 | return NULL; |
9876 | } |
9877 | goto done; |
9878 | } |
9879 | p->mark = _mark; |
9880 | D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9881 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'")); |
9882 | } |
9883 | { // '{' items_pattern ','? '}' |
9884 | if (p->error_indicator) { Branch (9884:13): [True: 3, False: 649]
|
9885 | p->level--; |
9886 | return NULL; |
9887 | } |
9888 | D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'")); |
9889 | Token * _literal; |
9890 | Token * _literal_1; |
9891 | void *_opt_var; |
9892 | UNUSED(_opt_var); // Silence compiler warnings |
9893 | asdl_seq* items; |
9894 | if ( |
9895 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (9895:13): [True: 265, False: 384]
|
9896 | && |
9897 | (items = items_pattern_rule(p))265 // items_pattern Branch (9897:13): [True: 255, False: 10]
|
9898 | && |
9899 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)255 // ','? Branch (9899:13): [True: 255, False: 0]
|
9900 | && |
9901 | (_literal_1 = _PyPegen_expect_token(p, 26))255 // token='}' Branch (9901:13): [True: 253, False: 2]
|
9902 | ) |
9903 | { |
9904 | D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'")); |
9905 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
9906 | if (_token == NULL) { Branch (9906:17): [True: 0, False: 253]
|
9907 | p->level--; |
9908 | return NULL; |
9909 | } |
9910 | int _end_lineno = _token->end_lineno; |
9911 | UNUSED(_end_lineno); // Only used by EXTRA macro |
9912 | int _end_col_offset = _token->end_col_offset; |
9913 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
9914 | _res = _PyAST_MatchMapping ( CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get_patterns ( p , items ) ) , NULL , EXTRA ); |
9915 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (9915:17): [True: 0, False: 253]
Branch (9915:33): [True: 0, False: 0]
|
9916 | p->error_indicator = 1; |
9917 | p->level--; |
9918 | return NULL; |
9919 | } |
9920 | goto done; |
9921 | } |
9922 | p->mark = _mark; |
9923 | D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9924 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ','? '}'")); |
9925 | } |
9926 | _res = NULL; |
9927 | done: |
9928 | p->level--; |
9929 | return _res; |
9930 | } |
9931 | |
9932 | // items_pattern: ','.key_value_pattern+ |
9933 | static asdl_seq* |
9934 | items_pattern_rule(Parser *p) |
9935 | { |
9936 | if (p->level++ == MAXSTACK) { Branch (9936:9): [True: 0, False: 548]
|
9937 | p->error_indicator = 1; |
9938 | PyErr_NoMemory(); |
9939 | } |
9940 | if (p->error_indicator) { Branch (9940:9): [True: 0, False: 548]
|
9941 | p->level--; |
9942 | return NULL; |
9943 | } |
9944 | asdl_seq* _res = NULL; |
9945 | int _mark = p->mark; |
9946 | { // ','.key_value_pattern+ |
9947 | if (p->error_indicator) { Branch (9947:13): [True: 0, False: 548]
|
9948 | p->level--; |
9949 | return NULL; |
9950 | } |
9951 | D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+")); |
9952 | asdl_seq * _gather_73_var; |
9953 | if ( |
9954 | (_gather_73_var = _gather_73_rule(p)) // ','.key_value_pattern+ Branch (9954:13): [True: 525, False: 23]
|
9955 | ) |
9956 | { |
9957 | D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+")); |
9958 | _res = _gather_73_var; |
9959 | goto done; |
9960 | } |
9961 | p->mark = _mark; |
9962 | D(fprintf(stderr, "%*c%s items_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
9963 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.key_value_pattern+")); |
9964 | } |
9965 | _res = NULL; |
9966 | done: |
9967 | p->level--; |
9968 | return _res; |
9969 | } |
9970 | |
9971 | // key_value_pattern: (literal_expr | attr) ':' pattern |
9972 | static KeyPatternPair* |
9973 | key_value_pattern_rule(Parser *p) |
9974 | { |
9975 | if (p->level++ == MAXSTACK) { Branch (9975:9): [True: 0, False: 683]
|
9976 | p->error_indicator = 1; |
9977 | PyErr_NoMemory(); |
9978 | } |
9979 | if (p->error_indicator) { Branch (9979:9): [True: 0, False: 683]
|
9980 | p->level--; |
9981 | return NULL; |
9982 | } |
9983 | KeyPatternPair* _res = NULL; |
9984 | int _mark = p->mark; |
9985 | { // (literal_expr | attr) ':' pattern |
9986 | if (p->error_indicator) { Branch (9986:13): [True: 0, False: 683]
|
9987 | p->level--; |
9988 | return NULL; |
9989 | } |
9990 | D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(literal_expr | attr) ':' pattern")); |
9991 | Token * _literal; |
9992 | void *key; |
9993 | pattern_ty pattern; |
9994 | if ( |
9995 | (key = _tmp_75_rule(p)) // literal_expr | attr Branch (9995:13): [True: 641, False: 42]
|
9996 | && |
9997 | (_literal = _PyPegen_expect_token(p, 11))641 // token=':' Branch (9997:13): [True: 641, False: 0]
|
9998 | && |
9999 | (pattern = pattern_rule(p))641 // pattern Branch (9999:13): [True: 641, False: 0]
|
10000 | ) |
10001 | { |
10002 | D(fprintf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(literal_expr | attr) ':' pattern")); |
10003 | _res = _PyPegen_key_pattern_pair ( p , key , pattern ); |
10004 | if (_res == NULL && PyErr_Occurred()0 ) { |
10005 | p->error_indicator = 1; |
10006 | p->level--; |
10007 | return NULL; |
10008 | } |
10009 | goto done; |
10010 | } |
10011 | p->mark = _mark; |
10012 | D(fprintf(stderr, "%*c%s key_value_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10013 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(literal_expr | attr) ':' pattern")); |
10014 | } |
10015 | _res = NULL; |
10016 | done: |
10017 | p->level--; |
10018 | return _res; |
10019 | } |
10020 | |
10021 | // double_star_pattern: '**' pattern_capture_target |
10022 | static expr_ty |
10023 | double_star_pattern_rule(Parser *p) |
10024 | { |
10025 | if (p->level++ == MAXSTACK) { Branch (10025:9): [True: 0, False: 309]
|
10026 | p->error_indicator = 1; |
10027 | PyErr_NoMemory(); |
10028 | } |
10029 | if (p->error_indicator) { Branch (10029:9): [True: 0, False: 309]
|
10030 | p->level--; |
10031 | return NULL; |
10032 | } |
10033 | expr_ty _res = NULL; |
10034 | int _mark = p->mark; |
10035 | { // '**' pattern_capture_target |
10036 | if (p->error_indicator) { Branch (10036:13): [True: 0, False: 309]
|
10037 | p->level--; |
10038 | return NULL; |
10039 | } |
10040 | D(fprintf(stderr, "%*c> double_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' pattern_capture_target")); |
10041 | Token * _literal; |
10042 | expr_ty target; |
10043 | if ( |
10044 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (10044:13): [True: 36, False: 273]
|
10045 | && |
10046 | (target = pattern_capture_target_rule(p))36 // pattern_capture_target |
10047 | ) |
10048 | { |
10049 | D(fprintf(stderr, "%*c+ double_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' pattern_capture_target")); |
10050 | _res = target; |
10051 | if (_res == NULL && PyErr_Occurred()0 ) { |
10052 | p->error_indicator = 1; |
10053 | p->level--; |
10054 | return NULL; |
10055 | } |
10056 | goto done; |
10057 | } |
10058 | p->mark = _mark; |
10059 | D(fprintf(stderr, "%*c%s double_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10060 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' pattern_capture_target")); |
10061 | } |
10062 | _res = NULL; |
10063 | done: |
10064 | p->level--; |
10065 | return _res; |
10066 | } |
10067 | |
10068 | // class_pattern: |
10069 | // | name_or_attr '(' ')' |
10070 | // | name_or_attr '(' positional_patterns ','? ')' |
10071 | // | name_or_attr '(' keyword_patterns ','? ')' |
10072 | // | name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')' |
10073 | // | invalid_class_pattern |
10074 | static pattern_ty |
10075 | class_pattern_rule(Parser *p) |
10076 | { |
10077 | if (p->level++ == MAXSTACK) { Branch (10077:9): [True: 0, False: 396]
|
10078 | p->error_indicator = 1; |
10079 | PyErr_NoMemory(); |
10080 | } |
10081 | if (p->error_indicator) { Branch (10081:9): [True: 0, False: 396]
|
10082 | p->level--; |
10083 | return NULL; |
10084 | } |
10085 | pattern_ty _res = NULL; |
10086 | int _mark = p->mark; |
10087 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (10087:9): [True: 0, False: 396]
Branch (10087:31): [True: 0, False: 0]
|
10088 | p->error_indicator = 1; |
10089 | p->level--; |
10090 | return NULL; |
10091 | } |
10092 | int _start_lineno = p->tokens[_mark]->lineno; |
10093 | UNUSED(_start_lineno); // Only used by EXTRA macro |
10094 | int _start_col_offset = p->tokens[_mark]->col_offset; |
10095 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
10096 | { // name_or_attr '(' ')' |
10097 | if (p->error_indicator) { Branch (10097:13): [True: 0, False: 396]
|
10098 | p->level--; |
10099 | return NULL; |
10100 | } |
10101 | D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' ')'")); |
10102 | Token * _literal; |
10103 | Token * _literal_1; |
10104 | expr_ty cls; |
10105 | if ( |
10106 | (cls = name_or_attr_rule(p)) // name_or_attr Branch (10106:13): [True: 258, False: 138]
|
10107 | && |
10108 | (_literal = _PyPegen_expect_token(p, 7))258 // token='(' Branch (10108:13): [True: 194, False: 64]
|
10109 | && |
10110 | (_literal_1 = _PyPegen_expect_token(p, 8))194 // token=')' Branch (10110:13): [True: 11, False: 183]
|
10111 | ) |
10112 | { |
10113 | D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' ')'")); |
10114 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10115 | if (_token == NULL) { |
10116 | p->level--; |
10117 | return NULL; |
10118 | } |
10119 | int _end_lineno = _token->end_lineno; |
10120 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10121 | int _end_col_offset = _token->end_col_offset; |
10122 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10123 | _res = _PyAST_MatchClass ( cls , NULL , NULL , NULL , EXTRA ); |
10124 | if (_res == NULL && PyErr_Occurred()0 ) { |
10125 | p->error_indicator = 1; |
10126 | p->level--; |
10127 | return NULL; |
10128 | } |
10129 | goto done; |
10130 | } |
10131 | p->mark = _mark; |
10132 | D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10133 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' ')'")); |
10134 | } |
10135 | { // name_or_attr '(' positional_patterns ','? ')' |
10136 | if (p->error_indicator) { Branch (10136:13): [True: 0, False: 385]
|
10137 | p->level--; |
10138 | return NULL; |
10139 | } |
10140 | D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')'")); |
10141 | Token * _literal; |
10142 | Token * _literal_1; |
10143 | void *_opt_var; |
10144 | UNUSED(_opt_var); // Silence compiler warnings |
10145 | expr_ty cls; |
10146 | asdl_pattern_seq* patterns; |
10147 | if ( |
10148 | (cls = name_or_attr_rule(p)) // name_or_attr Branch (10148:13): [True: 247, False: 138]
|
10149 | && |
10150 | (_literal = _PyPegen_expect_token(p, 7))247 // token='(' Branch (10150:13): [True: 183, False: 64]
|
10151 | && |
10152 | (patterns = positional_patterns_rule(p))183 // positional_patterns Branch (10152:13): [True: 158, False: 25]
|
10153 | && |
10154 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)158 // ','? Branch (10154:13): [True: 158, False: 0]
|
10155 | && |
10156 | (_literal_1 = _PyPegen_expect_token(p, 8))158 // token=')' Branch (10156:13): [True: 121, False: 37]
|
10157 | ) |
10158 | { |
10159 | D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')'")); |
10160 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10161 | if (_token == NULL) { Branch (10161:17): [True: 0, False: 121]
|
10162 | p->level--; |
10163 | return NULL; |
10164 | } |
10165 | int _end_lineno = _token->end_lineno; |
10166 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10167 | int _end_col_offset = _token->end_col_offset; |
10168 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10169 | _res = _PyAST_MatchClass ( cls , patterns , NULL , NULL , EXTRA ); |
10170 | if (_res == NULL && PyErr_Occurred()0 ) { |
10171 | p->error_indicator = 1; |
10172 | p->level--; |
10173 | return NULL; |
10174 | } |
10175 | goto done; |
10176 | } |
10177 | p->mark = _mark; |
10178 | D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10179 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')'")); |
10180 | } |
10181 | { // name_or_attr '(' keyword_patterns ','? ')' |
10182 | if (p->error_indicator) { Branch (10182:13): [True: 0, False: 264]
|
10183 | p->level--; |
10184 | return NULL; |
10185 | } |
10186 | D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'")); |
10187 | Token * _literal; |
10188 | Token * _literal_1; |
10189 | void *_opt_var; |
10190 | UNUSED(_opt_var); // Silence compiler warnings |
10191 | expr_ty cls; |
10192 | asdl_seq* keywords; |
10193 | if ( |
10194 | (cls = name_or_attr_rule(p)) // name_or_attr Branch (10194:13): [True: 126, False: 138]
|
10195 | && |
10196 | (_literal = _PyPegen_expect_token(p, 7))126 // token='(' Branch (10196:13): [True: 62, False: 64]
|
10197 | && |
10198 | (keywords = keyword_patterns_rule(p))62 // keyword_patterns Branch (10198:13): [True: 25, False: 37]
|
10199 | && |
10200 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)25 // ','? |
10201 | && |
10202 | (_literal_1 = _PyPegen_expect_token(p, 8))25 // token=')' |
10203 | ) |
10204 | { |
10205 | D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'")); |
10206 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10207 | if (_token == NULL) { |
10208 | p->level--; |
10209 | return NULL; |
10210 | } |
10211 | int _end_lineno = _token->end_lineno; |
10212 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10213 | int _end_col_offset = _token->end_col_offset; |
10214 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10215 | _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 ); |
10216 | if (_res == NULL && PyErr_Occurred()0 ) { |
10217 | p->error_indicator = 1; |
10218 | p->level--; |
10219 | return NULL; |
10220 | } |
10221 | goto done; |
10222 | } |
10223 | p->mark = _mark; |
10224 | D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10225 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'")); |
10226 | } |
10227 | { // name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')' |
10228 | if (p->error_indicator) { Branch (10228:13): [True: 0, False: 245]
|
10229 | p->level--; |
10230 | return NULL; |
10231 | } |
10232 | D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'")); |
10233 | Token * _literal; |
10234 | Token * _literal_1; |
10235 | Token * _literal_2; |
10236 | void *_opt_var; |
10237 | UNUSED(_opt_var); // Silence compiler warnings |
10238 | expr_ty cls; |
10239 | asdl_seq* keywords; |
10240 | asdl_pattern_seq* patterns; |
10241 | if ( |
10242 | (cls = name_or_attr_rule(p)) // name_or_attr Branch (10242:13): [True: 107, False: 138]
|
10243 | && |
10244 | (_literal = _PyPegen_expect_token(p, 7))107 // token='(' Branch (10244:13): [True: 43, False: 64]
|
10245 | && |
10246 | (patterns = positional_patterns_rule(p))43 // positional_patterns |
10247 | && |
10248 | (_literal_1 = _PyPegen_expect_token(p, 12))37 // token=',' |
10249 | && |
10250 | (keywords = keyword_patterns_rule(p))37 // keyword_patterns |
10251 | && |
10252 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)37 // ','? |
10253 | && |
10254 | (_literal_2 = _PyPegen_expect_token(p, 8))37 // token=')' |
10255 | ) |
10256 | { |
10257 | D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'")); |
10258 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10259 | if (_token == NULL) { |
10260 | p->level--; |
10261 | return NULL; |
10262 | } |
10263 | int _end_lineno = _token->end_lineno; |
10264 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10265 | int _end_col_offset = _token->end_col_offset; |
10266 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10267 | _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 ); |
10268 | if (_res == NULL && PyErr_Occurred()0 ) { |
10269 | p->error_indicator = 1; |
10270 | p->level--; |
10271 | return NULL; |
10272 | } |
10273 | goto done; |
10274 | } |
10275 | p->mark = _mark; |
10276 | D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10277 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'")); |
10278 | } |
10279 | if (p->call_invalid_rules) { // invalid_class_pattern Branch (10279:9): [True: 19, False: 191]
|
10280 | if (p->error_indicator) { |
10281 | p->level--; |
10282 | return NULL; |
10283 | } |
10284 | D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class_pattern")); |
10285 | void *invalid_class_pattern_var; |
10286 | if ( |
10287 | (invalid_class_pattern_var = invalid_class_pattern_rule(p)) // invalid_class_pattern |
10288 | ) |
10289 | { |
10290 | D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_class_pattern")); |
10291 | _res = invalid_class_pattern_var; |
10292 | goto done; |
10293 | } |
10294 | p->mark = _mark; |
10295 | D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10296 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_pattern")); |
10297 | } |
10298 | _res = NULL; |
10299 | done: |
10300 | p->level--; |
10301 | return _res; |
10302 | } |
10303 | |
10304 | // positional_patterns: ','.pattern+ |
10305 | static asdl_pattern_seq* |
10306 | positional_patterns_rule(Parser *p) |
10307 | { |
10308 | if (p->level++ == MAXSTACK) { Branch (10308:9): [True: 0, False: 234]
|
10309 | p->error_indicator = 1; |
10310 | PyErr_NoMemory(); |
10311 | } |
10312 | if (p->error_indicator) { Branch (10312:9): [True: 0, False: 234]
|
10313 | p->level--; |
10314 | return NULL; |
10315 | } |
10316 | asdl_pattern_seq* _res = NULL; |
10317 | int _mark = p->mark; |
10318 | { // ','.pattern+ |
10319 | if (p->error_indicator) { Branch (10319:13): [True: 0, False: 234]
|
10320 | p->level--; |
10321 | return NULL; |
10322 | } |
10323 | D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pattern+")); |
10324 | asdl_pattern_seq* args; |
10325 | if ( |
10326 | (args = (asdl_pattern_seq*)_gather_76_rule(p)) // ','.pattern+ Branch (10326:13): [True: 200, False: 34]
|
10327 | ) |
10328 | { |
10329 | D(fprintf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.pattern+")); |
10330 | _res = args; |
10331 | if (_res == NULL && PyErr_Occurred()0 ) { |
10332 | p->error_indicator = 1; |
10333 | p->level--; |
10334 | return NULL; |
10335 | } |
10336 | goto done; |
10337 | } |
10338 | p->mark = _mark; |
10339 | D(fprintf(stderr, "%*c%s positional_patterns[%d-%d]: %s failed!\n", p->level, ' ', |
10340 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.pattern+")); |
10341 | } |
10342 | _res = NULL; |
10343 | done: |
10344 | p->level--; |
10345 | return _res; |
10346 | } |
10347 | |
10348 | // keyword_patterns: ','.keyword_pattern+ |
10349 | static asdl_seq* |
10350 | keyword_patterns_rule(Parser *p) |
10351 | { |
10352 | if (p->level++ == MAXSTACK) { Branch (10352:9): [True: 0, False: 103]
|
10353 | p->error_indicator = 1; |
10354 | PyErr_NoMemory(); |
10355 | } |
10356 | if (p->error_indicator) { Branch (10356:9): [True: 0, False: 103]
|
10357 | p->level--; |
10358 | return NULL; |
10359 | } |
10360 | asdl_seq* _res = NULL; |
10361 | int _mark = p->mark; |
10362 | { // ','.keyword_pattern+ |
10363 | if (p->error_indicator) { Branch (10363:13): [True: 0, False: 103]
|
10364 | p->level--; |
10365 | return NULL; |
10366 | } |
10367 | D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+")); |
10368 | asdl_seq * _gather_78_var; |
10369 | if ( |
10370 | (_gather_78_var = _gather_78_rule(p)) // ','.keyword_pattern+ Branch (10370:13): [True: 66, False: 37]
|
10371 | ) |
10372 | { |
10373 | D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+")); |
10374 | _res = _gather_78_var; |
10375 | goto done; |
10376 | } |
10377 | p->mark = _mark; |
10378 | D(fprintf(stderr, "%*c%s keyword_patterns[%d-%d]: %s failed!\n", p->level, ' ', |
10379 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.keyword_pattern+")); |
10380 | } |
10381 | _res = NULL; |
10382 | done: |
10383 | p->level--; |
10384 | return _res; |
10385 | } |
10386 | |
10387 | // keyword_pattern: NAME '=' pattern |
10388 | static KeyPatternPair* |
10389 | keyword_pattern_rule(Parser *p) |
10390 | { |
10391 | if (p->level++ == MAXSTACK) { Branch (10391:9): [True: 0, False: 156]
|
10392 | p->error_indicator = 1; |
10393 | PyErr_NoMemory(); |
10394 | } |
10395 | if (p->error_indicator) { Branch (10395:9): [True: 0, False: 156]
|
10396 | p->level--; |
10397 | return NULL; |
10398 | } |
10399 | KeyPatternPair* _res = NULL; |
10400 | int _mark = p->mark; |
10401 | { // NAME '=' pattern |
10402 | if (p->error_indicator) { Branch (10402:13): [True: 0, False: 156]
|
10403 | p->level--; |
10404 | return NULL; |
10405 | } |
10406 | D(fprintf(stderr, "%*c> keyword_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern")); |
10407 | Token * _literal; |
10408 | expr_ty arg; |
10409 | pattern_ty value; |
10410 | if ( |
10411 | (arg = _PyPegen_name_token(p)) // NAME Branch (10411:13): [True: 153, False: 3]
|
10412 | && |
10413 | (_literal = _PyPegen_expect_token(p, 22))153 // token='=' Branch (10413:13): [True: 107, False: 46]
|
10414 | && |
10415 | (value = pattern_rule(p))107 // pattern Branch (10415:13): [True: 107, False: 0]
|
10416 | ) |
10417 | { |
10418 | D(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern")); |
10419 | _res = _PyPegen_key_pattern_pair ( p , arg , value ); |
10420 | if (_res == NULL && PyErr_Occurred()0 ) { |
10421 | p->error_indicator = 1; |
10422 | p->level--; |
10423 | return NULL; |
10424 | } |
10425 | goto done; |
10426 | } |
10427 | p->mark = _mark; |
10428 | D(fprintf(stderr, "%*c%s keyword_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
10429 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' pattern")); |
10430 | } |
10431 | _res = NULL; |
10432 | done: |
10433 | p->level--; |
10434 | return _res; |
10435 | } |
10436 | |
10437 | // expressions: expression ((',' expression))+ ','? | expression ',' | expression |
10438 | static expr_ty |
10439 | expressions_rule(Parser *p) |
10440 | { |
10441 | if (p->level++ == MAXSTACK) { Branch (10441:9): [True: 0, False: 37.0k]
|
10442 | p->error_indicator = 1; |
10443 | PyErr_NoMemory(); |
10444 | } |
10445 | if (p->error_indicator) { Branch (10445:9): [True: 0, False: 37.0k]
|
10446 | p->level--; |
10447 | return NULL; |
10448 | } |
10449 | expr_ty _res = NULL; |
10450 | int _mark = p->mark; |
10451 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 036.9k ) { Branch (10451:9): [True: 36.9k, False: 107]
Branch (10451:31): [True: 86, False: 36.8k]
|
10452 | p->error_indicator = 1; |
10453 | p->level--; |
10454 | return NULL; |
10455 | } |
10456 | int _start_lineno = p->tokens[_mark]->lineno; |
10457 | UNUSED(_start_lineno); // Only used by EXTRA macro |
10458 | int _start_col_offset = p->tokens[_mark]->col_offset; |
10459 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
10460 | { // expression ((',' expression))+ ','? |
10461 | if (p->error_indicator) { Branch (10461:13): [True: 0, False: 36.9k]
|
10462 | p->level--; |
10463 | return NULL; |
10464 | } |
10465 | D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?")); |
10466 | void *_opt_var; |
10467 | UNUSED(_opt_var); // Silence compiler warnings |
10468 | expr_ty a; |
10469 | asdl_seq * b; |
10470 | if ( |
10471 | (a = expression_rule(p)) // expression Branch (10471:13): [True: 36.6k, False: 338]
|
10472 | && |
10473 | (b = _loop1_80_rule(p))36.6k // ((',' expression))+ Branch (10473:13): [True: 206, False: 36.4k]
|
10474 | && |
10475 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)206 // ','? Branch (10475:13): [True: 206, False: 0]
|
10476 | ) |
10477 | { |
10478 | D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?")); |
10479 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10480 | if (_token == NULL) { Branch (10480:17): [True: 0, False: 206]
|
10481 | p->level--; |
10482 | return NULL; |
10483 | } |
10484 | int _end_lineno = _token->end_lineno; |
10485 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10486 | int _end_col_offset = _token->end_col_offset; |
10487 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10488 | _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA ); |
10489 | if (_res == NULL && PyErr_Occurred()0 ) { |
10490 | p->error_indicator = 1; |
10491 | p->level--; |
10492 | return NULL; |
10493 | } |
10494 | goto done; |
10495 | } |
10496 | p->mark = _mark; |
10497 | D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', |
10498 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ((',' expression))+ ','?")); |
10499 | } |
10500 | { // expression ',' |
10501 | if (p->error_indicator) { Branch (10501:13): [True: 307, False: 36.4k]
|
10502 | p->level--; |
10503 | return NULL; |
10504 | } |
10505 | D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','")); |
10506 | Token * _literal; |
10507 | expr_ty a; |
10508 | if ( |
10509 | (a = expression_rule(p)) // expression Branch (10509:13): [True: 36.4k, False: 31]
|
10510 | && |
10511 | (_literal = _PyPegen_expect_token(p, 12))36.4k // token=',' Branch (10511:13): [True: 0, False: 36.4k]
|
10512 | ) |
10513 | { |
10514 | D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ','")); |
10515 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10516 | if (_token == NULL) { |
10517 | p->level--; |
10518 | return NULL; |
10519 | } |
10520 | int _end_lineno = _token->end_lineno; |
10521 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10522 | int _end_col_offset = _token->end_col_offset; |
10523 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10524 | _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA ); |
10525 | if (_res == NULL && PyErr_Occurred()) { |
10526 | p->error_indicator = 1; |
10527 | p->level--; |
10528 | return NULL; |
10529 | } |
10530 | goto done; |
10531 | } |
10532 | p->mark = _mark; |
10533 | D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', |
10534 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ','")); |
10535 | } |
10536 | { // expression |
10537 | if (p->error_indicator) { Branch (10537:13): [True: 0, False: 36.4k]
|
10538 | p->level--; |
10539 | return NULL; |
10540 | } |
10541 | D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); |
10542 | expr_ty expression_var; |
10543 | if ( |
10544 | (expression_var = expression_rule(p)) // expression Branch (10544:13): [True: 36.4k, False: 31]
|
10545 | ) |
10546 | { |
10547 | D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); |
10548 | _res = expression_var; |
10549 | goto done; |
10550 | } |
10551 | p->mark = _mark; |
10552 | D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', |
10553 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); |
10554 | } |
10555 | _res = NULL; |
10556 | done: |
10557 | p->level--; |
10558 | return _res; |
10559 | } |
10560 | |
10561 | // expression: |
10562 | // | invalid_expression |
10563 | // | invalid_legacy_expression |
10564 | // | disjunction 'if' disjunction 'else' expression |
10565 | // | disjunction |
10566 | // | lambdef |
10567 | static expr_ty |
10568 | expression_rule(Parser *p) |
10569 | { |
10570 | if (p->level++ == MAXSTACK) { Branch (10570:9): [True: 0, False: 5.23M]
|
10571 | p->error_indicator = 1; |
10572 | PyErr_NoMemory(); |
10573 | } |
10574 | if (p->error_indicator) { Branch (10574:9): [True: 0, False: 5.23M]
|
10575 | p->level--; |
10576 | return NULL; |
10577 | } |
10578 | expr_ty _res = NULL; |
10579 | if (_PyPegen_is_memoized(p, expression_type, &_res)) { Branch (10579:9): [True: 2.99M, False: 2.24M]
|
10580 | p->level--; |
10581 | return _res; |
10582 | } |
10583 | int _mark = p->mark; |
10584 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (10584:9): [True: 0, False: 2.24M]
Branch (10584:31): [True: 0, False: 0]
|
10585 | p->error_indicator = 1; |
10586 | p->level--; |
10587 | return NULL; |
10588 | } |
10589 | int _start_lineno = p->tokens[_mark]->lineno; |
10590 | UNUSED(_start_lineno); // Only used by EXTRA macro |
10591 | int _start_col_offset = p->tokens[_mark]->col_offset; |
10592 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
10593 | if (p->call_invalid_rules) { // invalid_expression Branch (10593:9): [True: 2.68k, False: 2.23M]
|
10594 | if (p->error_indicator) { Branch (10594:13): [True: 0, False: 2.68k]
|
10595 | p->level--; |
10596 | return NULL; |
10597 | } |
10598 | D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_expression")); |
10599 | void *invalid_expression_var; |
10600 | if ( |
10601 | (invalid_expression_var = invalid_expression_rule(p)) // invalid_expression Branch (10601:13): [True: 0, False: 2.68k]
|
10602 | ) |
10603 | { |
10604 | D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_expression")); |
10605 | _res = invalid_expression_var; |
10606 | goto done; |
10607 | } |
10608 | p->mark = _mark; |
10609 | D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', |
10610 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_expression")); |
10611 | } |
10612 | if (p->call_invalid_rules) { // invalid_legacy_expression Branch (10612:9): [True: 2.68k, False: 2.23M]
|
10613 | if (p->error_indicator) { Branch (10613:13): [True: 29, False: 2.65k]
|
10614 | p->level--; |
10615 | return NULL; |
10616 | } |
10617 | D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_legacy_expression")); |
10618 | void *invalid_legacy_expression_var; |
10619 | if ( |
10620 | (invalid_legacy_expression_var = invalid_legacy_expression_rule(p)) // invalid_legacy_expression Branch (10620:13): [True: 0, False: 2.65k]
|
10621 | ) |
10622 | { |
10623 | D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_legacy_expression")); |
10624 | _res = invalid_legacy_expression_var; |
10625 | goto done; |
10626 | } |
10627 | p->mark = _mark; |
10628 | D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', |
10629 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_legacy_expression")); |
10630 | } |
10631 | { // disjunction 'if' disjunction 'else' expression |
10632 | if (p->error_indicator) { Branch (10632:13): [True: 27, False: 2.24M]
|
10633 | p->level--; |
10634 | return NULL; |
10635 | } |
10636 | D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); |
10637 | Token * _keyword; |
10638 | Token * _keyword_1; |
10639 | expr_ty a; |
10640 | expr_ty b; |
10641 | expr_ty c; |
10642 | if ( |
10643 | (a = disjunction_rule(p)) // disjunction Branch (10643:13): [True: 1.73M, False: 505k]
|
10644 | && |
10645 | (_keyword = _PyPegen_expect_token(p, 634))1.73M // token='if' Branch (10645:13): [True: 919, False: 1.73M]
|
10646 | && |
10647 | (b = disjunction_rule(p))919 // disjunction Branch (10647:13): [True: 909, False: 10]
|
10648 | && |
10649 | (_keyword_1 = _PyPegen_expect_token(p, 637))909 // token='else' Branch (10649:13): [True: 903, False: 6]
|
10650 | && |
10651 | (c = expression_rule(p))903 // expression Branch (10651:13): [True: 903, False: 0]
|
10652 | ) |
10653 | { |
10654 | D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); |
10655 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10656 | if (_token == NULL) { Branch (10656:17): [True: 0, False: 903]
|
10657 | p->level--; |
10658 | return NULL; |
10659 | } |
10660 | int _end_lineno = _token->end_lineno; |
10661 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10662 | int _end_col_offset = _token->end_col_offset; |
10663 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10664 | _res = _PyAST_IfExp ( b , a , c , EXTRA ); |
10665 | if (_res == NULL && PyErr_Occurred()0 ) { |
10666 | p->error_indicator = 1; |
10667 | p->level--; |
10668 | return NULL; |
10669 | } |
10670 | goto done; |
10671 | } |
10672 | p->mark = _mark; |
10673 | D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', |
10674 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); |
10675 | } |
10676 | { // disjunction |
10677 | if (p->error_indicator) { Branch (10677:13): [True: 376, False: 2.23M]
|
10678 | p->level--; |
10679 | return NULL; |
10680 | } |
10681 | D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction")); |
10682 | expr_ty disjunction_var; |
10683 | if ( |
10684 | (disjunction_var = disjunction_rule(p)) // disjunction Branch (10684:13): [True: 1.73M, False: 505k]
|
10685 | ) |
10686 | { |
10687 | D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction")); |
10688 | _res = disjunction_var; |
10689 | goto done; |
10690 | } |
10691 | p->mark = _mark; |
10692 | D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', |
10693 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); |
10694 | } |
10695 | { // lambdef |
10696 | if (p->error_indicator) { Branch (10696:13): [True: 0, False: 505k]
|
10697 | p->level--; |
10698 | return NULL; |
10699 | } |
10700 | D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef")); |
10701 | expr_ty lambdef_var; |
10702 | if ( |
10703 | (lambdef_var = lambdef_rule(p)) // lambdef Branch (10703:13): [True: 1.50k, False: 503k]
|
10704 | ) |
10705 | { |
10706 | D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef")); |
10707 | _res = lambdef_var; |
10708 | goto done; |
10709 | } |
10710 | p->mark = _mark; |
10711 | D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', |
10712 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef")); |
10713 | } |
10714 | _res = NULL; |
10715 | done: |
10716 | _PyPegen_insert_memo(p, _mark, expression_type, _res); |
10717 | p->level--; |
10718 | return _res; |
10719 | } |
10720 | |
10721 | // yield_expr: 'yield' 'from' expression | 'yield' star_expressions? |
10722 | static expr_ty |
10723 | yield_expr_rule(Parser *p) |
10724 | { |
10725 | if (p->level++ == MAXSTACK) { Branch (10725:9): [True: 0, False: 244k]
|
10726 | p->error_indicator = 1; |
10727 | PyErr_NoMemory(); |
10728 | } |
10729 | if (p->error_indicator) { Branch (10729:9): [True: 0, False: 244k]
|
10730 | p->level--; |
10731 | return NULL; |
10732 | } |
10733 | expr_ty _res = NULL; |
10734 | int _mark = p->mark; |
10735 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 02.41k ) { Branch (10735:9): [True: 2.41k, False: 242k]
Branch (10735:31): [True: 0, False: 2.41k]
|
10736 | p->error_indicator = 1; |
10737 | p->level--; |
10738 | return NULL; |
10739 | } |
10740 | int _start_lineno = p->tokens[_mark]->lineno; |
10741 | UNUSED(_start_lineno); // Only used by EXTRA macro |
10742 | int _start_col_offset = p->tokens[_mark]->col_offset; |
10743 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
10744 | { // 'yield' 'from' expression |
10745 | if (p->error_indicator) { Branch (10745:13): [True: 0, False: 244k]
|
10746 | p->level--; |
10747 | return NULL; |
10748 | } |
10749 | D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression")); |
10750 | Token * _keyword; |
10751 | Token * _keyword_1; |
10752 | expr_ty a; |
10753 | if ( |
10754 | (_keyword = _PyPegen_expect_token(p, 573)) // token='yield' Branch (10754:13): [True: 1.19k, False: 243k]
|
10755 | && |
10756 | (_keyword_1 = _PyPegen_expect_token(p, 572))1.19k // token='from' Branch (10756:13): [True: 197, False: 1.00k]
|
10757 | && |
10758 | (a = expression_rule(p))197 // expression Branch (10758:13): [True: 194, False: 3]
|
10759 | ) |
10760 | { |
10761 | D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression")); |
10762 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10763 | if (_token == NULL) { Branch (10763:17): [True: 0, False: 194]
|
10764 | p->level--; |
10765 | return NULL; |
10766 | } |
10767 | int _end_lineno = _token->end_lineno; |
10768 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10769 | int _end_col_offset = _token->end_col_offset; |
10770 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10771 | _res = _PyAST_YieldFrom ( a , EXTRA ); |
10772 | if (_res == NULL && PyErr_Occurred()0 ) { |
10773 | p->error_indicator = 1; |
10774 | p->level--; |
10775 | return NULL; |
10776 | } |
10777 | goto done; |
10778 | } |
10779 | p->mark = _mark; |
10780 | D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ', |
10781 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' 'from' expression")); |
10782 | } |
10783 | { // 'yield' star_expressions? |
10784 | if (p->error_indicator) { Branch (10784:13): [True: 0, False: 244k]
|
10785 | p->level--; |
10786 | return NULL; |
10787 | } |
10788 | D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?")); |
10789 | Token * _keyword; |
10790 | void *a; |
10791 | if ( |
10792 | (_keyword = _PyPegen_expect_token(p, 573)) // token='yield' Branch (10792:13): [True: 1.00k, False: 243k]
|
10793 | && |
10794 | (a = star_expressions_rule(p), !p->error_indicator)1.00k // star_expressions? Branch (10794:13): [True: 1.00k, False: 0]
|
10795 | ) |
10796 | { |
10797 | D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?")); |
10798 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10799 | if (_token == NULL) { Branch (10799:17): [True: 0, False: 1.00k]
|
10800 | p->level--; |
10801 | return NULL; |
10802 | } |
10803 | int _end_lineno = _token->end_lineno; |
10804 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10805 | int _end_col_offset = _token->end_col_offset; |
10806 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10807 | _res = _PyAST_Yield ( a , EXTRA ); |
10808 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (10808:17): [True: 0, False: 1.00k]
Branch (10808:33): [True: 0, False: 0]
|
10809 | p->error_indicator = 1; |
10810 | p->level--; |
10811 | return NULL; |
10812 | } |
10813 | goto done; |
10814 | } |
10815 | p->mark = _mark; |
10816 | D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ', |
10817 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' star_expressions?")); |
10818 | } |
10819 | _res = NULL; |
10820 | done: |
10821 | p->level--; |
10822 | return _res; |
10823 | } |
10824 | |
10825 | // star_expressions: |
10826 | // | star_expression ((',' star_expression))+ ','? |
10827 | // | star_expression ',' |
10828 | // | star_expression |
10829 | static expr_ty |
10830 | star_expressions_rule(Parser *p) |
10831 | { |
10832 | if (p->level++ == MAXSTACK) { Branch (10832:9): [True: 0, False: 583k]
|
10833 | p->error_indicator = 1; |
10834 | PyErr_NoMemory(); |
10835 | } |
10836 | if (p->error_indicator) { Branch (10836:9): [True: 0, False: 583k]
|
10837 | p->level--; |
10838 | return NULL; |
10839 | } |
10840 | expr_ty _res = NULL; |
10841 | int _mark = p->mark; |
10842 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 098.3k ) { Branch (10842:9): [True: 98.3k, False: 484k]
Branch (10842:31): [True: 0, False: 98.3k]
|
10843 | p->error_indicator = 1; |
10844 | p->level--; |
10845 | return NULL; |
10846 | } |
10847 | int _start_lineno = p->tokens[_mark]->lineno; |
10848 | UNUSED(_start_lineno); // Only used by EXTRA macro |
10849 | int _start_col_offset = p->tokens[_mark]->col_offset; |
10850 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
10851 | { // star_expression ((',' star_expression))+ ','? |
10852 | if (p->error_indicator) { Branch (10852:13): [True: 0, False: 583k]
|
10853 | p->level--; |
10854 | return NULL; |
10855 | } |
10856 | D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?")); |
10857 | void *_opt_var; |
10858 | UNUSED(_opt_var); // Silence compiler warnings |
10859 | expr_ty a; |
10860 | asdl_seq * b; |
10861 | if ( |
10862 | (a = star_expression_rule(p)) // star_expression Branch (10862:13): [True: 438k, False: 144k]
|
10863 | && |
10864 | (b = _loop1_81_rule(p))438k // ((',' star_expression))+ Branch (10864:13): [True: 1.71k, False: 436k]
|
10865 | && |
10866 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)1.71k // ','? Branch (10866:13): [True: 1.71k, False: 0]
|
10867 | ) |
10868 | { |
10869 | D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?")); |
10870 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10871 | if (_token == NULL) { Branch (10871:17): [True: 0, False: 1.71k]
|
10872 | p->level--; |
10873 | return NULL; |
10874 | } |
10875 | int _end_lineno = _token->end_lineno; |
10876 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10877 | int _end_col_offset = _token->end_col_offset; |
10878 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10879 | _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA ); |
10880 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (10880:17): [True: 0, False: 1.71k]
Branch (10880:33): [True: 0, False: 0]
|
10881 | p->error_indicator = 1; |
10882 | p->level--; |
10883 | return NULL; |
10884 | } |
10885 | goto done; |
10886 | } |
10887 | p->mark = _mark; |
10888 | D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
10889 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ((',' star_expression))+ ','?")); |
10890 | } |
10891 | { // star_expression ',' |
10892 | if (p->error_indicator) { Branch (10892:13): [True: 27, False: 581k]
|
10893 | p->level--; |
10894 | return NULL; |
10895 | } |
10896 | D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ','")); |
10897 | Token * _literal; |
10898 | expr_ty a; |
10899 | if ( |
10900 | (a = star_expression_rule(p)) // star_expression Branch (10900:13): [True: 436k, False: 144k]
|
10901 | && |
10902 | (_literal = _PyPegen_expect_token(p, 12))436k // token=',' Branch (10902:13): [True: 23, False: 436k]
|
10903 | ) |
10904 | { |
10905 | D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','")); |
10906 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10907 | if (_token == NULL) { |
10908 | p->level--; |
10909 | return NULL; |
10910 | } |
10911 | int _end_lineno = _token->end_lineno; |
10912 | UNUSED(_end_lineno); // Only used by EXTRA macro |
10913 | int _end_col_offset = _token->end_col_offset; |
10914 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
10915 | _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA ); |
10916 | if (_res == NULL && PyErr_Occurred()0 ) { |
10917 | p->error_indicator = 1; |
10918 | p->level--; |
10919 | return NULL; |
10920 | } |
10921 | goto done; |
10922 | } |
10923 | p->mark = _mark; |
10924 | D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
10925 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ','")); |
10926 | } |
10927 | { // star_expression |
10928 | if (p->error_indicator) { Branch (10928:13): [True: 0, False: 581k]
|
10929 | p->level--; |
10930 | return NULL; |
10931 | } |
10932 | D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression")); |
10933 | expr_ty star_expression_var; |
10934 | if ( |
10935 | (star_expression_var = star_expression_rule(p)) // star_expression Branch (10935:13): [True: 436k, False: 144k]
|
10936 | ) |
10937 | { |
10938 | D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression")); |
10939 | _res = star_expression_var; |
10940 | goto done; |
10941 | } |
10942 | p->mark = _mark; |
10943 | D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
10944 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression")); |
10945 | } |
10946 | _res = NULL; |
10947 | done: |
10948 | p->level--; |
10949 | return _res; |
10950 | } |
10951 | |
10952 | // star_expression: '*' bitwise_or | expression |
10953 | static expr_ty |
10954 | star_expression_rule(Parser *p) |
10955 | { |
10956 | if (p->level++ == MAXSTACK) { Branch (10956:9): [True: 0, False: 1.74M]
|
10957 | p->error_indicator = 1; |
10958 | PyErr_NoMemory(); |
10959 | } |
10960 | if (p->error_indicator) { Branch (10960:9): [True: 0, False: 1.74M]
|
10961 | p->level--; |
10962 | return NULL; |
10963 | } |
10964 | expr_ty _res = NULL; |
10965 | if (_PyPegen_is_memoized(p, star_expression_type, &_res)) { Branch (10965:9): [True: 1.16M, False: 584k]
|
10966 | p->level--; |
10967 | return _res; |
10968 | } |
10969 | int _mark = p->mark; |
10970 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (10970:9): [True: 0, False: 584k]
Branch (10970:31): [True: 0, False: 0]
|
10971 | p->error_indicator = 1; |
10972 | p->level--; |
10973 | return NULL; |
10974 | } |
10975 | int _start_lineno = p->tokens[_mark]->lineno; |
10976 | UNUSED(_start_lineno); // Only used by EXTRA macro |
10977 | int _start_col_offset = p->tokens[_mark]->col_offset; |
10978 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
10979 | { // '*' bitwise_or |
10980 | if (p->error_indicator) { Branch (10980:13): [True: 0, False: 584k]
|
10981 | p->level--; |
10982 | return NULL; |
10983 | } |
10984 | D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); |
10985 | Token * _literal; |
10986 | expr_ty a; |
10987 | if ( |
10988 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (10988:13): [True: 43, False: 584k]
|
10989 | && |
10990 | (a = bitwise_or_rule(p))43 // bitwise_or |
10991 | ) |
10992 | { |
10993 | D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); |
10994 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
10995 | if (_token == NULL) { |
10996 | p->level--; |
10997 | return NULL; |
10998 | } |
10999 | int _end_lineno = _token->end_lineno; |
11000 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11001 | int _end_col_offset = _token->end_col_offset; |
11002 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11003 | _res = _PyAST_Starred ( a , Load , EXTRA ); |
11004 | if (_res == NULL && PyErr_Occurred()0 ) { |
11005 | p->error_indicator = 1; |
11006 | p->level--; |
11007 | return NULL; |
11008 | } |
11009 | goto done; |
11010 | } |
11011 | p->mark = _mark; |
11012 | D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11013 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); |
11014 | } |
11015 | { // expression |
11016 | if (p->error_indicator) { Branch (11016:13): [True: 0, False: 584k]
|
11017 | p->level--; |
11018 | return NULL; |
11019 | } |
11020 | D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); |
11021 | expr_ty expression_var; |
11022 | if ( |
11023 | (expression_var = expression_rule(p)) // expression Branch (11023:13): [True: 440k, False: 143k]
|
11024 | ) |
11025 | { |
11026 | D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); |
11027 | _res = expression_var; |
11028 | goto done; |
11029 | } |
11030 | p->mark = _mark; |
11031 | D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11032 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); |
11033 | } |
11034 | _res = NULL; |
11035 | done: |
11036 | _PyPegen_insert_memo(p, _mark, star_expression_type, _res); |
11037 | p->level--; |
11038 | return _res; |
11039 | } |
11040 | |
11041 | // star_named_expressions: ','.star_named_expression+ ','? |
11042 | static asdl_expr_seq* |
11043 | star_named_expressions_rule(Parser *p) |
11044 | { |
11045 | if (p->level++ == MAXSTACK) { Branch (11045:9): [True: 0, False: 97.3k]
|
11046 | p->error_indicator = 1; |
11047 | PyErr_NoMemory(); |
11048 | } |
11049 | if (p->error_indicator) { Branch (11049:9): [True: 0, False: 97.3k]
|
11050 | p->level--; |
11051 | return NULL; |
11052 | } |
11053 | asdl_expr_seq* _res = NULL; |
11054 | int _mark = p->mark; |
11055 | { // ','.star_named_expression+ ','? |
11056 | if (p->error_indicator) { Branch (11056:13): [True: 0, False: 97.3k]
|
11057 | p->level--; |
11058 | return NULL; |
11059 | } |
11060 | D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?")); |
11061 | void *_opt_var; |
11062 | UNUSED(_opt_var); // Silence compiler warnings |
11063 | asdl_expr_seq* a; |
11064 | if ( |
11065 | (a = (asdl_expr_seq*)_gather_82_rule(p)) // ','.star_named_expression+ Branch (11065:13): [True: 40.4k, False: 56.9k]
|
11066 | && |
11067 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)40.4k // ','? Branch (11067:13): [True: 40.3k, False: 27]
|
11068 | ) |
11069 | { |
11070 | D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?")); |
11071 | _res = a; |
11072 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11072:17): [True: 0, False: 40.3k]
Branch (11072:33): [True: 0, False: 0]
|
11073 | p->error_indicator = 1; |
11074 | p->level--; |
11075 | return NULL; |
11076 | } |
11077 | goto done; |
11078 | } |
11079 | p->mark = _mark; |
11080 | D(fprintf(stderr, "%*c%s star_named_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
11081 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression+ ','?")); |
11082 | } |
11083 | _res = NULL; |
11084 | done: |
11085 | p->level--; |
11086 | return _res; |
11087 | } |
11088 | |
11089 | // star_named_expression: '*' bitwise_or | named_expression |
11090 | static expr_ty |
11091 | star_named_expression_rule(Parser *p) |
11092 | { |
11093 | if (p->level++ == MAXSTACK) { Branch (11093:9): [True: 0, False: 953k]
|
11094 | p->error_indicator = 1; |
11095 | PyErr_NoMemory(); |
11096 | } |
11097 | if (p->error_indicator) { Branch (11097:9): [True: 0, False: 953k]
|
11098 | p->level--; |
11099 | return NULL; |
11100 | } |
11101 | expr_ty _res = NULL; |
11102 | int _mark = p->mark; |
11103 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0397k ) { Branch (11103:9): [True: 397k, False: 555k]
Branch (11103:31): [True: 44, False: 397k]
|
11104 | p->error_indicator = 1; |
11105 | p->level--; |
11106 | return NULL; |
11107 | } |
11108 | int _start_lineno = p->tokens[_mark]->lineno; |
11109 | UNUSED(_start_lineno); // Only used by EXTRA macro |
11110 | int _start_col_offset = p->tokens[_mark]->col_offset; |
11111 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
11112 | { // '*' bitwise_or |
11113 | if (p->error_indicator) { Branch (11113:13): [True: 0, False: 953k]
|
11114 | p->level--; |
11115 | return NULL; |
11116 | } |
11117 | D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); |
11118 | Token * _literal; |
11119 | expr_ty a; |
11120 | if ( |
11121 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (11121:13): [True: 528, False: 952k]
|
11122 | && |
11123 | (a = bitwise_or_rule(p))528 // bitwise_or Branch (11123:13): [True: 503, False: 25]
|
11124 | ) |
11125 | { |
11126 | D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); |
11127 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
11128 | if (_token == NULL) { Branch (11128:17): [True: 0, False: 503]
|
11129 | p->level--; |
11130 | return NULL; |
11131 | } |
11132 | int _end_lineno = _token->end_lineno; |
11133 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11134 | int _end_col_offset = _token->end_col_offset; |
11135 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11136 | _res = _PyAST_Starred ( a , Load , EXTRA ); |
11137 | if (_res == NULL && PyErr_Occurred()0 ) { |
11138 | p->error_indicator = 1; |
11139 | p->level--; |
11140 | return NULL; |
11141 | } |
11142 | goto done; |
11143 | } |
11144 | p->mark = _mark; |
11145 | D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11146 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); |
11147 | } |
11148 | { // named_expression |
11149 | if (p->error_indicator) { Branch (11149:13): [True: 0, False: 952k]
|
11150 | p->level--; |
11151 | return NULL; |
11152 | } |
11153 | D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); |
11154 | expr_ty named_expression_var; |
11155 | if ( |
11156 | (named_expression_var = named_expression_rule(p)) // named_expression Branch (11156:13): [True: 890k, False: 61.8k]
|
11157 | ) |
11158 | { |
11159 | D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); |
11160 | _res = named_expression_var; |
11161 | goto done; |
11162 | } |
11163 | p->mark = _mark; |
11164 | D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11165 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); |
11166 | } |
11167 | _res = NULL; |
11168 | done: |
11169 | p->level--; |
11170 | return _res; |
11171 | } |
11172 | |
11173 | // assignment_expression: NAME ':=' ~ expression |
11174 | static expr_ty |
11175 | assignment_expression_rule(Parser *p) |
11176 | { |
11177 | if (p->level++ == MAXSTACK) { Branch (11177:9): [True: 0, False: 3.45M]
|
11178 | p->error_indicator = 1; |
11179 | PyErr_NoMemory(); |
11180 | } |
11181 | if (p->error_indicator) { Branch (11181:9): [True: 0, False: 3.45M]
|
11182 | p->level--; |
11183 | return NULL; |
11184 | } |
11185 | expr_ty _res = NULL; |
11186 | int _mark = p->mark; |
11187 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0644k ) { Branch (11187:9): [True: 644k, False: 2.81M]
Branch (11187:31): [True: 13, False: 644k]
|
11188 | p->error_indicator = 1; |
11189 | p->level--; |
11190 | return NULL; |
11191 | } |
11192 | int _start_lineno = p->tokens[_mark]->lineno; |
11193 | UNUSED(_start_lineno); // Only used by EXTRA macro |
11194 | int _start_col_offset = p->tokens[_mark]->col_offset; |
11195 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
11196 | { // NAME ':=' ~ expression |
11197 | if (p->error_indicator) { Branch (11197:13): [True: 0, False: 3.45M]
|
11198 | p->level--; |
11199 | return NULL; |
11200 | } |
11201 | D(fprintf(stderr, "%*c> assignment_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression")); |
11202 | int _cut_var = 0; |
11203 | Token * _literal; |
11204 | expr_ty a; |
11205 | expr_ty b; |
11206 | if ( |
11207 | (a = _PyPegen_name_token(p)) // NAME Branch (11207:13): [True: 1.05M, False: 2.40M]
|
11208 | && |
11209 | (_literal = _PyPegen_expect_token(p, 53))1.05M // token=':=' Branch (11209:13): [True: 1.37k, False: 1.05M]
|
11210 | && |
11211 | (_cut_var = 1)1.37k Branch (11211:13): [True: 1.37k, False: 0]
|
11212 | && |
11213 | (b = expression_rule(p))1.37k // expression Branch (11213:13): [True: 1.37k, False: 0]
|
11214 | ) |
11215 | { |
11216 | D(fprintf(stderr, "%*c+ assignment_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression")); |
11217 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
11218 | if (_token == NULL) { Branch (11218:17): [True: 0, False: 1.37k]
|
11219 | p->level--; |
11220 | return NULL; |
11221 | } |
11222 | int _end_lineno = _token->end_lineno; |
11223 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11224 | int _end_col_offset = _token->end_col_offset; |
11225 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11226 | _res = _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA ); |
11227 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11227:17): [True: 0, False: 1.37k]
Branch (11227:33): [True: 0, False: 0]
|
11228 | p->error_indicator = 1; |
11229 | p->level--; |
11230 | return NULL; |
11231 | } |
11232 | goto done; |
11233 | } |
11234 | p->mark = _mark; |
11235 | D(fprintf(stderr, "%*c%s assignment_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11236 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression")); |
11237 | if (_cut_var) { Branch (11237:13): [True: 0, False: 3.45M]
|
11238 | p->level--; |
11239 | return NULL; |
11240 | } |
11241 | } |
11242 | _res = NULL; |
11243 | done: |
11244 | p->level--; |
11245 | return _res; |
11246 | } |
11247 | |
11248 | // named_expression: assignment_expression | invalid_named_expression | expression !':=' |
11249 | static expr_ty |
11250 | named_expression_rule(Parser *p) |
11251 | { |
11252 | if (p->level++ == MAXSTACK) { Branch (11252:9): [True: 0, False: 2.20M]
|
11253 | p->error_indicator = 1; |
11254 | PyErr_NoMemory(); |
11255 | } |
11256 | if (p->error_indicator) { Branch (11256:9): [True: 0, False: 2.20M]
|
11257 | p->level--; |
11258 | return NULL; |
11259 | } |
11260 | expr_ty _res = NULL; |
11261 | int _mark = p->mark; |
11262 | { // assignment_expression |
11263 | if (p->error_indicator) { Branch (11263:13): [True: 0, False: 2.20M]
|
11264 | p->level--; |
11265 | return NULL; |
11266 | } |
11267 | D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); |
11268 | expr_ty assignment_expression_var; |
11269 | if ( |
11270 | (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression Branch (11270:13): [True: 1.36k, False: 2.20M]
|
11271 | ) |
11272 | { |
11273 | D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); |
11274 | _res = assignment_expression_var; |
11275 | goto done; |
11276 | } |
11277 | p->mark = _mark; |
11278 | D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11279 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); |
11280 | } |
11281 | if (p->call_invalid_rules) { // invalid_named_expression Branch (11281:9): [True: 2.41k, False: 2.20M]
|
11282 | if (p->error_indicator) { Branch (11282:13): [True: 0, False: 2.41k]
|
11283 | p->level--; |
11284 | return NULL; |
11285 | } |
11286 | D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_named_expression")); |
11287 | void *invalid_named_expression_var; |
11288 | if ( |
11289 | (invalid_named_expression_var = invalid_named_expression_rule(p)) // invalid_named_expression Branch (11289:13): [True: 0, False: 2.41k]
|
11290 | ) |
11291 | { |
11292 | D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_named_expression")); |
11293 | _res = invalid_named_expression_var; |
11294 | goto done; |
11295 | } |
11296 | p->mark = _mark; |
11297 | D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11298 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression")); |
11299 | } |
11300 | { // expression !':=' |
11301 | if (p->error_indicator) { Branch (11301:13): [True: 126, False: 2.20M]
|
11302 | p->level--; |
11303 | return NULL; |
11304 | } |
11305 | D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); |
11306 | expr_ty expression_var; |
11307 | if ( |
11308 | (expression_var = expression_rule(p)) // expression Branch (11308:13): [True: 2.14M, False: 64.4k]
|
11309 | && |
11310 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)2.14M // token=':=' Branch (11310:13): [True: 2.14M, False: 12]
|
11311 | ) |
11312 | { |
11313 | D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); |
11314 | _res = expression_var; |
11315 | goto done; |
11316 | } |
11317 | p->mark = _mark; |
11318 | D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
11319 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); |
11320 | } |
11321 | _res = NULL; |
11322 | done: |
11323 | p->level--; |
11324 | return _res; |
11325 | } |
11326 | |
11327 | // disjunction: conjunction (('or' conjunction))+ | conjunction |
11328 | static expr_ty |
11329 | disjunction_rule(Parser *p) |
11330 | { |
11331 | if (p->level++ == MAXSTACK) { Branch (11331:9): [True: 0, False: 4.49M]
|
11332 | p->error_indicator = 1; |
11333 | PyErr_NoMemory(); |
11334 | } |
11335 | if (p->error_indicator) { Branch (11335:9): [True: 0, False: 4.49M]
|
11336 | p->level--; |
11337 | return NULL; |
11338 | } |
11339 | expr_ty _res = NULL; |
11340 | if (_PyPegen_is_memoized(p, disjunction_type, &_res)) { Branch (11340:9): [True: 2.24M, False: 2.24M]
|
11341 | p->level--; |
11342 | return _res; |
11343 | } |
11344 | int _mark = p->mark; |
11345 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (11345:9): [True: 0, False: 2.24M]
Branch (11345:31): [True: 0, False: 0]
|
11346 | p->error_indicator = 1; |
11347 | p->level--; |
11348 | return NULL; |
11349 | } |
11350 | int _start_lineno = p->tokens[_mark]->lineno; |
11351 | UNUSED(_start_lineno); // Only used by EXTRA macro |
11352 | int _start_col_offset = p->tokens[_mark]->col_offset; |
11353 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
11354 | { // conjunction (('or' conjunction))+ |
11355 | if (p->error_indicator) { Branch (11355:13): [True: 0, False: 2.24M]
|
11356 | p->level--; |
11357 | return NULL; |
11358 | } |
11359 | D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+")); |
11360 | expr_ty a; |
11361 | asdl_seq * b; |
11362 | if ( |
11363 | (a = conjunction_rule(p)) // conjunction Branch (11363:13): [True: 1.73M, False: 506k]
|
11364 | && |
11365 | (b = _loop1_84_rule(p))1.73M // (('or' conjunction))+ Branch (11365:13): [True: 2.39k, False: 1.73M]
|
11366 | ) |
11367 | { |
11368 | D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+")); |
11369 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
11370 | if (_token == NULL) { Branch (11370:17): [True: 0, False: 2.39k]
|
11371 | p->level--; |
11372 | return NULL; |
11373 | } |
11374 | int _end_lineno = _token->end_lineno; |
11375 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11376 | int _end_col_offset = _token->end_col_offset; |
11377 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11378 | _res = _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA ); |
11379 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11379:17): [True: 0, False: 2.39k]
Branch (11379:33): [True: 0, False: 0]
|
11380 | p->error_indicator = 1; |
11381 | p->level--; |
11382 | return NULL; |
11383 | } |
11384 | goto done; |
11385 | } |
11386 | p->mark = _mark; |
11387 | D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ', |
11388 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction (('or' conjunction))+")); |
11389 | } |
11390 | { // conjunction |
11391 | if (p->error_indicator) { Branch (11391:13): [True: 386, False: 2.24M]
|
11392 | p->level--; |
11393 | return NULL; |
11394 | } |
11395 | D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction")); |
11396 | expr_ty conjunction_var; |
11397 | if ( |
11398 | (conjunction_var = conjunction_rule(p)) // conjunction Branch (11398:13): [True: 1.73M, False: 505k]
|
11399 | ) |
11400 | { |
11401 | D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction")); |
11402 | _res = conjunction_var; |
11403 | goto done; |
11404 | } |
11405 | p->mark = _mark; |
11406 | D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ', |
11407 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction")); |
11408 | } |
11409 | _res = NULL; |
11410 | done: |
11411 | _PyPegen_insert_memo(p, _mark, disjunction_type, _res); |
11412 | p->level--; |
11413 | return _res; |
11414 | } |
11415 | |
11416 | // conjunction: inversion (('and' inversion))+ | inversion |
11417 | static expr_ty |
11418 | conjunction_rule(Parser *p) |
11419 | { |
11420 | if (p->level++ == MAXSTACK) { Branch (11420:9): [True: 0, False: 4.49M]
|
11421 | p->error_indicator = 1; |
11422 | PyErr_NoMemory(); |
11423 | } |
11424 | if (p->error_indicator) { Branch (11424:9): [True: 0, False: 4.49M]
|
11425 | p->level--; |
11426 | return NULL; |
11427 | } |
11428 | expr_ty _res = NULL; |
11429 | if (_PyPegen_is_memoized(p, conjunction_type, &_res)) { Branch (11429:9): [True: 2.24M, False: 2.24M]
|
11430 | p->level--; |
11431 | return _res; |
11432 | } |
11433 | int _mark = p->mark; |
11434 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (11434:9): [True: 0, False: 2.24M]
Branch (11434:31): [True: 0, False: 0]
|
11435 | p->error_indicator = 1; |
11436 | p->level--; |
11437 | return NULL; |
11438 | } |
11439 | int _start_lineno = p->tokens[_mark]->lineno; |
11440 | UNUSED(_start_lineno); // Only used by EXTRA macro |
11441 | int _start_col_offset = p->tokens[_mark]->col_offset; |
11442 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
11443 | { // inversion (('and' inversion))+ |
11444 | if (p->error_indicator) { Branch (11444:13): [True: 0, False: 2.24M]
|
11445 | p->level--; |
11446 | return NULL; |
11447 | } |
11448 | D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+")); |
11449 | expr_ty a; |
11450 | asdl_seq * b; |
11451 | if ( |
11452 | (a = inversion_rule(p)) // inversion Branch (11452:13): [True: 1.74M, False: 506k]
|
11453 | && |
11454 | (b = _loop1_85_rule(p))1.74M // (('and' inversion))+ Branch (11454:13): [True: 3.83k, False: 1.73M]
|
11455 | ) |
11456 | { |
11457 | D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+")); |
11458 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
11459 | if (_token == NULL) { Branch (11459:17): [True: 0, False: 3.83k]
|
11460 | p->level--; |
11461 | return NULL; |
11462 | } |
11463 | int _end_lineno = _token->end_lineno; |
11464 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11465 | int _end_col_offset = _token->end_col_offset; |
11466 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11467 | _res = _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA ); |
11468 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11468:17): [True: 0, False: 3.83k]
Branch (11468:33): [True: 0, False: 0]
|
11469 | p->error_indicator = 1; |
11470 | p->level--; |
11471 | return NULL; |
11472 | } |
11473 | goto done; |
11474 | } |
11475 | p->mark = _mark; |
11476 | D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ', |
11477 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion (('and' inversion))+")); |
11478 | } |
11479 | { // inversion |
11480 | if (p->error_indicator) { Branch (11480:13): [True: 386, False: 2.24M]
|
11481 | p->level--; |
11482 | return NULL; |
11483 | } |
11484 | D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion")); |
11485 | expr_ty inversion_var; |
11486 | if ( |
11487 | (inversion_var = inversion_rule(p)) // inversion Branch (11487:13): [True: 1.73M, False: 505k]
|
11488 | ) |
11489 | { |
11490 | D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion")); |
11491 | _res = inversion_var; |
11492 | goto done; |
11493 | } |
11494 | p->mark = _mark; |
11495 | D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ', |
11496 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion")); |
11497 | } |
11498 | _res = NULL; |
11499 | done: |
11500 | _PyPegen_insert_memo(p, _mark, conjunction_type, _res); |
11501 | p->level--; |
11502 | return _res; |
11503 | } |
11504 | |
11505 | // inversion: 'not' inversion | comparison |
11506 | static expr_ty |
11507 | inversion_rule(Parser *p) |
11508 | { |
11509 | if (p->level++ == MAXSTACK) { Branch (11509:9): [True: 0, False: 4.50M]
|
11510 | p->error_indicator = 1; |
11511 | PyErr_NoMemory(); |
11512 | } |
11513 | if (p->error_indicator) { Branch (11513:9): [True: 0, False: 4.50M]
|
11514 | p->level--; |
11515 | return NULL; |
11516 | } |
11517 | expr_ty _res = NULL; |
11518 | if (_PyPegen_is_memoized(p, inversion_type, &_res)) { Branch (11518:9): [True: 2.24M, False: 2.25M]
|
11519 | p->level--; |
11520 | return _res; |
11521 | } |
11522 | int _mark = p->mark; |
11523 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (11523:9): [True: 0, False: 2.25M]
Branch (11523:31): [True: 0, False: 0]
|
11524 | p->error_indicator = 1; |
11525 | p->level--; |
11526 | return NULL; |
11527 | } |
11528 | int _start_lineno = p->tokens[_mark]->lineno; |
11529 | UNUSED(_start_lineno); // Only used by EXTRA macro |
11530 | int _start_col_offset = p->tokens[_mark]->col_offset; |
11531 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
11532 | { // 'not' inversion |
11533 | if (p->error_indicator) { Branch (11533:13): [True: 0, False: 2.25M]
|
11534 | p->level--; |
11535 | return NULL; |
11536 | } |
11537 | D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion")); |
11538 | Token * _keyword; |
11539 | expr_ty a; |
11540 | if ( |
11541 | (_keyword = _PyPegen_expect_token(p, 581)) // token='not' Branch (11541:13): [True: 5.13k, False: 2.25M]
|
11542 | && |
11543 | (a = inversion_rule(p))5.13k // inversion Branch (11543:13): [True: 5.13k, False: 2]
|
11544 | ) |
11545 | { |
11546 | D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion")); |
11547 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
11548 | if (_token == NULL) { Branch (11548:17): [True: 0, False: 5.13k]
|
11549 | p->level--; |
11550 | return NULL; |
11551 | } |
11552 | int _end_lineno = _token->end_lineno; |
11553 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11554 | int _end_col_offset = _token->end_col_offset; |
11555 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11556 | _res = _PyAST_UnaryOp ( Not , a , EXTRA ); |
11557 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11557:17): [True: 0, False: 5.13k]
Branch (11557:33): [True: 0, False: 0]
|
11558 | p->error_indicator = 1; |
11559 | p->level--; |
11560 | return NULL; |
11561 | } |
11562 | goto done; |
11563 | } |
11564 | p->mark = _mark; |
11565 | D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', |
11566 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion")); |
11567 | } |
11568 | { // comparison |
11569 | if (p->error_indicator) { Branch (11569:13): [True: 0, False: 2.25M]
|
11570 | p->level--; |
11571 | return NULL; |
11572 | } |
11573 | D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison")); |
11574 | expr_ty comparison_var; |
11575 | if ( |
11576 | (comparison_var = comparison_rule(p)) // comparison Branch (11576:13): [True: 1.74M, False: 506k]
|
11577 | ) |
11578 | { |
11579 | D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "comparison")); |
11580 | _res = comparison_var; |
11581 | goto done; |
11582 | } |
11583 | p->mark = _mark; |
11584 | D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', |
11585 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison")); |
11586 | } |
11587 | _res = NULL; |
11588 | done: |
11589 | _PyPegen_insert_memo(p, _mark, inversion_type, _res); |
11590 | p->level--; |
11591 | return _res; |
11592 | } |
11593 | |
11594 | // comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or |
11595 | static expr_ty |
11596 | comparison_rule(Parser *p) |
11597 | { |
11598 | if (p->level++ == MAXSTACK) { Branch (11598:9): [True: 0, False: 2.25M]
|
11599 | p->error_indicator = 1; |
11600 | PyErr_NoMemory(); |
11601 | } |
11602 | if (p->error_indicator) { Branch (11602:9): [True: 0, False: 2.25M]
|
11603 | p->level--; |
11604 | return NULL; |
11605 | } |
11606 | expr_ty _res = NULL; |
11607 | int _mark = p->mark; |
11608 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (11608:9): [True: 0, False: 2.25M]
Branch (11608:31): [True: 0, False: 0]
|
11609 | p->error_indicator = 1; |
11610 | p->level--; |
11611 | return NULL; |
11612 | } |
11613 | int _start_lineno = p->tokens[_mark]->lineno; |
11614 | UNUSED(_start_lineno); // Only used by EXTRA macro |
11615 | int _start_col_offset = p->tokens[_mark]->col_offset; |
11616 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
11617 | { // bitwise_or compare_op_bitwise_or_pair+ |
11618 | if (p->error_indicator) { Branch (11618:13): [True: 0, False: 2.25M]
|
11619 | p->level--; |
11620 | return NULL; |
11621 | } |
11622 | D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); |
11623 | expr_ty a; |
11624 | asdl_seq * b; |
11625 | if ( |
11626 | (a = bitwise_or_rule(p)) // bitwise_or Branch (11626:13): [True: 1.74M, False: 506k]
|
11627 | && |
11628 | (b = _loop1_86_rule(p))1.74M // compare_op_bitwise_or_pair+ Branch (11628:13): [True: 21.9k, False: 1.72M]
|
11629 | ) |
11630 | { |
11631 | D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); |
11632 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
11633 | if (_token == NULL) { Branch (11633:17): [True: 0, False: 21.9k]
|
11634 | p->level--; |
11635 | return NULL; |
11636 | } |
11637 | int _end_lineno = _token->end_lineno; |
11638 | UNUSED(_end_lineno); // Only used by EXTRA macro |
11639 | int _end_col_offset = _token->end_col_offset; |
11640 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
11641 | _res = _PyAST_Compare ( a , CHECK ( asdl_int_seq* , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_exprs ( p , b ) ) , EXTRA ); |
11642 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11642:17): [True: 0, False: 21.9k]
Branch (11642:33): [True: 0, False: 0]
|
11643 | p->error_indicator = 1; |
11644 | p->level--; |
11645 | return NULL; |
11646 | } |
11647 | goto done; |
11648 | } |
11649 | p->mark = _mark; |
11650 | D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ', |
11651 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); |
11652 | } |
11653 | { // bitwise_or |
11654 | if (p->error_indicator) { Branch (11654:13): [True: 386, False: 2.23M]
|
11655 | p->level--; |
11656 | return NULL; |
11657 | } |
11658 | D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or")); |
11659 | expr_ty bitwise_or_var; |
11660 | if ( |
11661 | (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or Branch (11661:13): [True: 1.72M, False: 505k]
|
11662 | ) |
11663 | { |
11664 | D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or")); |
11665 | _res = bitwise_or_var; |
11666 | goto done; |
11667 | } |
11668 | p->mark = _mark; |
11669 | D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ', |
11670 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or")); |
11671 | } |
11672 | _res = NULL; |
11673 | done: |
11674 | p->level--; |
11675 | return _res; |
11676 | } |
11677 | |
11678 | // compare_op_bitwise_or_pair: |
11679 | // | eq_bitwise_or |
11680 | // | noteq_bitwise_or |
11681 | // | lte_bitwise_or |
11682 | // | lt_bitwise_or |
11683 | // | gte_bitwise_or |
11684 | // | gt_bitwise_or |
11685 | // | notin_bitwise_or |
11686 | // | in_bitwise_or |
11687 | // | isnot_bitwise_or |
11688 | // | is_bitwise_or |
11689 | static CmpopExprPair* |
11690 | compare_op_bitwise_or_pair_rule(Parser *p) |
11691 | { |
11692 | if (p->level++ == MAXSTACK) { Branch (11692:9): [True: 0, False: 1.76M]
|
11693 | p->error_indicator = 1; |
11694 | PyErr_NoMemory(); |
11695 | } |
11696 | if (p->error_indicator) { Branch (11696:9): [True: 0, False: 1.76M]
|
11697 | p->level--; |
11698 | return NULL; |
11699 | } |
11700 | CmpopExprPair* _res = NULL; |
11701 | int _mark = p->mark; |
11702 | { // eq_bitwise_or |
11703 | if (p->error_indicator) { Branch (11703:13): [True: 0, False: 1.76M]
|
11704 | p->level--; |
11705 | return NULL; |
11706 | } |
11707 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or")); |
11708 | CmpopExprPair* eq_bitwise_or_var; |
11709 | if ( |
11710 | (eq_bitwise_or_var = eq_bitwise_or_rule(p)) // eq_bitwise_or Branch (11710:13): [True: 5.83k, False: 1.76M]
|
11711 | ) |
11712 | { |
11713 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or")); |
11714 | _res = eq_bitwise_or_var; |
11715 | goto done; |
11716 | } |
11717 | p->mark = _mark; |
11718 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11719 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "eq_bitwise_or")); |
11720 | } |
11721 | { // noteq_bitwise_or |
11722 | if (p->error_indicator) { Branch (11722:13): [True: 0, False: 1.76M]
|
11723 | p->level--; |
11724 | return NULL; |
11725 | } |
11726 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or")); |
11727 | CmpopExprPair* noteq_bitwise_or_var; |
11728 | if ( |
11729 | (noteq_bitwise_or_var = noteq_bitwise_or_rule(p)) // noteq_bitwise_or Branch (11729:13): [True: 1.72k, False: 1.76M]
|
11730 | ) |
11731 | { |
11732 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or")); |
11733 | _res = noteq_bitwise_or_var; |
11734 | goto done; |
11735 | } |
11736 | p->mark = _mark; |
11737 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11738 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "noteq_bitwise_or")); |
11739 | } |
11740 | { // lte_bitwise_or |
11741 | if (p->error_indicator) { Branch (11741:13): [True: 1, False: 1.76M]
|
11742 | p->level--; |
11743 | return NULL; |
11744 | } |
11745 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or")); |
11746 | CmpopExprPair* lte_bitwise_or_var; |
11747 | if ( |
11748 | (lte_bitwise_or_var = lte_bitwise_or_rule(p)) // lte_bitwise_or Branch (11748:13): [True: 992, False: 1.76M]
|
11749 | ) |
11750 | { |
11751 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or")); |
11752 | _res = lte_bitwise_or_var; |
11753 | goto done; |
11754 | } |
11755 | p->mark = _mark; |
11756 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11757 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lte_bitwise_or")); |
11758 | } |
11759 | { // lt_bitwise_or |
11760 | if (p->error_indicator) { Branch (11760:13): [True: 0, False: 1.76M]
|
11761 | p->level--; |
11762 | return NULL; |
11763 | } |
11764 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or")); |
11765 | CmpopExprPair* lt_bitwise_or_var; |
11766 | if ( |
11767 | (lt_bitwise_or_var = lt_bitwise_or_rule(p)) // lt_bitwise_or Branch (11767:13): [True: 1.59k, False: 1.75M]
|
11768 | ) |
11769 | { |
11770 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or")); |
11771 | _res = lt_bitwise_or_var; |
11772 | goto done; |
11773 | } |
11774 | p->mark = _mark; |
11775 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11776 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lt_bitwise_or")); |
11777 | } |
11778 | { // gte_bitwise_or |
11779 | if (p->error_indicator) { Branch (11779:13): [True: 0, False: 1.75M]
|
11780 | p->level--; |
11781 | return NULL; |
11782 | } |
11783 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or")); |
11784 | CmpopExprPair* gte_bitwise_or_var; |
11785 | if ( |
11786 | (gte_bitwise_or_var = gte_bitwise_or_rule(p)) // gte_bitwise_or Branch (11786:13): [True: 959, False: 1.75M]
|
11787 | ) |
11788 | { |
11789 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or")); |
11790 | _res = gte_bitwise_or_var; |
11791 | goto done; |
11792 | } |
11793 | p->mark = _mark; |
11794 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11795 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gte_bitwise_or")); |
11796 | } |
11797 | { // gt_bitwise_or |
11798 | if (p->error_indicator) { Branch (11798:13): [True: 0, False: 1.75M]
|
11799 | p->level--; |
11800 | return NULL; |
11801 | } |
11802 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or")); |
11803 | CmpopExprPair* gt_bitwise_or_var; |
11804 | if ( |
11805 | (gt_bitwise_or_var = gt_bitwise_or_rule(p)) // gt_bitwise_or Branch (11805:13): [True: 1.43k, False: 1.75M]
|
11806 | ) |
11807 | { |
11808 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or")); |
11809 | _res = gt_bitwise_or_var; |
11810 | goto done; |
11811 | } |
11812 | p->mark = _mark; |
11813 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11814 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gt_bitwise_or")); |
11815 | } |
11816 | { // notin_bitwise_or |
11817 | if (p->error_indicator) { Branch (11817:13): [True: 0, False: 1.75M]
|
11818 | p->level--; |
11819 | return NULL; |
11820 | } |
11821 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or")); |
11822 | CmpopExprPair* notin_bitwise_or_var; |
11823 | if ( |
11824 | (notin_bitwise_or_var = notin_bitwise_or_rule(p)) // notin_bitwise_or Branch (11824:13): [True: 723, False: 1.75M]
|
11825 | ) |
11826 | { |
11827 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or")); |
11828 | _res = notin_bitwise_or_var; |
11829 | goto done; |
11830 | } |
11831 | p->mark = _mark; |
11832 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11833 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "notin_bitwise_or")); |
11834 | } |
11835 | { // in_bitwise_or |
11836 | if (p->error_indicator) { Branch (11836:13): [True: 0, False: 1.75M]
|
11837 | p->level--; |
11838 | return NULL; |
11839 | } |
11840 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "in_bitwise_or")); |
11841 | CmpopExprPair* in_bitwise_or_var; |
11842 | if ( |
11843 | (in_bitwise_or_var = in_bitwise_or_rule(p)) // in_bitwise_or Branch (11843:13): [True: 2.54k, False: 1.75M]
|
11844 | ) |
11845 | { |
11846 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in_bitwise_or")); |
11847 | _res = in_bitwise_or_var; |
11848 | goto done; |
11849 | } |
11850 | p->mark = _mark; |
11851 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11852 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "in_bitwise_or")); |
11853 | } |
11854 | { // isnot_bitwise_or |
11855 | if (p->error_indicator) { Branch (11855:13): [True: 0, False: 1.75M]
|
11856 | p->level--; |
11857 | return NULL; |
11858 | } |
11859 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or")); |
11860 | CmpopExprPair* isnot_bitwise_or_var; |
11861 | if ( |
11862 | (isnot_bitwise_or_var = isnot_bitwise_or_rule(p)) // isnot_bitwise_or Branch (11862:13): [True: 2.19k, False: 1.75M]
|
11863 | ) |
11864 | { |
11865 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or")); |
11866 | _res = isnot_bitwise_or_var; |
11867 | goto done; |
11868 | } |
11869 | p->mark = _mark; |
11870 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11871 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "isnot_bitwise_or")); |
11872 | } |
11873 | { // is_bitwise_or |
11874 | if (p->error_indicator) { Branch (11874:13): [True: 0, False: 1.75M]
|
11875 | p->level--; |
11876 | return NULL; |
11877 | } |
11878 | D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "is_bitwise_or")); |
11879 | CmpopExprPair* is_bitwise_or_var; |
11880 | if ( |
11881 | (is_bitwise_or_var = is_bitwise_or_rule(p)) // is_bitwise_or Branch (11881:13): [True: 4.26k, False: 1.74M]
|
11882 | ) |
11883 | { |
11884 | D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "is_bitwise_or")); |
11885 | _res = is_bitwise_or_var; |
11886 | goto done; |
11887 | } |
11888 | p->mark = _mark; |
11889 | D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', |
11890 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "is_bitwise_or")); |
11891 | } |
11892 | _res = NULL; |
11893 | done: |
11894 | p->level--; |
11895 | return _res; |
11896 | } |
11897 | |
11898 | // eq_bitwise_or: '==' bitwise_or |
11899 | static CmpopExprPair* |
11900 | eq_bitwise_or_rule(Parser *p) |
11901 | { |
11902 | if (p->level++ == MAXSTACK) { Branch (11902:9): [True: 0, False: 1.76M]
|
11903 | p->error_indicator = 1; |
11904 | PyErr_NoMemory(); |
11905 | } |
11906 | if (p->error_indicator) { Branch (11906:9): [True: 0, False: 1.76M]
|
11907 | p->level--; |
11908 | return NULL; |
11909 | } |
11910 | CmpopExprPair* _res = NULL; |
11911 | int _mark = p->mark; |
11912 | { // '==' bitwise_or |
11913 | if (p->error_indicator) { Branch (11913:13): [True: 0, False: 1.76M]
|
11914 | p->level--; |
11915 | return NULL; |
11916 | } |
11917 | D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or")); |
11918 | Token * _literal; |
11919 | expr_ty a; |
11920 | if ( |
11921 | (_literal = _PyPegen_expect_token(p, 27)) // token='==' Branch (11921:13): [True: 5.83k, False: 1.76M]
|
11922 | && |
11923 | (a = bitwise_or_rule(p))5.83k // bitwise_or Branch (11923:13): [True: 5.83k, False: 0]
|
11924 | ) |
11925 | { |
11926 | D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or")); |
11927 | _res = _PyPegen_cmpop_expr_pair ( p , Eq , a ); |
11928 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11928:17): [True: 0, False: 5.83k]
Branch (11928:33): [True: 0, False: 0]
|
11929 | p->error_indicator = 1; |
11930 | p->level--; |
11931 | return NULL; |
11932 | } |
11933 | goto done; |
11934 | } |
11935 | p->mark = _mark; |
11936 | D(fprintf(stderr, "%*c%s eq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
11937 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or")); |
11938 | } |
11939 | _res = NULL; |
11940 | done: |
11941 | p->level--; |
11942 | return _res; |
11943 | } |
11944 | |
11945 | // noteq_bitwise_or: ('!=') bitwise_or |
11946 | static CmpopExprPair* |
11947 | noteq_bitwise_or_rule(Parser *p) |
11948 | { |
11949 | if (p->level++ == MAXSTACK) { Branch (11949:9): [True: 0, False: 1.76M]
|
11950 | p->error_indicator = 1; |
11951 | PyErr_NoMemory(); |
11952 | } |
11953 | if (p->error_indicator) { Branch (11953:9): [True: 0, False: 1.76M]
|
11954 | p->level--; |
11955 | return NULL; |
11956 | } |
11957 | CmpopExprPair* _res = NULL; |
11958 | int _mark = p->mark; |
11959 | { // ('!=') bitwise_or |
11960 | if (p->error_indicator) { Branch (11960:13): [True: 0, False: 1.76M]
|
11961 | p->level--; |
11962 | return NULL; |
11963 | } |
11964 | D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or")); |
11965 | void *_tmp_87_var; |
11966 | expr_ty a; |
11967 | if ( |
11968 | (_tmp_87_var = _tmp_87_rule(p)) // '!=' Branch (11968:13): [True: 1.72k, False: 1.76M]
|
11969 | && |
11970 | (a = bitwise_or_rule(p))1.72k // bitwise_or Branch (11970:13): [True: 1.72k, False: 0]
|
11971 | ) |
11972 | { |
11973 | D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or")); |
11974 | _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a ); |
11975 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (11975:17): [True: 0, False: 1.72k]
Branch (11975:33): [True: 0, False: 0]
|
11976 | p->error_indicator = 1; |
11977 | p->level--; |
11978 | return NULL; |
11979 | } |
11980 | goto done; |
11981 | } |
11982 | p->mark = _mark; |
11983 | D(fprintf(stderr, "%*c%s noteq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
11984 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or")); |
11985 | } |
11986 | _res = NULL; |
11987 | done: |
11988 | p->level--; |
11989 | return _res; |
11990 | } |
11991 | |
11992 | // lte_bitwise_or: '<=' bitwise_or |
11993 | static CmpopExprPair* |
11994 | lte_bitwise_or_rule(Parser *p) |
11995 | { |
11996 | if (p->level++ == MAXSTACK) { Branch (11996:9): [True: 0, False: 1.76M]
|
11997 | p->error_indicator = 1; |
11998 | PyErr_NoMemory(); |
11999 | } |
12000 | if (p->error_indicator) { Branch (12000:9): [True: 0, False: 1.76M]
|
12001 | p->level--; |
12002 | return NULL; |
12003 | } |
12004 | CmpopExprPair* _res = NULL; |
12005 | int _mark = p->mark; |
12006 | { // '<=' bitwise_or |
12007 | if (p->error_indicator) { Branch (12007:13): [True: 0, False: 1.76M]
|
12008 | p->level--; |
12009 | return NULL; |
12010 | } |
12011 | D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or")); |
12012 | Token * _literal; |
12013 | expr_ty a; |
12014 | if ( |
12015 | (_literal = _PyPegen_expect_token(p, 29)) // token='<=' Branch (12015:13): [True: 992, False: 1.76M]
|
12016 | && |
12017 | (a = bitwise_or_rule(p))992 // bitwise_or Branch (12017:13): [True: 992, False: 0]
|
12018 | ) |
12019 | { |
12020 | D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or")); |
12021 | _res = _PyPegen_cmpop_expr_pair ( p , LtE , a ); |
12022 | if (_res == NULL && PyErr_Occurred()0 ) { |
12023 | p->error_indicator = 1; |
12024 | p->level--; |
12025 | return NULL; |
12026 | } |
12027 | goto done; |
12028 | } |
12029 | p->mark = _mark; |
12030 | D(fprintf(stderr, "%*c%s lte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12031 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or")); |
12032 | } |
12033 | _res = NULL; |
12034 | done: |
12035 | p->level--; |
12036 | return _res; |
12037 | } |
12038 | |
12039 | // lt_bitwise_or: '<' bitwise_or |
12040 | static CmpopExprPair* |
12041 | lt_bitwise_or_rule(Parser *p) |
12042 | { |
12043 | if (p->level++ == MAXSTACK) { Branch (12043:9): [True: 0, False: 1.76M]
|
12044 | p->error_indicator = 1; |
12045 | PyErr_NoMemory(); |
12046 | } |
12047 | if (p->error_indicator) { Branch (12047:9): [True: 0, False: 1.76M]
|
12048 | p->level--; |
12049 | return NULL; |
12050 | } |
12051 | CmpopExprPair* _res = NULL; |
12052 | int _mark = p->mark; |
12053 | { // '<' bitwise_or |
12054 | if (p->error_indicator) { Branch (12054:13): [True: 0, False: 1.76M]
|
12055 | p->level--; |
12056 | return NULL; |
12057 | } |
12058 | D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or")); |
12059 | Token * _literal; |
12060 | expr_ty a; |
12061 | if ( |
12062 | (_literal = _PyPegen_expect_token(p, 20)) // token='<' Branch (12062:13): [True: 1.59k, False: 1.75M]
|
12063 | && |
12064 | (a = bitwise_or_rule(p))1.59k // bitwise_or Branch (12064:13): [True: 1.59k, False: 0]
|
12065 | ) |
12066 | { |
12067 | D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or")); |
12068 | _res = _PyPegen_cmpop_expr_pair ( p , Lt , a ); |
12069 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (12069:17): [True: 0, False: 1.59k]
Branch (12069:33): [True: 0, False: 0]
|
12070 | p->error_indicator = 1; |
12071 | p->level--; |
12072 | return NULL; |
12073 | } |
12074 | goto done; |
12075 | } |
12076 | p->mark = _mark; |
12077 | D(fprintf(stderr, "%*c%s lt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12078 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or")); |
12079 | } |
12080 | _res = NULL; |
12081 | done: |
12082 | p->level--; |
12083 | return _res; |
12084 | } |
12085 | |
12086 | // gte_bitwise_or: '>=' bitwise_or |
12087 | static CmpopExprPair* |
12088 | gte_bitwise_or_rule(Parser *p) |
12089 | { |
12090 | if (p->level++ == MAXSTACK) { Branch (12090:9): [True: 0, False: 1.75M]
|
12091 | p->error_indicator = 1; |
12092 | PyErr_NoMemory(); |
12093 | } |
12094 | if (p->error_indicator) { Branch (12094:9): [True: 0, False: 1.75M]
|
12095 | p->level--; |
12096 | return NULL; |
12097 | } |
12098 | CmpopExprPair* _res = NULL; |
12099 | int _mark = p->mark; |
12100 | { // '>=' bitwise_or |
12101 | if (p->error_indicator) { Branch (12101:13): [True: 0, False: 1.75M]
|
12102 | p->level--; |
12103 | return NULL; |
12104 | } |
12105 | D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or")); |
12106 | Token * _literal; |
12107 | expr_ty a; |
12108 | if ( |
12109 | (_literal = _PyPegen_expect_token(p, 30)) // token='>=' Branch (12109:13): [True: 959, False: 1.75M]
|
12110 | && |
12111 | (a = bitwise_or_rule(p))959 // bitwise_or Branch (12111:13): [True: 959, False: 0]
|
12112 | ) |
12113 | { |
12114 | D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or")); |
12115 | _res = _PyPegen_cmpop_expr_pair ( p , GtE , a ); |
12116 | if (_res == NULL && PyErr_Occurred()0 ) { |
12117 | p->error_indicator = 1; |
12118 | p->level--; |
12119 | return NULL; |
12120 | } |
12121 | goto done; |
12122 | } |
12123 | p->mark = _mark; |
12124 | D(fprintf(stderr, "%*c%s gte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12125 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or")); |
12126 | } |
12127 | _res = NULL; |
12128 | done: |
12129 | p->level--; |
12130 | return _res; |
12131 | } |
12132 | |
12133 | // gt_bitwise_or: '>' bitwise_or |
12134 | static CmpopExprPair* |
12135 | gt_bitwise_or_rule(Parser *p) |
12136 | { |
12137 | if (p->level++ == MAXSTACK) { Branch (12137:9): [True: 0, False: 1.75M]
|
12138 | p->error_indicator = 1; |
12139 | PyErr_NoMemory(); |
12140 | } |
12141 | if (p->error_indicator) { Branch (12141:9): [True: 0, False: 1.75M]
|
12142 | p->level--; |
12143 | return NULL; |
12144 | } |
12145 | CmpopExprPair* _res = NULL; |
12146 | int _mark = p->mark; |
12147 | { // '>' bitwise_or |
12148 | if (p->error_indicator) { Branch (12148:13): [True: 0, False: 1.75M]
|
12149 | p->level--; |
12150 | return NULL; |
12151 | } |
12152 | D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or")); |
12153 | Token * _literal; |
12154 | expr_ty a; |
12155 | if ( |
12156 | (_literal = _PyPegen_expect_token(p, 21)) // token='>' Branch (12156:13): [True: 1.43k, False: 1.75M]
|
12157 | && |
12158 | (a = bitwise_or_rule(p))1.43k // bitwise_or Branch (12158:13): [True: 1.43k, False: 0]
|
12159 | ) |
12160 | { |
12161 | D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or")); |
12162 | _res = _PyPegen_cmpop_expr_pair ( p , Gt , a ); |
12163 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (12163:17): [True: 0, False: 1.43k]
Branch (12163:33): [True: 0, False: 0]
|
12164 | p->error_indicator = 1; |
12165 | p->level--; |
12166 | return NULL; |
12167 | } |
12168 | goto done; |
12169 | } |
12170 | p->mark = _mark; |
12171 | D(fprintf(stderr, "%*c%s gt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12172 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or")); |
12173 | } |
12174 | _res = NULL; |
12175 | done: |
12176 | p->level--; |
12177 | return _res; |
12178 | } |
12179 | |
12180 | // notin_bitwise_or: 'not' 'in' bitwise_or |
12181 | static CmpopExprPair* |
12182 | notin_bitwise_or_rule(Parser *p) |
12183 | { |
12184 | if (p->level++ == MAXSTACK) { Branch (12184:9): [True: 0, False: 1.75M]
|
12185 | p->error_indicator = 1; |
12186 | PyErr_NoMemory(); |
12187 | } |
12188 | if (p->error_indicator) { Branch (12188:9): [True: 0, False: 1.75M]
|
12189 | p->level--; |
12190 | return NULL; |
12191 | } |
12192 | CmpopExprPair* _res = NULL; |
12193 | int _mark = p->mark; |
12194 | { // 'not' 'in' bitwise_or |
12195 | if (p->error_indicator) { Branch (12195:13): [True: 0, False: 1.75M]
|
12196 | p->level--; |
12197 | return NULL; |
12198 | } |
12199 | D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or")); |
12200 | Token * _keyword; |
12201 | Token * _keyword_1; |
12202 | expr_ty a; |
12203 | if ( |
12204 | (_keyword = _PyPegen_expect_token(p, 581)) // token='not' Branch (12204:13): [True: 723, False: 1.75M]
|
12205 | && |
12206 | (_keyword_1 = _PyPegen_expect_token(p, 643))723 // token='in' Branch (12206:13): [True: 723, False: 0]
|
12207 | && |
12208 | (a = bitwise_or_rule(p))723 // bitwise_or Branch (12208:13): [True: 723, False: 0]
|
12209 | ) |
12210 | { |
12211 | D(fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or")); |
12212 | _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a ); |
12213 | if (_res == NULL && PyErr_Occurred()0 ) { |
12214 | p->error_indicator = 1; |
12215 | p->level--; |
12216 | return NULL; |
12217 | } |
12218 | goto done; |
12219 | } |
12220 | p->mark = _mark; |
12221 | D(fprintf(stderr, "%*c%s notin_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12222 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or")); |
12223 | } |
12224 | _res = NULL; |
12225 | done: |
12226 | p->level--; |
12227 | return _res; |
12228 | } |
12229 | |
12230 | // in_bitwise_or: 'in' bitwise_or |
12231 | static CmpopExprPair* |
12232 | in_bitwise_or_rule(Parser *p) |
12233 | { |
12234 | if (p->level++ == MAXSTACK) { Branch (12234:9): [True: 0, False: 1.75M]
|
12235 | p->error_indicator = 1; |
12236 | PyErr_NoMemory(); |
12237 | } |
12238 | if (p->error_indicator) { Branch (12238:9): [True: 0, False: 1.75M]
|
12239 | p->level--; |
12240 | return NULL; |
12241 | } |
12242 | CmpopExprPair* _res = NULL; |
12243 | int _mark = p->mark; |
12244 | { // 'in' bitwise_or |
12245 | if (p->error_indicator) { Branch (12245:13): [True: 0, False: 1.75M]
|
12246 | p->level--; |
12247 | return NULL; |
12248 | } |
12249 | D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or")); |
12250 | Token * _keyword; |
12251 | expr_ty a; |
12252 | if ( |
12253 | (_keyword = _PyPegen_expect_token(p, 643)) // token='in' Branch (12253:13): [True: 2.54k, False: 1.75M]
|
12254 | && |
12255 | (a = bitwise_or_rule(p))2.54k // bitwise_or Branch (12255:13): [True: 2.54k, False: 0]
|
12256 | ) |
12257 | { |
12258 | D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or")); |
12259 | _res = _PyPegen_cmpop_expr_pair ( p , In , a ); |
12260 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (12260:17): [True: 0, False: 2.54k]
Branch (12260:33): [True: 0, False: 0]
|
12261 | p->error_indicator = 1; |
12262 | p->level--; |
12263 | return NULL; |
12264 | } |
12265 | goto done; |
12266 | } |
12267 | p->mark = _mark; |
12268 | D(fprintf(stderr, "%*c%s in_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12269 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or")); |
12270 | } |
12271 | _res = NULL; |
12272 | done: |
12273 | p->level--; |
12274 | return _res; |
12275 | } |
12276 | |
12277 | // isnot_bitwise_or: 'is' 'not' bitwise_or |
12278 | static CmpopExprPair* |
12279 | isnot_bitwise_or_rule(Parser *p) |
12280 | { |
12281 | if (p->level++ == MAXSTACK) { Branch (12281:9): [True: 0, False: 1.75M]
|
12282 | p->error_indicator = 1; |
12283 | PyErr_NoMemory(); |
12284 | } |
12285 | if (p->error_indicator) { Branch (12285:9): [True: 0, False: 1.75M]
|
12286 | p->level--; |
12287 | return NULL; |
12288 | } |
12289 | CmpopExprPair* _res = NULL; |
12290 | int _mark = p->mark; |
12291 | { // 'is' 'not' bitwise_or |
12292 | if (p->error_indicator) { Branch (12292:13): [True: 0, False: 1.75M]
|
12293 | p->level--; |
12294 | return NULL; |
12295 | } |
12296 | D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or")); |
12297 | Token * _keyword; |
12298 | Token * _keyword_1; |
12299 | expr_ty a; |
12300 | if ( |
12301 | (_keyword = _PyPegen_expect_token(p, 582)) // token='is' Branch (12301:13): [True: 6.45k, False: 1.74M]
|
12302 | && |
12303 | (_keyword_1 = _PyPegen_expect_token(p, 581))6.45k // token='not' Branch (12303:13): [True: 2.19k, False: 4.26k]
|
12304 | && |
12305 | (a = bitwise_or_rule(p))2.19k // bitwise_or Branch (12305:13): [True: 2.19k, False: 0]
|
12306 | ) |
12307 | { |
12308 | D(fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or")); |
12309 | _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a ); |
12310 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (12310:17): [True: 0, False: 2.19k]
Branch (12310:33): [True: 0, False: 0]
|
12311 | p->error_indicator = 1; |
12312 | p->level--; |
12313 | return NULL; |
12314 | } |
12315 | goto done; |
12316 | } |
12317 | p->mark = _mark; |
12318 | D(fprintf(stderr, "%*c%s isnot_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12319 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or")); |
12320 | } |
12321 | _res = NULL; |
12322 | done: |
12323 | p->level--; |
12324 | return _res; |
12325 | } |
12326 | |
12327 | // is_bitwise_or: 'is' bitwise_or |
12328 | static CmpopExprPair* |
12329 | is_bitwise_or_rule(Parser *p) |
12330 | { |
12331 | if (p->level++ == MAXSTACK) { Branch (12331:9): [True: 0, False: 1.75M]
|
12332 | p->error_indicator = 1; |
12333 | PyErr_NoMemory(); |
12334 | } |
12335 | if (p->error_indicator) { Branch (12335:9): [True: 0, False: 1.75M]
|
12336 | p->level--; |
12337 | return NULL; |
12338 | } |
12339 | CmpopExprPair* _res = NULL; |
12340 | int _mark = p->mark; |
12341 | { // 'is' bitwise_or |
12342 | if (p->error_indicator) { Branch (12342:13): [True: 0, False: 1.75M]
|
12343 | p->level--; |
12344 | return NULL; |
12345 | } |
12346 | D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or")); |
12347 | Token * _keyword; |
12348 | expr_ty a; |
12349 | if ( |
12350 | (_keyword = _PyPegen_expect_token(p, 582)) // token='is' Branch (12350:13): [True: 4.26k, False: 1.74M]
|
12351 | && |
12352 | (a = bitwise_or_rule(p))4.26k // bitwise_or Branch (12352:13): [True: 4.26k, False: 0]
|
12353 | ) |
12354 | { |
12355 | D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or")); |
12356 | _res = _PyPegen_cmpop_expr_pair ( p , Is , a ); |
12357 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (12357:17): [True: 0, False: 4.26k]
Branch (12357:33): [True: 0, False: 0]
|
12358 | p->error_indicator = 1; |
12359 | p->level--; |
12360 | return NULL; |
12361 | } |
12362 | goto done; |
12363 | } |
12364 | p->mark = _mark; |
12365 | D(fprintf(stderr, "%*c%s is_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12366 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' bitwise_or")); |
12367 | } |
12368 | _res = NULL; |
12369 | done: |
12370 | p->level--; |
12371 | return _res; |
12372 | } |
12373 | |
12374 | // Left-recursive |
12375 | // bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor |
12376 | static expr_ty bitwise_or_raw(Parser *); |
12377 | static expr_ty |
12378 | bitwise_or_rule(Parser *p) |
12379 | { |
12380 | if (p->level++ == MAXSTACK) { Branch (12380:9): [True: 0, False: 8.55M]
|
12381 | p->error_indicator = 1; |
12382 | PyErr_NoMemory(); |
12383 | } |
12384 | expr_ty _res = NULL; |
12385 | if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) { Branch (12385:9): [True: 6.28M, False: 2.27M]
|
12386 | p->level--; |
12387 | return _res; |
12388 | } |
12389 | int _mark = p->mark; |
12390 | int _resmark = p->mark; |
12391 | while (1) { |
12392 | int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res); |
12393 | if (tmpvar_2) { Branch (12393:13): [True: 0, False: 4.04M]
|
12394 | p->level--; |
12395 | return _res; |
12396 | } |
12397 | p->mark = _mark; |
12398 | void *_raw = bitwise_or_raw(p); |
12399 | if (p->error_indicator) { Branch (12399:13): [True: 385, False: 4.04M]
|
12400 | p->level--; |
12401 | return NULL; |
12402 | } |
12403 | if (_raw == NULL || p->mark <= _resmark3.54M ) Branch (12403:13): [True: 505k, False: 3.54M]
Branch (12403:29): [True: 1.77M, False: 1.77M]
|
12404 | break; |
12405 | _resmark = p->mark; |
12406 | _res = _raw; |
12407 | } |
12408 | p->mark = _resmark; |
12409 | p->level--; |
12410 | return _res; |
12411 | } |
12412 | static expr_ty |
12413 | bitwise_or_raw(Parser *p) |
12414 | { |
12415 | if (p->level++ == MAXSTACK) { Branch (12415:9): [True: 0, False: 4.04M]
|
12416 | p->error_indicator = 1; |
12417 | PyErr_NoMemory(); |
12418 | } |
12419 | if (p->error_indicator) { Branch (12419:9): [True: 0, False: 4.04M]
|
12420 | p->level--; |
12421 | return NULL; |
12422 | } |
12423 | expr_ty _res = NULL; |
12424 | int _mark = p->mark; |
12425 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (12425:9): [True: 0, False: 4.04M]
Branch (12425:31): [True: 0, False: 0]
|
12426 | p->error_indicator = 1; |
12427 | p->level--; |
12428 | return NULL; |
12429 | } |
12430 | int _start_lineno = p->tokens[_mark]->lineno; |
12431 | UNUSED(_start_lineno); // Only used by EXTRA macro |
12432 | int _start_col_offset = p->tokens[_mark]->col_offset; |
12433 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
12434 | { // bitwise_or '|' bitwise_xor |
12435 | if (p->error_indicator) { Branch (12435:13): [True: 0, False: 4.04M]
|
12436 | p->level--; |
12437 | return NULL; |
12438 | } |
12439 | D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor")); |
12440 | Token * _literal; |
12441 | expr_ty a; |
12442 | expr_ty b; |
12443 | if ( |
12444 | (a = bitwise_or_rule(p)) // bitwise_or Branch (12444:13): [True: 1.77M, False: 2.27M]
|
12445 | && |
12446 | (_literal = _PyPegen_expect_token(p, 18))1.77M // token='|' Branch (12446:13): [True: 543, False: 1.77M]
|
12447 | && |
12448 | (b = bitwise_xor_rule(p))543 // bitwise_xor Branch (12448:13): [True: 539, False: 4]
|
12449 | ) |
12450 | { |
12451 | D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor")); |
12452 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
12453 | if (_token == NULL) { Branch (12453:17): [True: 0, False: 539]
|
12454 | p->level--; |
12455 | return NULL; |
12456 | } |
12457 | int _end_lineno = _token->end_lineno; |
12458 | UNUSED(_end_lineno); // Only used by EXTRA macro |
12459 | int _end_col_offset = _token->end_col_offset; |
12460 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
12461 | _res = _PyAST_BinOp ( a , BitOr , b , EXTRA ); |
12462 | if (_res == NULL && PyErr_Occurred()0 ) { |
12463 | p->error_indicator = 1; |
12464 | p->level--; |
12465 | return NULL; |
12466 | } |
12467 | goto done; |
12468 | } |
12469 | p->mark = _mark; |
12470 | D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12471 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or '|' bitwise_xor")); |
12472 | } |
12473 | { // bitwise_xor |
12474 | if (p->error_indicator) { Branch (12474:13): [True: 0, False: 4.04M]
|
12475 | p->level--; |
12476 | return NULL; |
12477 | } |
12478 | D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor")); |
12479 | expr_ty bitwise_xor_var; |
12480 | if ( |
12481 | (bitwise_xor_var = bitwise_xor_rule(p)) // bitwise_xor Branch (12481:13): [True: 3.54M, False: 506k]
|
12482 | ) |
12483 | { |
12484 | D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor")); |
12485 | _res = bitwise_xor_var; |
12486 | goto done; |
12487 | } |
12488 | p->mark = _mark; |
12489 | D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', |
12490 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor")); |
12491 | } |
12492 | _res = NULL; |
12493 | done: |
12494 | p->level--; |
12495 | return _res; |
12496 | } |
12497 | |
12498 | // Left-recursive |
12499 | // bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and |
12500 | static expr_ty bitwise_xor_raw(Parser *); |
12501 | static expr_ty |
12502 | bitwise_xor_rule(Parser *p) |
12503 | { |
12504 | if (p->level++ == MAXSTACK) { Branch (12504:9): [True: 0, False: 8.09M]
|
12505 | p->error_indicator = 1; |
12506 | PyErr_NoMemory(); |
12507 | } |
12508 | expr_ty _res = NULL; |
12509 | if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) { Branch (12509:9): [True: 5.81M, False: 2.27M]
|
12510 | p->level--; |
12511 | return _res; |
12512 | } |
12513 | int _mark = p->mark; |
12514 | int _resmark = p->mark; |
12515 | while (1) { |
12516 | int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res); |
12517 | if (tmpvar_3) { Branch (12517:13): [True: 0, False: 4.04M]
|
12518 | p->level--; |
12519 | return _res; |
12520 | } |
12521 | p->mark = _mark; |
12522 | void *_raw = bitwise_xor_raw(p); |
12523 | if (p->error_indicator) { Branch (12523:13): [True: 385, False: 4.04M]
|
12524 | p->level--; |
12525 | return NULL; |
12526 | } |
12527 | if (_raw == NULL || p->mark <= _resmark3.54M ) Branch (12527:13): [True: 505k, False: 3.54M]
Branch (12527:29): [True: 1.77M, False: 1.77M]
|
12528 | break; |
12529 | _resmark = p->mark; |
12530 | _res = _raw; |
12531 | } |
12532 | p->mark = _resmark; |
12533 | p->level--; |
12534 | return _res; |
12535 | } |
12536 | static expr_ty |
12537 | bitwise_xor_raw(Parser *p) |
12538 | { |
12539 | if (p->level++ == MAXSTACK) { Branch (12539:9): [True: 0, False: 4.04M]
|
12540 | p->error_indicator = 1; |
12541 | PyErr_NoMemory(); |
12542 | } |
12543 | if (p->error_indicator) { Branch (12543:9): [True: 0, False: 4.04M]
|
12544 | p->level--; |
12545 | return NULL; |
12546 | } |
12547 | expr_ty _res = NULL; |
12548 | int _mark = p->mark; |
12549 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (12549:9): [True: 0, False: 4.04M]
Branch (12549:31): [True: 0, False: 0]
|
12550 | p->error_indicator = 1; |
12551 | p->level--; |
12552 | return NULL; |
12553 | } |
12554 | int _start_lineno = p->tokens[_mark]->lineno; |
12555 | UNUSED(_start_lineno); // Only used by EXTRA macro |
12556 | int _start_col_offset = p->tokens[_mark]->col_offset; |
12557 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
12558 | { // bitwise_xor '^' bitwise_and |
12559 | if (p->error_indicator) { Branch (12559:13): [True: 0, False: 4.04M]
|
12560 | p->level--; |
12561 | return NULL; |
12562 | } |
12563 | D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and")); |
12564 | Token * _literal; |
12565 | expr_ty a; |
12566 | expr_ty b; |
12567 | if ( |
12568 | (a = bitwise_xor_rule(p)) // bitwise_xor Branch (12568:13): [True: 1.77M, False: 2.27M]
|
12569 | && |
12570 | (_literal = _PyPegen_expect_token(p, 32))1.77M // token='^' Branch (12570:13): [True: 157, False: 1.77M]
|
12571 | && |
12572 | (b = bitwise_and_rule(p))157 // bitwise_and Branch (12572:13): [True: 157, False: 0]
|
12573 | ) |
12574 | { |
12575 | D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and")); |
12576 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
12577 | if (_token == NULL) { Branch (12577:17): [True: 0, False: 157]
|
12578 | p->level--; |
12579 | return NULL; |
12580 | } |
12581 | int _end_lineno = _token->end_lineno; |
12582 | UNUSED(_end_lineno); // Only used by EXTRA macro |
12583 | int _end_col_offset = _token->end_col_offset; |
12584 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
12585 | _res = _PyAST_BinOp ( a , BitXor , b , EXTRA ); |
12586 | if (_res == NULL && PyErr_Occurred()0 ) { |
12587 | p->error_indicator = 1; |
12588 | p->level--; |
12589 | return NULL; |
12590 | } |
12591 | goto done; |
12592 | } |
12593 | p->mark = _mark; |
12594 | D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ', |
12595 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor '^' bitwise_and")); |
12596 | } |
12597 | { // bitwise_and |
12598 | if (p->error_indicator) { Branch (12598:13): [True: 0, False: 4.04M]
|
12599 | p->level--; |
12600 | return NULL; |
12601 | } |
12602 | D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and")); |
12603 | expr_ty bitwise_and_var; |
12604 | if ( |
12605 | (bitwise_and_var = bitwise_and_rule(p)) // bitwise_and Branch (12605:13): [True: 3.54M, False: 506k]
|
12606 | ) |
12607 | { |
12608 | D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and")); |
12609 | _res = bitwise_and_var; |
12610 | goto done; |
12611 | } |
12612 | p->mark = _mark; |
12613 | D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ', |
12614 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and")); |
12615 | } |
12616 | _res = NULL; |
12617 | done: |
12618 | p->level--; |
12619 | return _res; |
12620 | } |
12621 | |
12622 | // Left-recursive |
12623 | // bitwise_and: bitwise_and '&' shift_expr | shift_expr |
12624 | static expr_ty bitwise_and_raw(Parser *); |
12625 | static expr_ty |
12626 | bitwise_and_rule(Parser *p) |
12627 | { |
12628 | if (p->level++ == MAXSTACK) { Branch (12628:9): [True: 0, False: 8.09M]
|
12629 | p->error_indicator = 1; |
12630 | PyErr_NoMemory(); |
12631 | } |
12632 | expr_ty _res = NULL; |
12633 | if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) { Branch (12633:9): [True: 5.81M, False: 2.27M]
|
12634 | p->level--; |
12635 | return _res; |
12636 | } |
12637 | int _mark = p->mark; |
12638 | int _resmark = p->mark; |
12639 | while (1) { |
12640 | int tmpvar_4 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res); |
12641 | if (tmpvar_4) { Branch (12641:13): [True: 0, False: 4.04M]
|
12642 | p->level--; |
12643 | return _res; |
12644 | } |
12645 | p->mark = _mark; |
12646 | void *_raw = bitwise_and_raw(p); |
12647 | if (p->error_indicator) { Branch (12647:13): [True: 385, False: 4.04M]
|
12648 | p->level--; |
12649 | return NULL; |
12650 | } |
12651 | if (_raw == NULL || p->mark <= _resmark3.54M ) Branch (12651:13): [True: 505k, False: 3.54M]
Branch (12651:29): [True: 1.77M, False: 1.77M]
|
12652 | break; |
12653 | _resmark = p->mark; |
12654 | _res = _raw; |
12655 | } |
12656 | p->mark = _resmark; |
12657 | p->level--; |
12658 | return _res; |
12659 | } |
12660 | static expr_ty |
12661 | bitwise_and_raw(Parser *p) |
12662 | { |
12663 | if (p->level++ == MAXSTACK) { Branch (12663:9): [True: 0, False: 4.04M]
|
12664 | p->error_indicator = 1; |
12665 | PyErr_NoMemory(); |
12666 | } |
12667 | if (p->error_indicator) { Branch (12667:9): [True: 0, False: 4.04M]
|
12668 | p->level--; |
12669 | return NULL; |
12670 | } |
12671 | expr_ty _res = NULL; |
12672 | int _mark = p->mark; |
12673 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (12673:9): [True: 0, False: 4.04M]
Branch (12673:31): [True: 0, False: 0]
|
12674 | p->error_indicator = 1; |
12675 | p->level--; |
12676 | return NULL; |
12677 | } |
12678 | int _start_lineno = p->tokens[_mark]->lineno; |
12679 | UNUSED(_start_lineno); // Only used by EXTRA macro |
12680 | int _start_col_offset = p->tokens[_mark]->col_offset; |
12681 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
12682 | { // bitwise_and '&' shift_expr |
12683 | if (p->error_indicator) { Branch (12683:13): [True: 0, False: 4.04M]
|
12684 | p->level--; |
12685 | return NULL; |
12686 | } |
12687 | D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr")); |
12688 | Token * _literal; |
12689 | expr_ty a; |
12690 | expr_ty b; |
12691 | if ( |
12692 | (a = bitwise_and_rule(p)) // bitwise_and Branch (12692:13): [True: 1.77M, False: 2.27M]
|
12693 | && |
12694 | (_literal = _PyPegen_expect_token(p, 19))1.77M // token='&' Branch (12694:13): [True: 744, False: 1.77M]
|
12695 | && |
12696 | (b = shift_expr_rule(p))744 // shift_expr Branch (12696:13): [True: 744, False: 0]
|
12697 | ) |
12698 | { |
12699 | D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr")); |
12700 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
12701 | if (_token == NULL) { Branch (12701:17): [True: 0, False: 744]
|
12702 | p->level--; |
12703 | return NULL; |
12704 | } |
12705 | int _end_lineno = _token->end_lineno; |
12706 | UNUSED(_end_lineno); // Only used by EXTRA macro |
12707 | int _end_col_offset = _token->end_col_offset; |
12708 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
12709 | _res = _PyAST_BinOp ( a , BitAnd , b , EXTRA ); |
12710 | if (_res == NULL && PyErr_Occurred()0 ) { |
12711 | p->error_indicator = 1; |
12712 | p->level--; |
12713 | return NULL; |
12714 | } |
12715 | goto done; |
12716 | } |
12717 | p->mark = _mark; |
12718 | D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ', |
12719 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and '&' shift_expr")); |
12720 | } |
12721 | { // shift_expr |
12722 | if (p->error_indicator) { Branch (12722:13): [True: 0, False: 4.04M]
|
12723 | p->level--; |
12724 | return NULL; |
12725 | } |
12726 | D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr")); |
12727 | expr_ty shift_expr_var; |
12728 | if ( |
12729 | (shift_expr_var = shift_expr_rule(p)) // shift_expr Branch (12729:13): [True: 3.54M, False: 506k]
|
12730 | ) |
12731 | { |
12732 | D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr")); |
12733 | _res = shift_expr_var; |
12734 | goto done; |
12735 | } |
12736 | p->mark = _mark; |
12737 | D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ', |
12738 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr")); |
12739 | } |
12740 | _res = NULL; |
12741 | done: |
12742 | p->level--; |
12743 | return _res; |
12744 | } |
12745 | |
12746 | // Left-recursive |
12747 | // shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | sum |
12748 | static expr_ty shift_expr_raw(Parser *); |
12749 | static expr_ty |
12750 | shift_expr_rule(Parser *p) |
12751 | { |
12752 | if (p->level++ == MAXSTACK) { Branch (12752:9): [True: 0, False: 12.1M]
|
12753 | p->error_indicator = 1; |
12754 | PyErr_NoMemory(); |
12755 | } |
12756 | expr_ty _res = NULL; |
12757 | if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) { Branch (12757:9): [True: 9.87M, False: 2.27M]
|
12758 | p->level--; |
12759 | return _res; |
12760 | } |
12761 | int _mark = p->mark; |
12762 | int _resmark = p->mark; |
12763 | while (1) { |
12764 | int tmpvar_5 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res); |
12765 | if (tmpvar_5) { Branch (12765:13): [True: 0, False: 4.04M]
|
12766 | p->level--; |
12767 | return _res; |
12768 | } |
12769 | p->mark = _mark; |
12770 | void *_raw = shift_expr_raw(p); |
12771 | if (p->error_indicator) { Branch (12771:13): [True: 385, False: 4.04M]
|
12772 | p->level--; |
12773 | return NULL; |
12774 | } |
12775 | if (_raw == NULL || p->mark <= _resmark3.54M ) Branch (12775:13): [True: 505k, False: 3.54M]
Branch (12775:29): [True: 1.77M, False: 1.77M]
|
12776 | break; |
12777 | _resmark = p->mark; |
12778 | _res = _raw; |
12779 | } |
12780 | p->mark = _resmark; |
12781 | p->level--; |
12782 | return _res; |
12783 | } |
12784 | static expr_ty |
12785 | shift_expr_raw(Parser *p) |
12786 | { |
12787 | if (p->level++ == MAXSTACK) { Branch (12787:9): [True: 0, False: 4.04M]
|
12788 | p->error_indicator = 1; |
12789 | PyErr_NoMemory(); |
12790 | } |
12791 | if (p->error_indicator) { Branch (12791:9): [True: 0, False: 4.04M]
|
12792 | p->level--; |
12793 | return NULL; |
12794 | } |
12795 | expr_ty _res = NULL; |
12796 | int _mark = p->mark; |
12797 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (12797:9): [True: 0, False: 4.04M]
Branch (12797:31): [True: 0, False: 0]
|
12798 | p->error_indicator = 1; |
12799 | p->level--; |
12800 | return NULL; |
12801 | } |
12802 | int _start_lineno = p->tokens[_mark]->lineno; |
12803 | UNUSED(_start_lineno); // Only used by EXTRA macro |
12804 | int _start_col_offset = p->tokens[_mark]->col_offset; |
12805 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
12806 | { // shift_expr '<<' sum |
12807 | if (p->error_indicator) { Branch (12807:13): [True: 0, False: 4.04M]
|
12808 | p->level--; |
12809 | return NULL; |
12810 | } |
12811 | D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum")); |
12812 | Token * _literal; |
12813 | expr_ty a; |
12814 | expr_ty b; |
12815 | if ( |
12816 | (a = shift_expr_rule(p)) // shift_expr Branch (12816:13): [True: 1.77M, False: 2.27M]
|
12817 | && |
12818 | (_literal = _PyPegen_expect_token(p, 33))1.77M // token='<<' Branch (12818:13): [True: 250, False: 1.77M]
|
12819 | && |
12820 | (b = sum_rule(p))250 // sum Branch (12820:13): [True: 250, False: 0]
|
12821 | ) |
12822 | { |
12823 | D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum")); |
12824 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
12825 | if (_token == NULL) { Branch (12825:17): [True: 0, False: 250]
|
12826 | p->level--; |
12827 | return NULL; |
12828 | } |
12829 | int _end_lineno = _token->end_lineno; |
12830 | UNUSED(_end_lineno); // Only used by EXTRA macro |
12831 | int _end_col_offset = _token->end_col_offset; |
12832 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
12833 | _res = _PyAST_BinOp ( a , LShift , b , EXTRA ); |
12834 | if (_res == NULL && PyErr_Occurred()0 ) { |
12835 | p->error_indicator = 1; |
12836 | p->level--; |
12837 | return NULL; |
12838 | } |
12839 | goto done; |
12840 | } |
12841 | p->mark = _mark; |
12842 | D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', |
12843 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '<<' sum")); |
12844 | } |
12845 | { // shift_expr '>>' sum |
12846 | if (p->error_indicator) { Branch (12846:13): [True: 0, False: 4.04M]
|
12847 | p->level--; |
12848 | return NULL; |
12849 | } |
12850 | D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum")); |
12851 | Token * _literal; |
12852 | expr_ty a; |
12853 | expr_ty b; |
12854 | if ( |
12855 | (a = shift_expr_rule(p)) // shift_expr Branch (12855:13): [True: 1.77M, False: 2.27M]
|
12856 | && |
12857 | (_literal = _PyPegen_expect_token(p, 34))1.77M // token='>>' Branch (12857:13): [True: 130, False: 1.77M]
|
12858 | && |
12859 | (b = sum_rule(p))130 // sum Branch (12859:13): [True: 130, False: 0]
|
12860 | ) |
12861 | { |
12862 | D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum")); |
12863 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
12864 | if (_token == NULL) { Branch (12864:17): [True: 0, False: 130]
|
12865 | p->level--; |
12866 | return NULL; |
12867 | } |
12868 | int _end_lineno = _token->end_lineno; |
12869 | UNUSED(_end_lineno); // Only used by EXTRA macro |
12870 | int _end_col_offset = _token->end_col_offset; |
12871 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
12872 | _res = _PyAST_BinOp ( a , RShift , b , EXTRA ); |
12873 | if (_res == NULL && PyErr_Occurred()0 ) { |
12874 | p->error_indicator = 1; |
12875 | p->level--; |
12876 | return NULL; |
12877 | } |
12878 | goto done; |
12879 | } |
12880 | p->mark = _mark; |
12881 | D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', |
12882 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '>>' sum")); |
12883 | } |
12884 | { // sum |
12885 | if (p->error_indicator) { Branch (12885:13): [True: 0, False: 4.04M]
|
12886 | p->level--; |
12887 | return NULL; |
12888 | } |
12889 | D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum")); |
12890 | expr_ty sum_var; |
12891 | if ( |
12892 | (sum_var = sum_rule(p)) // sum Branch (12892:13): [True: 3.54M, False: 506k]
|
12893 | ) |
12894 | { |
12895 | D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum")); |
12896 | _res = sum_var; |
12897 | goto done; |
12898 | } |
12899 | p->mark = _mark; |
12900 | D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', |
12901 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum")); |
12902 | } |
12903 | _res = NULL; |
12904 | done: |
12905 | p->level--; |
12906 | return _res; |
12907 | } |
12908 | |
12909 | // Left-recursive |
12910 | // sum: sum '+' term | sum '-' term | term |
12911 | static expr_ty sum_raw(Parser *); |
12912 | static expr_ty |
12913 | sum_rule(Parser *p) |
12914 | { |
12915 | if (p->level++ == MAXSTACK) { Branch (12915:9): [True: 0, False: 12.2M]
|
12916 | p->error_indicator = 1; |
12917 | PyErr_NoMemory(); |
12918 | } |
12919 | expr_ty _res = NULL; |
12920 | if (_PyPegen_is_memoized(p, sum_type, &_res)) { Branch (12920:9): [True: 9.94M, False: 2.27M]
|
12921 | p->level--; |
12922 | return _res; |
12923 | } |
12924 | int _mark = p->mark; |
12925 | int _resmark = p->mark; |
12926 | while (1) { |
12927 | int tmpvar_6 = _PyPegen_update_memo(p, _mark, sum_type, _res); |
12928 | if (tmpvar_6) { Branch (12928:13): [True: 0, False: 4.09M]
|
12929 | p->level--; |
12930 | return _res; |
12931 | } |
12932 | p->mark = _mark; |
12933 | void *_raw = sum_raw(p); |
12934 | if (p->error_indicator) { Branch (12934:13): [True: 385, False: 4.09M]
|
12935 | p->level--; |
12936 | return NULL; |
12937 | } |
12938 | if (_raw == NULL || p->mark <= _resmark3.58M ) Branch (12938:13): [True: 505k, False: 3.58M]
Branch (12938:29): [True: 1.77M, False: 1.81M]
|
12939 | break; |
12940 | _resmark = p->mark; |
12941 | _res = _raw; |
12942 | } |
12943 | p->mark = _resmark; |
12944 | p->level--; |
12945 | return _res; |
12946 | } |
12947 | static expr_ty |
12948 | sum_raw(Parser *p) |
12949 | { |
12950 | if (p->level++ == MAXSTACK) { Branch (12950:9): [True: 0, False: 4.09M]
|
12951 | p->error_indicator = 1; |
12952 | PyErr_NoMemory(); |
12953 | } |
12954 | if (p->error_indicator) { Branch (12954:9): [True: 0, False: 4.09M]
|
12955 | p->level--; |
12956 | return NULL; |
12957 | } |
12958 | expr_ty _res = NULL; |
12959 | int _mark = p->mark; |
12960 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (12960:9): [True: 0, False: 4.09M]
Branch (12960:31): [True: 0, False: 0]
|
12961 | p->error_indicator = 1; |
12962 | p->level--; |
12963 | return NULL; |
12964 | } |
12965 | int _start_lineno = p->tokens[_mark]->lineno; |
12966 | UNUSED(_start_lineno); // Only used by EXTRA macro |
12967 | int _start_col_offset = p->tokens[_mark]->col_offset; |
12968 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
12969 | { // sum '+' term |
12970 | if (p->error_indicator) { Branch (12970:13): [True: 0, False: 4.09M]
|
12971 | p->level--; |
12972 | return NULL; |
12973 | } |
12974 | D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term")); |
12975 | Token * _literal; |
12976 | expr_ty a; |
12977 | expr_ty b; |
12978 | if ( |
12979 | (a = sum_rule(p)) // sum Branch (12979:13): [True: 1.81M, False: 2.27M]
|
12980 | && |
12981 | (_literal = _PyPegen_expect_token(p, 14))1.81M // token='+' Branch (12981:13): [True: 14.0k, False: 1.79M]
|
12982 | && |
12983 | (b = term_rule(p))14.0k // term Branch (12983:13): [True: 14.0k, False: 46]
|
12984 | ) |
12985 | { |
12986 | D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term")); |
12987 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
12988 | if (_token == NULL) { Branch (12988:17): [True: 0, False: 14.0k]
|
12989 | p->level--; |
12990 | return NULL; |
12991 | } |
12992 | int _end_lineno = _token->end_lineno; |
12993 | UNUSED(_end_lineno); // Only used by EXTRA macro |
12994 | int _end_col_offset = _token->end_col_offset; |
12995 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
12996 | _res = _PyAST_BinOp ( a , Add , b , EXTRA ); |
12997 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (12997:17): [True: 0, False: 14.0k]
Branch (12997:33): [True: 0, False: 0]
|
12998 | p->error_indicator = 1; |
12999 | p->level--; |
13000 | return NULL; |
13001 | } |
13002 | goto done; |
13003 | } |
13004 | p->mark = _mark; |
13005 | D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', |
13006 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '+' term")); |
13007 | } |
13008 | { // sum '-' term |
13009 | if (p->error_indicator) { Branch (13009:13): [True: 14, False: 4.07M]
|
13010 | p->level--; |
13011 | return NULL; |
13012 | } |
13013 | D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term")); |
13014 | Token * _literal; |
13015 | expr_ty a; |
13016 | expr_ty b; |
13017 | if ( |
13018 | (a = sum_rule(p)) // sum Branch (13018:13): [True: 1.79M, False: 2.27M]
|
13019 | && |
13020 | (_literal = _PyPegen_expect_token(p, 15))1.79M // token='-' Branch (13020:13): [True: 27.0k, False: 1.77M]
|
13021 | && |
13022 | (b = term_rule(p))27.0k // term Branch (13022:13): [True: 27.0k, False: 1]
|
13023 | ) |
13024 | { |
13025 | D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term")); |
13026 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13027 | if (_token == NULL) { Branch (13027:17): [True: 0, False: 27.0k]
|
13028 | p->level--; |
13029 | return NULL; |
13030 | } |
13031 | int _end_lineno = _token->end_lineno; |
13032 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13033 | int _end_col_offset = _token->end_col_offset; |
13034 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13035 | _res = _PyAST_BinOp ( a , Sub , b , EXTRA ); |
13036 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13036:17): [True: 0, False: 27.0k]
Branch (13036:33): [True: 0, False: 0]
|
13037 | p->error_indicator = 1; |
13038 | p->level--; |
13039 | return NULL; |
13040 | } |
13041 | goto done; |
13042 | } |
13043 | p->mark = _mark; |
13044 | D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', |
13045 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '-' term")); |
13046 | } |
13047 | { // term |
13048 | if (p->error_indicator) { Branch (13048:13): [True: 1, False: 4.05M]
|
13049 | p->level--; |
13050 | return NULL; |
13051 | } |
13052 | D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term")); |
13053 | expr_ty term_var; |
13054 | if ( |
13055 | (term_var = term_rule(p)) // term Branch (13055:13): [True: 3.54M, False: 506k]
|
13056 | ) |
13057 | { |
13058 | D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term")); |
13059 | _res = term_var; |
13060 | goto done; |
13061 | } |
13062 | p->mark = _mark; |
13063 | D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', |
13064 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term")); |
13065 | } |
13066 | _res = NULL; |
13067 | done: |
13068 | p->level--; |
13069 | return _res; |
13070 | } |
13071 | |
13072 | // Left-recursive |
13073 | // term: |
13074 | // | term '*' factor |
13075 | // | term '/' factor |
13076 | // | term '//' factor |
13077 | // | term '%' factor |
13078 | // | term '@' factor |
13079 | // | factor |
13080 | static expr_ty term_raw(Parser *); |
13081 | static expr_ty |
13082 | term_rule(Parser *p) |
13083 | { |
13084 | if (p->level++ == MAXSTACK) { Branch (13084:9): [True: 0, False: 25.1M]
|
13085 | p->error_indicator = 1; |
13086 | PyErr_NoMemory(); |
13087 | } |
13088 | expr_ty _res = NULL; |
13089 | if (_PyPegen_is_memoized(p, term_type, &_res)) { Branch (13089:9): [True: 22.8M, False: 2.31M]
|
13090 | p->level--; |
13091 | return _res; |
13092 | } |
13093 | int _mark = p->mark; |
13094 | int _resmark = p->mark; |
13095 | while (1) { |
13096 | int tmpvar_7 = _PyPegen_update_memo(p, _mark, term_type, _res); |
13097 | if (tmpvar_7) { Branch (13097:13): [True: 0, False: 4.46M]
|
13098 | p->level--; |
13099 | return _res; |
13100 | } |
13101 | p->mark = _mark; |
13102 | void *_raw = term_raw(p); |
13103 | if (p->error_indicator) { Branch (13103:13): [True: 375, False: 4.46M]
|
13104 | p->level--; |
13105 | return NULL; |
13106 | } |
13107 | if (_raw == NULL || p->mark <= _resmark3.96M ) Branch (13107:13): [True: 506k, False: 3.96M]
Branch (13107:29): [True: 1.81M, False: 2.14M]
|
13108 | break; |
13109 | _resmark = p->mark; |
13110 | _res = _raw; |
13111 | } |
13112 | p->mark = _resmark; |
13113 | p->level--; |
13114 | return _res; |
13115 | } |
13116 | static expr_ty |
13117 | term_raw(Parser *p) |
13118 | { |
13119 | if (p->level++ == MAXSTACK) { Branch (13119:9): [True: 0, False: 4.46M]
|
13120 | p->error_indicator = 1; |
13121 | PyErr_NoMemory(); |
13122 | } |
13123 | if (p->error_indicator) { Branch (13123:9): [True: 0, False: 4.46M]
|
13124 | p->level--; |
13125 | return NULL; |
13126 | } |
13127 | expr_ty _res = NULL; |
13128 | int _mark = p->mark; |
13129 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (13129:9): [True: 0, False: 4.46M]
Branch (13129:31): [True: 0, False: 0]
|
13130 | p->error_indicator = 1; |
13131 | p->level--; |
13132 | return NULL; |
13133 | } |
13134 | int _start_lineno = p->tokens[_mark]->lineno; |
13135 | UNUSED(_start_lineno); // Only used by EXTRA macro |
13136 | int _start_col_offset = p->tokens[_mark]->col_offset; |
13137 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
13138 | { // term '*' factor |
13139 | if (p->error_indicator) { Branch (13139:13): [True: 0, False: 4.46M]
|
13140 | p->level--; |
13141 | return NULL; |
13142 | } |
13143 | D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor")); |
13144 | Token * _literal; |
13145 | expr_ty a; |
13146 | expr_ty b; |
13147 | if ( |
13148 | (a = term_rule(p)) // term Branch (13148:13): [True: 2.14M, False: 2.31M]
|
13149 | && |
13150 | (_literal = _PyPegen_expect_token(p, 16))2.14M // token='*' Branch (13150:13): [True: 307k, False: 1.84M]
|
13151 | && |
13152 | (b = factor_rule(p))307k // factor Branch (13152:13): [True: 307k, False: 0]
|
13153 | ) |
13154 | { |
13155 | D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor")); |
13156 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13157 | if (_token == NULL) { Branch (13157:17): [True: 0, False: 307k]
|
13158 | p->level--; |
13159 | return NULL; |
13160 | } |
13161 | int _end_lineno = _token->end_lineno; |
13162 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13163 | int _end_col_offset = _token->end_col_offset; |
13164 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13165 | _res = _PyAST_BinOp ( a , Mult , b , EXTRA ); |
13166 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13166:17): [True: 0, False: 307k]
Branch (13166:33): [True: 0, False: 0]
|
13167 | p->error_indicator = 1; |
13168 | p->level--; |
13169 | return NULL; |
13170 | } |
13171 | goto done; |
13172 | } |
13173 | p->mark = _mark; |
13174 | D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', |
13175 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '*' factor")); |
13176 | } |
13177 | { // term '/' factor |
13178 | if (p->error_indicator) { Branch (13178:13): [True: 0, False: 4.16M]
|
13179 | p->level--; |
13180 | return NULL; |
13181 | } |
13182 | D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor")); |
13183 | Token * _literal; |
13184 | expr_ty a; |
13185 | expr_ty b; |
13186 | if ( |
13187 | (a = term_rule(p)) // term Branch (13187:13): [True: 1.84M, False: 2.31M]
|
13188 | && |
13189 | (_literal = _PyPegen_expect_token(p, 17))1.84M // token='/' Branch (13189:13): [True: 1.42k, False: 1.83M]
|
13190 | && |
13191 | (b = factor_rule(p))1.42k // factor Branch (13191:13): [True: 1.41k, False: 6]
|
13192 | ) |
13193 | { |
13194 | D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor")); |
13195 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13196 | if (_token == NULL) { Branch (13196:17): [True: 0, False: 1.41k]
|
13197 | p->level--; |
13198 | return NULL; |
13199 | } |
13200 | int _end_lineno = _token->end_lineno; |
13201 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13202 | int _end_col_offset = _token->end_col_offset; |
13203 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13204 | _res = _PyAST_BinOp ( a , Div , b , EXTRA ); |
13205 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13205:17): [True: 0, False: 1.41k]
Branch (13205:33): [True: 0, False: 0]
|
13206 | p->error_indicator = 1; |
13207 | p->level--; |
13208 | return NULL; |
13209 | } |
13210 | goto done; |
13211 | } |
13212 | p->mark = _mark; |
13213 | D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', |
13214 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '/' factor")); |
13215 | } |
13216 | { // term '//' factor |
13217 | if (p->error_indicator) { Branch (13217:13): [True: 0, False: 4.15M]
|
13218 | p->level--; |
13219 | return NULL; |
13220 | } |
13221 | D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor")); |
13222 | Token * _literal; |
13223 | expr_ty a; |
13224 | expr_ty b; |
13225 | if ( |
13226 | (a = term_rule(p)) // term Branch (13226:13): [True: 1.83M, False: 2.31M]
|
13227 | && |
13228 | (_literal = _PyPegen_expect_token(p, 47))1.83M // token='//' Branch (13228:13): [True: 328, False: 1.83M]
|
13229 | && |
13230 | (b = factor_rule(p))328 // factor Branch (13230:13): [True: 328, False: 0]
|
13231 | ) |
13232 | { |
13233 | D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor")); |
13234 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13235 | if (_token == NULL) { Branch (13235:17): [True: 0, False: 328]
|
13236 | p->level--; |
13237 | return NULL; |
13238 | } |
13239 | int _end_lineno = _token->end_lineno; |
13240 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13241 | int _end_col_offset = _token->end_col_offset; |
13242 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13243 | _res = _PyAST_BinOp ( a , FloorDiv , b , EXTRA ); |
13244 | if (_res == NULL && PyErr_Occurred()0 ) { |
13245 | p->error_indicator = 1; |
13246 | p->level--; |
13247 | return NULL; |
13248 | } |
13249 | goto done; |
13250 | } |
13251 | p->mark = _mark; |
13252 | D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', |
13253 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '//' factor")); |
13254 | } |
13255 | { // term '%' factor |
13256 | if (p->error_indicator) { Branch (13256:13): [True: 0, False: 4.15M]
|
13257 | p->level--; |
13258 | return NULL; |
13259 | } |
13260 | D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor")); |
13261 | Token * _literal; |
13262 | expr_ty a; |
13263 | expr_ty b; |
13264 | if ( |
13265 | (a = term_rule(p)) // term Branch (13265:13): [True: 1.83M, False: 2.31M]
|
13266 | && |
13267 | (_literal = _PyPegen_expect_token(p, 24))1.83M // token='%' Branch (13267:13): [True: 26.3k, False: 1.81M]
|
13268 | && |
13269 | (b = factor_rule(p))26.3k // factor Branch (13269:13): [True: 26.3k, False: 0]
|
13270 | ) |
13271 | { |
13272 | D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor")); |
13273 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13274 | if (_token == NULL) { Branch (13274:17): [True: 0, False: 26.3k]
|
13275 | p->level--; |
13276 | return NULL; |
13277 | } |
13278 | int _end_lineno = _token->end_lineno; |
13279 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13280 | int _end_col_offset = _token->end_col_offset; |
13281 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13282 | _res = _PyAST_BinOp ( a , Mod , b , EXTRA ); |
13283 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13283:17): [True: 0, False: 26.3k]
Branch (13283:33): [True: 0, False: 0]
|
13284 | p->error_indicator = 1; |
13285 | p->level--; |
13286 | return NULL; |
13287 | } |
13288 | goto done; |
13289 | } |
13290 | p->mark = _mark; |
13291 | D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', |
13292 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '%' factor")); |
13293 | } |
13294 | { // term '@' factor |
13295 | if (p->error_indicator) { Branch (13295:13): [True: 0, False: 4.13M]
|
13296 | p->level--; |
13297 | return NULL; |
13298 | } |
13299 | D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor")); |
13300 | Token * _literal; |
13301 | expr_ty a; |
13302 | expr_ty b; |
13303 | if ( |
13304 | (a = term_rule(p)) // term Branch (13304:13): [True: 1.81M, False: 2.31M]
|
13305 | && |
13306 | (_literal = _PyPegen_expect_token(p, 49))1.81M // token='@' Branch (13306:13): [True: 29, False: 1.81M]
|
13307 | && |
13308 | (b = factor_rule(p))29 // factor |
13309 | ) |
13310 | { |
13311 | D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' factor")); |
13312 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13313 | if (_token == NULL) { |
13314 | p->level--; |
13315 | return NULL; |
13316 | } |
13317 | int _end_lineno = _token->end_lineno; |
13318 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13319 | int _end_col_offset = _token->end_col_offset; |
13320 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13321 | _res = CHECK_VERSION ( expr_ty , 5 , "The '@' operator is" , _PyAST_BinOp ( a , MatMult , b , EXTRA ) ); |
13322 | if (_res == NULL && PyErr_Occurred()1 ) { |
13323 | p->error_indicator = 1; |
13324 | p->level--; |
13325 | return NULL; |
13326 | } |
13327 | goto done; |
13328 | } |
13329 | p->mark = _mark; |
13330 | D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', |
13331 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '@' factor")); |
13332 | } |
13333 | { // factor |
13334 | if (p->error_indicator) { Branch (13334:13): [True: 0, False: 4.13M]
|
13335 | p->level--; |
13336 | return NULL; |
13337 | } |
13338 | D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor")); |
13339 | expr_ty factor_var; |
13340 | if ( |
13341 | (factor_var = factor_rule(p)) // factor Branch (13341:13): [True: 3.62M, False: 506k]
|
13342 | ) |
13343 | { |
13344 | D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor")); |
13345 | _res = factor_var; |
13346 | goto done; |
13347 | } |
13348 | p->mark = _mark; |
13349 | D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', |
13350 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor")); |
13351 | } |
13352 | _res = NULL; |
13353 | done: |
13354 | p->level--; |
13355 | return _res; |
13356 | } |
13357 | |
13358 | // factor: '+' factor | '-' factor | '~' factor | power |
13359 | static expr_ty |
13360 | factor_rule(Parser *p) |
13361 | { |
13362 | if (p->level++ == MAXSTACK) { Branch (13362:9): [True: 3, False: 4.49M]
|
13363 | p->error_indicator = 1; |
13364 | PyErr_NoMemory(); |
13365 | } |
13366 | if (p->error_indicator) { Branch (13366:9): [True: 3, False: 4.49M]
|
13367 | p->level--; |
13368 | return NULL; |
13369 | } |
13370 | expr_ty _res = NULL; |
13371 | if (_PyPegen_is_memoized(p, factor_type, &_res)) { Branch (13371:9): [True: 1.81M, False: 2.67M]
|
13372 | p->level--; |
13373 | return _res; |
13374 | } |
13375 | int _mark = p->mark; |
13376 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (13376:9): [True: 0, False: 2.67M]
Branch (13376:31): [True: 0, False: 0]
|
13377 | p->error_indicator = 1; |
13378 | p->level--; |
13379 | return NULL; |
13380 | } |
13381 | int _start_lineno = p->tokens[_mark]->lineno; |
13382 | UNUSED(_start_lineno); // Only used by EXTRA macro |
13383 | int _start_col_offset = p->tokens[_mark]->col_offset; |
13384 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
13385 | { // '+' factor |
13386 | if (p->error_indicator) { Branch (13386:13): [True: 0, False: 2.67M]
|
13387 | p->level--; |
13388 | return NULL; |
13389 | } |
13390 | D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor")); |
13391 | Token * _literal; |
13392 | expr_ty a; |
13393 | if ( |
13394 | (_literal = _PyPegen_expect_token(p, 14)) // token='+' Branch (13394:13): [True: 684, False: 2.67M]
|
13395 | && |
13396 | (a = factor_rule(p))684 // factor Branch (13396:13): [True: 660, False: 24]
|
13397 | ) |
13398 | { |
13399 | D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor")); |
13400 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13401 | if (_token == NULL) { Branch (13401:17): [True: 0, False: 660]
|
13402 | p->level--; |
13403 | return NULL; |
13404 | } |
13405 | int _end_lineno = _token->end_lineno; |
13406 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13407 | int _end_col_offset = _token->end_col_offset; |
13408 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13409 | _res = _PyAST_UnaryOp ( UAdd , a , EXTRA ); |
13410 | if (_res == NULL && PyErr_Occurred()0 ) { |
13411 | p->error_indicator = 1; |
13412 | p->level--; |
13413 | return NULL; |
13414 | } |
13415 | goto done; |
13416 | } |
13417 | p->mark = _mark; |
13418 | D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', |
13419 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor")); |
13420 | } |
13421 | { // '-' factor |
13422 | if (p->error_indicator) { Branch (13422:13): [True: 0, False: 2.67M]
|
13423 | p->level--; |
13424 | return NULL; |
13425 | } |
13426 | D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor")); |
13427 | Token * _literal; |
13428 | expr_ty a; |
13429 | if ( |
13430 | (_literal = _PyPegen_expect_token(p, 15)) // token='-' Branch (13430:13): [True: 21.5k, False: 2.65M]
|
13431 | && |
13432 | (a = factor_rule(p))21.5k // factor Branch (13432:13): [True: 3.58k, False: 17.9k]
|
13433 | ) |
13434 | { |
13435 | D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor")); |
13436 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13437 | if (_token == NULL) { Branch (13437:17): [True: 0, False: 3.58k]
|
13438 | p->level--; |
13439 | return NULL; |
13440 | } |
13441 | int _end_lineno = _token->end_lineno; |
13442 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13443 | int _end_col_offset = _token->end_col_offset; |
13444 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13445 | _res = _PyAST_UnaryOp ( USub , a , EXTRA ); |
13446 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13446:17): [True: 0, False: 3.58k]
Branch (13446:33): [True: 0, False: 0]
|
13447 | p->error_indicator = 1; |
13448 | p->level--; |
13449 | return NULL; |
13450 | } |
13451 | goto done; |
13452 | } |
13453 | p->mark = _mark; |
13454 | D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', |
13455 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor")); |
13456 | } |
13457 | { // '~' factor |
13458 | if (p->error_indicator) { Branch (13458:13): [True: 17.9k, False: 2.65M]
|
13459 | p->level--; |
13460 | return NULL; |
13461 | } |
13462 | D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor")); |
13463 | Token * _literal; |
13464 | expr_ty a; |
13465 | if ( |
13466 | (_literal = _PyPegen_expect_token(p, 31)) // token='~' Branch (13466:13): [True: 154, False: 2.65M]
|
13467 | && |
13468 | (a = factor_rule(p))154 // factor Branch (13468:13): [True: 154, False: 0]
|
13469 | ) |
13470 | { |
13471 | D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor")); |
13472 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13473 | if (_token == NULL) { Branch (13473:17): [True: 0, False: 154]
|
13474 | p->level--; |
13475 | return NULL; |
13476 | } |
13477 | int _end_lineno = _token->end_lineno; |
13478 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13479 | int _end_col_offset = _token->end_col_offset; |
13480 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13481 | _res = _PyAST_UnaryOp ( Invert , a , EXTRA ); |
13482 | if (_res == NULL && PyErr_Occurred()0 ) { |
13483 | p->error_indicator = 1; |
13484 | p->level--; |
13485 | return NULL; |
13486 | } |
13487 | goto done; |
13488 | } |
13489 | p->mark = _mark; |
13490 | D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', |
13491 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor")); |
13492 | } |
13493 | { // power |
13494 | if (p->error_indicator) { Branch (13494:13): [True: 0, False: 2.65M]
|
13495 | p->level--; |
13496 | return NULL; |
13497 | } |
13498 | D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power")); |
13499 | expr_ty power_var; |
13500 | if ( |
13501 | (power_var = power_rule(p)) // power Branch (13501:13): [True: 2.14M, False: 506k]
|
13502 | ) |
13503 | { |
13504 | D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power")); |
13505 | _res = power_var; |
13506 | goto done; |
13507 | } |
13508 | p->mark = _mark; |
13509 | D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', |
13510 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power")); |
13511 | } |
13512 | _res = NULL; |
13513 | done: |
13514 | _PyPegen_insert_memo(p, _mark, factor_type, _res); |
13515 | p->level--; |
13516 | return _res; |
13517 | } |
13518 | |
13519 | // power: await_primary '**' factor | await_primary |
13520 | static expr_ty |
13521 | power_rule(Parser *p) |
13522 | { |
13523 | if (p->level++ == MAXSTACK) { Branch (13523:9): [True: 0, False: 2.65M]
|
13524 | p->error_indicator = 1; |
13525 | PyErr_NoMemory(); |
13526 | } |
13527 | if (p->error_indicator) { Branch (13527:9): [True: 0, False: 2.65M]
|
13528 | p->level--; |
13529 | return NULL; |
13530 | } |
13531 | expr_ty _res = NULL; |
13532 | int _mark = p->mark; |
13533 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (13533:9): [True: 0, False: 2.65M]
Branch (13533:31): [True: 0, False: 0]
|
13534 | p->error_indicator = 1; |
13535 | p->level--; |
13536 | return NULL; |
13537 | } |
13538 | int _start_lineno = p->tokens[_mark]->lineno; |
13539 | UNUSED(_start_lineno); // Only used by EXTRA macro |
13540 | int _start_col_offset = p->tokens[_mark]->col_offset; |
13541 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
13542 | { // await_primary '**' factor |
13543 | if (p->error_indicator) { Branch (13543:13): [True: 0, False: 2.65M]
|
13544 | p->level--; |
13545 | return NULL; |
13546 | } |
13547 | D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor")); |
13548 | Token * _literal; |
13549 | expr_ty a; |
13550 | expr_ty b; |
13551 | if ( |
13552 | (a = await_primary_rule(p)) // await_primary Branch (13552:13): [True: 2.14M, False: 506k]
|
13553 | && |
13554 | (_literal = _PyPegen_expect_token(p, 35))2.14M // token='**' Branch (13554:13): [True: 441, False: 2.14M]
|
13555 | && |
13556 | (b = factor_rule(p))441 // factor Branch (13556:13): [True: 436, False: 5]
|
13557 | ) |
13558 | { |
13559 | D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor")); |
13560 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13561 | if (_token == NULL) { Branch (13561:17): [True: 0, False: 436]
|
13562 | p->level--; |
13563 | return NULL; |
13564 | } |
13565 | int _end_lineno = _token->end_lineno; |
13566 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13567 | int _end_col_offset = _token->end_col_offset; |
13568 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13569 | _res = _PyAST_BinOp ( a , Pow , b , EXTRA ); |
13570 | if (_res == NULL && PyErr_Occurred()0 ) { |
13571 | p->error_indicator = 1; |
13572 | p->level--; |
13573 | return NULL; |
13574 | } |
13575 | goto done; |
13576 | } |
13577 | p->mark = _mark; |
13578 | D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ', |
13579 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary '**' factor")); |
13580 | } |
13581 | { // await_primary |
13582 | if (p->error_indicator) { Branch (13582:13): [True: 371, False: 2.65M]
|
13583 | p->level--; |
13584 | return NULL; |
13585 | } |
13586 | D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary")); |
13587 | expr_ty await_primary_var; |
13588 | if ( |
13589 | (await_primary_var = await_primary_rule(p)) // await_primary Branch (13589:13): [True: 2.14M, False: 506k]
|
13590 | ) |
13591 | { |
13592 | D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary")); |
13593 | _res = await_primary_var; |
13594 | goto done; |
13595 | } |
13596 | p->mark = _mark; |
13597 | D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ', |
13598 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary")); |
13599 | } |
13600 | _res = NULL; |
13601 | done: |
13602 | p->level--; |
13603 | return _res; |
13604 | } |
13605 | |
13606 | // await_primary: AWAIT primary | primary |
13607 | static expr_ty |
13608 | await_primary_rule(Parser *p) |
13609 | { |
13610 | if (p->level++ == MAXSTACK) { Branch (13610:9): [True: 0, False: 5.30M]
|
13611 | p->error_indicator = 1; |
13612 | PyErr_NoMemory(); |
13613 | } |
13614 | if (p->error_indicator) { Branch (13614:9): [True: 0, False: 5.30M]
|
13615 | p->level--; |
13616 | return NULL; |
13617 | } |
13618 | expr_ty _res = NULL; |
13619 | if (_PyPegen_is_memoized(p, await_primary_type, &_res)) { Branch (13619:9): [True: 2.65M, False: 2.65M]
|
13620 | p->level--; |
13621 | return _res; |
13622 | } |
13623 | int _mark = p->mark; |
13624 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (13624:9): [True: 0, False: 2.65M]
Branch (13624:31): [True: 0, False: 0]
|
13625 | p->error_indicator = 1; |
13626 | p->level--; |
13627 | return NULL; |
13628 | } |
13629 | int _start_lineno = p->tokens[_mark]->lineno; |
13630 | UNUSED(_start_lineno); // Only used by EXTRA macro |
13631 | int _start_col_offset = p->tokens[_mark]->col_offset; |
13632 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
13633 | { // AWAIT primary |
13634 | if (p->error_indicator) { Branch (13634:13): [True: 0, False: 2.65M]
|
13635 | p->level--; |
13636 | return NULL; |
13637 | } |
13638 | D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AWAIT primary")); |
13639 | expr_ty a; |
13640 | Token * await_var; |
13641 | if ( |
13642 | (await_var = _PyPegen_expect_token(p, AWAIT)) // token='AWAIT' Branch (13642:13): [True: 199, False: 2.65M]
|
13643 | && |
13644 | (a = primary_rule(p))199 // primary Branch (13644:13): [True: 167, False: 32]
|
13645 | ) |
13646 | { |
13647 | D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AWAIT primary")); |
13648 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13649 | if (_token == NULL) { Branch (13649:17): [True: 0, False: 167]
|
13650 | p->level--; |
13651 | return NULL; |
13652 | } |
13653 | int _end_lineno = _token->end_lineno; |
13654 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13655 | int _end_col_offset = _token->end_col_offset; |
13656 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13657 | _res = CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( a , EXTRA ) ); |
13658 | if (_res == NULL && PyErr_Occurred()1 ) { |
13659 | p->error_indicator = 1; |
13660 | p->level--; |
13661 | return NULL; |
13662 | } |
13663 | goto done; |
13664 | } |
13665 | p->mark = _mark; |
13666 | D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', |
13667 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "AWAIT primary")); |
13668 | } |
13669 | { // primary |
13670 | if (p->error_indicator) { Branch (13670:13): [True: 0, False: 2.65M]
|
13671 | p->level--; |
13672 | return NULL; |
13673 | } |
13674 | D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary")); |
13675 | expr_ty primary_var; |
13676 | if ( |
13677 | (primary_var = primary_rule(p)) // primary Branch (13677:13): [True: 2.14M, False: 506k]
|
13678 | ) |
13679 | { |
13680 | D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary")); |
13681 | _res = primary_var; |
13682 | goto done; |
13683 | } |
13684 | p->mark = _mark; |
13685 | D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', |
13686 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary")); |
13687 | } |
13688 | _res = NULL; |
13689 | done: |
13690 | _PyPegen_insert_memo(p, _mark, await_primary_type, _res); |
13691 | p->level--; |
13692 | return _res; |
13693 | } |
13694 | |
13695 | // Left-recursive |
13696 | // primary: |
13697 | // | primary '.' NAME |
13698 | // | primary genexp |
13699 | // | primary '(' arguments? ')' |
13700 | // | primary '[' slices ']' |
13701 | // | atom |
13702 | static expr_ty primary_raw(Parser *); |
13703 | static expr_ty |
13704 | primary_rule(Parser *p) |
13705 | { |
13706 | if (p->level++ == MAXSTACK) { Branch (13706:9): [True: 0, False: 24.7M]
|
13707 | p->error_indicator = 1; |
13708 | PyErr_NoMemory(); |
13709 | } |
13710 | expr_ty _res = NULL; |
13711 | if (_PyPegen_is_memoized(p, primary_type, &_res)) { Branch (13711:9): [True: 22.1M, False: 2.65M]
|
13712 | p->level--; |
13713 | return _res; |
13714 | } |
13715 | int _mark = p->mark; |
13716 | int _resmark = p->mark; |
13717 | while (1) { |
13718 | int tmpvar_8 = _PyPegen_update_memo(p, _mark, primary_type, _res); |
13719 | if (tmpvar_8) { Branch (13719:13): [True: 0, False: 5.94M]
|
13720 | p->level--; |
13721 | return _res; |
13722 | } |
13723 | p->mark = _mark; |
13724 | void *_raw = primary_raw(p); |
13725 | if (p->error_indicator) { Branch (13725:13): [True: 368, False: 5.94M]
|
13726 | p->level--; |
13727 | return NULL; |
13728 | } |
13729 | if (_raw == NULL || p->mark <= _resmark5.44M ) Branch (13729:13): [True: 506k, False: 5.44M]
Branch (13729:29): [True: 2.14M, False: 3.29M]
|
13730 | break; |
13731 | _resmark = p->mark; |
13732 | _res = _raw; |
13733 | } |
13734 | p->mark = _resmark; |
13735 | p->level--; |
13736 | return _res; |
13737 | } |
13738 | static expr_ty |
13739 | primary_raw(Parser *p) |
13740 | { |
13741 | if (p->level++ == MAXSTACK) { Branch (13741:9): [True: 0, False: 5.94M]
|
13742 | p->error_indicator = 1; |
13743 | PyErr_NoMemory(); |
13744 | } |
13745 | if (p->error_indicator) { Branch (13745:9): [True: 0, False: 5.94M]
|
13746 | p->level--; |
13747 | return NULL; |
13748 | } |
13749 | expr_ty _res = NULL; |
13750 | int _mark = p->mark; |
13751 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (13751:9): [True: 0, False: 5.94M]
Branch (13751:31): [True: 0, False: 0]
|
13752 | p->error_indicator = 1; |
13753 | p->level--; |
13754 | return NULL; |
13755 | } |
13756 | int _start_lineno = p->tokens[_mark]->lineno; |
13757 | UNUSED(_start_lineno); // Only used by EXTRA macro |
13758 | int _start_col_offset = p->tokens[_mark]->col_offset; |
13759 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
13760 | { // primary '.' NAME |
13761 | if (p->error_indicator) { Branch (13761:13): [True: 0, False: 5.94M]
|
13762 | p->level--; |
13763 | return NULL; |
13764 | } |
13765 | D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME")); |
13766 | Token * _literal; |
13767 | expr_ty a; |
13768 | expr_ty b; |
13769 | if ( |
13770 | (a = primary_rule(p)) // primary Branch (13770:13): [True: 3.29M, False: 2.65M]
|
13771 | && |
13772 | (_literal = _PyPegen_expect_token(p, 23))3.29M // token='.' Branch (13772:13): [True: 411k, False: 2.88M]
|
13773 | && |
13774 | (b = _PyPegen_name_token(p))411k // NAME Branch (13774:13): [True: 411k, False: 26]
|
13775 | ) |
13776 | { |
13777 | D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME")); |
13778 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13779 | if (_token == NULL) { Branch (13779:17): [True: 0, False: 411k]
|
13780 | p->level--; |
13781 | return NULL; |
13782 | } |
13783 | int _end_lineno = _token->end_lineno; |
13784 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13785 | int _end_col_offset = _token->end_col_offset; |
13786 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13787 | _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA ); |
13788 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13788:17): [True: 0, False: 411k]
Branch (13788:33): [True: 0, False: 0]
|
13789 | p->error_indicator = 1; |
13790 | p->level--; |
13791 | return NULL; |
13792 | } |
13793 | goto done; |
13794 | } |
13795 | p->mark = _mark; |
13796 | D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', |
13797 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '.' NAME")); |
13798 | } |
13799 | { // primary genexp |
13800 | if (p->error_indicator) { Branch (13800:13): [True: 22, False: 5.53M]
|
13801 | p->level--; |
13802 | return NULL; |
13803 | } |
13804 | D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp")); |
13805 | expr_ty a; |
13806 | expr_ty b; |
13807 | if ( |
13808 | (a = primary_rule(p)) // primary Branch (13808:13): [True: 2.88M, False: 2.65M]
|
13809 | && |
13810 | (b = genexp_rule(p))2.88M // genexp Branch (13810:13): [True: 570, False: 2.88M]
|
13811 | ) |
13812 | { |
13813 | D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp")); |
13814 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13815 | if (_token == NULL) { Branch (13815:17): [True: 0, False: 570]
|
13816 | p->level--; |
13817 | return NULL; |
13818 | } |
13819 | int _end_lineno = _token->end_lineno; |
13820 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13821 | int _end_col_offset = _token->end_col_offset; |
13822 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13823 | _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA ); |
13824 | if (_res == NULL && PyErr_Occurred()0 ) { |
13825 | p->error_indicator = 1; |
13826 | p->level--; |
13827 | return NULL; |
13828 | } |
13829 | goto done; |
13830 | } |
13831 | p->mark = _mark; |
13832 | D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', |
13833 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary genexp")); |
13834 | } |
13835 | { // primary '(' arguments? ')' |
13836 | if (p->error_indicator) { Branch (13836:13): [True: 4, False: 5.53M]
|
13837 | p->level--; |
13838 | return NULL; |
13839 | } |
13840 | D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'")); |
13841 | Token * _literal; |
13842 | Token * _literal_1; |
13843 | expr_ty a; |
13844 | void *b; |
13845 | if ( |
13846 | (a = primary_rule(p)) // primary Branch (13846:13): [True: 2.88M, False: 2.65M]
|
13847 | && |
13848 | (_literal = _PyPegen_expect_token(p, 7))2.88M // token='(' Branch (13848:13): [True: 413k, False: 2.46M]
|
13849 | && |
13850 | (b = arguments_rule(p), !p->error_indicator)413k // arguments? Branch (13850:13): [True: 413k, False: 13]
|
13851 | && |
13852 | (_literal_1 = _PyPegen_expect_token(p, 8))413k // token=')' Branch (13852:13): [True: 413k, False: 83]
|
13853 | ) |
13854 | { |
13855 | D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'")); |
13856 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13857 | if (_token == NULL) { Branch (13857:17): [True: 0, False: 413k]
|
13858 | p->level--; |
13859 | return NULL; |
13860 | } |
13861 | int _end_lineno = _token->end_lineno; |
13862 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13863 | int _end_col_offset = _token->end_col_offset; |
13864 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13865 | _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args89.8k : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords89.8k : NULL , EXTRA ); Branch (13865:38): [True: 89.8k, False: 323k]
Branch (13865:92): [True: 89.8k, False: 323k]
|
13866 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13866:17): [True: 0, False: 413k]
Branch (13866:33): [True: 0, False: 0]
|
13867 | p->error_indicator = 1; |
13868 | p->level--; |
13869 | return NULL; |
13870 | } |
13871 | goto done; |
13872 | } |
13873 | p->mark = _mark; |
13874 | D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', |
13875 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '(' arguments? ')'")); |
13876 | } |
13877 | { // primary '[' slices ']' |
13878 | if (p->error_indicator) { Branch (13878:13): [True: 13, False: 5.12M]
|
13879 | p->level--; |
13880 | return NULL; |
13881 | } |
13882 | D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'")); |
13883 | Token * _literal; |
13884 | Token * _literal_1; |
13885 | expr_ty a; |
13886 | expr_ty b; |
13887 | if ( |
13888 | (a = primary_rule(p)) // primary Branch (13888:13): [True: 2.46M, False: 2.65M]
|
13889 | && |
13890 | (_literal = _PyPegen_expect_token(p, 9))2.46M // token='[' Branch (13890:13): [True: 318k, False: 2.14M]
|
13891 | && |
13892 | (b = slices_rule(p))318k // slices Branch (13892:13): [True: 318k, False: 20]
|
13893 | && |
13894 | (_literal_1 = _PyPegen_expect_token(p, 10))318k // token=']' Branch (13894:13): [True: 318k, False: 18]
|
13895 | ) |
13896 | { |
13897 | D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'")); |
13898 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
13899 | if (_token == NULL) { Branch (13899:17): [True: 0, False: 318k]
|
13900 | p->level--; |
13901 | return NULL; |
13902 | } |
13903 | int _end_lineno = _token->end_lineno; |
13904 | UNUSED(_end_lineno); // Only used by EXTRA macro |
13905 | int _end_col_offset = _token->end_col_offset; |
13906 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
13907 | _res = _PyAST_Subscript ( a , b , Load , EXTRA ); |
13908 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13908:17): [True: 0, False: 318k]
Branch (13908:33): [True: 0, False: 0]
|
13909 | p->error_indicator = 1; |
13910 | p->level--; |
13911 | return NULL; |
13912 | } |
13913 | goto done; |
13914 | } |
13915 | p->mark = _mark; |
13916 | D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', |
13917 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '[' slices ']'")); |
13918 | } |
13919 | { // atom |
13920 | if (p->error_indicator) { Branch (13920:13): [True: 1, False: 4.80M]
|
13921 | p->level--; |
13922 | return NULL; |
13923 | } |
13924 | D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom")); |
13925 | expr_ty atom_var; |
13926 | if ( |
13927 | (atom_var = atom_rule(p)) // atom Branch (13927:13): [True: 4.29M, False: 506k]
|
13928 | ) |
13929 | { |
13930 | D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom")); |
13931 | _res = atom_var; |
13932 | goto done; |
13933 | } |
13934 | p->mark = _mark; |
13935 | D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', |
13936 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom")); |
13937 | } |
13938 | _res = NULL; |
13939 | done: |
13940 | p->level--; |
13941 | return _res; |
13942 | } |
13943 | |
13944 | // slices: slice !',' | ','.(slice | starred_expression)+ ','? |
13945 | static expr_ty |
13946 | slices_rule(Parser *p) |
13947 | { |
13948 | if (p->level++ == MAXSTACK) { Branch (13948:9): [True: 0, False: 642k]
|
13949 | p->error_indicator = 1; |
13950 | PyErr_NoMemory(); |
13951 | } |
13952 | if (p->error_indicator) { Branch (13952:9): [True: 0, False: 642k]
|
13953 | p->level--; |
13954 | return NULL; |
13955 | } |
13956 | expr_ty _res = NULL; |
13957 | int _mark = p->mark; |
13958 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0322k ) { Branch (13958:9): [True: 322k, False: 319k]
Branch (13958:31): [True: 2, False: 322k]
|
13959 | p->error_indicator = 1; |
13960 | p->level--; |
13961 | return NULL; |
13962 | } |
13963 | int _start_lineno = p->tokens[_mark]->lineno; |
13964 | UNUSED(_start_lineno); // Only used by EXTRA macro |
13965 | int _start_col_offset = p->tokens[_mark]->col_offset; |
13966 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
13967 | { // slice !',' |
13968 | if (p->error_indicator) { Branch (13968:13): [True: 0, False: 642k]
|
13969 | p->level--; |
13970 | return NULL; |
13971 | } |
13972 | D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','")); |
13973 | expr_ty a; |
13974 | if ( |
13975 | (a = slice_rule(p)) // slice Branch (13975:13): [True: 641k, False: 872]
|
13976 | && |
13977 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)641k // token=',' Branch (13977:13): [True: 639k, False: 1.97k]
|
13978 | ) |
13979 | { |
13980 | D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !','")); |
13981 | _res = a; |
13982 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (13982:17): [True: 0, False: 639k]
Branch (13982:33): [True: 0, False: 0]
|
13983 | p->error_indicator = 1; |
13984 | p->level--; |
13985 | return NULL; |
13986 | } |
13987 | goto done; |
13988 | } |
13989 | p->mark = _mark; |
13990 | D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', |
13991 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','")); |
13992 | } |
13993 | { // ','.(slice | starred_expression)+ ','? |
13994 | if (p->error_indicator) { Branch (13994:13): [True: 13, False: 2.83k]
|
13995 | p->level--; |
13996 | return NULL; |
13997 | } |
13998 | D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(slice | starred_expression)+ ','?")); |
13999 | void *_opt_var; |
14000 | UNUSED(_opt_var); // Silence compiler warnings |
14001 | asdl_expr_seq* a; |
14002 | if ( |
14003 | (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(slice | starred_expression)+ Branch (14003:13): [True: 2.73k, False: 95]
|
14004 | && |
14005 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)2.73k // ','? Branch (14005:13): [True: 2.73k, False: 2]
|
14006 | ) |
14007 | { |
14008 | D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(slice | starred_expression)+ ','?")); |
14009 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14010 | if (_token == NULL) { Branch (14010:17): [True: 0, False: 2.73k]
|
14011 | p->level--; |
14012 | return NULL; |
14013 | } |
14014 | int _end_lineno = _token->end_lineno; |
14015 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14016 | int _end_col_offset = _token->end_col_offset; |
14017 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14018 | _res = _PyAST_Tuple ( a , Load , EXTRA ); |
14019 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14019:17): [True: 0, False: 2.73k]
Branch (14019:33): [True: 0, False: 0]
|
14020 | p->error_indicator = 1; |
14021 | p->level--; |
14022 | return NULL; |
14023 | } |
14024 | goto done; |
14025 | } |
14026 | p->mark = _mark; |
14027 | D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', |
14028 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(slice | starred_expression)+ ','?")); |
14029 | } |
14030 | _res = NULL; |
14031 | done: |
14032 | p->level--; |
14033 | return _res; |
14034 | } |
14035 | |
14036 | // slice: expression? ':' expression? [':' expression?] | named_expression |
14037 | static expr_ty |
14038 | slice_rule(Parser *p) |
14039 | { |
14040 | if (p->level++ == MAXSTACK) { Branch (14040:9): [True: 0, False: 647k]
|
14041 | p->error_indicator = 1; |
14042 | PyErr_NoMemory(); |
14043 | } |
14044 | if (p->error_indicator) { Branch (14044:9): [True: 0, False: 647k]
|
14045 | p->level--; |
14046 | return NULL; |
14047 | } |
14048 | expr_ty _res = NULL; |
14049 | int _mark = p->mark; |
14050 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 02.11k ) { Branch (14050:9): [True: 2.11k, False: 645k]
Branch (14050:31): [True: 2, False: 2.11k]
|
14051 | p->error_indicator = 1; |
14052 | p->level--; |
14053 | return NULL; |
14054 | } |
14055 | int _start_lineno = p->tokens[_mark]->lineno; |
14056 | UNUSED(_start_lineno); // Only used by EXTRA macro |
14057 | int _start_col_offset = p->tokens[_mark]->col_offset; |
14058 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
14059 | { // expression? ':' expression? [':' expression?] |
14060 | if (p->error_indicator) { Branch (14060:13): [True: 0, False: 647k]
|
14061 | p->level--; |
14062 | return NULL; |
14063 | } |
14064 | D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]")); |
14065 | Token * _literal; |
14066 | void *a; |
14067 | void *b; |
14068 | void *c; |
14069 | if ( |
14070 | (a = expression_rule(p), !p->error_indicator) // expression? Branch (14070:13): [True: 647k, False: 4]
|
14071 | && |
14072 | (_literal = _PyPegen_expect_token(p, 11))647k // token=':' Branch (14072:13): [True: 5.36k, False: 642k]
|
14073 | && |
14074 | (b = expression_rule(p), !p->error_indicator)5.36k // expression? Branch (14074:13): [True: 5.36k, False: 5]
|
14075 | && |
14076 | (c = _tmp_90_rule(p), !p->error_indicator)5.36k // [':' expression?] Branch (14076:13): [True: 5.36k, False: 4]
|
14077 | ) |
14078 | { |
14079 | D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]")); |
14080 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14081 | if (_token == NULL) { Branch (14081:17): [True: 0, False: 5.36k]
|
14082 | p->level--; |
14083 | return NULL; |
14084 | } |
14085 | int _end_lineno = _token->end_lineno; |
14086 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14087 | int _end_col_offset = _token->end_col_offset; |
14088 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14089 | _res = _PyAST_Slice ( a , b , c , EXTRA ); |
14090 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14090:17): [True: 0, False: 5.36k]
Branch (14090:33): [True: 0, False: 0]
|
14091 | p->error_indicator = 1; |
14092 | p->level--; |
14093 | return NULL; |
14094 | } |
14095 | goto done; |
14096 | } |
14097 | p->mark = _mark; |
14098 | D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', |
14099 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]")); |
14100 | } |
14101 | { // named_expression |
14102 | if (p->error_indicator) { Branch (14102:13): [True: 13, False: 642k]
|
14103 | p->level--; |
14104 | return NULL; |
14105 | } |
14106 | D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); |
14107 | expr_ty a; |
14108 | if ( |
14109 | (a = named_expression_rule(p)) // named_expression Branch (14109:13): [True: 640k, False: 2.52k]
|
14110 | ) |
14111 | { |
14112 | D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); |
14113 | _res = a; |
14114 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14114:17): [True: 0, False: 640k]
Branch (14114:33): [True: 0, False: 0]
|
14115 | p->error_indicator = 1; |
14116 | p->level--; |
14117 | return NULL; |
14118 | } |
14119 | goto done; |
14120 | } |
14121 | p->mark = _mark; |
14122 | D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', |
14123 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); |
14124 | } |
14125 | _res = NULL; |
14126 | done: |
14127 | p->level--; |
14128 | return _res; |
14129 | } |
14130 | |
14131 | // atom: |
14132 | // | NAME |
14133 | // | 'True' |
14134 | // | 'False' |
14135 | // | 'None' |
14136 | // | &STRING strings |
14137 | // | NUMBER |
14138 | // | &'(' (tuple | group | genexp) |
14139 | // | &'[' (list | listcomp) |
14140 | // | &'{' (dict | set | dictcomp | setcomp) |
14141 | // | '...' |
14142 | static expr_ty |
14143 | atom_rule(Parser *p) |
14144 | { |
14145 | if (p->level++ == MAXSTACK) { Branch (14145:9): [True: 0, False: 5.47M]
|
14146 | p->error_indicator = 1; |
14147 | PyErr_NoMemory(); |
14148 | } |
14149 | if (p->error_indicator) { Branch (14149:9): [True: 0, False: 5.47M]
|
14150 | p->level--; |
14151 | return NULL; |
14152 | } |
14153 | expr_ty _res = NULL; |
14154 | int _mark = p->mark; |
14155 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (14155:9): [True: 0, False: 5.47M]
Branch (14155:31): [True: 0, False: 0]
|
14156 | p->error_indicator = 1; |
14157 | p->level--; |
14158 | return NULL; |
14159 | } |
14160 | int _start_lineno = p->tokens[_mark]->lineno; |
14161 | UNUSED(_start_lineno); // Only used by EXTRA macro |
14162 | int _start_col_offset = p->tokens[_mark]->col_offset; |
14163 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
14164 | { // NAME |
14165 | if (p->error_indicator) { Branch (14165:13): [True: 0, False: 5.47M]
|
14166 | p->level--; |
14167 | return NULL; |
14168 | } |
14169 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
14170 | expr_ty name_var; |
14171 | if ( |
14172 | (name_var = _PyPegen_name_token(p)) // NAME Branch (14172:13): [True: 2.84M, False: 2.63M]
|
14173 | ) |
14174 | { |
14175 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
14176 | _res = name_var; |
14177 | goto done; |
14178 | } |
14179 | p->mark = _mark; |
14180 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14181 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
14182 | } |
14183 | { // 'True' |
14184 | if (p->error_indicator) { Branch (14184:13): [True: 0, False: 2.63M]
|
14185 | p->level--; |
14186 | return NULL; |
14187 | } |
14188 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); |
14189 | Token * _keyword; |
14190 | if ( |
14191 | (_keyword = _PyPegen_expect_token(p, 600)) // token='True' Branch (14191:13): [True: 8.29k, False: 2.62M]
|
14192 | ) |
14193 | { |
14194 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); |
14195 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14196 | if (_token == NULL) { Branch (14196:17): [True: 0, False: 8.29k]
|
14197 | p->level--; |
14198 | return NULL; |
14199 | } |
14200 | int _end_lineno = _token->end_lineno; |
14201 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14202 | int _end_col_offset = _token->end_col_offset; |
14203 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14204 | _res = _PyAST_Constant ( Py_True , NULL , EXTRA ); |
14205 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14205:17): [True: 0, False: 8.29k]
Branch (14205:33): [True: 0, False: 0]
|
14206 | p->error_indicator = 1; |
14207 | p->level--; |
14208 | return NULL; |
14209 | } |
14210 | goto done; |
14211 | } |
14212 | p->mark = _mark; |
14213 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14214 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); |
14215 | } |
14216 | { // 'False' |
14217 | if (p->error_indicator) { Branch (14217:13): [True: 0, False: 2.62M]
|
14218 | p->level--; |
14219 | return NULL; |
14220 | } |
14221 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); |
14222 | Token * _keyword; |
14223 | if ( |
14224 | (_keyword = _PyPegen_expect_token(p, 602)) // token='False' Branch (14224:13): [True: 7.16k, False: 2.62M]
|
14225 | ) |
14226 | { |
14227 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); |
14228 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14229 | if (_token == NULL) { Branch (14229:17): [True: 0, False: 7.16k]
|
14230 | p->level--; |
14231 | return NULL; |
14232 | } |
14233 | int _end_lineno = _token->end_lineno; |
14234 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14235 | int _end_col_offset = _token->end_col_offset; |
14236 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14237 | _res = _PyAST_Constant ( Py_False , NULL , EXTRA ); |
14238 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14238:17): [True: 0, False: 7.16k]
Branch (14238:33): [True: 0, False: 0]
|
14239 | p->error_indicator = 1; |
14240 | p->level--; |
14241 | return NULL; |
14242 | } |
14243 | goto done; |
14244 | } |
14245 | p->mark = _mark; |
14246 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14247 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); |
14248 | } |
14249 | { // 'None' |
14250 | if (p->error_indicator) { Branch (14250:13): [True: 0, False: 2.62M]
|
14251 | p->level--; |
14252 | return NULL; |
14253 | } |
14254 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); |
14255 | Token * _keyword; |
14256 | if ( |
14257 | (_keyword = _PyPegen_expect_token(p, 601)) // token='None' Branch (14257:13): [True: 28.0k, False: 2.59M]
|
14258 | ) |
14259 | { |
14260 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); |
14261 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14262 | if (_token == NULL) { Branch (14262:17): [True: 0, False: 28.0k]
|
14263 | p->level--; |
14264 | return NULL; |
14265 | } |
14266 | int _end_lineno = _token->end_lineno; |
14267 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14268 | int _end_col_offset = _token->end_col_offset; |
14269 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14270 | _res = _PyAST_Constant ( Py_None , NULL , EXTRA ); |
14271 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14271:17): [True: 0, False: 28.0k]
Branch (14271:33): [True: 0, False: 0]
|
14272 | p->error_indicator = 1; |
14273 | p->level--; |
14274 | return NULL; |
14275 | } |
14276 | goto done; |
14277 | } |
14278 | p->mark = _mark; |
14279 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14280 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); |
14281 | } |
14282 | { // &STRING strings |
14283 | if (p->error_indicator) { Branch (14283:13): [True: 0, False: 2.59M]
|
14284 | p->level--; |
14285 | return NULL; |
14286 | } |
14287 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings")); |
14288 | expr_ty strings_var; |
14289 | if ( |
14290 | _PyPegen_lookahead(1, _PyPegen_string_token, p) Branch (14290:13): [True: 377k, False: 2.21M]
|
14291 | && |
14292 | (strings_var = strings_rule(p))377k // strings Branch (14292:13): [True: 377k, False: 303]
|
14293 | ) |
14294 | { |
14295 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING strings")); |
14296 | _res = strings_var; |
14297 | goto done; |
14298 | } |
14299 | p->mark = _mark; |
14300 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14301 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&STRING strings")); |
14302 | } |
14303 | { // NUMBER |
14304 | if (p->error_indicator) { Branch (14304:13): [True: 303, False: 2.21M]
|
14305 | p->level--; |
14306 | return NULL; |
14307 | } |
14308 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
14309 | expr_ty number_var; |
14310 | if ( |
14311 | (number_var = _PyPegen_number_token(p)) // NUMBER Branch (14311:13): [True: 1.29M, False: 918k]
|
14312 | ) |
14313 | { |
14314 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); |
14315 | _res = number_var; |
14316 | goto done; |
14317 | } |
14318 | p->mark = _mark; |
14319 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14320 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); |
14321 | } |
14322 | { // &'(' (tuple | group | genexp) |
14323 | if (p->error_indicator) { Branch (14323:13): [True: 2, False: 918k]
|
14324 | p->level--; |
14325 | return NULL; |
14326 | } |
14327 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)")); |
14328 | void *_tmp_91_var; |
14329 | if ( |
14330 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='(' Branch (14330:13): [True: 232k, False: 685k]
|
14331 | && |
14332 | (_tmp_91_var = _tmp_91_rule(p))232k // tuple | group | genexp Branch (14332:13): [True: 232k, False: 177]
|
14333 | ) |
14334 | { |
14335 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)")); |
14336 | _res = _tmp_91_var; |
14337 | goto done; |
14338 | } |
14339 | p->mark = _mark; |
14340 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14341 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)")); |
14342 | } |
14343 | { // &'[' (list | listcomp) |
14344 | if (p->error_indicator) { Branch (14344:13): [True: 65, False: 686k]
|
14345 | p->level--; |
14346 | return NULL; |
14347 | } |
14348 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)")); |
14349 | void *_tmp_92_var; |
14350 | if ( |
14351 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='[' Branch (14351:13): [True: 21.3k, False: 664k]
|
14352 | && |
14353 | (_tmp_92_var = _tmp_92_rule(p))21.3k // list | listcomp Branch (14353:13): [True: 21.2k, False: 123]
|
14354 | ) |
14355 | { |
14356 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)")); |
14357 | _res = _tmp_92_var; |
14358 | goto done; |
14359 | } |
14360 | p->mark = _mark; |
14361 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14362 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)")); |
14363 | } |
14364 | { // &'{' (dict | set | dictcomp | setcomp) |
14365 | if (p->error_indicator) { Branch (14365:13): [True: 53, False: 664k]
|
14366 | p->level--; |
14367 | return NULL; |
14368 | } |
14369 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); |
14370 | void *_tmp_93_var; |
14371 | if ( |
14372 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{' Branch (14372:13): [True: 10.4k, False: 654k]
|
14373 | && |
14374 | (_tmp_93_var = _tmp_93_rule(p))10.4k // dict | set | dictcomp | setcomp Branch (14374:13): [True: 10.3k, False: 96]
|
14375 | ) |
14376 | { |
14377 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); |
14378 | _res = _tmp_93_var; |
14379 | goto done; |
14380 | } |
14381 | p->mark = _mark; |
14382 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14383 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); |
14384 | } |
14385 | { // '...' |
14386 | if (p->error_indicator) { Branch (14386:13): [True: 39, False: 654k]
|
14387 | p->level--; |
14388 | return NULL; |
14389 | } |
14390 | D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); |
14391 | Token * _literal; |
14392 | if ( |
14393 | (_literal = _PyPegen_expect_token(p, 52)) // token='...' Branch (14393:13): [True: 3.55k, False: 650k]
|
14394 | ) |
14395 | { |
14396 | D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); |
14397 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14398 | if (_token == NULL) { Branch (14398:17): [True: 0, False: 3.55k]
|
14399 | p->level--; |
14400 | return NULL; |
14401 | } |
14402 | int _end_lineno = _token->end_lineno; |
14403 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14404 | int _end_col_offset = _token->end_col_offset; |
14405 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14406 | _res = _PyAST_Constant ( Py_Ellipsis , NULL , EXTRA ); |
14407 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14407:17): [True: 0, False: 3.55k]
Branch (14407:33): [True: 0, False: 0]
|
14408 | p->error_indicator = 1; |
14409 | p->level--; |
14410 | return NULL; |
14411 | } |
14412 | goto done; |
14413 | } |
14414 | p->mark = _mark; |
14415 | D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', |
14416 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); |
14417 | } |
14418 | _res = NULL; |
14419 | done: |
14420 | p->level--; |
14421 | return _res; |
14422 | } |
14423 | |
14424 | // group: '(' (yield_expr | named_expression) ')' | invalid_group |
14425 | static expr_ty |
14426 | group_rule(Parser *p) |
14427 | { |
14428 | if (p->level++ == MAXSTACK) { Branch (14428:9): [True: 0, False: 156k]
|
14429 | p->error_indicator = 1; |
14430 | PyErr_NoMemory(); |
14431 | } |
14432 | if (p->error_indicator) { Branch (14432:9): [True: 0, False: 156k]
|
14433 | p->level--; |
14434 | return NULL; |
14435 | } |
14436 | expr_ty _res = NULL; |
14437 | int _mark = p->mark; |
14438 | { // '(' (yield_expr | named_expression) ')' |
14439 | if (p->error_indicator) { Branch (14439:13): [True: 0, False: 156k]
|
14440 | p->level--; |
14441 | return NULL; |
14442 | } |
14443 | D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); |
14444 | Token * _literal; |
14445 | Token * _literal_1; |
14446 | void *a; |
14447 | if ( |
14448 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (14448:13): [True: 156k, False: 0]
|
14449 | && |
14450 | (a = _tmp_94_rule(p)) // yield_expr | named_expression Branch (14450:13): [True: 156k, False: 60]
|
14451 | && |
14452 | (_literal_1 = _PyPegen_expect_token(p, 8))156k // token=')' Branch (14452:13): [True: 155k, False: 658]
|
14453 | ) |
14454 | { |
14455 | D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); |
14456 | _res = a; |
14457 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14457:17): [True: 0, False: 155k]
Branch (14457:33): [True: 0, False: 0]
|
14458 | p->error_indicator = 1; |
14459 | p->level--; |
14460 | return NULL; |
14461 | } |
14462 | goto done; |
14463 | } |
14464 | p->mark = _mark; |
14465 | D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ', |
14466 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); |
14467 | } |
14468 | if (p->call_invalid_rules) { // invalid_group Branch (14468:9): [True: 50, False: 668]
|
14469 | if (p->error_indicator) { |
14470 | p->level--; |
14471 | return NULL; |
14472 | } |
14473 | D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group")); |
14474 | void *invalid_group_var; |
14475 | if ( |
14476 | (invalid_group_var = invalid_group_rule(p)) // invalid_group |
14477 | ) |
14478 | { |
14479 | D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_group")); |
14480 | _res = invalid_group_var; |
14481 | goto done; |
14482 | } |
14483 | p->mark = _mark; |
14484 | D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ', |
14485 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_group")); |
14486 | } |
14487 | _res = NULL; |
14488 | done: |
14489 | p->level--; |
14490 | return _res; |
14491 | } |
14492 | |
14493 | // lambdef: 'lambda' lambda_params? ':' expression |
14494 | static expr_ty |
14495 | lambdef_rule(Parser *p) |
14496 | { |
14497 | if (p->level++ == MAXSTACK) { Branch (14497:9): [True: 0, False: 506k]
|
14498 | p->error_indicator = 1; |
14499 | PyErr_NoMemory(); |
14500 | } |
14501 | if (p->error_indicator) { Branch (14501:9): [True: 0, False: 506k]
|
14502 | p->level--; |
14503 | return NULL; |
14504 | } |
14505 | expr_ty _res = NULL; |
14506 | int _mark = p->mark; |
14507 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (14507:9): [True: 0, False: 506k]
Branch (14507:31): [True: 0, False: 0]
|
14508 | p->error_indicator = 1; |
14509 | p->level--; |
14510 | return NULL; |
14511 | } |
14512 | int _start_lineno = p->tokens[_mark]->lineno; |
14513 | UNUSED(_start_lineno); // Only used by EXTRA macro |
14514 | int _start_col_offset = p->tokens[_mark]->col_offset; |
14515 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
14516 | { // 'lambda' lambda_params? ':' expression |
14517 | if (p->error_indicator) { Branch (14517:13): [True: 0, False: 506k]
|
14518 | p->level--; |
14519 | return NULL; |
14520 | } |
14521 | D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression")); |
14522 | Token * _keyword; |
14523 | Token * _literal; |
14524 | void *a; |
14525 | expr_ty b; |
14526 | if ( |
14527 | (_keyword = _PyPegen_expect_token(p, 586)) // token='lambda' Branch (14527:13): [True: 1.60k, False: 504k]
|
14528 | && |
14529 | (a = lambda_params_rule(p), !p->error_indicator)1.60k // lambda_params? Branch (14529:13): [True: 1.56k, False: 40]
|
14530 | && |
14531 | (_literal = _PyPegen_expect_token(p, 11))1.56k // token=':' Branch (14531:13): [True: 1.51k, False: 50]
|
14532 | && |
14533 | (b = expression_rule(p))1.51k // expression Branch (14533:13): [True: 1.50k, False: 7]
|
14534 | ) |
14535 | { |
14536 | D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression")); |
14537 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
14538 | if (_token == NULL) { Branch (14538:17): [True: 0, False: 1.50k]
|
14539 | p->level--; |
14540 | return NULL; |
14541 | } |
14542 | int _end_lineno = _token->end_lineno; |
14543 | UNUSED(_end_lineno); // Only used by EXTRA macro |
14544 | int _end_col_offset = _token->end_col_offset; |
14545 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
14546 | _res = _PyAST_Lambda ( ( a ) ? a1.20k : CHECK301 ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , EXTRA ); Branch (14546:36): [True: 1.20k, False: 301]
|
14547 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14547:17): [True: 0, False: 1.50k]
Branch (14547:33): [True: 0, False: 0]
|
14548 | p->error_indicator = 1; |
14549 | p->level--; |
14550 | return NULL; |
14551 | } |
14552 | goto done; |
14553 | } |
14554 | p->mark = _mark; |
14555 | D(fprintf(stderr, "%*c%s lambdef[%d-%d]: %s failed!\n", p->level, ' ', |
14556 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' expression")); |
14557 | } |
14558 | _res = NULL; |
14559 | done: |
14560 | p->level--; |
14561 | return _res; |
14562 | } |
14563 | |
14564 | // lambda_params: invalid_lambda_parameters | lambda_parameters |
14565 | static arguments_ty |
14566 | lambda_params_rule(Parser *p) |
14567 | { |
14568 | if (p->level++ == MAXSTACK) { Branch (14568:9): [True: 0, False: 1.60k]
|
14569 | p->error_indicator = 1; |
14570 | PyErr_NoMemory(); |
14571 | } |
14572 | if (p->error_indicator) { Branch (14572:9): [True: 0, False: 1.60k]
|
14573 | p->level--; |
14574 | return NULL; |
14575 | } |
14576 | arguments_ty _res = NULL; |
14577 | int _mark = p->mark; |
14578 | if (p->call_invalid_rules) { // invalid_lambda_parameters Branch (14578:9): [True: 52, False: 1.55k]
|
14579 | if (p->error_indicator) { |
14580 | p->level--; |
14581 | return NULL; |
14582 | } |
14583 | D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters")); |
14584 | void *invalid_lambda_parameters_var; |
14585 | if ( |
14586 | (invalid_lambda_parameters_var = invalid_lambda_parameters_rule(p)) // invalid_lambda_parameters |
14587 | ) |
14588 | { |
14589 | D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters")); |
14590 | _res = invalid_lambda_parameters_var; |
14591 | goto done; |
14592 | } |
14593 | p->mark = _mark; |
14594 | D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ', |
14595 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_parameters")); |
14596 | } |
14597 | { // lambda_parameters |
14598 | if (p->error_indicator) { Branch (14598:13): [True: 27, False: 1.57k]
|
14599 | p->level--; |
14600 | return NULL; |
14601 | } |
14602 | D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parameters")); |
14603 | arguments_ty lambda_parameters_var; |
14604 | if ( |
14605 | (lambda_parameters_var = lambda_parameters_rule(p)) // lambda_parameters Branch (14605:13): [True: 1.24k, False: 331]
|
14606 | ) |
14607 | { |
14608 | D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_parameters")); |
14609 | _res = lambda_parameters_var; |
14610 | goto done; |
14611 | } |
14612 | p->mark = _mark; |
14613 | D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ', |
14614 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_parameters")); |
14615 | } |
14616 | _res = NULL; |
14617 | done: |
14618 | p->level--; |
14619 | return _res; |
14620 | } |
14621 | |
14622 | // lambda_parameters: |
14623 | // | lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? |
14624 | // | lambda_slash_with_default lambda_param_with_default* lambda_star_etc? |
14625 | // | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? |
14626 | // | lambda_param_with_default+ lambda_star_etc? |
14627 | // | lambda_star_etc |
14628 | static arguments_ty |
14629 | lambda_parameters_rule(Parser *p) |
14630 | { |
14631 | if (p->level++ == MAXSTACK) { Branch (14631:9): [True: 0, False: 1.57k]
|
14632 | p->error_indicator = 1; |
14633 | PyErr_NoMemory(); |
14634 | } |
14635 | if (p->error_indicator) { Branch (14635:9): [True: 0, False: 1.57k]
|
14636 | p->level--; |
14637 | return NULL; |
14638 | } |
14639 | arguments_ty _res = NULL; |
14640 | int _mark = p->mark; |
14641 | { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? |
14642 | if (p->error_indicator) { Branch (14642:13): [True: 0, False: 1.57k]
|
14643 | p->level--; |
14644 | return NULL; |
14645 | } |
14646 | D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?")); |
14647 | asdl_arg_seq* a; |
14648 | asdl_arg_seq* b; |
14649 | asdl_seq * c; |
14650 | void *d; |
14651 | if ( |
14652 | (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default Branch (14652:13): [True: 67, False: 1.51k]
|
14653 | && |
14654 | (b = (asdl_arg_seq*)_loop0_95_rule(p))67 // lambda_param_no_default* |
14655 | && |
14656 | (c = _loop0_96_rule(p))67 // lambda_param_with_default* |
14657 | && |
14658 | (d = lambda_star_etc_rule(p), !p->error_indicator)67 // lambda_star_etc? |
14659 | ) |
14660 | { |
14661 | D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?")); |
14662 | _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d ); |
14663 | if (_res == NULL && PyErr_Occurred()0 ) { |
14664 | p->error_indicator = 1; |
14665 | p->level--; |
14666 | return NULL; |
14667 | } |
14668 | goto done; |
14669 | } |
14670 | p->mark = _mark; |
14671 | D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
14672 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?")); |
14673 | } |
14674 | { // lambda_slash_with_default lambda_param_with_default* lambda_star_etc? |
14675 | if (p->error_indicator) { Branch (14675:13): [True: 2, False: 1.51k]
|
14676 | p->level--; |
14677 | return NULL; |
14678 | } |
14679 | D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?")); |
14680 | SlashWithDefault* a; |
14681 | asdl_seq * b; |
14682 | void *c; |
14683 | if ( |
14684 | (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default Branch (14684:13): [True: 58, False: 1.45k]
|
14685 | && |
14686 | (b = _loop0_97_rule(p))58 // lambda_param_with_default* |
14687 | && |
14688 | (c = lambda_star_etc_rule(p), !p->error_indicator)58 // lambda_star_etc? |
14689 | ) |
14690 | { |
14691 | D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?")); |
14692 | _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ); |
14693 | if (_res == NULL && PyErr_Occurred()0 ) { |
14694 | p->error_indicator = 1; |
14695 | p->level--; |
14696 | return NULL; |
14697 | } |
14698 | goto done; |
14699 | } |
14700 | p->mark = _mark; |
14701 | D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
14702 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?")); |
14703 | } |
14704 | { // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? |
14705 | if (p->error_indicator) { Branch (14705:13): [True: 1, False: 1.45k]
|
14706 | p->level--; |
14707 | return NULL; |
14708 | } |
14709 | D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?")); |
14710 | asdl_arg_seq* a; |
14711 | asdl_seq * b; |
14712 | void *c; |
14713 | if ( |
14714 | (a = (asdl_arg_seq*)_loop1_98_rule(p)) // lambda_param_no_default+ Branch (14714:13): [True: 1.04k, False: 408]
|
14715 | && |
14716 | (b = _loop0_99_rule(p))1.04k // lambda_param_with_default* Branch (14716:13): [True: 1.04k, False: 0]
|
14717 | && |
14718 | (c = lambda_star_etc_rule(p), !p->error_indicator)1.04k // lambda_star_etc? Branch (14718:13): [True: 1.03k, False: 7]
|
14719 | ) |
14720 | { |
14721 | D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?")); |
14722 | _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); |
14723 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (14723:17): [True: 0, False: 1.03k]
Branch (14723:33): [True: 0, False: 0]
|
14724 | p->error_indicator = 1; |
14725 | p->level--; |
14726 | return NULL; |
14727 | } |
14728 | goto done; |
14729 | } |
14730 | p->mark = _mark; |
14731 | D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
14732 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?")); |
14733 | } |
14734 | { // lambda_param_with_default+ lambda_star_etc? |
14735 | if (p->error_indicator) { Branch (14735:13): [True: 7, False: 408]
|
14736 | p->level--; |
14737 | return NULL; |
14738 | } |
14739 | D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?")); |
14740 | asdl_seq * a; |
14741 | void *b; |
14742 | if ( |
14743 | (a = _loop1_100_rule(p)) // lambda_param_with_default+ Branch (14743:13): [True: 52, False: 356]
|
14744 | && |
14745 | (b = lambda_star_etc_rule(p), !p->error_indicator)52 // lambda_star_etc? |
14746 | ) |
14747 | { |
14748 | D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?")); |
14749 | _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b ); |
14750 | if (_res == NULL && PyErr_Occurred()0 ) { |
14751 | p->error_indicator = 1; |
14752 | p->level--; |
14753 | return NULL; |
14754 | } |
14755 | goto done; |
14756 | } |
14757 | p->mark = _mark; |
14758 | D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
14759 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?")); |
14760 | } |
14761 | { // lambda_star_etc |
14762 | if (p->error_indicator) { Branch (14762:13): [True: 0, False: 356]
|
14763 | p->level--; |
14764 | return NULL; |
14765 | } |
14766 | D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_star_etc")); |
14767 | StarEtc* a; |
14768 | if ( |
14769 | (a = lambda_star_etc_rule(p)) // lambda_star_etc Branch (14769:13): [True: 35, False: 321]
|
14770 | ) |
14771 | { |
14772 | D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_star_etc")); |
14773 | _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a ); |
14774 | if (_res == NULL && PyErr_Occurred()0 ) { |
14775 | p->error_indicator = 1; |
14776 | p->level--; |
14777 | return NULL; |
14778 | } |
14779 | goto done; |
14780 | } |
14781 | p->mark = _mark; |
14782 | D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
14783 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_star_etc")); |
14784 | } |
14785 | _res = NULL; |
14786 | done: |
14787 | p->level--; |
14788 | return _res; |
14789 | } |
14790 | |
14791 | // lambda_slash_no_default: |
14792 | // | lambda_param_no_default+ '/' ',' |
14793 | // | lambda_param_no_default+ '/' &':' |
14794 | static asdl_arg_seq* |
14795 | lambda_slash_no_default_rule(Parser *p) |
14796 | { |
14797 | if (p->level++ == MAXSTACK) { Branch (14797:9): [True: 0, False: 1.65k]
|
14798 | p->error_indicator = 1; |
14799 | PyErr_NoMemory(); |
14800 | } |
14801 | if (p->error_indicator) { Branch (14801:9): [True: 0, False: 1.65k]
|
14802 | p->level--; |
14803 | return NULL; |
14804 | } |
14805 | asdl_arg_seq* _res = NULL; |
14806 | int _mark = p->mark; |
14807 | { // lambda_param_no_default+ '/' ',' |
14808 | if (p->error_indicator) { Branch (14808:13): [True: 0, False: 1.65k]
|
14809 | p->level--; |
14810 | return NULL; |
14811 | } |
14812 | D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','")); |
14813 | Token * _literal; |
14814 | Token * _literal_1; |
14815 | asdl_arg_seq* a; |
14816 | if ( |
14817 | (a = (asdl_arg_seq*)_loop1_101_rule(p)) // lambda_param_no_default+ Branch (14817:13): [True: 1.15k, False: 500]
|
14818 | && |
14819 | (_literal = _PyPegen_expect_token(p, 17))1.15k // token='/' Branch (14819:13): [True: 77, False: 1.07k]
|
14820 | && |
14821 | (_literal_1 = _PyPegen_expect_token(p, 12))77 // token=',' |
14822 | ) |
14823 | { |
14824 | D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','")); |
14825 | _res = a; |
14826 | if (_res == NULL && PyErr_Occurred()0 ) { |
14827 | p->error_indicator = 1; |
14828 | p->level--; |
14829 | return NULL; |
14830 | } |
14831 | goto done; |
14832 | } |
14833 | p->mark = _mark; |
14834 | D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
14835 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' ','")); |
14836 | } |
14837 | { // lambda_param_no_default+ '/' &':' |
14838 | if (p->error_indicator) { Branch (14838:13): [True: 0, False: 1.58k]
|
14839 | p->level--; |
14840 | return NULL; |
14841 | } |
14842 | D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'")); |
14843 | Token * _literal; |
14844 | asdl_arg_seq* a; |
14845 | if ( |
14846 | (a = (asdl_arg_seq*)_loop1_102_rule(p)) // lambda_param_no_default+ Branch (14846:13): [True: 1.08k, False: 500]
|
14847 | && |
14848 | (_literal = _PyPegen_expect_token(p, 17))1.08k // token='/' Branch (14848:13): [True: 9, False: 1.07k]
|
14849 | && |
14850 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)9 // token=':' |
14851 | ) |
14852 | { |
14853 | D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'")); |
14854 | _res = a; |
14855 | if (_res == NULL && PyErr_Occurred()0 ) { |
14856 | p->error_indicator = 1; |
14857 | p->level--; |
14858 | return NULL; |
14859 | } |
14860 | goto done; |
14861 | } |
14862 | p->mark = _mark; |
14863 | D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
14864 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' &':'")); |
14865 | } |
14866 | _res = NULL; |
14867 | done: |
14868 | p->level--; |
14869 | return _res; |
14870 | } |
14871 | |
14872 | // lambda_slash_with_default: |
14873 | // | lambda_param_no_default* lambda_param_with_default+ '/' ',' |
14874 | // | lambda_param_no_default* lambda_param_with_default+ '/' &':' |
14875 | static SlashWithDefault* |
14876 | lambda_slash_with_default_rule(Parser *p) |
14877 | { |
14878 | if (p->level++ == MAXSTACK) { Branch (14878:9): [True: 0, False: 1.62k]
|
14879 | p->error_indicator = 1; |
14880 | PyErr_NoMemory(); |
14881 | } |
14882 | if (p->error_indicator) { Branch (14882:9): [True: 0, False: 1.62k]
|
14883 | p->level--; |
14884 | return NULL; |
14885 | } |
14886 | SlashWithDefault* _res = NULL; |
14887 | int _mark = p->mark; |
14888 | { // lambda_param_no_default* lambda_param_with_default+ '/' ',' |
14889 | if (p->error_indicator) { Branch (14889:13): [True: 0, False: 1.62k]
|
14890 | p->level--; |
14891 | return NULL; |
14892 | } |
14893 | D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','")); |
14894 | Token * _literal; |
14895 | Token * _literal_1; |
14896 | asdl_seq * a; |
14897 | asdl_seq * b; |
14898 | if ( |
14899 | (a = _loop0_103_rule(p)) // lambda_param_no_default* Branch (14899:13): [True: 1.62k, False: 0]
|
14900 | && |
14901 | (b = _loop1_104_rule(p)) // lambda_param_with_default+ Branch (14901:13): [True: 175, False: 1.45k]
|
14902 | && |
14903 | (_literal = _PyPegen_expect_token(p, 17))175 // token='/' Branch (14903:13): [True: 68, False: 107]
|
14904 | && |
14905 | (_literal_1 = _PyPegen_expect_token(p, 12))68 // token=',' Branch (14905:13): [True: 55, False: 13]
|
14906 | ) |
14907 | { |
14908 | D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','")); |
14909 | _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); |
14910 | if (_res == NULL && PyErr_Occurred()0 ) { |
14911 | p->error_indicator = 1; |
14912 | p->level--; |
14913 | return NULL; |
14914 | } |
14915 | goto done; |
14916 | } |
14917 | p->mark = _mark; |
14918 | D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
14919 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','")); |
14920 | } |
14921 | { // lambda_param_no_default* lambda_param_with_default+ '/' &':' |
14922 | if (p->error_indicator) { Branch (14922:13): [True: 2, False: 1.56k]
|
14923 | p->level--; |
14924 | return NULL; |
14925 | } |
14926 | D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'")); |
14927 | Token * _literal; |
14928 | asdl_seq * a; |
14929 | asdl_seq * b; |
14930 | if ( |
14931 | (a = _loop0_105_rule(p)) // lambda_param_no_default* Branch (14931:13): [True: 1.56k, False: 0]
|
14932 | && |
14933 | (b = _loop1_106_rule(p)) // lambda_param_with_default+ Branch (14933:13): [True: 120, False: 1.44k]
|
14934 | && |
14935 | (_literal = _PyPegen_expect_token(p, 17))120 // token='/' Branch (14935:13): [True: 13, False: 107]
|
14936 | && |
14937 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)13 // token=':' |
14938 | ) |
14939 | { |
14940 | D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'")); |
14941 | _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b ); |
14942 | if (_res == NULL && PyErr_Occurred()0 ) { |
14943 | p->error_indicator = 1; |
14944 | p->level--; |
14945 | return NULL; |
14946 | } |
14947 | goto done; |
14948 | } |
14949 | p->mark = _mark; |
14950 | D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
14951 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'")); |
14952 | } |
14953 | _res = NULL; |
14954 | done: |
14955 | p->level--; |
14956 | return _res; |
14957 | } |
14958 | |
14959 | // lambda_star_etc: |
14960 | // | invalid_lambda_star_etc |
14961 | // | '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? |
14962 | // | '*' ',' lambda_param_maybe_default+ lambda_kwds? |
14963 | // | lambda_kwds |
14964 | static StarEtc* |
14965 | lambda_star_etc_rule(Parser *p) |
14966 | { |
14967 | if (p->level++ == MAXSTACK) { Branch (14967:9): [True: 0, False: 1.57k]
|
14968 | p->error_indicator = 1; |
14969 | PyErr_NoMemory(); |
14970 | } |
14971 | if (p->error_indicator) { Branch (14971:9): [True: 0, False: 1.57k]
|
14972 | p->level--; |
14973 | return NULL; |
14974 | } |
14975 | StarEtc* _res = NULL; |
14976 | int _mark = p->mark; |
14977 | if (p->call_invalid_rules) { // invalid_lambda_star_etc Branch (14977:9): [True: 25, False: 1.55k]
|
14978 | if (p->error_indicator) { |
14979 | p->level--; |
14980 | return NULL; |
14981 | } |
14982 | D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc")); |
14983 | void *invalid_lambda_star_etc_var; |
14984 | if ( |
14985 | (invalid_lambda_star_etc_var = invalid_lambda_star_etc_rule(p)) // invalid_lambda_star_etc |
14986 | ) |
14987 | { |
14988 | D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc")); |
14989 | _res = invalid_lambda_star_etc_var; |
14990 | goto done; |
14991 | } |
14992 | p->mark = _mark; |
14993 | D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
14994 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_star_etc")); |
14995 | } |
14996 | { // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? |
14997 | if (p->error_indicator) { Branch (14997:13): [True: 6, False: 1.57k]
|
14998 | p->level--; |
14999 | return NULL; |
15000 | } |
15001 | D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?")); |
15002 | Token * _literal; |
15003 | arg_ty a; |
15004 | asdl_seq * b; |
15005 | void *c; |
15006 | if ( |
15007 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (15007:13): [True: 168, False: 1.40k]
|
15008 | && |
15009 | (a = lambda_param_no_default_rule(p))168 // lambda_param_no_default Branch (15009:13): [True: 74, False: 94]
|
15010 | && |
15011 | (b = _loop0_107_rule(p))74 // lambda_param_maybe_default* |
15012 | && |
15013 | (c = lambda_kwds_rule(p), !p->error_indicator)74 // lambda_kwds? |
15014 | ) |
15015 | { |
15016 | D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?")); |
15017 | _res = _PyPegen_star_etc ( p , a , b , c ); |
15018 | if (_res == NULL && PyErr_Occurred()0 ) { |
15019 | p->error_indicator = 1; |
15020 | p->level--; |
15021 | return NULL; |
15022 | } |
15023 | goto done; |
15024 | } |
15025 | p->mark = _mark; |
15026 | D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
15027 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?")); |
15028 | } |
15029 | { // '*' ',' lambda_param_maybe_default+ lambda_kwds? |
15030 | if (p->error_indicator) { Branch (15030:13): [True: 4, False: 1.49k]
|
15031 | p->level--; |
15032 | return NULL; |
15033 | } |
15034 | D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?")); |
15035 | Token * _literal; |
15036 | Token * _literal_1; |
15037 | asdl_seq * b; |
15038 | void *c; |
15039 | if ( |
15040 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (15040:13): [True: 94, False: 1.40k]
|
15041 | && |
15042 | (_literal_1 = _PyPegen_expect_token(p, 12))94 // token=',' |
15043 | && |
15044 | (b = _loop1_108_rule(p))92 // lambda_param_maybe_default+ |
15045 | && |
15046 | (c = lambda_kwds_rule(p), !p->error_indicator)91 // lambda_kwds? |
15047 | ) |
15048 | { |
15049 | D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?")); |
15050 | _res = _PyPegen_star_etc ( p , NULL , b , c ); |
15051 | if (_res == NULL && PyErr_Occurred()0 ) { |
15052 | p->error_indicator = 1; |
15053 | p->level--; |
15054 | return NULL; |
15055 | } |
15056 | goto done; |
15057 | } |
15058 | p->mark = _mark; |
15059 | D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
15060 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?")); |
15061 | } |
15062 | { // lambda_kwds |
15063 | if (p->error_indicator) { Branch (15063:13): [True: 0, False: 1.40k]
|
15064 | p->level--; |
15065 | return NULL; |
15066 | } |
15067 | D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds")); |
15068 | arg_ty a; |
15069 | if ( |
15070 | (a = lambda_kwds_rule(p)) // lambda_kwds Branch (15070:13): [True: 17, False: 1.38k]
|
15071 | ) |
15072 | { |
15073 | D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_kwds")); |
15074 | _res = _PyPegen_star_etc ( p , NULL , NULL , a ); |
15075 | if (_res == NULL && PyErr_Occurred()0 ) { |
15076 | p->error_indicator = 1; |
15077 | p->level--; |
15078 | return NULL; |
15079 | } |
15080 | goto done; |
15081 | } |
15082 | p->mark = _mark; |
15083 | D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
15084 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_kwds")); |
15085 | } |
15086 | _res = NULL; |
15087 | done: |
15088 | p->level--; |
15089 | return _res; |
15090 | } |
15091 | |
15092 | // lambda_kwds: invalid_lambda_kwds | '**' lambda_param_no_default |
15093 | static arg_ty |
15094 | lambda_kwds_rule(Parser *p) |
15095 | { |
15096 | if (p->level++ == MAXSTACK) { Branch (15096:9): [True: 0, False: 1.57k]
|
15097 | p->error_indicator = 1; |
15098 | PyErr_NoMemory(); |
15099 | } |
15100 | if (p->error_indicator) { Branch (15100:9): [True: 0, False: 1.57k]
|
15101 | p->level--; |
15102 | return NULL; |
15103 | } |
15104 | arg_ty _res = NULL; |
15105 | int _mark = p->mark; |
15106 | if (p->call_invalid_rules) { // invalid_lambda_kwds Branch (15106:9): [True: 19, False: 1.55k]
|
15107 | if (p->error_indicator) { |
15108 | p->level--; |
15109 | return NULL; |
15110 | } |
15111 | D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_kwds")); |
15112 | void *invalid_lambda_kwds_var; |
15113 | if ( |
15114 | (invalid_lambda_kwds_var = invalid_lambda_kwds_rule(p)) // invalid_lambda_kwds |
15115 | ) |
15116 | { |
15117 | D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_kwds")); |
15118 | _res = invalid_lambda_kwds_var; |
15119 | goto done; |
15120 | } |
15121 | p->mark = _mark; |
15122 | D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
15123 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_kwds")); |
15124 | } |
15125 | { // '**' lambda_param_no_default |
15126 | if (p->error_indicator) { Branch (15126:13): [True: 7, False: 1.56k]
|
15127 | p->level--; |
15128 | return NULL; |
15129 | } |
15130 | D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default")); |
15131 | Token * _literal; |
15132 | arg_ty a; |
15133 | if ( |
15134 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (15134:13): [True: 74, False: 1.49k]
|
15135 | && |
15136 | (a = lambda_param_no_default_rule(p))74 // lambda_param_no_default |
15137 | ) |
15138 | { |
15139 | D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default")); |
15140 | _res = a; |
15141 | if (_res == NULL && PyErr_Occurred()0 ) { |
15142 | p->error_indicator = 1; |
15143 | p->level--; |
15144 | return NULL; |
15145 | } |
15146 | goto done; |
15147 | } |
15148 | p->mark = _mark; |
15149 | D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
15150 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param_no_default")); |
15151 | } |
15152 | _res = NULL; |
15153 | done: |
15154 | p->level--; |
15155 | return _res; |
15156 | } |
15157 | |
15158 | // lambda_param_no_default: lambda_param ',' | lambda_param &':' |
15159 | static arg_ty |
15160 | lambda_param_no_default_rule(Parser *p) |
15161 | { |
15162 | if (p->level++ == MAXSTACK) { Branch (15162:9): [True: 0, False: 48.7k]
|
15163 | p->error_indicator = 1; |
15164 | PyErr_NoMemory(); |
15165 | } |
15166 | if (p->error_indicator) { Branch (15166:9): [True: 0, False: 48.7k]
|
15167 | p->level--; |
15168 | return NULL; |
15169 | } |
15170 | arg_ty _res = NULL; |
15171 | int _mark = p->mark; |
15172 | { // lambda_param ',' |
15173 | if (p->error_indicator) { Branch (15173:13): [True: 0, False: 48.7k]
|
15174 | p->level--; |
15175 | return NULL; |
15176 | } |
15177 | D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param ','")); |
15178 | Token * _literal; |
15179 | arg_ty a; |
15180 | if ( |
15181 | (a = lambda_param_rule(p)) // lambda_param Branch (15181:13): [True: 41.4k, False: 7.32k]
|
15182 | && |
15183 | (_literal = _PyPegen_expect_token(p, 12))41.4k // token=',' Branch (15183:13): [True: 35.9k, False: 5.53k]
|
15184 | ) |
15185 | { |
15186 | D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param ','")); |
15187 | _res = a; |
15188 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15188:17): [True: 0, False: 35.9k]
Branch (15188:33): [True: 0, False: 0]
|
15189 | p->error_indicator = 1; |
15190 | p->level--; |
15191 | return NULL; |
15192 | } |
15193 | goto done; |
15194 | } |
15195 | p->mark = _mark; |
15196 | D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
15197 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param ','")); |
15198 | } |
15199 | { // lambda_param &':' |
15200 | if (p->error_indicator) { Branch (15200:13): [True: 0, False: 12.8k]
|
15201 | p->level--; |
15202 | return NULL; |
15203 | } |
15204 | D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param &':'")); |
15205 | arg_ty a; |
15206 | if ( |
15207 | (a = lambda_param_rule(p)) // lambda_param Branch (15207:13): [True: 5.53k, False: 7.32k]
|
15208 | && |
15209 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)5.53k // token=':' Branch (15209:13): [True: 4.71k, False: 816]
|
15210 | ) |
15211 | { |
15212 | D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param &':'")); |
15213 | _res = a; |
15214 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15214:17): [True: 0, False: 4.71k]
Branch (15214:33): [True: 0, False: 0]
|
15215 | p->error_indicator = 1; |
15216 | p->level--; |
15217 | return NULL; |
15218 | } |
15219 | goto done; |
15220 | } |
15221 | p->mark = _mark; |
15222 | D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ', |
15223 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param &':'")); |
15224 | } |
15225 | _res = NULL; |
15226 | done: |
15227 | p->level--; |
15228 | return _res; |
15229 | } |
15230 | |
15231 | // lambda_param_with_default: lambda_param default ',' | lambda_param default &':' |
15232 | static NameDefaultPair* |
15233 | lambda_param_with_default_rule(Parser *p) |
15234 | { |
15235 | if (p->level++ == MAXSTACK) { Branch (15235:9): [True: 0, False: 5.34k]
|
15236 | p->error_indicator = 1; |
15237 | PyErr_NoMemory(); |
15238 | } |
15239 | if (p->error_indicator) { Branch (15239:9): [True: 0, False: 5.34k]
|
15240 | p->level--; |
15241 | return NULL; |
15242 | } |
15243 | NameDefaultPair* _res = NULL; |
15244 | int _mark = p->mark; |
15245 | { // lambda_param default ',' |
15246 | if (p->error_indicator) { Branch (15246:13): [True: 0, False: 5.34k]
|
15247 | p->level--; |
15248 | return NULL; |
15249 | } |
15250 | D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default ','")); |
15251 | Token * _literal; |
15252 | arg_ty a; |
15253 | expr_ty c; |
15254 | if ( |
15255 | (a = lambda_param_rule(p)) // lambda_param Branch (15255:13): [True: 558, False: 4.78k]
|
15256 | && |
15257 | (c = default_rule(p))558 // default Branch (15257:13): [True: 524, False: 34]
|
15258 | && |
15259 | (_literal = _PyPegen_expect_token(p, 12))524 // token=',' Branch (15259:13): [True: 311, False: 213]
|
15260 | ) |
15261 | { |
15262 | D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default ','")); |
15263 | _res = _PyPegen_name_default_pair ( p , a , c , NULL ); |
15264 | if (_res == NULL && PyErr_Occurred()0 ) { |
15265 | p->error_indicator = 1; |
15266 | p->level--; |
15267 | return NULL; |
15268 | } |
15269 | goto done; |
15270 | } |
15271 | p->mark = _mark; |
15272 | D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
15273 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default ','")); |
15274 | } |
15275 | { // lambda_param default &':' |
15276 | if (p->error_indicator) { Branch (15276:13): [True: 2, False: 5.02k]
|
15277 | p->level--; |
15278 | return NULL; |
15279 | } |
15280 | D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'")); |
15281 | arg_ty a; |
15282 | expr_ty c; |
15283 | if ( |
15284 | (a = lambda_param_rule(p)) // lambda_param Branch (15284:13): [True: 245, False: 4.78k]
|
15285 | && |
15286 | (c = default_rule(p))245 // default Branch (15286:13): [True: 213, False: 32]
|
15287 | && |
15288 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)213 // token=':' Branch (15288:13): [True: 213, False: 0]
|
15289 | ) |
15290 | { |
15291 | D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'")); |
15292 | _res = _PyPegen_name_default_pair ( p , a , c , NULL ); |
15293 | if (_res == NULL && PyErr_Occurred()0 ) { |
15294 | p->error_indicator = 1; |
15295 | p->level--; |
15296 | return NULL; |
15297 | } |
15298 | goto done; |
15299 | } |
15300 | p->mark = _mark; |
15301 | D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ', |
15302 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default &':'")); |
15303 | } |
15304 | _res = NULL; |
15305 | done: |
15306 | p->level--; |
15307 | return _res; |
15308 | } |
15309 | |
15310 | // lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':' |
15311 | static NameDefaultPair* |
15312 | lambda_param_maybe_default_rule(Parser *p) |
15313 | { |
15314 | if (p->level++ == MAXSTACK) { Branch (15314:9): [True: 0, False: 515]
|
15315 | p->error_indicator = 1; |
15316 | PyErr_NoMemory(); |
15317 | } |
15318 | if (p->error_indicator) { Branch (15318:9): [True: 0, False: 515]
|
15319 | p->level--; |
15320 | return NULL; |
15321 | } |
15322 | NameDefaultPair* _res = NULL; |
15323 | int _mark = p->mark; |
15324 | { // lambda_param default? ',' |
15325 | if (p->error_indicator) { Branch (15325:13): [True: 0, False: 515]
|
15326 | p->level--; |
15327 | return NULL; |
15328 | } |
15329 | D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','")); |
15330 | Token * _literal; |
15331 | arg_ty a; |
15332 | void *c; |
15333 | if ( |
15334 | (a = lambda_param_rule(p)) // lambda_param Branch (15334:13): [True: 259, False: 256]
|
15335 | && |
15336 | (c = default_rule(p), !p->error_indicator)259 // default? Branch (15336:13): [True: 259, False: 0]
|
15337 | && |
15338 | (_literal = _PyPegen_expect_token(p, 12))259 // token=',' Branch (15338:13): [True: 175, False: 84]
|
15339 | ) |
15340 | { |
15341 | D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','")); |
15342 | _res = _PyPegen_name_default_pair ( p , a , c , NULL ); |
15343 | if (_res == NULL && PyErr_Occurred()0 ) { |
15344 | p->error_indicator = 1; |
15345 | p->level--; |
15346 | return NULL; |
15347 | } |
15348 | goto done; |
15349 | } |
15350 | p->mark = _mark; |
15351 | D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', |
15352 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? ','")); |
15353 | } |
15354 | { // lambda_param default? &':' |
15355 | if (p->error_indicator) { Branch (15355:13): [True: 0, False: 340]
|
15356 | p->level--; |
15357 | return NULL; |
15358 | } |
15359 | D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'")); |
15360 | arg_ty a; |
15361 | void *c; |
15362 | if ( |
15363 | (a = lambda_param_rule(p)) // lambda_param Branch (15363:13): [True: 84, False: 256]
|
15364 | && |
15365 | (c = default_rule(p), !p->error_indicator)84 // default? |
15366 | && |
15367 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)84 // token=':' |
15368 | ) |
15369 | { |
15370 | D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'")); |
15371 | _res = _PyPegen_name_default_pair ( p , a , c , NULL ); |
15372 | if (_res == NULL && PyErr_Occurred()0 ) { |
15373 | p->error_indicator = 1; |
15374 | p->level--; |
15375 | return NULL; |
15376 | } |
15377 | goto done; |
15378 | } |
15379 | p->mark = _mark; |
15380 | D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', |
15381 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? &':'")); |
15382 | } |
15383 | _res = NULL; |
15384 | done: |
15385 | p->level--; |
15386 | return _res; |
15387 | } |
15388 | |
15389 | // lambda_param: NAME |
15390 | static arg_ty |
15391 | lambda_param_rule(Parser *p) |
15392 | { |
15393 | if (p->level++ == MAXSTACK) { Branch (15393:9): [True: 0, False: 72.9k]
|
15394 | p->error_indicator = 1; |
15395 | PyErr_NoMemory(); |
15396 | } |
15397 | if (p->error_indicator) { Branch (15397:9): [True: 0, False: 72.9k]
|
15398 | p->level--; |
15399 | return NULL; |
15400 | } |
15401 | arg_ty _res = NULL; |
15402 | int _mark = p->mark; |
15403 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 09.57k ) { Branch (15403:9): [True: 9.57k, False: 63.3k]
Branch (15403:31): [True: 0, False: 9.57k]
|
15404 | p->error_indicator = 1; |
15405 | p->level--; |
15406 | return NULL; |
15407 | } |
15408 | int _start_lineno = p->tokens[_mark]->lineno; |
15409 | UNUSED(_start_lineno); // Only used by EXTRA macro |
15410 | int _start_col_offset = p->tokens[_mark]->col_offset; |
15411 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
15412 | { // NAME |
15413 | if (p->error_indicator) { Branch (15413:13): [True: 0, False: 72.9k]
|
15414 | p->level--; |
15415 | return NULL; |
15416 | } |
15417 | D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
15418 | expr_ty a; |
15419 | if ( |
15420 | (a = _PyPegen_name_token(p)) // NAME Branch (15420:13): [True: 48.1k, False: 24.7k]
|
15421 | ) |
15422 | { |
15423 | D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
15424 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
15425 | if (_token == NULL) { Branch (15425:17): [True: 0, False: 48.1k]
|
15426 | p->level--; |
15427 | return NULL; |
15428 | } |
15429 | int _end_lineno = _token->end_lineno; |
15430 | UNUSED(_end_lineno); // Only used by EXTRA macro |
15431 | int _end_col_offset = _token->end_col_offset; |
15432 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
15433 | _res = _PyAST_arg ( a -> v . Name . id , NULL , NULL , EXTRA ); |
15434 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15434:17): [True: 0, False: 48.1k]
Branch (15434:33): [True: 0, False: 0]
|
15435 | p->error_indicator = 1; |
15436 | p->level--; |
15437 | return NULL; |
15438 | } |
15439 | goto done; |
15440 | } |
15441 | p->mark = _mark; |
15442 | D(fprintf(stderr, "%*c%s lambda_param[%d-%d]: %s failed!\n", p->level, ' ', |
15443 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
15444 | } |
15445 | _res = NULL; |
15446 | done: |
15447 | p->level--; |
15448 | return _res; |
15449 | } |
15450 | |
15451 | // strings: STRING+ |
15452 | static expr_ty |
15453 | strings_rule(Parser *p) |
15454 | { |
15455 | if (p->level++ == MAXSTACK) { Branch (15455:9): [True: 0, False: 380k]
|
15456 | p->error_indicator = 1; |
15457 | PyErr_NoMemory(); |
15458 | } |
15459 | if (p->error_indicator) { Branch (15459:9): [True: 0, False: 380k]
|
15460 | p->level--; |
15461 | return NULL; |
15462 | } |
15463 | expr_ty _res = NULL; |
15464 | if (_PyPegen_is_memoized(p, strings_type, &_res)) { Branch (15464:9): [True: 197k, False: 183k]
|
15465 | p->level--; |
15466 | return _res; |
15467 | } |
15468 | int _mark = p->mark; |
15469 | { // STRING+ |
15470 | if (p->error_indicator) { Branch (15470:13): [True: 0, False: 183k]
|
15471 | p->level--; |
15472 | return NULL; |
15473 | } |
15474 | D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+")); |
15475 | asdl_seq * a; |
15476 | if ( |
15477 | (a = _loop1_109_rule(p)) // STRING+ Branch (15477:13): [True: 181k, False: 2.57k]
|
15478 | ) |
15479 | { |
15480 | D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+")); |
15481 | _res = _PyPegen_concatenate_strings ( p , a ); |
15482 | if (_res == NULL && PyErr_Occurred()301 ) { Branch (15482:17): [True: 301, False: 180k]
Branch (15482:33): [True: 301, False: 0]
|
15483 | p->error_indicator = 1; |
15484 | p->level--; |
15485 | return NULL; |
15486 | } |
15487 | goto done; |
15488 | } |
15489 | p->mark = _mark; |
15490 | D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', |
15491 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING+")); |
15492 | } |
15493 | _res = NULL; |
15494 | done: |
15495 | _PyPegen_insert_memo(p, _mark, strings_type, _res); |
15496 | p->level--; |
15497 | return _res; |
15498 | } |
15499 | |
15500 | // list: '[' star_named_expressions? ']' |
15501 | static expr_ty |
15502 | list_rule(Parser *p) |
15503 | { |
15504 | if (p->level++ == MAXSTACK) { Branch (15504:9): [True: 0, False: 23.4k]
|
15505 | p->error_indicator = 1; |
15506 | PyErr_NoMemory(); |
15507 | } |
15508 | if (p->error_indicator) { Branch (15508:9): [True: 0, False: 23.4k]
|
15509 | p->level--; |
15510 | return NULL; |
15511 | } |
15512 | expr_ty _res = NULL; |
15513 | int _mark = p->mark; |
15514 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (15514:9): [True: 0, False: 23.4k]
Branch (15514:31): [True: 0, False: 0]
|
15515 | p->error_indicator = 1; |
15516 | p->level--; |
15517 | return NULL; |
15518 | } |
15519 | int _start_lineno = p->tokens[_mark]->lineno; |
15520 | UNUSED(_start_lineno); // Only used by EXTRA macro |
15521 | int _start_col_offset = p->tokens[_mark]->col_offset; |
15522 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
15523 | { // '[' star_named_expressions? ']' |
15524 | if (p->error_indicator) { Branch (15524:13): [True: 0, False: 23.4k]
|
15525 | p->level--; |
15526 | return NULL; |
15527 | } |
15528 | D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'")); |
15529 | Token * _literal; |
15530 | Token * _literal_1; |
15531 | void *a; |
15532 | if ( |
15533 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (15533:13): [True: 21.3k, False: 2.09k]
|
15534 | && |
15535 | (a = star_named_expressions_rule(p), !p->error_indicator)21.3k // star_named_expressions? Branch (15535:13): [True: 21.3k, False: 34]
|
15536 | && |
15537 | (_literal_1 = _PyPegen_expect_token(p, 10))21.3k // token=']' Branch (15537:13): [True: 18.4k, False: 2.83k]
|
15538 | ) |
15539 | { |
15540 | D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'")); |
15541 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
15542 | if (_token == NULL) { Branch (15542:17): [True: 0, False: 18.4k]
|
15543 | p->level--; |
15544 | return NULL; |
15545 | } |
15546 | int _end_lineno = _token->end_lineno; |
15547 | UNUSED(_end_lineno); // Only used by EXTRA macro |
15548 | int _end_col_offset = _token->end_col_offset; |
15549 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
15550 | _res = _PyAST_List ( a , Load , EXTRA ); |
15551 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15551:17): [True: 0, False: 18.4k]
Branch (15551:33): [True: 0, False: 0]
|
15552 | p->error_indicator = 1; |
15553 | p->level--; |
15554 | return NULL; |
15555 | } |
15556 | goto done; |
15557 | } |
15558 | p->mark = _mark; |
15559 | D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ', |
15560 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'")); |
15561 | } |
15562 | _res = NULL; |
15563 | done: |
15564 | p->level--; |
15565 | return _res; |
15566 | } |
15567 | |
15568 | // tuple: '(' [star_named_expression ',' star_named_expressions?] ')' |
15569 | static expr_ty |
15570 | tuple_rule(Parser *p) |
15571 | { |
15572 | if (p->level++ == MAXSTACK) { Branch (15572:9): [True: 0, False: 234k]
|
15573 | p->error_indicator = 1; |
15574 | PyErr_NoMemory(); |
15575 | } |
15576 | if (p->error_indicator) { Branch (15576:9): [True: 0, False: 234k]
|
15577 | p->level--; |
15578 | return NULL; |
15579 | } |
15580 | expr_ty _res = NULL; |
15581 | int _mark = p->mark; |
15582 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (15582:9): [True: 0, False: 234k]
Branch (15582:31): [True: 0, False: 0]
|
15583 | p->error_indicator = 1; |
15584 | p->level--; |
15585 | return NULL; |
15586 | } |
15587 | int _start_lineno = p->tokens[_mark]->lineno; |
15588 | UNUSED(_start_lineno); // Only used by EXTRA macro |
15589 | int _start_col_offset = p->tokens[_mark]->col_offset; |
15590 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
15591 | { // '(' [star_named_expression ',' star_named_expressions?] ')' |
15592 | if (p->error_indicator) { Branch (15592:13): [True: 0, False: 234k]
|
15593 | p->level--; |
15594 | return NULL; |
15595 | } |
15596 | D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); |
15597 | Token * _literal; |
15598 | Token * _literal_1; |
15599 | void *a; |
15600 | if ( |
15601 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (15601:13): [True: 232k, False: 2.05k]
|
15602 | && |
15603 | (a = _tmp_110_rule(p), !p->error_indicator)232k // [star_named_expression ',' star_named_expressions?] Branch (15603:13): [True: 232k, False: 49]
|
15604 | && |
15605 | (_literal_1 = _PyPegen_expect_token(p, 8))232k // token=')' Branch (15605:13): [True: 76.0k, False: 156k]
|
15606 | ) |
15607 | { |
15608 | D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); |
15609 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
15610 | if (_token == NULL) { Branch (15610:17): [True: 0, False: 76.0k]
|
15611 | p->level--; |
15612 | return NULL; |
15613 | } |
15614 | int _end_lineno = _token->end_lineno; |
15615 | UNUSED(_end_lineno); // Only used by EXTRA macro |
15616 | int _end_col_offset = _token->end_col_offset; |
15617 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
15618 | _res = _PyAST_Tuple ( a , Load , EXTRA ); |
15619 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15619:17): [True: 0, False: 76.0k]
Branch (15619:33): [True: 0, False: 0]
|
15620 | p->error_indicator = 1; |
15621 | p->level--; |
15622 | return NULL; |
15623 | } |
15624 | goto done; |
15625 | } |
15626 | p->mark = _mark; |
15627 | D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ', |
15628 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); |
15629 | } |
15630 | _res = NULL; |
15631 | done: |
15632 | p->level--; |
15633 | return _res; |
15634 | } |
15635 | |
15636 | // set: '{' star_named_expressions '}' |
15637 | static expr_ty |
15638 | set_rule(Parser *p) |
15639 | { |
15640 | if (p->level++ == MAXSTACK) { Branch (15640:9): [True: 0, False: 1.81k]
|
15641 | p->error_indicator = 1; |
15642 | PyErr_NoMemory(); |
15643 | } |
15644 | if (p->error_indicator) { Branch (15644:9): [True: 0, False: 1.81k]
|
15645 | p->level--; |
15646 | return NULL; |
15647 | } |
15648 | expr_ty _res = NULL; |
15649 | int _mark = p->mark; |
15650 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (15650:9): [True: 0, False: 1.81k]
Branch (15650:31): [True: 0, False: 0]
|
15651 | p->error_indicator = 1; |
15652 | p->level--; |
15653 | return NULL; |
15654 | } |
15655 | int _start_lineno = p->tokens[_mark]->lineno; |
15656 | UNUSED(_start_lineno); // Only used by EXTRA macro |
15657 | int _start_col_offset = p->tokens[_mark]->col_offset; |
15658 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
15659 | { // '{' star_named_expressions '}' |
15660 | if (p->error_indicator) { Branch (15660:13): [True: 0, False: 1.81k]
|
15661 | p->level--; |
15662 | return NULL; |
15663 | } |
15664 | D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'")); |
15665 | Token * _literal; |
15666 | Token * _literal_1; |
15667 | asdl_expr_seq* a; |
15668 | if ( |
15669 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (15669:13): [True: 1.81k, False: 0]
|
15670 | && |
15671 | (a = star_named_expressions_rule(p)) // star_named_expressions Branch (15671:13): [True: 1.77k, False: 33]
|
15672 | && |
15673 | (_literal_1 = _PyPegen_expect_token(p, 26))1.77k // token='}' Branch (15673:13): [True: 929, False: 849]
|
15674 | ) |
15675 | { |
15676 | D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'")); |
15677 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
15678 | if (_token == NULL) { Branch (15678:17): [True: 0, False: 929]
|
15679 | p->level--; |
15680 | return NULL; |
15681 | } |
15682 | int _end_lineno = _token->end_lineno; |
15683 | UNUSED(_end_lineno); // Only used by EXTRA macro |
15684 | int _end_col_offset = _token->end_col_offset; |
15685 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
15686 | _res = _PyAST_Set ( a , EXTRA ); |
15687 | if (_res == NULL && PyErr_Occurred()0 ) { |
15688 | p->error_indicator = 1; |
15689 | p->level--; |
15690 | return NULL; |
15691 | } |
15692 | goto done; |
15693 | } |
15694 | p->mark = _mark; |
15695 | D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ', |
15696 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'")); |
15697 | } |
15698 | _res = NULL; |
15699 | done: |
15700 | p->level--; |
15701 | return _res; |
15702 | } |
15703 | |
15704 | // dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}' |
15705 | static expr_ty |
15706 | dict_rule(Parser *p) |
15707 | { |
15708 | if (p->level++ == MAXSTACK) { Branch (15708:9): [True: 0, False: 10.4k]
|
15709 | p->error_indicator = 1; |
15710 | PyErr_NoMemory(); |
15711 | } |
15712 | if (p->error_indicator) { Branch (15712:9): [True: 0, False: 10.4k]
|
15713 | p->level--; |
15714 | return NULL; |
15715 | } |
15716 | expr_ty _res = NULL; |
15717 | int _mark = p->mark; |
15718 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (15718:9): [True: 0, False: 10.4k]
Branch (15718:31): [True: 0, False: 0]
|
15719 | p->error_indicator = 1; |
15720 | p->level--; |
15721 | return NULL; |
15722 | } |
15723 | int _start_lineno = p->tokens[_mark]->lineno; |
15724 | UNUSED(_start_lineno); // Only used by EXTRA macro |
15725 | int _start_col_offset = p->tokens[_mark]->col_offset; |
15726 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
15727 | { // '{' double_starred_kvpairs? '}' |
15728 | if (p->error_indicator) { Branch (15728:13): [True: 0, False: 10.4k]
|
15729 | p->level--; |
15730 | return NULL; |
15731 | } |
15732 | D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'")); |
15733 | Token * _literal; |
15734 | Token * _literal_1; |
15735 | void *a; |
15736 | if ( |
15737 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (15737:13): [True: 10.4k, False: 0]
|
15738 | && |
15739 | (a = double_starred_kvpairs_rule(p), !p->error_indicator) // double_starred_kvpairs? Branch (15739:13): [True: 10.3k, False: 26]
|
15740 | && |
15741 | (_literal_1 = _PyPegen_expect_token(p, 26))10.3k // token='}' Branch (15741:13): [True: 8.57k, False: 1.81k]
|
15742 | ) |
15743 | { |
15744 | D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'")); |
15745 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
15746 | if (_token == NULL) { Branch (15746:17): [True: 0, False: 8.57k]
|
15747 | p->level--; |
15748 | return NULL; |
15749 | } |
15750 | int _end_lineno = _token->end_lineno; |
15751 | UNUSED(_end_lineno); // Only used by EXTRA macro |
15752 | int _end_col_offset = _token->end_col_offset; |
15753 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
15754 | _res = _PyAST_Dict ( CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_values ( p , a ) ) , EXTRA ); |
15755 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15755:17): [True: 0, False: 8.57k]
Branch (15755:33): [True: 0, False: 0]
|
15756 | p->error_indicator = 1; |
15757 | p->level--; |
15758 | return NULL; |
15759 | } |
15760 | goto done; |
15761 | } |
15762 | p->mark = _mark; |
15763 | D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ', |
15764 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_starred_kvpairs? '}'")); |
15765 | } |
15766 | { // '{' invalid_double_starred_kvpairs '}' |
15767 | if (p->error_indicator) { Branch (15767:13): [True: 26, False: 1.81k]
|
15768 | p->level--; |
15769 | return NULL; |
15770 | } |
15771 | D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'")); |
15772 | Token * _literal; |
15773 | Token * _literal_1; |
15774 | void *invalid_double_starred_kvpairs_var; |
15775 | if ( |
15776 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (15776:13): [True: 1.81k, False: 0]
|
15777 | && |
15778 | (invalid_double_starred_kvpairs_var = invalid_double_starred_kvpairs_rule(p)) // invalid_double_starred_kvpairs Branch (15778:13): [True: 0, False: 1.81k]
|
15779 | && |
15780 | (_literal_1 = _PyPegen_expect_token(p, 26))0 // token='}' |
15781 | ) |
15782 | { |
15783 | D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'")); |
15784 | _res = _PyPegen_dummy_name(p, _literal, invalid_double_starred_kvpairs_var, _literal_1); |
15785 | goto done; |
15786 | } |
15787 | p->mark = _mark; |
15788 | D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ', |
15789 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'")); |
15790 | } |
15791 | _res = NULL; |
15792 | done: |
15793 | p->level--; |
15794 | return _res; |
15795 | } |
15796 | |
15797 | // double_starred_kvpairs: ','.double_starred_kvpair+ ','? |
15798 | static asdl_seq* |
15799 | double_starred_kvpairs_rule(Parser *p) |
15800 | { |
15801 | if (p->level++ == MAXSTACK) { Branch (15801:9): [True: 0, False: 10.4k]
|
15802 | p->error_indicator = 1; |
15803 | PyErr_NoMemory(); |
15804 | } |
15805 | if (p->error_indicator) { Branch (15805:9): [True: 0, False: 10.4k]
|
15806 | p->level--; |
15807 | return NULL; |
15808 | } |
15809 | asdl_seq* _res = NULL; |
15810 | int _mark = p->mark; |
15811 | { // ','.double_starred_kvpair+ ','? |
15812 | if (p->error_indicator) { Branch (15812:13): [True: 0, False: 10.4k]
|
15813 | p->level--; |
15814 | return NULL; |
15815 | } |
15816 | D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?")); |
15817 | void *_opt_var; |
15818 | UNUSED(_opt_var); // Silence compiler warnings |
15819 | asdl_seq * a; |
15820 | if ( |
15821 | (a = _gather_111_rule(p)) // ','.double_starred_kvpair+ Branch (15821:13): [True: 5.70k, False: 4.70k]
|
15822 | && |
15823 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)5.70k // ','? Branch (15823:13): [True: 5.69k, False: 13]
|
15824 | ) |
15825 | { |
15826 | D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?")); |
15827 | _res = a; |
15828 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15828:17): [True: 0, False: 5.69k]
Branch (15828:33): [True: 0, False: 0]
|
15829 | p->error_indicator = 1; |
15830 | p->level--; |
15831 | return NULL; |
15832 | } |
15833 | goto done; |
15834 | } |
15835 | p->mark = _mark; |
15836 | D(fprintf(stderr, "%*c%s double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', |
15837 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ','?")); |
15838 | } |
15839 | _res = NULL; |
15840 | done: |
15841 | p->level--; |
15842 | return _res; |
15843 | } |
15844 | |
15845 | // double_starred_kvpair: '**' bitwise_or | kvpair |
15846 | static KeyValuePair* |
15847 | double_starred_kvpair_rule(Parser *p) |
15848 | { |
15849 | if (p->level++ == MAXSTACK) { Branch (15849:9): [True: 0, False: 173k]
|
15850 | p->error_indicator = 1; |
15851 | PyErr_NoMemory(); |
15852 | } |
15853 | if (p->error_indicator) { Branch (15853:9): [True: 0, False: 173k]
|
15854 | p->level--; |
15855 | return NULL; |
15856 | } |
15857 | KeyValuePair* _res = NULL; |
15858 | int _mark = p->mark; |
15859 | { // '**' bitwise_or |
15860 | if (p->error_indicator) { Branch (15860:13): [True: 0, False: 173k]
|
15861 | p->level--; |
15862 | return NULL; |
15863 | } |
15864 | D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or")); |
15865 | Token * _literal; |
15866 | expr_ty a; |
15867 | if ( |
15868 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (15868:13): [True: 2.31k, False: 171k]
|
15869 | && |
15870 | (a = bitwise_or_rule(p))2.31k // bitwise_or Branch (15870:13): [True: 2.31k, False: 0]
|
15871 | ) |
15872 | { |
15873 | D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or")); |
15874 | _res = _PyPegen_key_value_pair ( p , NULL , a ); |
15875 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15875:17): [True: 0, False: 2.31k]
Branch (15875:33): [True: 0, False: 0]
|
15876 | p->error_indicator = 1; |
15877 | p->level--; |
15878 | return NULL; |
15879 | } |
15880 | goto done; |
15881 | } |
15882 | p->mark = _mark; |
15883 | D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', |
15884 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or")); |
15885 | } |
15886 | { // kvpair |
15887 | if (p->error_indicator) { Branch (15887:13): [True: 12, False: 171k]
|
15888 | p->level--; |
15889 | return NULL; |
15890 | } |
15891 | D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpair")); |
15892 | KeyValuePair* kvpair_var; |
15893 | if ( |
15894 | (kvpair_var = kvpair_rule(p)) // kvpair Branch (15894:13): [True: 164k, False: 6.74k]
|
15895 | ) |
15896 | { |
15897 | D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kvpair")); |
15898 | _res = kvpair_var; |
15899 | goto done; |
15900 | } |
15901 | p->mark = _mark; |
15902 | D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', |
15903 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair")); |
15904 | } |
15905 | _res = NULL; |
15906 | done: |
15907 | p->level--; |
15908 | return _res; |
15909 | } |
15910 | |
15911 | // kvpair: expression ':' expression |
15912 | static KeyValuePair* |
15913 | kvpair_rule(Parser *p) |
15914 | { |
15915 | if (p->level++ == MAXSTACK) { Branch (15915:9): [True: 0, False: 172k]
|
15916 | p->error_indicator = 1; |
15917 | PyErr_NoMemory(); |
15918 | } |
15919 | if (p->error_indicator) { Branch (15919:9): [True: 0, False: 172k]
|
15920 | p->level--; |
15921 | return NULL; |
15922 | } |
15923 | KeyValuePair* _res = NULL; |
15924 | int _mark = p->mark; |
15925 | { // expression ':' expression |
15926 | if (p->error_indicator) { Branch (15926:13): [True: 0, False: 172k]
|
15927 | p->level--; |
15928 | return NULL; |
15929 | } |
15930 | D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); |
15931 | Token * _literal; |
15932 | expr_ty a; |
15933 | expr_ty b; |
15934 | if ( |
15935 | (a = expression_rule(p)) // expression Branch (15935:13): [True: 168k, False: 4.00k]
|
15936 | && |
15937 | (_literal = _PyPegen_expect_token(p, 11))168k // token=':' Branch (15937:13): [True: 165k, False: 3.19k]
|
15938 | && |
15939 | (b = expression_rule(p))165k // expression Branch (15939:13): [True: 165k, False: 55]
|
15940 | ) |
15941 | { |
15942 | D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); |
15943 | _res = _PyPegen_key_value_pair ( p , a , b ); |
15944 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15944:17): [True: 0, False: 165k]
Branch (15944:33): [True: 0, False: 0]
|
15945 | p->error_indicator = 1; |
15946 | p->level--; |
15947 | return NULL; |
15948 | } |
15949 | goto done; |
15950 | } |
15951 | p->mark = _mark; |
15952 | D(fprintf(stderr, "%*c%s kvpair[%d-%d]: %s failed!\n", p->level, ' ', |
15953 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); |
15954 | } |
15955 | _res = NULL; |
15956 | done: |
15957 | p->level--; |
15958 | return _res; |
15959 | } |
15960 | |
15961 | // for_if_clauses: for_if_clause+ |
15962 | static asdl_comprehension_seq* |
15963 | for_if_clauses_rule(Parser *p) |
15964 | { |
15965 | if (p->level++ == MAXSTACK) { Branch (15965:9): [True: 0, False: 144k]
|
15966 | p->error_indicator = 1; |
15967 | PyErr_NoMemory(); |
15968 | } |
15969 | if (p->error_indicator) { Branch (15969:9): [True: 0, False: 144k]
|
15970 | p->level--; |
15971 | return NULL; |
15972 | } |
15973 | asdl_comprehension_seq* _res = NULL; |
15974 | int _mark = p->mark; |
15975 | { // for_if_clause+ |
15976 | if (p->error_indicator) { Branch (15976:13): [True: 0, False: 144k]
|
15977 | p->level--; |
15978 | return NULL; |
15979 | } |
15980 | D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); |
15981 | asdl_comprehension_seq* a; |
15982 | if ( |
15983 | (a = (asdl_comprehension_seq*)_loop1_113_rule(p)) // for_if_clause+ Branch (15983:13): [True: 5.00k, False: 139k]
|
15984 | ) |
15985 | { |
15986 | D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); |
15987 | _res = a; |
15988 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (15988:17): [True: 0, False: 5.00k]
Branch (15988:33): [True: 0, False: 0]
|
15989 | p->error_indicator = 1; |
15990 | p->level--; |
15991 | return NULL; |
15992 | } |
15993 | goto done; |
15994 | } |
15995 | p->mark = _mark; |
15996 | D(fprintf(stderr, "%*c%s for_if_clauses[%d-%d]: %s failed!\n", p->level, ' ', |
15997 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause+")); |
15998 | } |
15999 | _res = NULL; |
16000 | done: |
16001 | p->level--; |
16002 | return _res; |
16003 | } |
16004 | |
16005 | // for_if_clause: |
16006 | // | ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* |
16007 | // | 'for' star_targets 'in' ~ disjunction (('if' disjunction))* |
16008 | // | invalid_for_target |
16009 | static comprehension_ty |
16010 | for_if_clause_rule(Parser *p) |
16011 | { |
16012 | if (p->level++ == MAXSTACK) { Branch (16012:9): [True: 0, False: 150k]
|
16013 | p->error_indicator = 1; |
16014 | PyErr_NoMemory(); |
16015 | } |
16016 | if (p->error_indicator) { Branch (16016:9): [True: 0, False: 150k]
|
16017 | p->level--; |
16018 | return NULL; |
16019 | } |
16020 | comprehension_ty _res = NULL; |
16021 | int _mark = p->mark; |
16022 | { // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* |
16023 | if (p->error_indicator) { Branch (16023:13): [True: 0, False: 150k]
|
16024 | p->level--; |
16025 | return NULL; |
16026 | } |
16027 | D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); |
16028 | int _cut_var = 0; |
16029 | Token * _keyword; |
16030 | Token * _keyword_1; |
16031 | expr_ty a; |
16032 | Token * async_var; |
16033 | expr_ty b; |
16034 | asdl_expr_seq* c; |
16035 | if ( |
16036 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (16036:13): [True: 218, False: 150k]
|
16037 | && |
16038 | (_keyword = _PyPegen_expect_token(p, 642))218 // token='for' Branch (16038:13): [True: 218, False: 0]
|
16039 | && |
16040 | (a = star_targets_rule(p))218 // star_targets Branch (16040:13): [True: 218, False: 0]
|
16041 | && |
16042 | (_keyword_1 = _PyPegen_expect_token(p, 643))218 // token='in' Branch (16042:13): [True: 218, False: 0]
|
16043 | && |
16044 | (_cut_var = 1)218 Branch (16044:13): [True: 218, False: 0]
|
16045 | && |
16046 | (b = disjunction_rule(p))218 // disjunction Branch (16046:13): [True: 218, False: 0]
|
16047 | && |
16048 | (c = (asdl_expr_seq*)_loop0_114_rule(p))218 // (('if' disjunction))* Branch (16048:13): [True: 218, False: 0]
|
16049 | ) |
16050 | { |
16051 | D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); |
16052 | _res = CHECK_VERSION ( comprehension_ty , 6 , "Async comprehensions are" , _PyAST_comprehension ( a , b , c , 1 , p -> arena ) ); |
16053 | if (_res == NULL && PyErr_Occurred()2 ) { |
16054 | p->error_indicator = 1; |
16055 | p->level--; |
16056 | return NULL; |
16057 | } |
16058 | goto done; |
16059 | } |
16060 | p->mark = _mark; |
16061 | D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', |
16062 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); |
16063 | if (_cut_var) { Branch (16063:13): [True: 0, False: 150k]
|
16064 | p->level--; |
16065 | return NULL; |
16066 | } |
16067 | } |
16068 | { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))* |
16069 | if (p->error_indicator) { Branch (16069:13): [True: 0, False: 150k]
|
16070 | p->level--; |
16071 | return NULL; |
16072 | } |
16073 | D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); |
16074 | int _cut_var = 0; |
16075 | Token * _keyword; |
16076 | Token * _keyword_1; |
16077 | expr_ty a; |
16078 | expr_ty b; |
16079 | asdl_expr_seq* c; |
16080 | if ( |
16081 | (_keyword = _PyPegen_expect_token(p, 642)) // token='for' Branch (16081:13): [True: 5.20k, False: 144k]
|
16082 | && |
16083 | (a = star_targets_rule(p))5.20k // star_targets Branch (16083:13): [True: 5.19k, False: 4]
|
16084 | && |
16085 | (_keyword_1 = _PyPegen_expect_token(p, 643))5.19k // token='in' Branch (16085:13): [True: 5.18k, False: 9]
|
16086 | && |
16087 | (_cut_var = 1)5.18k Branch (16087:13): [True: 5.18k, False: 0]
|
16088 | && |
16089 | (b = disjunction_rule(p))5.18k // disjunction Branch (16089:13): [True: 5.18k, False: 8]
|
16090 | && |
16091 | (c = (asdl_expr_seq*)_loop0_115_rule(p))5.18k // (('if' disjunction))* Branch (16091:13): [True: 5.18k, False: 0]
|
16092 | ) |
16093 | { |
16094 | D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); |
16095 | _res = _PyAST_comprehension ( a , b , c , 0 , p -> arena ); |
16096 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16096:17): [True: 0, False: 5.18k]
Branch (16096:33): [True: 0, False: 0]
|
16097 | p->error_indicator = 1; |
16098 | p->level--; |
16099 | return NULL; |
16100 | } |
16101 | goto done; |
16102 | } |
16103 | p->mark = _mark; |
16104 | D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', |
16105 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); |
16106 | if (_cut_var) { Branch (16106:13): [True: 8, False: 144k]
|
16107 | p->level--; |
16108 | return NULL; |
16109 | } |
16110 | } |
16111 | if (p->call_invalid_rules) { // invalid_for_target Branch (16111:9): [True: 482, False: 144k]
|
16112 | if (p->error_indicator) { Branch (16112:13): [True: 0, False: 482]
|
16113 | p->level--; |
16114 | return NULL; |
16115 | } |
16116 | D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); |
16117 | void *invalid_for_target_var; |
16118 | if ( |
16119 | (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target Branch (16119:13): [True: 0, False: 482]
|
16120 | ) |
16121 | { |
16122 | D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); |
16123 | _res = invalid_for_target_var; |
16124 | goto done; |
16125 | } |
16126 | p->mark = _mark; |
16127 | D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', |
16128 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); |
16129 | } |
16130 | _res = NULL; |
16131 | done: |
16132 | p->level--; |
16133 | return _res; |
16134 | } |
16135 | |
16136 | // listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension |
16137 | static expr_ty |
16138 | listcomp_rule(Parser *p) |
16139 | { |
16140 | if (p->level++ == MAXSTACK) { Branch (16140:9): [True: 0, False: 2.81k]
|
16141 | p->error_indicator = 1; |
16142 | PyErr_NoMemory(); |
16143 | } |
16144 | if (p->error_indicator) { Branch (16144:9): [True: 0, False: 2.81k]
|
16145 | p->level--; |
16146 | return NULL; |
16147 | } |
16148 | expr_ty _res = NULL; |
16149 | int _mark = p->mark; |
16150 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (16150:9): [True: 0, False: 2.81k]
Branch (16150:31): [True: 0, False: 0]
|
16151 | p->error_indicator = 1; |
16152 | p->level--; |
16153 | return NULL; |
16154 | } |
16155 | int _start_lineno = p->tokens[_mark]->lineno; |
16156 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16157 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16158 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16159 | { // '[' named_expression for_if_clauses ']' |
16160 | if (p->error_indicator) { Branch (16160:13): [True: 0, False: 2.81k]
|
16161 | p->level--; |
16162 | return NULL; |
16163 | } |
16164 | D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'")); |
16165 | Token * _literal; |
16166 | Token * _literal_1; |
16167 | expr_ty a; |
16168 | asdl_comprehension_seq* b; |
16169 | if ( |
16170 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (16170:13): [True: 2.81k, False: 0]
|
16171 | && |
16172 | (a = named_expression_rule(p)) // named_expression Branch (16172:13): [True: 2.77k, False: 43]
|
16173 | && |
16174 | (b = for_if_clauses_rule(p))2.77k // for_if_clauses Branch (16174:13): [True: 2.73k, False: 42]
|
16175 | && |
16176 | (_literal_1 = _PyPegen_expect_token(p, 10))2.73k // token=']' Branch (16176:13): [True: 2.73k, False: 4]
|
16177 | ) |
16178 | { |
16179 | D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'")); |
16180 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16181 | if (_token == NULL) { Branch (16181:17): [True: 0, False: 2.73k]
|
16182 | p->level--; |
16183 | return NULL; |
16184 | } |
16185 | int _end_lineno = _token->end_lineno; |
16186 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16187 | int _end_col_offset = _token->end_col_offset; |
16188 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16189 | _res = _PyAST_ListComp ( a , b , EXTRA ); |
16190 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16190:17): [True: 0, False: 2.73k]
Branch (16190:33): [True: 0, False: 0]
|
16191 | p->error_indicator = 1; |
16192 | p->level--; |
16193 | return NULL; |
16194 | } |
16195 | goto done; |
16196 | } |
16197 | p->mark = _mark; |
16198 | D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', |
16199 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression for_if_clauses ']'")); |
16200 | } |
16201 | if (p->call_invalid_rules) { // invalid_comprehension Branch (16201:9): [True: 17, False: 72]
|
16202 | if (p->error_indicator) { |
16203 | p->level--; |
16204 | return NULL; |
16205 | } |
16206 | D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); |
16207 | void *invalid_comprehension_var; |
16208 | if ( |
16209 | (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension |
16210 | ) |
16211 | { |
16212 | D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); |
16213 | _res = invalid_comprehension_var; |
16214 | goto done; |
16215 | } |
16216 | p->mark = _mark; |
16217 | D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', |
16218 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); |
16219 | } |
16220 | _res = NULL; |
16221 | done: |
16222 | p->level--; |
16223 | return _res; |
16224 | } |
16225 | |
16226 | // setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension |
16227 | static expr_ty |
16228 | setcomp_rule(Parser *p) |
16229 | { |
16230 | if (p->level++ == MAXSTACK) { Branch (16230:9): [True: 0, False: 511]
|
16231 | p->error_indicator = 1; |
16232 | PyErr_NoMemory(); |
16233 | } |
16234 | if (p->error_indicator) { Branch (16234:9): [True: 0, False: 511]
|
16235 | p->level--; |
16236 | return NULL; |
16237 | } |
16238 | expr_ty _res = NULL; |
16239 | int _mark = p->mark; |
16240 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (16240:9): [True: 0, False: 511]
Branch (16240:31): [True: 0, False: 0]
|
16241 | p->error_indicator = 1; |
16242 | p->level--; |
16243 | return NULL; |
16244 | } |
16245 | int _start_lineno = p->tokens[_mark]->lineno; |
16246 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16247 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16248 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16249 | { // '{' named_expression for_if_clauses '}' |
16250 | if (p->error_indicator) { Branch (16250:13): [True: 0, False: 511]
|
16251 | p->level--; |
16252 | return NULL; |
16253 | } |
16254 | D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'")); |
16255 | Token * _literal; |
16256 | Token * _literal_1; |
16257 | expr_ty a; |
16258 | asdl_comprehension_seq* b; |
16259 | if ( |
16260 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (16260:13): [True: 511, False: 0]
|
16261 | && |
16262 | (a = named_expression_rule(p)) // named_expression Branch (16262:13): [True: 484, False: 27]
|
16263 | && |
16264 | (b = for_if_clauses_rule(p))484 // for_if_clauses Branch (16264:13): [True: 453, False: 31]
|
16265 | && |
16266 | (_literal_1 = _PyPegen_expect_token(p, 26))453 // token='}' Branch (16266:13): [True: 453, False: 0]
|
16267 | ) |
16268 | { |
16269 | D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'")); |
16270 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16271 | if (_token == NULL) { Branch (16271:17): [True: 0, False: 453]
|
16272 | p->level--; |
16273 | return NULL; |
16274 | } |
16275 | int _end_lineno = _token->end_lineno; |
16276 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16277 | int _end_col_offset = _token->end_col_offset; |
16278 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16279 | _res = _PyAST_SetComp ( a , b , EXTRA ); |
16280 | if (_res == NULL && PyErr_Occurred()0 ) { |
16281 | p->error_indicator = 1; |
16282 | p->level--; |
16283 | return NULL; |
16284 | } |
16285 | goto done; |
16286 | } |
16287 | p->mark = _mark; |
16288 | D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', |
16289 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression for_if_clauses '}'")); |
16290 | } |
16291 | if (p->call_invalid_rules) { // invalid_comprehension Branch (16291:9): [True: 30, False: 28]
|
16292 | if (p->error_indicator) { |
16293 | p->level--; |
16294 | return NULL; |
16295 | } |
16296 | D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); |
16297 | void *invalid_comprehension_var; |
16298 | if ( |
16299 | (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension |
16300 | ) |
16301 | { |
16302 | D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); |
16303 | _res = invalid_comprehension_var; |
16304 | goto done; |
16305 | } |
16306 | p->mark = _mark; |
16307 | D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', |
16308 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); |
16309 | } |
16310 | _res = NULL; |
16311 | done: |
16312 | p->level--; |
16313 | return _res; |
16314 | } |
16315 | |
16316 | // genexp: |
16317 | // | '(' (assignment_expression | expression !':=') for_if_clauses ')' |
16318 | // | invalid_comprehension |
16319 | static expr_ty |
16320 | genexp_rule(Parser *p) |
16321 | { |
16322 | if (p->level++ == MAXSTACK) { Branch (16322:9): [True: 0, False: 3.27M]
|
16323 | p->error_indicator = 1; |
16324 | PyErr_NoMemory(); |
16325 | } |
16326 | if (p->error_indicator) { Branch (16326:9): [True: 0, False: 3.27M]
|
16327 | p->level--; |
16328 | return NULL; |
16329 | } |
16330 | expr_ty _res = NULL; |
16331 | int _mark = p->mark; |
16332 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (16332:9): [True: 0, False: 3.27M]
Branch (16332:31): [True: 0, False: 0]
|
16333 | p->error_indicator = 1; |
16334 | p->level--; |
16335 | return NULL; |
16336 | } |
16337 | int _start_lineno = p->tokens[_mark]->lineno; |
16338 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16339 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16340 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16341 | { // '(' (assignment_expression | expression !':=') for_if_clauses ')' |
16342 | if (p->error_indicator) { Branch (16342:13): [True: 0, False: 3.27M]
|
16343 | p->level--; |
16344 | return NULL; |
16345 | } |
16346 | D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'")); |
16347 | Token * _literal; |
16348 | Token * _literal_1; |
16349 | void *a; |
16350 | asdl_comprehension_seq* b; |
16351 | if ( |
16352 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (16352:13): [True: 782k, False: 2.48M]
|
16353 | && |
16354 | (a = _tmp_116_rule(p))782k // assignment_expression | expression !':=' Branch (16354:13): [True: 141k, False: 641k]
|
16355 | && |
16356 | (b = for_if_clauses_rule(p))141k // for_if_clauses Branch (16356:13): [True: 1.42k, False: 139k]
|
16357 | && |
16358 | (_literal_1 = _PyPegen_expect_token(p, 8))1.42k // token=')' Branch (16358:13): [True: 1.38k, False: 34]
|
16359 | ) |
16360 | { |
16361 | D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'")); |
16362 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16363 | if (_token == NULL) { Branch (16363:17): [True: 0, False: 1.38k]
|
16364 | p->level--; |
16365 | return NULL; |
16366 | } |
16367 | int _end_lineno = _token->end_lineno; |
16368 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16369 | int _end_col_offset = _token->end_col_offset; |
16370 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16371 | _res = _PyAST_GeneratorExp ( a , b , EXTRA ); |
16372 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16372:17): [True: 0, False: 1.38k]
Branch (16372:33): [True: 0, False: 0]
|
16373 | p->error_indicator = 1; |
16374 | p->level--; |
16375 | return NULL; |
16376 | } |
16377 | goto done; |
16378 | } |
16379 | p->mark = _mark; |
16380 | D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', |
16381 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'")); |
16382 | } |
16383 | if (p->call_invalid_rules) { // invalid_comprehension Branch (16383:9): [True: 2.82k, False: 3.26M]
|
16384 | if (p->error_indicator) { Branch (16384:13): [True: 0, False: 2.82k]
|
16385 | p->level--; |
16386 | return NULL; |
16387 | } |
16388 | D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); |
16389 | void *invalid_comprehension_var; |
16390 | if ( |
16391 | (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension Branch (16391:13): [True: 0, False: 2.82k]
|
16392 | ) |
16393 | { |
16394 | D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); |
16395 | _res = invalid_comprehension_var; |
16396 | goto done; |
16397 | } |
16398 | p->mark = _mark; |
16399 | D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', |
16400 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); |
16401 | } |
16402 | _res = NULL; |
16403 | done: |
16404 | p->level--; |
16405 | return _res; |
16406 | } |
16407 | |
16408 | // dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension |
16409 | static expr_ty |
16410 | dictcomp_rule(Parser *p) |
16411 | { |
16412 | if (p->level++ == MAXSTACK) { Branch (16412:9): [True: 0, False: 877]
|
16413 | p->error_indicator = 1; |
16414 | PyErr_NoMemory(); |
16415 | } |
16416 | if (p->error_indicator) { Branch (16416:9): [True: 0, False: 877]
|
16417 | p->level--; |
16418 | return NULL; |
16419 | } |
16420 | expr_ty _res = NULL; |
16421 | int _mark = p->mark; |
16422 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (16422:9): [True: 0, False: 877]
Branch (16422:31): [True: 0, False: 0]
|
16423 | p->error_indicator = 1; |
16424 | p->level--; |
16425 | return NULL; |
16426 | } |
16427 | int _start_lineno = p->tokens[_mark]->lineno; |
16428 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16429 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16430 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16431 | { // '{' kvpair for_if_clauses '}' |
16432 | if (p->error_indicator) { Branch (16432:13): [True: 0, False: 877]
|
16433 | p->level--; |
16434 | return NULL; |
16435 | } |
16436 | D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'")); |
16437 | Token * _literal; |
16438 | Token * _literal_1; |
16439 | KeyValuePair* a; |
16440 | asdl_comprehension_seq* b; |
16441 | if ( |
16442 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (16442:13): [True: 877, False: 0]
|
16443 | && |
16444 | (a = kvpair_rule(p)) // kvpair Branch (16444:13): [True: 371, False: 506]
|
16445 | && |
16446 | (b = for_if_clauses_rule(p))371 // for_if_clauses Branch (16446:13): [True: 365, False: 6]
|
16447 | && |
16448 | (_literal_1 = _PyPegen_expect_token(p, 26))365 // token='}' Branch (16448:13): [True: 365, False: 0]
|
16449 | ) |
16450 | { |
16451 | D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'")); |
16452 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16453 | if (_token == NULL) { Branch (16453:17): [True: 0, False: 365]
|
16454 | p->level--; |
16455 | return NULL; |
16456 | } |
16457 | int _end_lineno = _token->end_lineno; |
16458 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16459 | int _end_col_offset = _token->end_col_offset; |
16460 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16461 | _res = _PyAST_DictComp ( a -> key , a -> value , b , EXTRA ); |
16462 | if (_res == NULL && PyErr_Occurred()0 ) { |
16463 | p->error_indicator = 1; |
16464 | p->level--; |
16465 | return NULL; |
16466 | } |
16467 | goto done; |
16468 | } |
16469 | p->mark = _mark; |
16470 | D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', |
16471 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'")); |
16472 | } |
16473 | if (p->call_invalid_rules) { // invalid_dict_comprehension Branch (16473:9): [True: 37, False: 475]
|
16474 | if (p->error_indicator) { |
16475 | p->level--; |
16476 | return NULL; |
16477 | } |
16478 | D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension")); |
16479 | void *invalid_dict_comprehension_var; |
16480 | if ( |
16481 | (invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p)) // invalid_dict_comprehension |
16482 | ) |
16483 | { |
16484 | D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension")); |
16485 | _res = invalid_dict_comprehension_var; |
16486 | goto done; |
16487 | } |
16488 | p->mark = _mark; |
16489 | D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', |
16490 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension")); |
16491 | } |
16492 | _res = NULL; |
16493 | done: |
16494 | p->level--; |
16495 | return _res; |
16496 | } |
16497 | |
16498 | // arguments: args ','? &')' | invalid_arguments |
16499 | static expr_ty |
16500 | arguments_rule(Parser *p) |
16501 | { |
16502 | if (p->level++ == MAXSTACK) { Branch (16502:9): [True: 0, False: 783k]
|
16503 | p->error_indicator = 1; |
16504 | PyErr_NoMemory(); |
16505 | } |
16506 | if (p->error_indicator) { Branch (16506:9): [True: 0, False: 783k]
|
16507 | p->level--; |
16508 | return NULL; |
16509 | } |
16510 | expr_ty _res = NULL; |
16511 | if (_PyPegen_is_memoized(p, arguments_type, &_res)) { Branch (16511:9): [True: 367k, False: 416k]
|
16512 | p->level--; |
16513 | return _res; |
16514 | } |
16515 | int _mark = p->mark; |
16516 | { // args ','? &')' |
16517 | if (p->error_indicator) { Branch (16517:13): [True: 0, False: 416k]
|
16518 | p->level--; |
16519 | return NULL; |
16520 | } |
16521 | D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'")); |
16522 | void *_opt_var; |
16523 | UNUSED(_opt_var); // Silence compiler warnings |
16524 | expr_ty a; |
16525 | if ( |
16526 | (a = args_rule(p)) // args Branch (16526:13): [True: 92.6k, False: 323k]
|
16527 | && |
16528 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)92.6k // ','? Branch (16528:13): [True: 92.6k, False: 0]
|
16529 | && |
16530 | _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)92.6k // token=')' Branch (16530:13): [True: 92.3k, False: 313]
|
16531 | ) |
16532 | { |
16533 | D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','? &')'")); |
16534 | _res = a; |
16535 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16535:17): [True: 0, False: 92.3k]
Branch (16535:33): [True: 0, False: 0]
|
16536 | p->error_indicator = 1; |
16537 | p->level--; |
16538 | return NULL; |
16539 | } |
16540 | goto done; |
16541 | } |
16542 | p->mark = _mark; |
16543 | D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ', |
16544 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'")); |
16545 | } |
16546 | if (p->call_invalid_rules) { // invalid_arguments Branch (16546:9): [True: 108, False: 323k]
|
16547 | if (p->error_indicator) { Branch (16547:13): [True: 15, False: 93]
|
16548 | p->level--; |
16549 | return NULL; |
16550 | } |
16551 | D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments")); |
16552 | void *invalid_arguments_var; |
16553 | if ( |
16554 | (invalid_arguments_var = invalid_arguments_rule(p)) // invalid_arguments |
16555 | ) |
16556 | { |
16557 | D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_arguments")); |
16558 | _res = invalid_arguments_var; |
16559 | goto done; |
16560 | } |
16561 | p->mark = _mark; |
16562 | D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ', |
16563 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arguments")); |
16564 | } |
16565 | _res = NULL; |
16566 | done: |
16567 | _PyPegen_insert_memo(p, _mark, arguments_type, _res); |
16568 | p->level--; |
16569 | return _res; |
16570 | } |
16571 | |
16572 | // args: |
16573 | // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs] |
16574 | // | kwargs |
16575 | static expr_ty |
16576 | args_rule(Parser *p) |
16577 | { |
16578 | if (p->level++ == MAXSTACK) { Branch (16578:9): [True: 0, False: 416k]
|
16579 | p->error_indicator = 1; |
16580 | PyErr_NoMemory(); |
16581 | } |
16582 | if (p->error_indicator) { Branch (16582:9): [True: 0, False: 416k]
|
16583 | p->level--; |
16584 | return NULL; |
16585 | } |
16586 | expr_ty _res = NULL; |
16587 | int _mark = p->mark; |
16588 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 011 ) { Branch (16588:9): [True: 11, False: 416k]
Branch (16588:31): [True: 1, False: 10]
|
16589 | p->error_indicator = 1; |
16590 | p->level--; |
16591 | return NULL; |
16592 | } |
16593 | int _start_lineno = p->tokens[_mark]->lineno; |
16594 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16595 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16596 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16597 | { // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs] |
16598 | if (p->error_indicator) { Branch (16598:13): [True: 0, False: 416k]
|
16599 | p->level--; |
16600 | return NULL; |
16601 | } |
16602 | D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); |
16603 | asdl_expr_seq* a; |
16604 | void *b; |
16605 | if ( |
16606 | (a = (asdl_expr_seq*)_gather_117_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ Branch (16606:13): [True: 90.7k, False: 325k]
|
16607 | && |
16608 | (b = _tmp_119_rule(p), !p->error_indicator)90.7k // [',' kwargs] Branch (16608:13): [True: 90.7k, False: 14]
|
16609 | ) |
16610 | { |
16611 | D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); |
16612 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16613 | if (_token == NULL) { Branch (16613:17): [True: 0, False: 90.7k]
|
16614 | p->level--; |
16615 | return NULL; |
16616 | } |
16617 | int _end_lineno = _token->end_lineno; |
16618 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16619 | int _end_col_offset = _token->end_col_offset; |
16620 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16621 | _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA ); |
16622 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16622:17): [True: 0, False: 90.7k]
Branch (16622:33): [True: 0, False: 0]
|
16623 | p->error_indicator = 1; |
16624 | p->level--; |
16625 | return NULL; |
16626 | } |
16627 | goto done; |
16628 | } |
16629 | p->mark = _mark; |
16630 | D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', |
16631 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); |
16632 | } |
16633 | { // kwargs |
16634 | if (p->error_indicator) { Branch (16634:13): [True: 16, False: 325k]
|
16635 | p->level--; |
16636 | return NULL; |
16637 | } |
16638 | D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); |
16639 | asdl_seq* a; |
16640 | if ( |
16641 | (a = kwargs_rule(p)) // kwargs Branch (16641:13): [True: 2.03k, False: 323k]
|
16642 | ) |
16643 | { |
16644 | D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); |
16645 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16646 | if (_token == NULL) { Branch (16646:17): [True: 0, False: 2.03k]
|
16647 | p->level--; |
16648 | return NULL; |
16649 | } |
16650 | int _end_lineno = _token->end_lineno; |
16651 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16652 | int _end_col_offset = _token->end_col_offset; |
16653 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16654 | _res = _PyAST_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( asdl_expr_seq* , _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( asdl_keyword_seq* , _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA ); |
16655 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16655:17): [True: 0, False: 2.03k]
Branch (16655:33): [True: 0, False: 0]
|
16656 | p->error_indicator = 1; |
16657 | p->level--; |
16658 | return NULL; |
16659 | } |
16660 | goto done; |
16661 | } |
16662 | p->mark = _mark; |
16663 | D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', |
16664 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); |
16665 | } |
16666 | _res = NULL; |
16667 | done: |
16668 | p->level--; |
16669 | return _res; |
16670 | } |
16671 | |
16672 | // kwargs: |
16673 | // | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+ |
16674 | // | ','.kwarg_or_starred+ |
16675 | // | ','.kwarg_or_double_starred+ |
16676 | static asdl_seq* |
16677 | kwargs_rule(Parser *p) |
16678 | { |
16679 | if (p->level++ == MAXSTACK) { Branch (16679:9): [True: 0, False: 329k]
|
16680 | p->error_indicator = 1; |
16681 | PyErr_NoMemory(); |
16682 | } |
16683 | if (p->error_indicator) { Branch (16683:9): [True: 0, False: 329k]
|
16684 | p->level--; |
16685 | return NULL; |
16686 | } |
16687 | asdl_seq* _res = NULL; |
16688 | int _mark = p->mark; |
16689 | { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+ |
16690 | if (p->error_indicator) { Branch (16690:13): [True: 0, False: 329k]
|
16691 | p->level--; |
16692 | return NULL; |
16693 | } |
16694 | D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); |
16695 | Token * _literal; |
16696 | asdl_seq * a; |
16697 | asdl_seq * b; |
16698 | if ( |
16699 | (a = _gather_120_rule(p)) // ','.kwarg_or_starred+ Branch (16699:13): [True: 5.31k, False: 324k]
|
16700 | && |
16701 | (_literal = _PyPegen_expect_token(p, 12))5.31k // token=',' Branch (16701:13): [True: 304, False: 5.01k]
|
16702 | && |
16703 | (b = _gather_122_rule(p))304 // ','.kwarg_or_double_starred+ Branch (16703:13): [True: 153, False: 151]
|
16704 | ) |
16705 | { |
16706 | D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); |
16707 | _res = _PyPegen_join_sequences ( p , a , b ); |
16708 | if (_res == NULL && PyErr_Occurred()0 ) { |
16709 | p->error_indicator = 1; |
16710 | p->level--; |
16711 | return NULL; |
16712 | } |
16713 | goto done; |
16714 | } |
16715 | p->mark = _mark; |
16716 | D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', |
16717 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); |
16718 | } |
16719 | { // ','.kwarg_or_starred+ |
16720 | if (p->error_indicator) { Branch (16720:13): [True: 14, False: 329k]
|
16721 | p->level--; |
16722 | return NULL; |
16723 | } |
16724 | D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); |
16725 | asdl_seq * _gather_124_var; |
16726 | if ( |
16727 | (_gather_124_var = _gather_124_rule(p)) // ','.kwarg_or_starred+ Branch (16727:13): [True: 5.16k, False: 324k]
|
16728 | ) |
16729 | { |
16730 | D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); |
16731 | _res = _gather_124_var; |
16732 | goto done; |
16733 | } |
16734 | p->mark = _mark; |
16735 | D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', |
16736 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+")); |
16737 | } |
16738 | { // ','.kwarg_or_double_starred+ |
16739 | if (p->error_indicator) { Branch (16739:13): [True: 0, False: 324k]
|
16740 | p->level--; |
16741 | return NULL; |
16742 | } |
16743 | D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); |
16744 | asdl_seq * _gather_126_var; |
16745 | if ( |
16746 | (_gather_126_var = _gather_126_rule(p)) // ','.kwarg_or_double_starred+ Branch (16746:13): [True: 680, False: 323k]
|
16747 | ) |
16748 | { |
16749 | D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); |
16750 | _res = _gather_126_var; |
16751 | goto done; |
16752 | } |
16753 | p->mark = _mark; |
16754 | D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', |
16755 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_double_starred+")); |
16756 | } |
16757 | _res = NULL; |
16758 | done: |
16759 | p->level--; |
16760 | return _res; |
16761 | } |
16762 | |
16763 | // starred_expression: '*' expression |
16764 | static expr_ty |
16765 | starred_expression_rule(Parser *p) |
16766 | { |
16767 | if (p->level++ == MAXSTACK) { Branch (16767:9): [True: 0, False: 1.11M]
|
16768 | p->error_indicator = 1; |
16769 | PyErr_NoMemory(); |
16770 | } |
16771 | if (p->error_indicator) { Branch (16771:9): [True: 0, False: 1.11M]
|
16772 | p->level--; |
16773 | return NULL; |
16774 | } |
16775 | expr_ty _res = NULL; |
16776 | int _mark = p->mark; |
16777 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 050.6k ) { Branch (16777:9): [True: 50.6k, False: 1.06M]
Branch (16777:31): [True: 10, False: 50.6k]
|
16778 | p->error_indicator = 1; |
16779 | p->level--; |
16780 | return NULL; |
16781 | } |
16782 | int _start_lineno = p->tokens[_mark]->lineno; |
16783 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16784 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16785 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16786 | { // '*' expression |
16787 | if (p->error_indicator) { Branch (16787:13): [True: 0, False: 1.11M]
|
16788 | p->level--; |
16789 | return NULL; |
16790 | } |
16791 | D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression")); |
16792 | Token * _literal; |
16793 | expr_ty a; |
16794 | if ( |
16795 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (16795:13): [True: 2.76k, False: 1.11M]
|
16796 | && |
16797 | (a = expression_rule(p))2.76k // expression Branch (16797:13): [True: 2.70k, False: 56]
|
16798 | ) |
16799 | { |
16800 | D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression")); |
16801 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16802 | if (_token == NULL) { Branch (16802:17): [True: 0, False: 2.70k]
|
16803 | p->level--; |
16804 | return NULL; |
16805 | } |
16806 | int _end_lineno = _token->end_lineno; |
16807 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16808 | int _end_col_offset = _token->end_col_offset; |
16809 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16810 | _res = _PyAST_Starred ( a , Load , EXTRA ); |
16811 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16811:17): [True: 0, False: 2.70k]
Branch (16811:33): [True: 0, False: 0]
|
16812 | p->error_indicator = 1; |
16813 | p->level--; |
16814 | return NULL; |
16815 | } |
16816 | goto done; |
16817 | } |
16818 | p->mark = _mark; |
16819 | D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ', |
16820 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); |
16821 | } |
16822 | _res = NULL; |
16823 | done: |
16824 | p->level--; |
16825 | return _res; |
16826 | } |
16827 | |
16828 | // kwarg_or_starred: invalid_kwarg | NAME '=' expression | starred_expression |
16829 | static KeywordOrStarred* |
16830 | kwarg_or_starred_rule(Parser *p) |
16831 | { |
16832 | if (p->level++ == MAXSTACK) { Branch (16832:9): [True: 0, False: 667k]
|
16833 | p->error_indicator = 1; |
16834 | PyErr_NoMemory(); |
16835 | } |
16836 | if (p->error_indicator) { Branch (16836:9): [True: 0, False: 667k]
|
16837 | p->level--; |
16838 | return NULL; |
16839 | } |
16840 | KeywordOrStarred* _res = NULL; |
16841 | int _mark = p->mark; |
16842 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 04.15k ) { Branch (16842:9): [True: 4.15k, False: 663k]
Branch (16842:31): [True: 0, False: 4.15k]
|
16843 | p->error_indicator = 1; |
16844 | p->level--; |
16845 | return NULL; |
16846 | } |
16847 | int _start_lineno = p->tokens[_mark]->lineno; |
16848 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16849 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16850 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16851 | if (p->call_invalid_rules) { // invalid_kwarg Branch (16851:9): [True: 804, False: 667k]
|
16852 | if (p->error_indicator) { Branch (16852:13): [True: 0, False: 804]
|
16853 | p->level--; |
16854 | return NULL; |
16855 | } |
16856 | D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); |
16857 | void *invalid_kwarg_var; |
16858 | if ( |
16859 | (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg Branch (16859:13): [True: 0, False: 804]
|
16860 | ) |
16861 | { |
16862 | D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); |
16863 | _res = invalid_kwarg_var; |
16864 | goto done; |
16865 | } |
16866 | p->mark = _mark; |
16867 | D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', |
16868 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); |
16869 | } |
16870 | { // NAME '=' expression |
16871 | if (p->error_indicator) { Branch (16871:13): [True: 14, False: 667k]
|
16872 | p->level--; |
16873 | return NULL; |
16874 | } |
16875 | D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); |
16876 | Token * _literal; |
16877 | expr_ty a; |
16878 | expr_ty b; |
16879 | if ( |
16880 | (a = _PyPegen_name_token(p)) // NAME Branch (16880:13): [True: 18.1k, False: 649k]
|
16881 | && |
16882 | (_literal = _PyPegen_expect_token(p, 22))18.1k // token='=' Branch (16882:13): [True: 18.0k, False: 92]
|
16883 | && |
16884 | (b = expression_rule(p))18.0k // expression Branch (16884:13): [True: 18.0k, False: 12]
|
16885 | ) |
16886 | { |
16887 | D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); |
16888 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
16889 | if (_token == NULL) { Branch (16889:17): [True: 0, False: 18.0k]
|
16890 | p->level--; |
16891 | return NULL; |
16892 | } |
16893 | int _end_lineno = _token->end_lineno; |
16894 | UNUSED(_end_lineno); // Only used by EXTRA macro |
16895 | int _end_col_offset = _token->end_col_offset; |
16896 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
16897 | _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 ); |
16898 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (16898:17): [True: 0, False: 18.0k]
Branch (16898:33): [True: 0, False: 0]
|
16899 | p->error_indicator = 1; |
16900 | p->level--; |
16901 | return NULL; |
16902 | } |
16903 | goto done; |
16904 | } |
16905 | p->mark = _mark; |
16906 | D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', |
16907 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); |
16908 | } |
16909 | { // starred_expression |
16910 | if (p->error_indicator) { Branch (16910:13): [True: 0, False: 649k]
|
16911 | p->level--; |
16912 | return NULL; |
16913 | } |
16914 | D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); |
16915 | expr_ty a; |
16916 | if ( |
16917 | (a = starred_expression_rule(p)) // starred_expression Branch (16917:13): [True: 114, False: 649k]
|
16918 | ) |
16919 | { |
16920 | D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); |
16921 | _res = _PyPegen_keyword_or_starred ( p , a , 0 ); |
16922 | if (_res == NULL && PyErr_Occurred()0 ) { |
16923 | p->error_indicator = 1; |
16924 | p->level--; |
16925 | return NULL; |
16926 | } |
16927 | goto done; |
16928 | } |
16929 | p->mark = _mark; |
16930 | D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', |
16931 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); |
16932 | } |
16933 | _res = NULL; |
16934 | done: |
16935 | p->level--; |
16936 | return _res; |
16937 | } |
16938 | |
16939 | // kwarg_or_double_starred: invalid_kwarg | NAME '=' expression | '**' expression |
16940 | static KeywordOrStarred* |
16941 | kwarg_or_double_starred_rule(Parser *p) |
16942 | { |
16943 | if (p->level++ == MAXSTACK) { Branch (16943:9): [True: 0, False: 324k]
|
16944 | p->error_indicator = 1; |
16945 | PyErr_NoMemory(); |
16946 | } |
16947 | if (p->error_indicator) { Branch (16947:9): [True: 0, False: 324k]
|
16948 | p->level--; |
16949 | return NULL; |
16950 | } |
16951 | KeywordOrStarred* _res = NULL; |
16952 | int _mark = p->mark; |
16953 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 050 ) { Branch (16953:9): [True: 50, False: 324k]
Branch (16953:31): [True: 0, False: 50]
|
16954 | p->error_indicator = 1; |
16955 | p->level--; |
16956 | return NULL; |
16957 | } |
16958 | int _start_lineno = p->tokens[_mark]->lineno; |
16959 | UNUSED(_start_lineno); // Only used by EXTRA macro |
16960 | int _start_col_offset = p->tokens[_mark]->col_offset; |
16961 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
16962 | if (p->call_invalid_rules) { // invalid_kwarg Branch (16962:9): [True: 326, False: 324k]
|
16963 | if (p->error_indicator) { Branch (16963:13): [True: 0, False: 326]
|
16964 | p->level--; |
16965 | return NULL; |
16966 | } |
16967 | D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); |
16968 | void *invalid_kwarg_var; |
16969 | if ( |
16970 | (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg Branch (16970:13): [True: 0, False: 326]
|
16971 | ) |
16972 | { |
16973 | D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); |
16974 | _res = invalid_kwarg_var; |
16975 | goto done; |
16976 | } |
16977 | p->mark = _mark; |
16978 | D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', |
16979 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); |
16980 | } |
16981 | { // NAME '=' expression |
16982 | if (p->error_indicator) { Branch (16982:13): [True: 0, False: 324k]
|
16983 | p->level--; |
16984 | return NULL; |
16985 | } |
16986 | D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); |
16987 | Token * _literal; |
16988 | expr_ty a; |
16989 | expr_ty b; |
16990 | if ( |
16991 | (a = _PyPegen_name_token(p)) // NAME Branch (16991:13): [True: 78, False: 324k]
|
16992 | && |
16993 | (_literal = _PyPegen_expect_token(p, 22))78 // token='=' Branch (16993:13): [True: 32, False: 46]
|
16994 | && |
16995 | (b = expression_rule(p))32 // expression |
16996 | ) |
16997 | { |
16998 | D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); |
16999 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17000 | if (_token == NULL) { |
17001 | p->level--; |
17002 | return NULL; |
17003 | } |
17004 | int _end_lineno = _token->end_lineno; |
17005 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17006 | int _end_col_offset = _token->end_col_offset; |
17007 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17008 | _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 ); |
17009 | if (_res == NULL && PyErr_Occurred()0 ) { |
17010 | p->error_indicator = 1; |
17011 | p->level--; |
17012 | return NULL; |
17013 | } |
17014 | goto done; |
17015 | } |
17016 | p->mark = _mark; |
17017 | D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', |
17018 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); |
17019 | } |
17020 | { // '**' expression |
17021 | if (p->error_indicator) { Branch (17021:13): [True: 0, False: 324k]
|
17022 | p->level--; |
17023 | return NULL; |
17024 | } |
17025 | D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression")); |
17026 | Token * _literal; |
17027 | expr_ty a; |
17028 | if ( |
17029 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (17029:13): [True: 855, False: 324k]
|
17030 | && |
17031 | (a = expression_rule(p))855 // expression Branch (17031:13): [True: 854, False: 1]
|
17032 | ) |
17033 | { |
17034 | D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression")); |
17035 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17036 | if (_token == NULL) { Branch (17036:17): [True: 0, False: 854]
|
17037 | p->level--; |
17038 | return NULL; |
17039 | } |
17040 | int _end_lineno = _token->end_lineno; |
17041 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17042 | int _end_col_offset = _token->end_col_offset; |
17043 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17044 | _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) ) , 1 ); |
17045 | if (_res == NULL && PyErr_Occurred()0 ) { |
17046 | p->error_indicator = 1; |
17047 | p->level--; |
17048 | return NULL; |
17049 | } |
17050 | goto done; |
17051 | } |
17052 | p->mark = _mark; |
17053 | D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', |
17054 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); |
17055 | } |
17056 | _res = NULL; |
17057 | done: |
17058 | p->level--; |
17059 | return _res; |
17060 | } |
17061 | |
17062 | // star_targets: star_target !',' | star_target ((',' star_target))* ','? |
17063 | static expr_ty |
17064 | star_targets_rule(Parser *p) |
17065 | { |
17066 | if (p->level++ == MAXSTACK) { Branch (17066:9): [True: 0, False: 577k]
|
17067 | p->error_indicator = 1; |
17068 | PyErr_NoMemory(); |
17069 | } |
17070 | if (p->error_indicator) { Branch (17070:9): [True: 0, False: 577k]
|
17071 | p->level--; |
17072 | return NULL; |
17073 | } |
17074 | expr_ty _res = NULL; |
17075 | int _mark = p->mark; |
17076 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 091.9k ) { Branch (17076:9): [True: 91.9k, False: 486k]
Branch (17076:31): [True: 20, False: 91.8k]
|
17077 | p->error_indicator = 1; |
17078 | p->level--; |
17079 | return NULL; |
17080 | } |
17081 | int _start_lineno = p->tokens[_mark]->lineno; |
17082 | UNUSED(_start_lineno); // Only used by EXTRA macro |
17083 | int _start_col_offset = p->tokens[_mark]->col_offset; |
17084 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
17085 | { // star_target !',' |
17086 | if (p->error_indicator) { Branch (17086:13): [True: 0, False: 577k]
|
17087 | p->level--; |
17088 | return NULL; |
17089 | } |
17090 | D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !','")); |
17091 | expr_ty a; |
17092 | if ( |
17093 | (a = star_target_rule(p)) // star_target Branch (17093:13): [True: 402k, False: 175k]
|
17094 | && |
17095 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)402k // token=',' Branch (17095:13): [True: 398k, False: 4.39k]
|
17096 | ) |
17097 | { |
17098 | D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target !','")); |
17099 | _res = a; |
17100 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17100:17): [True: 0, False: 398k]
Branch (17100:33): [True: 0, False: 0]
|
17101 | p->error_indicator = 1; |
17102 | p->level--; |
17103 | return NULL; |
17104 | } |
17105 | goto done; |
17106 | } |
17107 | p->mark = _mark; |
17108 | D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ', |
17109 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target !','")); |
17110 | } |
17111 | { // star_target ((',' star_target))* ','? |
17112 | if (p->error_indicator) { Branch (17112:13): [True: 15, False: 179k]
|
17113 | p->level--; |
17114 | return NULL; |
17115 | } |
17116 | D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?")); |
17117 | void *_opt_var; |
17118 | UNUSED(_opt_var); // Silence compiler warnings |
17119 | expr_ty a; |
17120 | asdl_seq * b; |
17121 | if ( |
17122 | (a = star_target_rule(p)) // star_target Branch (17122:13): [True: 4.39k, False: 175k]
|
17123 | && |
17124 | (b = _loop0_128_rule(p))4.39k // ((',' star_target))* Branch (17124:13): [True: 4.39k, False: 0]
|
17125 | && |
17126 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)4.39k // ','? Branch (17126:13): [True: 4.38k, False: 2]
|
17127 | ) |
17128 | { |
17129 | D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?")); |
17130 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17131 | if (_token == NULL) { Branch (17131:17): [True: 0, False: 4.38k]
|
17132 | p->level--; |
17133 | return NULL; |
17134 | } |
17135 | int _end_lineno = _token->end_lineno; |
17136 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17137 | int _end_col_offset = _token->end_col_offset; |
17138 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17139 | _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA ); |
17140 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17140:17): [True: 0, False: 4.38k]
Branch (17140:33): [True: 0, False: 0]
|
17141 | p->error_indicator = 1; |
17142 | p->level--; |
17143 | return NULL; |
17144 | } |
17145 | goto done; |
17146 | } |
17147 | p->mark = _mark; |
17148 | D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ', |
17149 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))* ','?")); |
17150 | } |
17151 | _res = NULL; |
17152 | done: |
17153 | p->level--; |
17154 | return _res; |
17155 | } |
17156 | |
17157 | // star_targets_list_seq: ','.star_target+ ','? |
17158 | static asdl_expr_seq* |
17159 | star_targets_list_seq_rule(Parser *p) |
17160 | { |
17161 | if (p->level++ == MAXSTACK) { Branch (17161:9): [True: 0, False: 3.49k]
|
17162 | p->error_indicator = 1; |
17163 | PyErr_NoMemory(); |
17164 | } |
17165 | if (p->error_indicator) { Branch (17165:9): [True: 0, False: 3.49k]
|
17166 | p->level--; |
17167 | return NULL; |
17168 | } |
17169 | asdl_expr_seq* _res = NULL; |
17170 | int _mark = p->mark; |
17171 | { // ','.star_target+ ','? |
17172 | if (p->error_indicator) { Branch (17172:13): [True: 0, False: 3.49k]
|
17173 | p->level--; |
17174 | return NULL; |
17175 | } |
17176 | D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?")); |
17177 | void *_opt_var; |
17178 | UNUSED(_opt_var); // Silence compiler warnings |
17179 | asdl_expr_seq* a; |
17180 | if ( |
17181 | (a = (asdl_expr_seq*)_gather_129_rule(p)) // ','.star_target+ Branch (17181:13): [True: 1.16k, False: 2.32k]
|
17182 | && |
17183 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)1.16k // ','? Branch (17183:13): [True: 1.16k, False: 0]
|
17184 | ) |
17185 | { |
17186 | D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?")); |
17187 | _res = a; |
17188 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17188:17): [True: 0, False: 1.16k]
Branch (17188:33): [True: 0, False: 0]
|
17189 | p->error_indicator = 1; |
17190 | p->level--; |
17191 | return NULL; |
17192 | } |
17193 | goto done; |
17194 | } |
17195 | p->mark = _mark; |
17196 | D(fprintf(stderr, "%*c%s star_targets_list_seq[%d-%d]: %s failed!\n", p->level, ' ', |
17197 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_target+ ','?")); |
17198 | } |
17199 | _res = NULL; |
17200 | done: |
17201 | p->level--; |
17202 | return _res; |
17203 | } |
17204 | |
17205 | // star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ',' |
17206 | static asdl_expr_seq* |
17207 | star_targets_tuple_seq_rule(Parser *p) |
17208 | { |
17209 | if (p->level++ == MAXSTACK) { Branch (17209:9): [True: 0, False: 2.38k]
|
17210 | p->error_indicator = 1; |
17211 | PyErr_NoMemory(); |
17212 | } |
17213 | if (p->error_indicator) { Branch (17213:9): [True: 0, False: 2.38k]
|
17214 | p->level--; |
17215 | return NULL; |
17216 | } |
17217 | asdl_expr_seq* _res = NULL; |
17218 | int _mark = p->mark; |
17219 | { // star_target ((',' star_target))+ ','? |
17220 | if (p->error_indicator) { Branch (17220:13): [True: 0, False: 2.38k]
|
17221 | p->level--; |
17222 | return NULL; |
17223 | } |
17224 | D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?")); |
17225 | void *_opt_var; |
17226 | UNUSED(_opt_var); // Silence compiler warnings |
17227 | expr_ty a; |
17228 | asdl_seq * b; |
17229 | if ( |
17230 | (a = star_target_rule(p)) // star_target Branch (17230:13): [True: 1.26k, False: 1.11k]
|
17231 | && |
17232 | (b = _loop1_131_rule(p))1.26k // ((',' star_target))+ Branch (17232:13): [True: 623, False: 645]
|
17233 | && |
17234 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)623 // ','? Branch (17234:13): [True: 623, False: 0]
|
17235 | ) |
17236 | { |
17237 | D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?")); |
17238 | _res = ( asdl_expr_seq* ) _PyPegen_seq_insert_in_front ( p , a , b ); |
17239 | if (_res == NULL && PyErr_Occurred()0 ) { |
17240 | p->error_indicator = 1; |
17241 | p->level--; |
17242 | return NULL; |
17243 | } |
17244 | goto done; |
17245 | } |
17246 | p->mark = _mark; |
17247 | D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ', |
17248 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))+ ','?")); |
17249 | } |
17250 | { // star_target ',' |
17251 | if (p->error_indicator) { Branch (17251:13): [True: 0, False: 1.75k]
|
17252 | p->level--; |
17253 | return NULL; |
17254 | } |
17255 | D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ','")); |
17256 | Token * _literal; |
17257 | expr_ty a; |
17258 | if ( |
17259 | (a = star_target_rule(p)) // star_target Branch (17259:13): [True: 645, False: 1.11k]
|
17260 | && |
17261 | (_literal = _PyPegen_expect_token(p, 12))645 // token=',' Branch (17261:13): [True: 175, False: 470]
|
17262 | ) |
17263 | { |
17264 | D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ','")); |
17265 | _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a ); |
17266 | if (_res == NULL && PyErr_Occurred()0 ) { |
17267 | p->error_indicator = 1; |
17268 | p->level--; |
17269 | return NULL; |
17270 | } |
17271 | goto done; |
17272 | } |
17273 | p->mark = _mark; |
17274 | D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ', |
17275 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ','")); |
17276 | } |
17277 | _res = NULL; |
17278 | done: |
17279 | p->level--; |
17280 | return _res; |
17281 | } |
17282 | |
17283 | // star_target: '*' (!'*' star_target) | target_with_star_atom |
17284 | static expr_ty |
17285 | star_target_rule(Parser *p) |
17286 | { |
17287 | if (p->level++ == MAXSTACK) { Branch (17287:9): [True: 0, False: 778k]
|
17288 | p->error_indicator = 1; |
17289 | PyErr_NoMemory(); |
17290 | } |
17291 | if (p->error_indicator) { Branch (17291:9): [True: 0, False: 778k]
|
17292 | p->level--; |
17293 | return NULL; |
17294 | } |
17295 | expr_ty _res = NULL; |
17296 | if (_PyPegen_is_memoized(p, star_target_type, &_res)) { Branch (17296:9): [True: 186k, False: 592k]
|
17297 | p->level--; |
17298 | return _res; |
17299 | } |
17300 | int _mark = p->mark; |
17301 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (17301:9): [True: 0, False: 592k]
Branch (17301:31): [True: 0, False: 0]
|
17302 | p->error_indicator = 1; |
17303 | p->level--; |
17304 | return NULL; |
17305 | } |
17306 | int _start_lineno = p->tokens[_mark]->lineno; |
17307 | UNUSED(_start_lineno); // Only used by EXTRA macro |
17308 | int _start_col_offset = p->tokens[_mark]->col_offset; |
17309 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
17310 | { // '*' (!'*' star_target) |
17311 | if (p->error_indicator) { Branch (17311:13): [True: 0, False: 592k]
|
17312 | p->level--; |
17313 | return NULL; |
17314 | } |
17315 | D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); |
17316 | Token * _literal; |
17317 | void *a; |
17318 | if ( |
17319 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (17319:13): [True: 150, False: 592k]
|
17320 | && |
17321 | (a = _tmp_132_rule(p))150 // !'*' star_target Branch (17321:13): [True: 139, False: 11]
|
17322 | ) |
17323 | { |
17324 | D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); |
17325 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17326 | if (_token == NULL) { Branch (17326:17): [True: 0, False: 139]
|
17327 | p->level--; |
17328 | return NULL; |
17329 | } |
17330 | int _end_lineno = _token->end_lineno; |
17331 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17332 | int _end_col_offset = _token->end_col_offset; |
17333 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17334 | _res = _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA ); |
17335 | if (_res == NULL && PyErr_Occurred()0 ) { |
17336 | p->error_indicator = 1; |
17337 | p->level--; |
17338 | return NULL; |
17339 | } |
17340 | goto done; |
17341 | } |
17342 | p->mark = _mark; |
17343 | D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', |
17344 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)")); |
17345 | } |
17346 | { // target_with_star_atom |
17347 | if (p->error_indicator) { Branch (17347:13): [True: 0, False: 592k]
|
17348 | p->level--; |
17349 | return NULL; |
17350 | } |
17351 | D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_star_atom")); |
17352 | expr_ty target_with_star_atom_var; |
17353 | if ( |
17354 | (target_with_star_atom_var = target_with_star_atom_rule(p)) // target_with_star_atom Branch (17354:13): [True: 414k, False: 177k]
|
17355 | ) |
17356 | { |
17357 | D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "target_with_star_atom")); |
17358 | _res = target_with_star_atom_var; |
17359 | goto done; |
17360 | } |
17361 | p->mark = _mark; |
17362 | D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', |
17363 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target_with_star_atom")); |
17364 | } |
17365 | _res = NULL; |
17366 | done: |
17367 | _PyPegen_insert_memo(p, _mark, star_target_type, _res); |
17368 | p->level--; |
17369 | return _res; |
17370 | } |
17371 | |
17372 | // target_with_star_atom: |
17373 | // | t_primary '.' NAME !t_lookahead |
17374 | // | t_primary '[' slices ']' !t_lookahead |
17375 | // | star_atom |
17376 | static expr_ty |
17377 | target_with_star_atom_rule(Parser *p) |
17378 | { |
17379 | if (p->level++ == MAXSTACK) { Branch (17379:9): [True: 0, False: 594k]
|
17380 | p->error_indicator = 1; |
17381 | PyErr_NoMemory(); |
17382 | } |
17383 | if (p->error_indicator) { Branch (17383:9): [True: 0, False: 594k]
|
17384 | p->level--; |
17385 | return NULL; |
17386 | } |
17387 | expr_ty _res = NULL; |
17388 | if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) { Branch (17388:9): [True: 2.36k, False: 592k]
|
17389 | p->level--; |
17390 | return _res; |
17391 | } |
17392 | int _mark = p->mark; |
17393 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (17393:9): [True: 0, False: 592k]
Branch (17393:31): [True: 0, False: 0]
|
17394 | p->error_indicator = 1; |
17395 | p->level--; |
17396 | return NULL; |
17397 | } |
17398 | int _start_lineno = p->tokens[_mark]->lineno; |
17399 | UNUSED(_start_lineno); // Only used by EXTRA macro |
17400 | int _start_col_offset = p->tokens[_mark]->col_offset; |
17401 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
17402 | { // t_primary '.' NAME !t_lookahead |
17403 | if (p->error_indicator) { Branch (17403:13): [True: 0, False: 592k]
|
17404 | p->level--; |
17405 | return NULL; |
17406 | } |
17407 | D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
17408 | Token * _literal; |
17409 | expr_ty a; |
17410 | expr_ty b; |
17411 | if ( |
17412 | (a = t_primary_rule(p)) // t_primary Branch (17412:13): [True: 80.3k, False: 511k]
|
17413 | && |
17414 | (_literal = _PyPegen_expect_token(p, 23))80.3k // token='.' Branch (17414:13): [True: 14.1k, False: 66.1k]
|
17415 | && |
17416 | (b = _PyPegen_name_token(p))14.1k // NAME Branch (17416:13): [True: 14.1k, False: 8]
|
17417 | && |
17418 | _PyPegen_lookahead(0, t_lookahead_rule, p)14.1k Branch (17418:13): [True: 14.1k, False: 0]
|
17419 | ) |
17420 | { |
17421 | D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
17422 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17423 | if (_token == NULL) { Branch (17423:17): [True: 0, False: 14.1k]
|
17424 | p->level--; |
17425 | return NULL; |
17426 | } |
17427 | int _end_lineno = _token->end_lineno; |
17428 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17429 | int _end_col_offset = _token->end_col_offset; |
17430 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17431 | _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA ); |
17432 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17432:17): [True: 0, False: 14.1k]
Branch (17432:33): [True: 0, False: 0]
|
17433 | p->error_indicator = 1; |
17434 | p->level--; |
17435 | return NULL; |
17436 | } |
17437 | goto done; |
17438 | } |
17439 | p->mark = _mark; |
17440 | D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17441 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
17442 | } |
17443 | { // t_primary '[' slices ']' !t_lookahead |
17444 | if (p->error_indicator) { Branch (17444:13): [True: 17, False: 577k]
|
17445 | p->level--; |
17446 | return NULL; |
17447 | } |
17448 | D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
17449 | Token * _literal; |
17450 | Token * _literal_1; |
17451 | expr_ty a; |
17452 | expr_ty b; |
17453 | if ( |
17454 | (a = t_primary_rule(p)) // t_primary Branch (17454:13): [True: 66.1k, False: 511k]
|
17455 | && |
17456 | (_literal = _PyPegen_expect_token(p, 9))66.1k // token='[' Branch (17456:13): [True: 6.44k, False: 59.7k]
|
17457 | && |
17458 | (b = slices_rule(p))6.44k // slices Branch (17458:13): [True: 6.42k, False: 17]
|
17459 | && |
17460 | (_literal_1 = _PyPegen_expect_token(p, 10))6.42k // token=']' Branch (17460:13): [True: 6.41k, False: 15]
|
17461 | && |
17462 | _PyPegen_lookahead(0, t_lookahead_rule, p)6.41k Branch (17462:13): [True: 6.41k, False: 0]
|
17463 | ) |
17464 | { |
17465 | D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
17466 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17467 | if (_token == NULL) { Branch (17467:17): [True: 0, False: 6.41k]
|
17468 | p->level--; |
17469 | return NULL; |
17470 | } |
17471 | int _end_lineno = _token->end_lineno; |
17472 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17473 | int _end_col_offset = _token->end_col_offset; |
17474 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17475 | _res = _PyAST_Subscript ( a , b , Store , EXTRA ); |
17476 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17476:17): [True: 0, False: 6.41k]
Branch (17476:33): [True: 0, False: 0]
|
17477 | p->error_indicator = 1; |
17478 | p->level--; |
17479 | return NULL; |
17480 | } |
17481 | goto done; |
17482 | } |
17483 | p->mark = _mark; |
17484 | D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17485 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
17486 | } |
17487 | { // star_atom |
17488 | if (p->error_indicator) { Branch (17488:13): [True: 0, False: 571k]
|
17489 | p->level--; |
17490 | return NULL; |
17491 | } |
17492 | D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_atom")); |
17493 | expr_ty star_atom_var; |
17494 | if ( |
17495 | (star_atom_var = star_atom_rule(p)) // star_atom Branch (17495:13): [True: 394k, False: 177k]
|
17496 | ) |
17497 | { |
17498 | D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_atom")); |
17499 | _res = star_atom_var; |
17500 | goto done; |
17501 | } |
17502 | p->mark = _mark; |
17503 | D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17504 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_atom")); |
17505 | } |
17506 | _res = NULL; |
17507 | done: |
17508 | _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res); |
17509 | p->level--; |
17510 | return _res; |
17511 | } |
17512 | |
17513 | // star_atom: |
17514 | // | NAME |
17515 | // | '(' target_with_star_atom ')' |
17516 | // | '(' star_targets_tuple_seq? ')' |
17517 | // | '[' star_targets_list_seq? ']' |
17518 | static expr_ty |
17519 | star_atom_rule(Parser *p) |
17520 | { |
17521 | if (p->level++ == MAXSTACK) { Branch (17521:9): [True: 0, False: 571k]
|
17522 | p->error_indicator = 1; |
17523 | PyErr_NoMemory(); |
17524 | } |
17525 | if (p->error_indicator) { Branch (17525:9): [True: 0, False: 571k]
|
17526 | p->level--; |
17527 | return NULL; |
17528 | } |
17529 | expr_ty _res = NULL; |
17530 | int _mark = p->mark; |
17531 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (17531:9): [True: 0, False: 571k]
Branch (17531:31): [True: 0, False: 0]
|
17532 | p->error_indicator = 1; |
17533 | p->level--; |
17534 | return NULL; |
17535 | } |
17536 | int _start_lineno = p->tokens[_mark]->lineno; |
17537 | UNUSED(_start_lineno); // Only used by EXTRA macro |
17538 | int _start_col_offset = p->tokens[_mark]->col_offset; |
17539 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
17540 | { // NAME |
17541 | if (p->error_indicator) { Branch (17541:13): [True: 0, False: 571k]
|
17542 | p->level--; |
17543 | return NULL; |
17544 | } |
17545 | D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
17546 | expr_ty a; |
17547 | if ( |
17548 | (a = _PyPegen_name_token(p)) // NAME Branch (17548:13): [True: 391k, False: 180k]
|
17549 | ) |
17550 | { |
17551 | D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
17552 | _res = _PyPegen_set_expr_context ( p , a , Store ); |
17553 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17553:17): [True: 0, False: 391k]
Branch (17553:33): [True: 0, False: 0]
|
17554 | p->error_indicator = 1; |
17555 | p->level--; |
17556 | return NULL; |
17557 | } |
17558 | goto done; |
17559 | } |
17560 | p->mark = _mark; |
17561 | D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17562 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
17563 | } |
17564 | { // '(' target_with_star_atom ')' |
17565 | if (p->error_indicator) { Branch (17565:13): [True: 0, False: 180k]
|
17566 | p->level--; |
17567 | return NULL; |
17568 | } |
17569 | D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'")); |
17570 | Token * _literal; |
17571 | Token * _literal_1; |
17572 | expr_ty a; |
17573 | if ( |
17574 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (17574:13): [True: 2.39k, False: 177k]
|
17575 | && |
17576 | (a = target_with_star_atom_rule(p))2.39k // target_with_star_atom Branch (17576:13): [True: 1.26k, False: 1.13k]
|
17577 | && |
17578 | (_literal_1 = _PyPegen_expect_token(p, 8))1.26k // token=')' Branch (17578:13): [True: 19, False: 1.25k]
|
17579 | ) |
17580 | { |
17581 | D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'")); |
17582 | _res = _PyPegen_set_expr_context ( p , a , Store ); |
17583 | if (_res == NULL && PyErr_Occurred()0 ) { |
17584 | p->error_indicator = 1; |
17585 | p->level--; |
17586 | return NULL; |
17587 | } |
17588 | goto done; |
17589 | } |
17590 | p->mark = _mark; |
17591 | D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17592 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' target_with_star_atom ')'")); |
17593 | } |
17594 | { // '(' star_targets_tuple_seq? ')' |
17595 | if (p->error_indicator) { Branch (17595:13): [True: 0, False: 180k]
|
17596 | p->level--; |
17597 | return NULL; |
17598 | } |
17599 | D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); |
17600 | Token * _literal; |
17601 | Token * _literal_1; |
17602 | void *a; |
17603 | if ( |
17604 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (17604:13): [True: 2.38k, False: 177k]
|
17605 | && |
17606 | (a = star_targets_tuple_seq_rule(p), !p->error_indicator)2.38k // star_targets_tuple_seq? Branch (17606:13): [True: 2.38k, False: 0]
|
17607 | && |
17608 | (_literal_1 = _PyPegen_expect_token(p, 8))2.38k // token=')' Branch (17608:13): [True: 934, False: 1.44k]
|
17609 | ) |
17610 | { |
17611 | D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); |
17612 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17613 | if (_token == NULL) { Branch (17613:17): [True: 0, False: 934]
|
17614 | p->level--; |
17615 | return NULL; |
17616 | } |
17617 | int _end_lineno = _token->end_lineno; |
17618 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17619 | int _end_col_offset = _token->end_col_offset; |
17620 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17621 | _res = _PyAST_Tuple ( a , Store , EXTRA ); |
17622 | if (_res == NULL && PyErr_Occurred()0 ) { |
17623 | p->error_indicator = 1; |
17624 | p->level--; |
17625 | return NULL; |
17626 | } |
17627 | goto done; |
17628 | } |
17629 | p->mark = _mark; |
17630 | D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17631 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); |
17632 | } |
17633 | { // '[' star_targets_list_seq? ']' |
17634 | if (p->error_indicator) { Branch (17634:13): [True: 0, False: 179k]
|
17635 | p->level--; |
17636 | return NULL; |
17637 | } |
17638 | D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'")); |
17639 | Token * _literal; |
17640 | Token * _literal_1; |
17641 | void *a; |
17642 | if ( |
17643 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (17643:13): [True: 3.49k, False: 175k]
|
17644 | && |
17645 | (a = star_targets_list_seq_rule(p), !p->error_indicator)3.49k // star_targets_list_seq? Branch (17645:13): [True: 3.49k, False: 0]
|
17646 | && |
17647 | (_literal_1 = _PyPegen_expect_token(p, 10))3.49k // token=']' Branch (17647:13): [True: 1.76k, False: 1.73k]
|
17648 | ) |
17649 | { |
17650 | D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'")); |
17651 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17652 | if (_token == NULL) { Branch (17652:17): [True: 0, False: 1.76k]
|
17653 | p->level--; |
17654 | return NULL; |
17655 | } |
17656 | int _end_lineno = _token->end_lineno; |
17657 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17658 | int _end_col_offset = _token->end_col_offset; |
17659 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17660 | _res = _PyAST_List ( a , Store , EXTRA ); |
17661 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17661:17): [True: 0, False: 1.76k]
Branch (17661:33): [True: 0, False: 0]
|
17662 | p->error_indicator = 1; |
17663 | p->level--; |
17664 | return NULL; |
17665 | } |
17666 | goto done; |
17667 | } |
17668 | p->mark = _mark; |
17669 | D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', |
17670 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_targets_list_seq? ']'")); |
17671 | } |
17672 | _res = NULL; |
17673 | done: |
17674 | p->level--; |
17675 | return _res; |
17676 | } |
17677 | |
17678 | // single_target: single_subscript_attribute_target | NAME | '(' single_target ')' |
17679 | static expr_ty |
17680 | single_target_rule(Parser *p) |
17681 | { |
17682 | if (p->level++ == MAXSTACK) { Branch (17682:9): [True: 0, False: 397k]
|
17683 | p->error_indicator = 1; |
17684 | PyErr_NoMemory(); |
17685 | } |
17686 | if (p->error_indicator) { Branch (17686:9): [True: 0, False: 397k]
|
17687 | p->level--; |
17688 | return NULL; |
17689 | } |
17690 | expr_ty _res = NULL; |
17691 | int _mark = p->mark; |
17692 | { // single_subscript_attribute_target |
17693 | if (p->error_indicator) { Branch (17693:13): [True: 0, False: 397k]
|
17694 | p->level--; |
17695 | return NULL; |
17696 | } |
17697 | D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); |
17698 | expr_ty single_subscript_attribute_target_var; |
17699 | if ( |
17700 | (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target Branch (17700:13): [True: 826, False: 396k]
|
17701 | ) |
17702 | { |
17703 | D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); |
17704 | _res = single_subscript_attribute_target_var; |
17705 | goto done; |
17706 | } |
17707 | p->mark = _mark; |
17708 | D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', |
17709 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target")); |
17710 | } |
17711 | { // NAME |
17712 | if (p->error_indicator) { Branch (17712:13): [True: 7, False: 396k]
|
17713 | p->level--; |
17714 | return NULL; |
17715 | } |
17716 | D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
17717 | expr_ty a; |
17718 | if ( |
17719 | (a = _PyPegen_name_token(p)) // NAME Branch (17719:13): [True: 242k, False: 154k]
|
17720 | ) |
17721 | { |
17722 | D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
17723 | _res = _PyPegen_set_expr_context ( p , a , Store ); |
17724 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17724:17): [True: 0, False: 242k]
Branch (17724:33): [True: 0, False: 0]
|
17725 | p->error_indicator = 1; |
17726 | p->level--; |
17727 | return NULL; |
17728 | } |
17729 | goto done; |
17730 | } |
17731 | p->mark = _mark; |
17732 | D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', |
17733 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
17734 | } |
17735 | { // '(' single_target ')' |
17736 | if (p->error_indicator) { Branch (17736:13): [True: 0, False: 154k]
|
17737 | p->level--; |
17738 | return NULL; |
17739 | } |
17740 | D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); |
17741 | Token * _literal; |
17742 | Token * _literal_1; |
17743 | expr_ty a; |
17744 | if ( |
17745 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (17745:13): [True: 189, False: 153k]
|
17746 | && |
17747 | (a = single_target_rule(p))189 // single_target Branch (17747:13): [True: 99, False: 90]
|
17748 | && |
17749 | (_literal_1 = _PyPegen_expect_token(p, 8))99 // token=')' Branch (17749:13): [True: 17, False: 82]
|
17750 | ) |
17751 | { |
17752 | D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); |
17753 | _res = a; |
17754 | if (_res == NULL && PyErr_Occurred()0 ) { |
17755 | p->error_indicator = 1; |
17756 | p->level--; |
17757 | return NULL; |
17758 | } |
17759 | goto done; |
17760 | } |
17761 | p->mark = _mark; |
17762 | D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', |
17763 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); |
17764 | } |
17765 | _res = NULL; |
17766 | done: |
17767 | p->level--; |
17768 | return _res; |
17769 | } |
17770 | |
17771 | // single_subscript_attribute_target: |
17772 | // | t_primary '.' NAME !t_lookahead |
17773 | // | t_primary '[' slices ']' !t_lookahead |
17774 | static expr_ty |
17775 | single_subscript_attribute_target_rule(Parser *p) |
17776 | { |
17777 | if (p->level++ == MAXSTACK) { Branch (17777:9): [True: 0, False: 879k]
|
17778 | p->error_indicator = 1; |
17779 | PyErr_NoMemory(); |
17780 | } |
17781 | if (p->error_indicator) { Branch (17781:9): [True: 0, False: 879k]
|
17782 | p->level--; |
17783 | return NULL; |
17784 | } |
17785 | expr_ty _res = NULL; |
17786 | int _mark = p->mark; |
17787 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 0280 ) { Branch (17787:9): [True: 280, False: 879k]
Branch (17787:31): [True: 3, False: 277]
|
17788 | p->error_indicator = 1; |
17789 | p->level--; |
17790 | return NULL; |
17791 | } |
17792 | int _start_lineno = p->tokens[_mark]->lineno; |
17793 | UNUSED(_start_lineno); // Only used by EXTRA macro |
17794 | int _start_col_offset = p->tokens[_mark]->col_offset; |
17795 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
17796 | { // t_primary '.' NAME !t_lookahead |
17797 | if (p->error_indicator) { Branch (17797:13): [True: 0, False: 879k]
|
17798 | p->level--; |
17799 | return NULL; |
17800 | } |
17801 | D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
17802 | Token * _literal; |
17803 | expr_ty a; |
17804 | expr_ty b; |
17805 | if ( |
17806 | (a = t_primary_rule(p)) // t_primary Branch (17806:13): [True: 88.3k, False: 790k]
|
17807 | && |
17808 | (_literal = _PyPegen_expect_token(p, 23))88.3k // token='.' Branch (17808:13): [True: 9.69k, False: 78.6k]
|
17809 | && |
17810 | (b = _PyPegen_name_token(p))9.69k // NAME Branch (17810:13): [True: 9.68k, False: 16]
|
17811 | && |
17812 | _PyPegen_lookahead(0, t_lookahead_rule, p)9.68k Branch (17812:13): [True: 9.68k, False: 0]
|
17813 | ) |
17814 | { |
17815 | D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
17816 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17817 | if (_token == NULL) { Branch (17817:17): [True: 0, False: 9.68k]
|
17818 | p->level--; |
17819 | return NULL; |
17820 | } |
17821 | int _end_lineno = _token->end_lineno; |
17822 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17823 | int _end_col_offset = _token->end_col_offset; |
17824 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17825 | _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA ); |
17826 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17826:17): [True: 0, False: 9.68k]
Branch (17826:33): [True: 0, False: 0]
|
17827 | p->error_indicator = 1; |
17828 | p->level--; |
17829 | return NULL; |
17830 | } |
17831 | goto done; |
17832 | } |
17833 | p->mark = _mark; |
17834 | D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ', |
17835 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
17836 | } |
17837 | { // t_primary '[' slices ']' !t_lookahead |
17838 | if (p->error_indicator) { Branch (17838:13): [True: 206, False: 869k]
|
17839 | p->level--; |
17840 | return NULL; |
17841 | } |
17842 | D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
17843 | Token * _literal; |
17844 | Token * _literal_1; |
17845 | expr_ty a; |
17846 | expr_ty b; |
17847 | if ( |
17848 | (a = t_primary_rule(p)) // t_primary Branch (17848:13): [True: 78.7k, False: 790k]
|
17849 | && |
17850 | (_literal = _PyPegen_expect_token(p, 9))78.7k // token='[' Branch (17850:13): [True: 3.83k, False: 74.8k]
|
17851 | && |
17852 | (b = slices_rule(p))3.83k // slices Branch (17852:13): [True: 3.80k, False: 34]
|
17853 | && |
17854 | (_literal_1 = _PyPegen_expect_token(p, 10))3.80k // token=']' Branch (17854:13): [True: 3.77k, False: 30]
|
17855 | && |
17856 | _PyPegen_lookahead(0, t_lookahead_rule, p)3.77k Branch (17856:13): [True: 3.77k, False: 0]
|
17857 | ) |
17858 | { |
17859 | D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
17860 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17861 | if (_token == NULL) { Branch (17861:17): [True: 0, False: 3.77k]
|
17862 | p->level--; |
17863 | return NULL; |
17864 | } |
17865 | int _end_lineno = _token->end_lineno; |
17866 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17867 | int _end_col_offset = _token->end_col_offset; |
17868 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17869 | _res = _PyAST_Subscript ( a , b , Store , EXTRA ); |
17870 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17870:17): [True: 0, False: 3.77k]
Branch (17870:33): [True: 0, False: 0]
|
17871 | p->error_indicator = 1; |
17872 | p->level--; |
17873 | return NULL; |
17874 | } |
17875 | goto done; |
17876 | } |
17877 | p->mark = _mark; |
17878 | D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ', |
17879 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
17880 | } |
17881 | _res = NULL; |
17882 | done: |
17883 | p->level--; |
17884 | return _res; |
17885 | } |
17886 | |
17887 | // Left-recursive |
17888 | // t_primary: |
17889 | // | t_primary '.' NAME &t_lookahead |
17890 | // | t_primary '[' slices ']' &t_lookahead |
17891 | // | t_primary genexp &t_lookahead |
17892 | // | t_primary '(' arguments? ')' &t_lookahead |
17893 | // | atom &t_lookahead |
17894 | static expr_ty t_primary_raw(Parser *); |
17895 | static expr_ty |
17896 | t_primary_rule(Parser *p) |
17897 | { |
17898 | if (p->level++ == MAXSTACK) { Branch (17898:9): [True: 0, False: 7.81M]
|
17899 | p->error_indicator = 1; |
17900 | PyErr_NoMemory(); |
17901 | } |
17902 | expr_ty _res = NULL; |
17903 | if (_PyPegen_is_memoized(p, t_primary_type, &_res)) { Branch (17903:9): [True: 7.22M, False: 593k]
|
17904 | p->level--; |
17905 | return _res; |
17906 | } |
17907 | int _mark = p->mark; |
17908 | int _resmark = p->mark; |
17909 | while (1) { |
17910 | int tmpvar_9 = _PyPegen_update_memo(p, _mark, t_primary_type, _res); |
17911 | if (tmpvar_9) { Branch (17911:13): [True: 0, False: 1.63M]
|
17912 | p->level--; |
17913 | return _res; |
17914 | } |
17915 | p->mark = _mark; |
17916 | void *_raw = t_primary_raw(p); |
17917 | if (p->error_indicator) { Branch (17917:13): [True: 224, False: 1.63M]
|
17918 | p->level--; |
17919 | return NULL; |
17920 | } |
17921 | if (_raw == NULL || p->mark <= _resmark1.12M ) Branch (17921:13): [True: 512k, False: 1.12M]
Branch (17921:29): [True: 81.2k, False: 1.04M]
|
17922 | break; |
17923 | _resmark = p->mark; |
17924 | _res = _raw; |
17925 | } |
17926 | p->mark = _resmark; |
17927 | p->level--; |
17928 | return _res; |
17929 | } |
17930 | static expr_ty |
17931 | t_primary_raw(Parser *p) |
17932 | { |
17933 | if (p->level++ == MAXSTACK) { Branch (17933:9): [True: 0, False: 1.63M]
|
17934 | p->error_indicator = 1; |
17935 | PyErr_NoMemory(); |
17936 | } |
17937 | if (p->error_indicator) { Branch (17937:9): [True: 0, False: 1.63M]
|
17938 | p->level--; |
17939 | return NULL; |
17940 | } |
17941 | expr_ty _res = NULL; |
17942 | int _mark = p->mark; |
17943 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (17943:9): [True: 0, False: 1.63M]
Branch (17943:31): [True: 0, False: 0]
|
17944 | p->error_indicator = 1; |
17945 | p->level--; |
17946 | return NULL; |
17947 | } |
17948 | int _start_lineno = p->tokens[_mark]->lineno; |
17949 | UNUSED(_start_lineno); // Only used by EXTRA macro |
17950 | int _start_col_offset = p->tokens[_mark]->col_offset; |
17951 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
17952 | { // t_primary '.' NAME &t_lookahead |
17953 | if (p->error_indicator) { Branch (17953:13): [True: 0, False: 1.63M]
|
17954 | p->level--; |
17955 | return NULL; |
17956 | } |
17957 | D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead")); |
17958 | Token * _literal; |
17959 | expr_ty a; |
17960 | expr_ty b; |
17961 | if ( |
17962 | (a = t_primary_rule(p)) // t_primary Branch (17962:13): [True: 1.04M, False: 593k]
|
17963 | && |
17964 | (_literal = _PyPegen_expect_token(p, 23))1.04M // token='.' Branch (17964:13): [True: 365k, False: 680k]
|
17965 | && |
17966 | (b = _PyPegen_name_token(p))365k // NAME Branch (17966:13): [True: 365k, False: 8]
|
17967 | && |
17968 | _PyPegen_lookahead(1, t_lookahead_rule, p)365k Branch (17968:13): [True: 351k, False: 14.5k]
|
17969 | ) |
17970 | { |
17971 | D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead")); |
17972 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
17973 | if (_token == NULL) { Branch (17973:17): [True: 0, False: 351k]
|
17974 | p->level--; |
17975 | return NULL; |
17976 | } |
17977 | int _end_lineno = _token->end_lineno; |
17978 | UNUSED(_end_lineno); // Only used by EXTRA macro |
17979 | int _end_col_offset = _token->end_col_offset; |
17980 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
17981 | _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA ); |
17982 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (17982:17): [True: 0, False: 351k]
Branch (17982:33): [True: 0, False: 0]
|
17983 | p->error_indicator = 1; |
17984 | p->level--; |
17985 | return NULL; |
17986 | } |
17987 | goto done; |
17988 | } |
17989 | p->mark = _mark; |
17990 | D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', |
17991 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME &t_lookahead")); |
17992 | } |
17993 | { // t_primary '[' slices ']' &t_lookahead |
17994 | if (p->error_indicator) { Branch (17994:13): [True: 2, False: 1.28M]
|
17995 | p->level--; |
17996 | return NULL; |
17997 | } |
17998 | D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); |
17999 | Token * _literal; |
18000 | Token * _literal_1; |
18001 | expr_ty a; |
18002 | expr_ty b; |
18003 | if ( |
18004 | (a = t_primary_rule(p)) // t_primary Branch (18004:13): [True: 694k, False: 593k]
|
18005 | && |
18006 | (_literal = _PyPegen_expect_token(p, 9))694k // token='[' Branch (18006:13): [True: 312k, False: 381k]
|
18007 | && |
18008 | (b = slices_rule(p))312k // slices Branch (18008:13): [True: 312k, False: 37]
|
18009 | && |
18010 | (_literal_1 = _PyPegen_expect_token(p, 10))312k // token=']' Branch (18010:13): [True: 312k, False: 21]
|
18011 | && |
18012 | _PyPegen_lookahead(1, t_lookahead_rule, p)312k Branch (18012:13): [True: 305k, False: 6.90k]
|
18013 | ) |
18014 | { |
18015 | D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); |
18016 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18017 | if (_token == NULL) { Branch (18017:17): [True: 0, False: 305k]
|
18018 | p->level--; |
18019 | return NULL; |
18020 | } |
18021 | int _end_lineno = _token->end_lineno; |
18022 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18023 | int _end_col_offset = _token->end_col_offset; |
18024 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18025 | _res = _PyAST_Subscript ( a , b , Load , EXTRA ); |
18026 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (18026:17): [True: 0, False: 305k]
Branch (18026:33): [True: 0, False: 0]
|
18027 | p->error_indicator = 1; |
18028 | p->level--; |
18029 | return NULL; |
18030 | } |
18031 | goto done; |
18032 | } |
18033 | p->mark = _mark; |
18034 | D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', |
18035 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); |
18036 | } |
18037 | { // t_primary genexp &t_lookahead |
18038 | if (p->error_indicator) { Branch (18038:13): [True: 16, False: 982k]
|
18039 | p->level--; |
18040 | return NULL; |
18041 | } |
18042 | D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead")); |
18043 | expr_ty a; |
18044 | expr_ty b; |
18045 | if ( |
18046 | (a = t_primary_rule(p)) // t_primary Branch (18046:13): [True: 388k, False: 593k]
|
18047 | && |
18048 | (b = genexp_rule(p))388k // genexp Branch (18048:13): [True: 224, False: 388k]
|
18049 | && |
18050 | _PyPegen_lookahead(1, t_lookahead_rule, p)224 Branch (18050:13): [True: 0, False: 224]
|
18051 | ) |
18052 | { |
18053 | D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead")); |
18054 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18055 | if (_token == NULL) { |
18056 | p->level--; |
18057 | return NULL; |
18058 | } |
18059 | int _end_lineno = _token->end_lineno; |
18060 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18061 | int _end_col_offset = _token->end_col_offset; |
18062 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18063 | _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA ); |
18064 | if (_res == NULL && PyErr_Occurred()) { |
18065 | p->error_indicator = 1; |
18066 | p->level--; |
18067 | return NULL; |
18068 | } |
18069 | goto done; |
18070 | } |
18071 | p->mark = _mark; |
18072 | D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', |
18073 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary genexp &t_lookahead")); |
18074 | } |
18075 | { // t_primary '(' arguments? ')' &t_lookahead |
18076 | if (p->error_indicator) { Branch (18076:13): [True: 23, False: 982k]
|
18077 | p->level--; |
18078 | return NULL; |
18079 | } |
18080 | D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); |
18081 | Token * _literal; |
18082 | Token * _literal_1; |
18083 | expr_ty a; |
18084 | void *b; |
18085 | if ( |
18086 | (a = t_primary_rule(p)) // t_primary Branch (18086:13): [True: 388k, False: 593k]
|
18087 | && |
18088 | (_literal = _PyPegen_expect_token(p, 7))388k // token='(' Branch (18088:13): [True: 367k, False: 21.5k]
|
18089 | && |
18090 | (b = arguments_rule(p), !p->error_indicator)367k // arguments? Branch (18090:13): [True: 367k, False: 45]
|
18091 | && |
18092 | (_literal_1 = _PyPegen_expect_token(p, 8))367k // token=')' Branch (18092:13): [True: 367k, False: 298]
|
18093 | && |
18094 | _PyPegen_lookahead(1, t_lookahead_rule, p)367k Branch (18094:13): [True: 307k, False: 59.4k]
|
18095 | ) |
18096 | { |
18097 | D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); |
18098 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18099 | if (_token == NULL) { Branch (18099:17): [True: 0, False: 307k]
|
18100 | p->level--; |
18101 | return NULL; |
18102 | } |
18103 | int _end_lineno = _token->end_lineno; |
18104 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18105 | int _end_col_offset = _token->end_col_offset; |
18106 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18107 | _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args1.50k : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords1.50k : NULL , EXTRA ); Branch (18107:38): [True: 1.50k, False: 306k]
Branch (18107:92): [True: 1.50k, False: 306k]
|
18108 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (18108:17): [True: 0, False: 307k]
Branch (18108:33): [True: 0, False: 0]
|
18109 | p->error_indicator = 1; |
18110 | p->level--; |
18111 | return NULL; |
18112 | } |
18113 | goto done; |
18114 | } |
18115 | p->mark = _mark; |
18116 | D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', |
18117 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); |
18118 | } |
18119 | { // atom &t_lookahead |
18120 | if (p->error_indicator) { Branch (18120:13): [True: 45, False: 675k]
|
18121 | p->level--; |
18122 | return NULL; |
18123 | } |
18124 | D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead")); |
18125 | expr_ty a; |
18126 | if ( |
18127 | (a = atom_rule(p)) // atom Branch (18127:13): [True: 530k, False: 144k]
|
18128 | && |
18129 | _PyPegen_lookahead(1, t_lookahead_rule, p)530k Branch (18129:13): [True: 162k, False: 367k]
|
18130 | ) |
18131 | { |
18132 | D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead")); |
18133 | _res = a; |
18134 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (18134:17): [True: 0, False: 162k]
Branch (18134:33): [True: 0, False: 0]
|
18135 | p->error_indicator = 1; |
18136 | p->level--; |
18137 | return NULL; |
18138 | } |
18139 | goto done; |
18140 | } |
18141 | p->mark = _mark; |
18142 | D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', |
18143 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom &t_lookahead")); |
18144 | } |
18145 | _res = NULL; |
18146 | done: |
18147 | p->level--; |
18148 | return _res; |
18149 | } |
18150 | |
18151 | // t_lookahead: '(' | '[' | '.' |
18152 | static void * |
18153 | t_lookahead_rule(Parser *p) |
18154 | { |
18155 | if (p->level++ == MAXSTACK) { Branch (18155:9): [True: 0, False: 1.61M]
|
18156 | p->error_indicator = 1; |
18157 | PyErr_NoMemory(); |
18158 | } |
18159 | if (p->error_indicator) { Branch (18159:9): [True: 0, False: 1.61M]
|
18160 | p->level--; |
18161 | return NULL; |
18162 | } |
18163 | void * _res = NULL; |
18164 | int _mark = p->mark; |
18165 | { // '(' |
18166 | if (p->error_indicator) { Branch (18166:13): [True: 0, False: 1.61M]
|
18167 | p->level--; |
18168 | return NULL; |
18169 | } |
18170 | D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); |
18171 | Token * _literal; |
18172 | if ( |
18173 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (18173:13): [True: 389k, False: 1.22M]
|
18174 | ) |
18175 | { |
18176 | D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); |
18177 | _res = _literal; |
18178 | goto done; |
18179 | } |
18180 | p->mark = _mark; |
18181 | D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', |
18182 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); |
18183 | } |
18184 | { // '[' |
18185 | if (p->error_indicator) { Branch (18185:13): [True: 6, False: 1.22M]
|
18186 | p->level--; |
18187 | return NULL; |
18188 | } |
18189 | D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); |
18190 | Token * _literal; |
18191 | if ( |
18192 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (18192:13): [True: 318k, False: 902k]
|
18193 | ) |
18194 | { |
18195 | D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); |
18196 | _res = _literal; |
18197 | goto done; |
18198 | } |
18199 | p->mark = _mark; |
18200 | D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', |
18201 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); |
18202 | } |
18203 | { // '.' |
18204 | if (p->error_indicator) { Branch (18204:13): [True: 0, False: 902k]
|
18205 | p->level--; |
18206 | return NULL; |
18207 | } |
18208 | D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); |
18209 | Token * _literal; |
18210 | if ( |
18211 | (_literal = _PyPegen_expect_token(p, 23)) // token='.' Branch (18211:13): [True: 419k, False: 483k]
|
18212 | ) |
18213 | { |
18214 | D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); |
18215 | _res = _literal; |
18216 | goto done; |
18217 | } |
18218 | p->mark = _mark; |
18219 | D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', |
18220 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); |
18221 | } |
18222 | _res = NULL; |
18223 | done: |
18224 | p->level--; |
18225 | return _res; |
18226 | } |
18227 | |
18228 | // del_targets: ','.del_target+ ','? |
18229 | static asdl_expr_seq* |
18230 | del_targets_rule(Parser *p) |
18231 | { |
18232 | if (p->level++ == MAXSTACK) { Branch (18232:9): [True: 0, False: 894]
|
18233 | p->error_indicator = 1; |
18234 | PyErr_NoMemory(); |
18235 | } |
18236 | if (p->error_indicator) { Branch (18236:9): [True: 0, False: 894]
|
18237 | p->level--; |
18238 | return NULL; |
18239 | } |
18240 | asdl_expr_seq* _res = NULL; |
18241 | int _mark = p->mark; |
18242 | { // ','.del_target+ ','? |
18243 | if (p->error_indicator) { Branch (18243:13): [True: 0, False: 894]
|
18244 | p->level--; |
18245 | return NULL; |
18246 | } |
18247 | D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?")); |
18248 | void *_opt_var; |
18249 | UNUSED(_opt_var); // Silence compiler warnings |
18250 | asdl_expr_seq* a; |
18251 | if ( |
18252 | (a = (asdl_expr_seq*)_gather_133_rule(p)) // ','.del_target+ Branch (18252:13): [True: 829, False: 65]
|
18253 | && |
18254 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)829 // ','? Branch (18254:13): [True: 829, False: 0]
|
18255 | ) |
18256 | { |
18257 | D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?")); |
18258 | _res = a; |
18259 | if (_res == NULL && PyErr_Occurred()0 ) { |
18260 | p->error_indicator = 1; |
18261 | p->level--; |
18262 | return NULL; |
18263 | } |
18264 | goto done; |
18265 | } |
18266 | p->mark = _mark; |
18267 | D(fprintf(stderr, "%*c%s del_targets[%d-%d]: %s failed!\n", p->level, ' ', |
18268 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.del_target+ ','?")); |
18269 | } |
18270 | _res = NULL; |
18271 | done: |
18272 | p->level--; |
18273 | return _res; |
18274 | } |
18275 | |
18276 | // del_target: |
18277 | // | t_primary '.' NAME !t_lookahead |
18278 | // | t_primary '[' slices ']' !t_lookahead |
18279 | // | del_t_atom |
18280 | static expr_ty |
18281 | del_target_rule(Parser *p) |
18282 | { |
18283 | if (p->level++ == MAXSTACK) { Branch (18283:9): [True: 0, False: 1.17k]
|
18284 | p->error_indicator = 1; |
18285 | PyErr_NoMemory(); |
18286 | } |
18287 | if (p->error_indicator) { Branch (18287:9): [True: 0, False: 1.17k]
|
18288 | p->level--; |
18289 | return NULL; |
18290 | } |
18291 | expr_ty _res = NULL; |
18292 | if (_PyPegen_is_memoized(p, del_target_type, &_res)) { Branch (18292:9): [True: 50, False: 1.12k]
|
18293 | p->level--; |
18294 | return _res; |
18295 | } |
18296 | int _mark = p->mark; |
18297 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (18297:9): [True: 0, False: 1.12k]
Branch (18297:31): [True: 0, False: 0]
|
18298 | p->error_indicator = 1; |
18299 | p->level--; |
18300 | return NULL; |
18301 | } |
18302 | int _start_lineno = p->tokens[_mark]->lineno; |
18303 | UNUSED(_start_lineno); // Only used by EXTRA macro |
18304 | int _start_col_offset = p->tokens[_mark]->col_offset; |
18305 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
18306 | { // t_primary '.' NAME !t_lookahead |
18307 | if (p->error_indicator) { Branch (18307:13): [True: 0, False: 1.12k]
|
18308 | p->level--; |
18309 | return NULL; |
18310 | } |
18311 | D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
18312 | Token * _literal; |
18313 | expr_ty a; |
18314 | expr_ty b; |
18315 | if ( |
18316 | (a = t_primary_rule(p)) // t_primary Branch (18316:13): [True: 576, False: 545]
|
18317 | && |
18318 | (_literal = _PyPegen_expect_token(p, 23))576 // token='.' Branch (18318:13): [True: 67, False: 509]
|
18319 | && |
18320 | (b = _PyPegen_name_token(p))67 // NAME |
18321 | && |
18322 | _PyPegen_lookahead(0, t_lookahead_rule, p)67 |
18323 | ) |
18324 | { |
18325 | D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
18326 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18327 | if (_token == NULL) { |
18328 | p->level--; |
18329 | return NULL; |
18330 | } |
18331 | int _end_lineno = _token->end_lineno; |
18332 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18333 | int _end_col_offset = _token->end_col_offset; |
18334 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18335 | _res = _PyAST_Attribute ( a , b -> v . Name . id , Del , EXTRA ); |
18336 | if (_res == NULL && PyErr_Occurred()0 ) { |
18337 | p->error_indicator = 1; |
18338 | p->level--; |
18339 | return NULL; |
18340 | } |
18341 | goto done; |
18342 | } |
18343 | p->mark = _mark; |
18344 | D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', |
18345 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); |
18346 | } |
18347 | { // t_primary '[' slices ']' !t_lookahead |
18348 | if (p->error_indicator) { Branch (18348:13): [True: 1, False: 1.05k]
|
18349 | p->level--; |
18350 | return NULL; |
18351 | } |
18352 | D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
18353 | Token * _literal; |
18354 | Token * _literal_1; |
18355 | expr_ty a; |
18356 | expr_ty b; |
18357 | if ( |
18358 | (a = t_primary_rule(p)) // t_primary Branch (18358:13): [True: 509, False: 544]
|
18359 | && |
18360 | (_literal = _PyPegen_expect_token(p, 9))509 // token='[' Branch (18360:13): [True: 493, False: 16]
|
18361 | && |
18362 | (b = slices_rule(p))493 // slices Branch (18362:13): [True: 489, False: 4]
|
18363 | && |
18364 | (_literal_1 = _PyPegen_expect_token(p, 10))489 // token=']' Branch (18364:13): [True: 483, False: 6]
|
18365 | && |
18366 | _PyPegen_lookahead(0, t_lookahead_rule, p)483 Branch (18366:13): [True: 483, False: 0]
|
18367 | ) |
18368 | { |
18369 | D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
18370 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18371 | if (_token == NULL) { Branch (18371:17): [True: 0, False: 483]
|
18372 | p->level--; |
18373 | return NULL; |
18374 | } |
18375 | int _end_lineno = _token->end_lineno; |
18376 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18377 | int _end_col_offset = _token->end_col_offset; |
18378 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18379 | _res = _PyAST_Subscript ( a , b , Del , EXTRA ); |
18380 | if (_res == NULL && PyErr_Occurred()0 ) { |
18381 | p->error_indicator = 1; |
18382 | p->level--; |
18383 | return NULL; |
18384 | } |
18385 | goto done; |
18386 | } |
18387 | p->mark = _mark; |
18388 | D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', |
18389 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); |
18390 | } |
18391 | { // del_t_atom |
18392 | if (p->error_indicator) { Branch (18392:13): [True: 0, False: 570]
|
18393 | p->level--; |
18394 | return NULL; |
18395 | } |
18396 | D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom")); |
18397 | expr_ty del_t_atom_var; |
18398 | if ( |
18399 | (del_t_atom_var = del_t_atom_rule(p)) // del_t_atom Branch (18399:13): [True: 494, False: 76]
|
18400 | ) |
18401 | { |
18402 | D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t_atom")); |
18403 | _res = del_t_atom_var; |
18404 | goto done; |
18405 | } |
18406 | p->mark = _mark; |
18407 | D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', |
18408 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_t_atom")); |
18409 | } |
18410 | _res = NULL; |
18411 | done: |
18412 | _PyPegen_insert_memo(p, _mark, del_target_type, _res); |
18413 | p->level--; |
18414 | return _res; |
18415 | } |
18416 | |
18417 | // del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']' |
18418 | static expr_ty |
18419 | del_t_atom_rule(Parser *p) |
18420 | { |
18421 | if (p->level++ == MAXSTACK) { Branch (18421:9): [True: 0, False: 570]
|
18422 | p->error_indicator = 1; |
18423 | PyErr_NoMemory(); |
18424 | } |
18425 | if (p->error_indicator) { Branch (18425:9): [True: 0, False: 570]
|
18426 | p->level--; |
18427 | return NULL; |
18428 | } |
18429 | expr_ty _res = NULL; |
18430 | int _mark = p->mark; |
18431 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (18431:9): [True: 0, False: 570]
Branch (18431:31): [True: 0, False: 0]
|
18432 | p->error_indicator = 1; |
18433 | p->level--; |
18434 | return NULL; |
18435 | } |
18436 | int _start_lineno = p->tokens[_mark]->lineno; |
18437 | UNUSED(_start_lineno); // Only used by EXTRA macro |
18438 | int _start_col_offset = p->tokens[_mark]->col_offset; |
18439 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
18440 | { // NAME |
18441 | if (p->error_indicator) { Branch (18441:13): [True: 0, False: 570]
|
18442 | p->level--; |
18443 | return NULL; |
18444 | } |
18445 | D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); |
18446 | expr_ty a; |
18447 | if ( |
18448 | (a = _PyPegen_name_token(p)) // NAME Branch (18448:13): [True: 459, False: 111]
|
18449 | ) |
18450 | { |
18451 | D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); |
18452 | _res = _PyPegen_set_expr_context ( p , a , Del ); |
18453 | if (_res == NULL && PyErr_Occurred()0 ) { |
18454 | p->error_indicator = 1; |
18455 | p->level--; |
18456 | return NULL; |
18457 | } |
18458 | goto done; |
18459 | } |
18460 | p->mark = _mark; |
18461 | D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', |
18462 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); |
18463 | } |
18464 | { // '(' del_target ')' |
18465 | if (p->error_indicator) { Branch (18465:13): [True: 0, False: 111]
|
18466 | p->level--; |
18467 | return NULL; |
18468 | } |
18469 | D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'")); |
18470 | Token * _literal; |
18471 | Token * _literal_1; |
18472 | expr_ty a; |
18473 | if ( |
18474 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (18474:13): [True: 54, False: 57]
|
18475 | && |
18476 | (a = del_target_rule(p))54 // del_target Branch (18476:13): [True: 40, False: 14]
|
18477 | && |
18478 | (_literal_1 = _PyPegen_expect_token(p, 8))40 // token=')' |
18479 | ) |
18480 | { |
18481 | D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'")); |
18482 | _res = _PyPegen_set_expr_context ( p , a , Del ); |
18483 | if (_res == NULL && PyErr_Occurred()0 ) { |
18484 | p->error_indicator = 1; |
18485 | p->level--; |
18486 | return NULL; |
18487 | } |
18488 | goto done; |
18489 | } |
18490 | p->mark = _mark; |
18491 | D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', |
18492 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_target ')'")); |
18493 | } |
18494 | { // '(' del_targets? ')' |
18495 | if (p->error_indicator) { Branch (18495:13): [True: 0, False: 107]
|
18496 | p->level--; |
18497 | return NULL; |
18498 | } |
18499 | D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'")); |
18500 | Token * _literal; |
18501 | Token * _literal_1; |
18502 | void *a; |
18503 | if ( |
18504 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (18504:13): [True: 50, False: 57]
|
18505 | && |
18506 | (a = del_targets_rule(p), !p->error_indicator)50 // del_targets? |
18507 | && |
18508 | (_literal_1 = _PyPegen_expect_token(p, 8))50 // token=')' Branch (18508:13): [True: 24, False: 26]
|
18509 | ) |
18510 | { |
18511 | D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'")); |
18512 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18513 | if (_token == NULL) { |
18514 | p->level--; |
18515 | return NULL; |
18516 | } |
18517 | int _end_lineno = _token->end_lineno; |
18518 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18519 | int _end_col_offset = _token->end_col_offset; |
18520 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18521 | _res = _PyAST_Tuple ( a , Del , EXTRA ); |
18522 | if (_res == NULL && PyErr_Occurred()0 ) { |
18523 | p->error_indicator = 1; |
18524 | p->level--; |
18525 | return NULL; |
18526 | } |
18527 | goto done; |
18528 | } |
18529 | p->mark = _mark; |
18530 | D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', |
18531 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_targets? ')'")); |
18532 | } |
18533 | { // '[' del_targets? ']' |
18534 | if (p->error_indicator) { |
18535 | p->level--; |
18536 | return NULL; |
18537 | } |
18538 | D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'")); |
18539 | Token * _literal; |
18540 | Token * _literal_1; |
18541 | void *a; |
18542 | if ( |
18543 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (18543:13): [True: 16, False: 67]
|
18544 | && |
18545 | (a = del_targets_rule(p), !p->error_indicator)16 // del_targets? |
18546 | && |
18547 | (_literal_1 = _PyPegen_expect_token(p, 10))16 // token=']' |
18548 | ) |
18549 | { |
18550 | D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'")); |
18551 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
18552 | if (_token == NULL) { |
18553 | p->level--; |
18554 | return NULL; |
18555 | } |
18556 | int _end_lineno = _token->end_lineno; |
18557 | UNUSED(_end_lineno); // Only used by EXTRA macro |
18558 | int _end_col_offset = _token->end_col_offset; |
18559 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
18560 | _res = _PyAST_List ( a , Del , EXTRA ); |
18561 | if (_res == NULL && PyErr_Occurred()0 ) { |
18562 | p->error_indicator = 1; |
18563 | p->level--; |
18564 | return NULL; |
18565 | } |
18566 | goto done; |
18567 | } |
18568 | p->mark = _mark; |
18569 | D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', |
18570 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' del_targets? ']'")); |
18571 | } |
18572 | _res = NULL; |
18573 | done: |
18574 | p->level--; |
18575 | return _res; |
18576 | } |
18577 | |
18578 | // type_expressions: |
18579 | // | ','.expression+ ',' '*' expression ',' '**' expression |
18580 | // | ','.expression+ ',' '*' expression |
18581 | // | ','.expression+ ',' '**' expression |
18582 | // | '*' expression ',' '**' expression |
18583 | // | '*' expression |
18584 | // | '**' expression |
18585 | // | ','.expression+ |
18586 | static asdl_expr_seq* |
18587 | type_expressions_rule(Parser *p) |
18588 | { |
18589 | if (p->level++ == MAXSTACK) { Branch (18589:9): [True: 0, False: 18]
|
18590 | p->error_indicator = 1; |
18591 | PyErr_NoMemory(); |
18592 | } |
18593 | if (p->error_indicator) { Branch (18593:9): [True: 0, False: 18]
|
18594 | p->level--; |
18595 | return NULL; |
18596 | } |
18597 | asdl_expr_seq* _res = NULL; |
18598 | int _mark = p->mark; |
18599 | { // ','.expression+ ',' '*' expression ',' '**' expression |
18600 | if (p->error_indicator) { |
18601 | p->level--; |
18602 | return NULL; |
18603 | } |
18604 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); |
18605 | Token * _literal; |
18606 | Token * _literal_1; |
18607 | Token * _literal_2; |
18608 | Token * _literal_3; |
18609 | asdl_seq * a; |
18610 | expr_ty b; |
18611 | expr_ty c; |
18612 | if ( |
18613 | (a = _gather_135_rule(p)) // ','.expression+ |
18614 | && |
18615 | (_literal = _PyPegen_expect_token(p, 12))10 // token=',' |
18616 | && |
18617 | (_literal_1 = _PyPegen_expect_token(p, 16))5 // token='*' |
18618 | && |
18619 | (b = expression_rule(p))3 // expression |
18620 | && |
18621 | (_literal_2 = _PyPegen_expect_token(p, 12))3 // token=',' |
18622 | && |
18623 | (_literal_3 = _PyPegen_expect_token(p, 35))3 // token='**' |
18624 | && |
18625 | (c = expression_rule(p))1 // expression |
18626 | ) |
18627 | { |
18628 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); |
18629 | _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_seq_append_to_end ( p , a , b ) ) , c ); |
18630 | if (_res == NULL && PyErr_Occurred()0 ) { |
18631 | p->error_indicator = 1; |
18632 | p->level--; |
18633 | return NULL; |
18634 | } |
18635 | goto done; |
18636 | } |
18637 | p->mark = _mark; |
18638 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18639 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); |
18640 | } |
18641 | { // ','.expression+ ',' '*' expression |
18642 | if (p->error_indicator) { |
18643 | p->level--; |
18644 | return NULL; |
18645 | } |
18646 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression")); |
18647 | Token * _literal; |
18648 | Token * _literal_1; |
18649 | asdl_seq * a; |
18650 | expr_ty b; |
18651 | if ( |
18652 | (a = _gather_137_rule(p)) // ','.expression+ |
18653 | && |
18654 | (_literal = _PyPegen_expect_token(p, 12))9 // token=',' |
18655 | && |
18656 | (_literal_1 = _PyPegen_expect_token(p, 16))4 // token='*' |
18657 | && |
18658 | (b = expression_rule(p))2 // expression |
18659 | ) |
18660 | { |
18661 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression")); |
18662 | _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b ); |
18663 | if (_res == NULL && PyErr_Occurred()0 ) { |
18664 | p->error_indicator = 1; |
18665 | p->level--; |
18666 | return NULL; |
18667 | } |
18668 | goto done; |
18669 | } |
18670 | p->mark = _mark; |
18671 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18672 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression")); |
18673 | } |
18674 | { // ','.expression+ ',' '**' expression |
18675 | if (p->error_indicator) { |
18676 | p->level--; |
18677 | return NULL; |
18678 | } |
18679 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression")); |
18680 | Token * _literal; |
18681 | Token * _literal_1; |
18682 | asdl_seq * a; |
18683 | expr_ty b; |
18684 | if ( |
18685 | (a = _gather_139_rule(p)) // ','.expression+ |
18686 | && |
18687 | (_literal = _PyPegen_expect_token(p, 12))7 // token=',' |
18688 | && |
18689 | (_literal_1 = _PyPegen_expect_token(p, 35))2 // token='**' |
18690 | && |
18691 | (b = expression_rule(p))2 // expression |
18692 | ) |
18693 | { |
18694 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression")); |
18695 | _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b ); |
18696 | if (_res == NULL && PyErr_Occurred()0 ) { |
18697 | p->error_indicator = 1; |
18698 | p->level--; |
18699 | return NULL; |
18700 | } |
18701 | goto done; |
18702 | } |
18703 | p->mark = _mark; |
18704 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18705 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression")); |
18706 | } |
18707 | { // '*' expression ',' '**' expression |
18708 | if (p->error_indicator) { |
18709 | p->level--; |
18710 | return NULL; |
18711 | } |
18712 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression")); |
18713 | Token * _literal; |
18714 | Token * _literal_1; |
18715 | Token * _literal_2; |
18716 | expr_ty a; |
18717 | expr_ty b; |
18718 | if ( |
18719 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' |
18720 | && |
18721 | (a = expression_rule(p))2 // expression |
18722 | && |
18723 | (_literal_1 = _PyPegen_expect_token(p, 12))2 // token=',' |
18724 | && |
18725 | (_literal_2 = _PyPegen_expect_token(p, 35))1 // token='**' |
18726 | && |
18727 | (b = expression_rule(p))1 // expression |
18728 | ) |
18729 | { |
18730 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression")); |
18731 | _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_singleton_seq ( p , a ) ) , b ); |
18732 | if (_res == NULL && PyErr_Occurred()0 ) { |
18733 | p->error_indicator = 1; |
18734 | p->level--; |
18735 | return NULL; |
18736 | } |
18737 | goto done; |
18738 | } |
18739 | p->mark = _mark; |
18740 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18741 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression ',' '**' expression")); |
18742 | } |
18743 | { // '*' expression |
18744 | if (p->error_indicator) { |
18745 | p->level--; |
18746 | return NULL; |
18747 | } |
18748 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression")); |
18749 | Token * _literal; |
18750 | expr_ty a; |
18751 | if ( |
18752 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' |
18753 | && |
18754 | (a = expression_rule(p))1 // expression |
18755 | ) |
18756 | { |
18757 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression")); |
18758 | _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a ); |
18759 | if (_res == NULL && PyErr_Occurred()0 ) { |
18760 | p->error_indicator = 1; |
18761 | p->level--; |
18762 | return NULL; |
18763 | } |
18764 | goto done; |
18765 | } |
18766 | p->mark = _mark; |
18767 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18768 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); |
18769 | } |
18770 | { // '**' expression |
18771 | if (p->error_indicator) { |
18772 | p->level--; |
18773 | return NULL; |
18774 | } |
18775 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression")); |
18776 | Token * _literal; |
18777 | expr_ty a; |
18778 | if ( |
18779 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
18780 | && |
18781 | (a = expression_rule(p))3 // expression |
18782 | ) |
18783 | { |
18784 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression")); |
18785 | _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a ); |
18786 | if (_res == NULL && PyErr_Occurred()0 ) { |
18787 | p->error_indicator = 1; |
18788 | p->level--; |
18789 | return NULL; |
18790 | } |
18791 | goto done; |
18792 | } |
18793 | p->mark = _mark; |
18794 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18795 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); |
18796 | } |
18797 | { // ','.expression+ |
18798 | if (p->error_indicator) { |
18799 | p->level--; |
18800 | return NULL; |
18801 | } |
18802 | D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+")); |
18803 | asdl_expr_seq* a; |
18804 | if ( |
18805 | (a = (asdl_expr_seq*)_gather_141_rule(p)) // ','.expression+ |
18806 | ) |
18807 | { |
18808 | D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); |
18809 | _res = a; |
18810 | if (_res == NULL && PyErr_Occurred()0 ) { |
18811 | p->error_indicator = 1; |
18812 | p->level--; |
18813 | return NULL; |
18814 | } |
18815 | goto done; |
18816 | } |
18817 | p->mark = _mark; |
18818 | D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', |
18819 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+")); |
18820 | } |
18821 | _res = NULL; |
18822 | done: |
18823 | p->level--; |
18824 | return _res; |
18825 | } |
18826 | |
18827 | // func_type_comment: |
18828 | // | NEWLINE TYPE_COMMENT &(NEWLINE INDENT) |
18829 | // | invalid_double_type_comments |
18830 | // | TYPE_COMMENT |
18831 | static Token* |
18832 | func_type_comment_rule(Parser *p) |
18833 | { |
18834 | if (p->level++ == MAXSTACK) { Branch (18834:9): [True: 0, False: 33.0k]
|
18835 | p->error_indicator = 1; |
18836 | PyErr_NoMemory(); |
18837 | } |
18838 | if (p->error_indicator) { Branch (18838:9): [True: 0, False: 33.0k]
|
18839 | p->level--; |
18840 | return NULL; |
18841 | } |
18842 | Token* _res = NULL; |
18843 | int _mark = p->mark; |
18844 | { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT) |
18845 | if (p->error_indicator) { Branch (18845:13): [True: 0, False: 33.0k]
|
18846 | p->level--; |
18847 | return NULL; |
18848 | } |
18849 | D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); |
18850 | Token * newline_var; |
18851 | Token * t; |
18852 | if ( |
18853 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (18853:13): [True: 28.9k, False: 4.13k]
|
18854 | && |
18855 | (t = _PyPegen_expect_token(p, 28.9k TYPE_COMMENT28.9k )) // token='TYPE_COMMENT' Branch (18855:13): [True: 27, False: 28.8k]
|
18856 | && |
18857 | _PyPegen_lookahead(1, _tmp_143_rule, p)27 |
18858 | ) |
18859 | { |
18860 | D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); |
18861 | _res = t; |
18862 | if (_res == NULL && PyErr_Occurred()0 ) { |
18863 | p->error_indicator = 1; |
18864 | p->level--; |
18865 | return NULL; |
18866 | } |
18867 | goto done; |
18868 | } |
18869 | p->mark = _mark; |
18870 | D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', |
18871 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); |
18872 | } |
18873 | if (p->call_invalid_rules) { // invalid_double_type_comments Branch (18873:9): [True: 62, False: 32.9k]
|
18874 | if (p->error_indicator) { |
18875 | p->level--; |
18876 | return NULL; |
18877 | } |
18878 | D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments")); |
18879 | void *invalid_double_type_comments_var; |
18880 | if ( |
18881 | (invalid_double_type_comments_var = invalid_double_type_comments_rule(p)) // invalid_double_type_comments |
18882 | ) |
18883 | { |
18884 | D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments")); |
18885 | _res = invalid_double_type_comments_var; |
18886 | goto done; |
18887 | } |
18888 | p->mark = _mark; |
18889 | D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', |
18890 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_double_type_comments")); |
18891 | } |
18892 | { // TYPE_COMMENT |
18893 | if (p->error_indicator) { Branch (18893:13): [True: 9, False: 33.0k]
|
18894 | p->level--; |
18895 | return NULL; |
18896 | } |
18897 | D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT")); |
18898 | Token * type_comment_var; |
18899 | if ( |
18900 | (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' Branch (18900:13): [True: 34, False: 32.9k]
|
18901 | ) |
18902 | { |
18903 | D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT")); |
18904 | _res = type_comment_var; |
18905 | goto done; |
18906 | } |
18907 | p->mark = _mark; |
18908 | D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', |
18909 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT")); |
18910 | } |
18911 | _res = NULL; |
18912 | done: |
18913 | p->level--; |
18914 | return _res; |
18915 | } |
18916 | |
18917 | // invalid_arguments: |
18918 | // | args ',' '*' |
18919 | // | expression for_if_clauses ',' [args | expression for_if_clauses] |
18920 | // | NAME '=' expression for_if_clauses |
18921 | // | args for_if_clauses |
18922 | // | args ',' expression for_if_clauses |
18923 | // | args ',' args |
18924 | static void * |
18925 | invalid_arguments_rule(Parser *p) |
18926 | { |
18927 | if (p->level++ == MAXSTACK) { Branch (18927:9): [True: 0, False: 93]
|
18928 | p->error_indicator = 1; |
18929 | PyErr_NoMemory(); |
18930 | } |
18931 | if (p->error_indicator) { Branch (18931:9): [True: 0, False: 93]
|
18932 | p->level--; |
18933 | return NULL; |
18934 | } |
18935 | void * _res = NULL; |
18936 | int _mark = p->mark; |
18937 | { // args ',' '*' |
18938 | if (p->error_indicator) { |
18939 | p->level--; |
18940 | return NULL; |
18941 | } |
18942 | D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' '*'")); |
18943 | Token * _literal; |
18944 | Token * _literal_1; |
18945 | expr_ty a; |
18946 | if ( |
18947 | (a = args_rule(p)) // args Branch (18947:13): [True: 43, False: 50]
|
18948 | && |
18949 | (_literal = _PyPegen_expect_token(p, 12))43 // token=',' Branch (18949:13): [True: 13, False: 30]
|
18950 | && |
18951 | (_literal_1 = _PyPegen_expect_token(p, 16))13 // token='*' |
18952 | ) |
18953 | { |
18954 | D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' '*'")); |
18955 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable argument unpacking follows keyword argument unpacking" ); |
18956 | if (_res == NULL && PyErr_Occurred()) { |
18957 | p->error_indicator = 1; |
18958 | p->level--; |
18959 | return NULL; |
18960 | } |
18961 | goto done; |
18962 | } |
18963 | p->mark = _mark; |
18964 | D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', |
18965 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' '*'")); |
18966 | } |
18967 | { // expression for_if_clauses ',' [args | expression for_if_clauses] |
18968 | if (p->error_indicator) { |
18969 | p->level--; |
18970 | return NULL; |
18971 | } |
18972 | D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); |
18973 | Token * _literal; |
18974 | void *_opt_var; |
18975 | UNUSED(_opt_var); // Silence compiler warnings |
18976 | expr_ty a; |
18977 | asdl_comprehension_seq* b; |
18978 | if ( |
18979 | (a = expression_rule(p)) // expression Branch (18979:13): [True: 41, False: 51]
|
18980 | && |
18981 | (b = for_if_clauses_rule(p))41 // for_if_clauses Branch (18981:13): [True: 12, False: 29]
|
18982 | && |
18983 | (_literal = _PyPegen_expect_token(p, 12))12 // token=',' |
18984 | && |
18985 | (_opt_var = _tmp_144_rule(p), !p->error_indicator)11 // [args | expression for_if_clauses] |
18986 | ) |
18987 | { |
18988 | D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); |
18989 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" ); |
18990 | if (_res == NULL && PyErr_Occurred()) { |
18991 | p->error_indicator = 1; |
18992 | p->level--; |
18993 | return NULL; |
18994 | } |
18995 | goto done; |
18996 | } |
18997 | p->mark = _mark; |
18998 | D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', |
18999 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); |
19000 | } |
19001 | { // NAME '=' expression for_if_clauses |
19002 | if (p->error_indicator) { |
19003 | p->level--; |
19004 | return NULL; |
19005 | } |
19006 | D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses")); |
19007 | expr_ty a; |
19008 | Token * b; |
19009 | expr_ty expression_var; |
19010 | asdl_comprehension_seq* for_if_clauses_var; |
19011 | if ( |
19012 | (a = _PyPegen_name_token(p)) // NAME Branch (19012:13): [True: 28, False: 53]
|
19013 | && |
19014 | (b = _PyPegen_expect_token(p, 22))28 // token='=' Branch (19014:13): [True: 13, False: 15]
|
19015 | && |
19016 | (expression_var = expression_rule(p))13 // expression |
19017 | && |
19018 | (for_if_clauses_var = for_if_clauses_rule(p))12 // for_if_clauses |
19019 | ) |
19020 | { |
19021 | D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses")); |
19022 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" ); |
19023 | if (_res == NULL && PyErr_Occurred()) { |
19024 | p->error_indicator = 1; |
19025 | p->level--; |
19026 | return NULL; |
19027 | } |
19028 | goto done; |
19029 | } |
19030 | p->mark = _mark; |
19031 | D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', |
19032 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses")); |
19033 | } |
19034 | { // args for_if_clauses |
19035 | if (p->error_indicator) { |
19036 | p->level--; |
19037 | return NULL; |
19038 | } |
19039 | D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_if_clauses")); |
19040 | expr_ty a; |
19041 | asdl_comprehension_seq* b; |
19042 | if ( |
19043 | (a = args_rule(p)) // args Branch (19043:13): [True: 31, False: 50]
|
19044 | && |
19045 | (b = for_if_clauses_rule(p))31 // for_if_clauses Branch (19045:13): [True: 10, False: 21]
|
19046 | ) |
19047 | { |
19048 | D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args for_if_clauses")); |
19049 | _res = _PyPegen_nonparen_genexp_in_call ( p , a , b ); |
19050 | if (_res == NULL && PyErr_Occurred()) { |
19051 | p->error_indicator = 1; |
19052 | p->level--; |
19053 | return NULL; |
19054 | } |
19055 | goto done; |
19056 | } |
19057 | p->mark = _mark; |
19058 | D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', |
19059 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args for_if_clauses")); |
19060 | } |
19061 | { // args ',' expression for_if_clauses |
19062 | if (p->error_indicator) { |
19063 | p->level--; |
19064 | return NULL; |
19065 | } |
19066 | D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses")); |
19067 | Token * _literal; |
19068 | expr_ty a; |
19069 | expr_ty args_var; |
19070 | asdl_comprehension_seq* b; |
19071 | if ( |
19072 | (args_var = args_rule(p)) // args Branch (19072:13): [True: 21, False: 50]
|
19073 | && |
19074 | (_literal = _PyPegen_expect_token(p, 12))21 // token=',' |
19075 | && |
19076 | (a = expression_rule(p))12 // expression |
19077 | && |
19078 | (b = for_if_clauses_rule(p))11 // for_if_clauses |
19079 | ) |
19080 | { |
19081 | D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses")); |
19082 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" ); |
19083 | if (_res == NULL && PyErr_Occurred()) { |
19084 | p->error_indicator = 1; |
19085 | p->level--; |
19086 | return NULL; |
19087 | } |
19088 | goto done; |
19089 | } |
19090 | p->mark = _mark; |
19091 | D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', |
19092 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses")); |
19093 | } |
19094 | { // args ',' args |
19095 | if (p->error_indicator) { |
19096 | p->level--; |
19097 | return NULL; |
19098 | } |
19099 | D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' args")); |
19100 | Token * _literal; |
19101 | expr_ty a; |
19102 | expr_ty args_var; |
19103 | if ( |
19104 | (a = args_rule(p)) // args Branch (19104:13): [True: 21, False: 50]
|
19105 | && |
19106 | (_literal = _PyPegen_expect_token(p, 12))21 // token=',' |
19107 | && |
19108 | (args_var = args_rule(p))12 // args |
19109 | ) |
19110 | { |
19111 | D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' args")); |
19112 | _res = _PyPegen_arguments_parsing_error ( p , a ); |
19113 | if (_res == NULL && PyErr_Occurred()) { |
19114 | p->error_indicator = 1; |
19115 | p->level--; |
19116 | return NULL; |
19117 | } |
19118 | goto done; |
19119 | } |
19120 | p->mark = _mark; |
19121 | D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', |
19122 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' args")); |
19123 | } |
19124 | _res = NULL; |
19125 | done: |
19126 | p->level--; |
19127 | return _res; |
19128 | } |
19129 | |
19130 | // invalid_kwarg: |
19131 | // | ('True' | 'False' | 'None') '=' |
19132 | // | NAME '=' expression for_if_clauses |
19133 | // | !(NAME '=') expression '=' |
19134 | static void * |
19135 | invalid_kwarg_rule(Parser *p) |
19136 | { |
19137 | if (p->level++ == MAXSTACK) { Branch (19137:9): [True: 0, False: 1.13k]
|
19138 | p->error_indicator = 1; |
19139 | PyErr_NoMemory(); |
19140 | } |
19141 | if (p->error_indicator) { Branch (19141:9): [True: 0, False: 1.13k]
|
19142 | p->level--; |
19143 | return NULL; |
19144 | } |
19145 | void * _res = NULL; |
19146 | int _mark = p->mark; |
19147 | { // ('True' | 'False' | 'None') '=' |
19148 | if (p->error_indicator) { Branch (19148:13): [True: 0, False: 1.13k]
|
19149 | p->level--; |
19150 | return NULL; |
19151 | } |
19152 | D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('True' | 'False' | 'None') '='")); |
19153 | Token* a; |
19154 | Token * b; |
19155 | if ( |
19156 | (a = (Token*)_tmp_145_rule(p)) // 'True' | 'False' | 'None' Branch (19156:13): [True: 4, False: 1.12k]
|
19157 | && |
19158 | (b = _PyPegen_expect_token(p, 22))4 // token='=' |
19159 | ) |
19160 | { |
19161 | D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('True' | 'False' | 'None') '='")); |
19162 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to %s" , PyBytes_AS_STRING ( a -> bytes ) ); |
19163 | if (_res == NULL && PyErr_Occurred()) { |
19164 | p->error_indicator = 1; |
19165 | p->level--; |
19166 | return NULL; |
19167 | } |
19168 | goto done; |
19169 | } |
19170 | p->mark = _mark; |
19171 | D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', |
19172 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('True' | 'False' | 'None') '='")); |
19173 | } |
19174 | { // NAME '=' expression for_if_clauses |
19175 | if (p->error_indicator) { Branch (19175:13): [True: 0, False: 1.12k]
|
19176 | p->level--; |
19177 | return NULL; |
19178 | } |
19179 | D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses")); |
19180 | expr_ty a; |
19181 | Token * b; |
19182 | expr_ty expression_var; |
19183 | asdl_comprehension_seq* for_if_clauses_var; |
19184 | if ( |
19185 | (a = _PyPegen_name_token(p)) // NAME Branch (19185:13): [True: 277, False: 849]
|
19186 | && |
19187 | (b = _PyPegen_expect_token(p, 22))277 // token='=' Branch (19187:13): [True: 168, False: 109]
|
19188 | && |
19189 | (expression_var = expression_rule(p))168 // expression Branch (19189:13): [True: 153, False: 15]
|
19190 | && |
19191 | (for_if_clauses_var = for_if_clauses_rule(p))153 // for_if_clauses Branch (19191:13): [True: 1, False: 152]
|
19192 | ) |
19193 | { |
19194 | D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses")); |
19195 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" ); |
19196 | if (_res == NULL && PyErr_Occurred()) { |
19197 | p->error_indicator = 1; |
19198 | p->level--; |
19199 | return NULL; |
19200 | } |
19201 | goto done; |
19202 | } |
19203 | p->mark = _mark; |
19204 | D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', |
19205 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses")); |
19206 | } |
19207 | { // !(NAME '=') expression '=' |
19208 | if (p->error_indicator) { Branch (19208:13): [True: 0, False: 1.12k]
|
19209 | p->level--; |
19210 | return NULL; |
19211 | } |
19212 | D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='")); |
19213 | expr_ty a; |
19214 | Token * b; |
19215 | if ( |
19216 | _PyPegen_lookahead(0, _tmp_146_rule, p) Branch (19216:13): [True: 958, False: 167]
|
19217 | && |
19218 | (a = expression_rule(p))958 // expression Branch (19218:13): [True: 164, False: 794]
|
19219 | && |
19220 | (b = _PyPegen_expect_token(p, 22))164 // token='=' Branch (19220:13): [True: 9, False: 155]
|
19221 | ) |
19222 | { |
19223 | D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='")); |
19224 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expression cannot contain assignment, perhaps you meant \"==\"?" ); |
19225 | if (_res == NULL && PyErr_Occurred()) { |
19226 | p->error_indicator = 1; |
19227 | p->level--; |
19228 | return NULL; |
19229 | } |
19230 | goto done; |
19231 | } |
19232 | p->mark = _mark; |
19233 | D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', |
19234 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='")); |
19235 | } |
19236 | _res = NULL; |
19237 | done: |
19238 | p->level--; |
19239 | return _res; |
19240 | } |
19241 | |
19242 | // expression_without_invalid: |
19243 | // | disjunction 'if' disjunction 'else' expression |
19244 | // | disjunction |
19245 | // | lambdef |
19246 | static expr_ty |
19247 | expression_without_invalid_rule(Parser *p) |
19248 | { |
19249 | int _prev_call_invalid = p->call_invalid_rules; |
19250 | p->call_invalid_rules = 0; |
19251 | if (p->level++ == MAXSTACK) { Branch (19251:9): [True: 0, False: 1.15k]
|
19252 | p->error_indicator = 1; |
19253 | PyErr_NoMemory(); |
19254 | } |
19255 | if (p->error_indicator) { Branch (19255:9): [True: 0, False: 1.15k]
|
19256 | p->call_invalid_rules = _prev_call_invalid; |
19257 | p->level--; |
19258 | return NULL; |
19259 | } |
19260 | expr_ty _res = NULL; |
19261 | int _mark = p->mark; |
19262 | if (p->mark == p->fill && _PyPegen_fill_token(p) < 00 ) { Branch (19262:9): [True: 0, False: 1.15k]
Branch (19262:31): [True: 0, False: 0]
|
19263 | p->error_indicator = 1; |
19264 | p->call_invalid_rules = _prev_call_invalid; |
19265 | p->level--; |
19266 | return NULL; |
19267 | } |
19268 | int _start_lineno = p->tokens[_mark]->lineno; |
19269 | UNUSED(_start_lineno); // Only used by EXTRA macro |
19270 | int _start_col_offset = p->tokens[_mark]->col_offset; |
19271 | UNUSED(_start_col_offset); // Only used by EXTRA macro |
19272 | { // disjunction 'if' disjunction 'else' expression |
19273 | if (p->error_indicator) { Branch (19273:13): [True: 0, False: 1.15k]
|
19274 | p->call_invalid_rules = _prev_call_invalid; |
19275 | p->level--; |
19276 | return NULL; |
19277 | } |
19278 | D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); |
19279 | Token * _keyword; |
19280 | Token * _keyword_1; |
19281 | expr_ty a; |
19282 | expr_ty b; |
19283 | expr_ty c; |
19284 | if ( |
19285 | (a = disjunction_rule(p)) // disjunction Branch (19285:13): [True: 52, False: 1.09k]
|
19286 | && |
19287 | (_keyword = _PyPegen_expect_token(p, 634))52 // token='if' |
19288 | && |
19289 | (b = disjunction_rule(p))0 // disjunction |
19290 | && |
19291 | (_keyword_1 = _PyPegen_expect_token(p, 637))0 // token='else' |
19292 | && |
19293 | (c = expression_rule(p))0 // expression |
19294 | ) |
19295 | { |
19296 | D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); |
19297 | Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); |
19298 | if (_token == NULL) { |
19299 | p->call_invalid_rules = _prev_call_invalid; |
19300 | p->level--; |
19301 | return NULL; |
19302 | } |
19303 | int _end_lineno = _token->end_lineno; |
19304 | UNUSED(_end_lineno); // Only used by EXTRA macro |
19305 | int _end_col_offset = _token->end_col_offset; |
19306 | UNUSED(_end_col_offset); // Only used by EXTRA macro |
19307 | _res = _PyAST_IfExp ( b , a , c , EXTRA ); |
19308 | if (_res == NULL && PyErr_Occurred()) { |
19309 | p->error_indicator = 1; |
19310 | p->call_invalid_rules = _prev_call_invalid; |
19311 | p->level--; |
19312 | return NULL; |
19313 | } |
19314 | goto done; |
19315 | } |
19316 | p->mark = _mark; |
19317 | D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', |
19318 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); |
19319 | } |
19320 | { // disjunction |
19321 | if (p->error_indicator) { Branch (19321:13): [True: 2, False: 1.14k]
|
19322 | p->call_invalid_rules = _prev_call_invalid; |
19323 | p->level--; |
19324 | return NULL; |
19325 | } |
19326 | D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction")); |
19327 | expr_ty disjunction_var; |
19328 | if ( |
19329 | (disjunction_var = disjunction_rule(p)) // disjunction Branch (19329:13): [True: 52, False: 1.09k]
|
19330 | ) |
19331 | { |
19332 | D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction")); |
19333 | _res = disjunction_var; |
19334 | goto done; |
19335 | } |
19336 | p->mark = _mark; |
19337 | D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', |
19338 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); |
19339 | } |
19340 | { // lambdef |
19341 | if (p->error_indicator) { Branch (19341:13): [True: 0, False: 1.09k]
|
19342 | p->call_invalid_rules = _prev_call_invalid; |
19343 | p->level--; |
19344 | return NULL; |
19345 | } |
19346 | D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef")); |
19347 | expr_ty lambdef_var; |
19348 | if ( |
19349 | (lambdef_var = lambdef_rule(p)) // lambdef Branch (19349:13): [True: 0, False: 1.09k]
|
19350 | ) |
19351 | { |
19352 | D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef")); |
19353 | _res = lambdef_var; |
19354 | goto done; |
19355 | } |
19356 | p->mark = _mark; |
19357 | D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', |
19358 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef")); |
19359 | } |
19360 | _res = NULL; |
19361 | done: |
19362 | p->call_invalid_rules = _prev_call_invalid; |
19363 | p->level--; |
19364 | return _res; |
19365 | } |
19366 | |
19367 | // invalid_legacy_expression: NAME !'(' star_expressions |
19368 | static void * |
19369 | invalid_legacy_expression_rule(Parser *p) |
19370 | { |
19371 | if (p->level++ == MAXSTACK) { Branch (19371:9): [True: 0, False: 2.65k]
|
19372 | p->error_indicator = 1; |
19373 | PyErr_NoMemory(); |
19374 | } |
19375 | if (p->error_indicator) { Branch (19375:9): [True: 0, False: 2.65k]
|
19376 | p->level--; |
19377 | return NULL; |
19378 | } |
19379 | void * _res = NULL; |
19380 | int _mark = p->mark; |
19381 | { // NAME !'(' star_expressions |
19382 | if (p->error_indicator) { Branch (19382:13): [True: 0, False: 2.65k]
|
19383 | p->level--; |
19384 | return NULL; |
19385 | } |
19386 | D(fprintf(stderr, "%*c> invalid_legacy_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME !'(' star_expressions")); |
19387 | expr_ty a; |
19388 | expr_ty b; |
19389 | if ( |
19390 | (a = _PyPegen_name_token(p)) // NAME Branch (19390:13): [True: 691, False: 1.96k]
|
19391 | && |
19392 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 7)691 // token='(' Branch (19392:13): [True: 597, False: 94]
|
19393 | && |
19394 | (b = star_expressions_rule(p))597 // star_expressions Branch (19394:13): [True: 126, False: 471]
|
19395 | ) |
19396 | { |
19397 | D(fprintf(stderr, "%*c+ invalid_legacy_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME !'(' star_expressions")); |
19398 | _res = _PyPegen_check_legacy_stmt ( p , a ) ? RAISE_SYNTAX_ERROR_KNOWN_RANGE27 ( a , b , "Missing parentheses in call to '%U'. Did you mean %U(...)?" , a -> v . Name . id , a -> v . Name . id ) : NULL; Branch (19398:20): [True: 27, False: 99]
|
19399 | if (_res == NULL && PyErr_Occurred()) { Branch (19399:17): [True: 126, False: 0]
Branch (19399:33): [True: 27, False: 99]
|
19400 | p->error_indicator = 1; |
19401 | p->level--; |
19402 | return NULL; |
19403 | } |
19404 | goto done; |
19405 | } |
19406 | p->mark = _mark; |
19407 | D(fprintf(stderr, "%*c%s invalid_legacy_expression[%d-%d]: %s failed!\n", p->level, ' ', |
19408 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME !'(' star_expressions")); |
19409 | } |
19410 | _res = NULL; |
19411 | done: |
19412 | p->level--; |
19413 | return _res; |
19414 | } |
19415 | |
19416 | // invalid_expression: |
19417 | // | !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid |
19418 | // | disjunction 'if' disjunction !('else' | ':') |
19419 | static void * |
19420 | invalid_expression_rule(Parser *p) |
19421 | { |
19422 | if (p->level++ == MAXSTACK) { Branch (19422:9): [True: 0, False: 2.68k]
|
19423 | p->error_indicator = 1; |
19424 | PyErr_NoMemory(); |
19425 | } |
19426 | if (p->error_indicator) { Branch (19426:9): [True: 0, False: 2.68k]
|
19427 | p->level--; |
19428 | return NULL; |
19429 | } |
19430 | void * _res = NULL; |
19431 | int _mark = p->mark; |
19432 | { // !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid |
19433 | if (p->error_indicator) { Branch (19433:13): [True: 0, False: 2.68k]
|
19434 | p->level--; |
19435 | return NULL; |
19436 | } |
19437 | D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid")); |
19438 | expr_ty a; |
19439 | expr_ty b; |
19440 | if ( |
19441 | _PyPegen_lookahead(0, _tmp_147_rule, p) Branch (19441:13): [True: 2.58k, False: 94]
|
19442 | && |
19443 | (a = disjunction_rule(p))2.58k // disjunction Branch (19443:13): [True: 1.15k, False: 1.43k]
|
19444 | && |
19445 | (b = expression_without_invalid_rule(p))1.15k // expression_without_invalid Branch (19445:13): [True: 52, False: 1.09k]
|
19446 | ) |
19447 | { |
19448 | D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid")); |
19449 | _res = _PyPegen_check_legacy_stmt ( p , a ) ? NULL : p -> tokens [p -> mark - 1] -> level == 034 ? NULL : RAISE_SYNTAX_ERROR_KNOWN_RANGE9 ( a , b , "invalid syntax. Perhaps you forgot a comma?" ); Branch (19449:20): [True: 18, False: 34]
Branch (19449:66): [True: 25, False: 9]
|
19450 | if (_res == NULL && PyErr_Occurred()) { |
19451 | p->error_indicator = 1; |
19452 | p->level--; |
19453 | return NULL; |
19454 | } |
19455 | goto done; |
19456 | } |
19457 | p->mark = _mark; |
19458 | D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', |
19459 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid")); |
19460 | } |
19461 | { // disjunction 'if' disjunction !('else' | ':') |
19462 | if (p->error_indicator) { Branch (19462:13): [True: 16, False: 2.61k]
|
19463 | p->level--; |
19464 | return NULL; |
19465 | } |
19466 | D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); |
19467 | Token * _keyword; |
19468 | expr_ty a; |
19469 | expr_ty b; |
19470 | if ( |
19471 | (a = disjunction_rule(p)) // disjunction Branch (19471:13): [True: 1.19k, False: 1.42k]
|
19472 | && |
19473 | (_keyword = _PyPegen_expect_token(p, 634))1.19k // token='if' Branch (19473:13): [True: 7, False: 1.18k]
|
19474 | && |
19475 | (b = disjunction_rule(p))7 // disjunction |
19476 | && |
19477 | _PyPegen_lookahead(0, _tmp_148_rule, p)7 |
19478 | ) |
19479 | { |
19480 | D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); |
19481 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expected 'else' after 'if' expression" ); |
19482 | if (_res == NULL && PyErr_Occurred()) { |
19483 | p->error_indicator = 1; |
19484 | p->level--; |
19485 | return NULL; |
19486 | } |
19487 | goto done; |
19488 | } |
19489 | p->mark = _mark; |
19490 | D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', |
19491 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); |
19492 | } |
19493 | _res = NULL; |
19494 | done: |
19495 | p->level--; |
19496 | return _res; |
19497 | } |
19498 | |
19499 | // invalid_named_expression: |
19500 | // | expression ':=' expression |
19501 | // | NAME '=' bitwise_or !('=' | ':=') |
19502 | // | !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=') |
19503 | static void * |
19504 | invalid_named_expression_rule(Parser *p) |
19505 | { |
19506 | if (p->level++ == MAXSTACK) { Branch (19506:9): [True: 0, False: 2.41k]
|
19507 | p->error_indicator = 1; |
19508 | PyErr_NoMemory(); |
19509 | } |
19510 | if (p->error_indicator) { Branch (19510:9): [True: 0, False: 2.41k]
|
19511 | p->level--; |
19512 | return NULL; |
19513 | } |
19514 | void * _res = NULL; |
19515 | if (_PyPegen_is_memoized(p, invalid_named_expression_type, &_res)) { Branch (19515:9): [True: 1.09k, False: 1.31k]
|
19516 | p->level--; |
19517 | return _res; |
19518 | } |
19519 | int _mark = p->mark; |
19520 | { // expression ':=' expression |
19521 | if (p->error_indicator) { Branch (19521:13): [True: 0, False: 1.31k]
|
19522 | p->level--; |
19523 | return NULL; |
19524 | } |
19525 | D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':=' expression")); |
19526 | Token * _literal; |
19527 | expr_ty a; |
19528 | expr_ty expression_var; |
19529 | if ( |
19530 | (a = expression_rule(p)) // expression Branch (19530:13): [True: 496, False: 819]
|
19531 | && |
19532 | (_literal = _PyPegen_expect_token(p, 53))496 // token=':=' Branch (19532:13): [True: 3, False: 493]
|
19533 | && |
19534 | (expression_var = expression_rule(p))3 // expression |
19535 | ) |
19536 | { |
19537 | D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':=' expression")); |
19538 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) ); |
19539 | if (_res == NULL && PyErr_Occurred()) { |
19540 | p->error_indicator = 1; |
19541 | p->level--; |
19542 | return NULL; |
19543 | } |
19544 | goto done; |
19545 | } |
19546 | p->mark = _mark; |
19547 | D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
19548 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression")); |
19549 | } |
19550 | { // NAME '=' bitwise_or !('=' | ':=') |
19551 | if (p->error_indicator) { Branch (19551:13): [True: 81, False: 1.23k]
|
19552 | p->level--; |
19553 | return NULL; |
19554 | } |
19555 | D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); |
19556 | Token * _literal; |
19557 | expr_ty a; |
19558 | expr_ty b; |
19559 | if ( |
19560 | (a = _PyPegen_name_token(p)) // NAME Branch (19560:13): [True: 257, False: 974]
|
19561 | && |
19562 | (_literal = _PyPegen_expect_token(p, 22))257 // token='=' Branch (19562:13): [True: 12, False: 245]
|
19563 | && |
19564 | (b = bitwise_or_rule(p))12 // bitwise_or |
19565 | && |
19566 | _PyPegen_lookahead(0, _tmp_149_rule, p)11 |
19567 | ) |
19568 | { |
19569 | D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); |
19570 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" ); |
19571 | if (_res == NULL && PyErr_Occurred()) { |
19572 | p->error_indicator = 1; |
19573 | p->level--; |
19574 | return NULL; |
19575 | } |
19576 | goto done; |
19577 | } |
19578 | p->mark = _mark; |
19579 | D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
19580 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); |
19581 | } |
19582 | { // !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=') |
19583 | if (p->error_indicator) { Branch (19583:13): [True: 0, False: 1.22k]
|
19584 | p->level--; |
19585 | return NULL; |
19586 | } |
19587 | D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')")); |
19588 | expr_ty a; |
19589 | Token * b; |
19590 | expr_ty bitwise_or_var; |
19591 | if ( |
19592 | _PyPegen_lookahead(0, _tmp_150_rule, p) Branch (19592:13): [True: 1.15k, False: 64]
|
19593 | && |
19594 | (a = bitwise_or_rule(p))1.15k // bitwise_or Branch (19594:13): [True: 419, False: 740]
|
19595 | && |
19596 | (b = _PyPegen_expect_token(p, 22))419 // token='=' Branch (19596:13): [True: 32, False: 387]
|
19597 | && |
19598 | (bitwise_or_var = bitwise_or_rule(p))32 // bitwise_or |
19599 | && |
19600 | _PyPegen_lookahead(0, _tmp_151_rule, p)31 |
19601 | ) |
19602 | { |
19603 | D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')")); |
19604 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot assign to %s here. Maybe you meant '==' instead of '='?" , _PyPegen_get_expr_name ( a ) ); |
19605 | if (_res == NULL && PyErr_Occurred()) { |
19606 | p->error_indicator = 1; |
19607 | p->level--; |
19608 | return NULL; |
19609 | } |
19610 | goto done; |
19611 | } |
19612 | p->mark = _mark; |
19613 | D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', |
19614 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')")); |
19615 | } |
19616 | _res = NULL; |
19617 | done: |
19618 | _PyPegen_insert_memo(p, _mark, invalid_named_expression_type, _res); |
19619 | p->level--; |
19620 | return _res; |
19621 | } |
19622 | |
19623 | // invalid_assignment: |
19624 | // | invalid_ann_assign_target ':' expression |
19625 | // | star_named_expression ',' star_named_expressions* ':' expression |
19626 | // | expression ':' expression |
19627 | // | ((star_targets '='))* star_expressions '=' |
19628 | // | ((star_targets '='))* yield_expr '=' |
19629 | // | star_expressions augassign (yield_expr | star_expressions) |
19630 | static void * |
19631 | invalid_assignment_rule(Parser *p) |
19632 | { |
19633 | if (p->level++ == MAXSTACK) { Branch (19633:9): [True: 0, False: 886]
|
19634 | p->error_indicator = 1; |
19635 | PyErr_NoMemory(); |
19636 | } |
19637 | if (p->error_indicator) { Branch (19637:9): [True: 0, False: 886]
|
19638 | p->level--; |
19639 | return NULL; |
19640 | } |
19641 | void * _res = NULL; |
19642 | int _mark = p->mark; |
19643 | { // invalid_ann_assign_target ':' expression |
19644 | if (p->error_indicator) { Branch (19644:13): [True: 0, False: 886]
|
19645 | p->level--; |
19646 | return NULL; |
19647 | } |
19648 | D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression")); |
19649 | Token * _literal; |
19650 | expr_ty a; |
19651 | expr_ty expression_var; |
19652 | if ( |
19653 | (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target Branch (19653:13): [True: 17, False: 869]
|
19654 | && |
19655 | (_literal = _PyPegen_expect_token(p, 11))17 // token=':' |
19656 | && |
19657 | (expression_var = expression_rule(p))7 // expression |
19658 | ) |
19659 | { |
19660 | D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression")); |
19661 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) ); |
19662 | if (_res == NULL && PyErr_Occurred()) { |
19663 | p->error_indicator = 1; |
19664 | p->level--; |
19665 | return NULL; |
19666 | } |
19667 | goto done; |
19668 | } |
19669 | p->mark = _mark; |
19670 | D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', |
19671 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_ann_assign_target ':' expression")); |
19672 | } |
19673 | { // star_named_expression ',' star_named_expressions* ':' expression |
19674 | if (p->error_indicator) { Branch (19674:13): [True: 0, False: 879]
|
19675 | p->level--; |
19676 | return NULL; |
19677 | } |
19678 | D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); |
19679 | Token * _literal; |
19680 | Token * _literal_1; |
19681 | asdl_seq * _loop0_152_var; |
19682 | expr_ty a; |
19683 | expr_ty expression_var; |
19684 | if ( |
19685 | (a = star_named_expression_rule(p)) // star_named_expression Branch (19685:13): [True: 155, False: 724]
|
19686 | && |
19687 | (_literal = _PyPegen_expect_token(p, 12))155 // token=',' Branch (19687:13): [True: 5, False: 150]
|
19688 | && |
19689 | (_loop0_152_var = _loop0_152_rule(p))5 // star_named_expressions* |
19690 | && |
19691 | (_literal_1 = _PyPegen_expect_token(p, 11))5 // token=':' |
19692 | && |
19693 | (expression_var = expression_rule(p))1 // expression |
19694 | ) |
19695 | { |
19696 | D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); |
19697 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" ); |
19698 | if (_res == NULL && PyErr_Occurred()) { |
19699 | p->error_indicator = 1; |
19700 | p->level--; |
19701 | return NULL; |
19702 | } |
19703 | goto done; |
19704 | } |
19705 | p->mark = _mark; |
19706 | D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', |
19707 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); |
19708 | } |
19709 | { // expression ':' expression |
19710 | if (p->error_indicator) { Branch (19710:13): [True: 92, False: 786]
|
19711 | p->level--; |
19712 | return NULL; |
19713 | } |
19714 | D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); |
19715 | Token * _literal; |
19716 | expr_ty a; |
19717 | expr_ty expression_var; |
19718 | if ( |
19719 | (a = expression_rule(p)) // expression Branch (19719:13): [True: 154, False: 632]
|
19720 | && |
19721 | (_literal = _PyPegen_expect_token(p, 11))154 // token=':' Branch (19721:13): [True: 3, False: 151]
|
19722 | && |
19723 | (expression_var = expression_rule(p))3 // expression |
19724 | ) |
19725 | { |
19726 | D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); |
19727 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" ); |
19728 | if (_res == NULL && PyErr_Occurred()) { |
19729 | p->error_indicator = 1; |
19730 | p->level--; |
19731 | return NULL; |
19732 | } |
19733 | goto done; |
19734 | } |
19735 | p->mark = _mark; |
19736 | D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', |
19737 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); |
19738 | } |
19739 | { // ((star_targets '='))* star_expressions '=' |
19740 | if (p->error_indicator) { Branch (19740:13): [True: 0, False: 785]
|
19741 | p->level--; |
19742 | return NULL; |
19743 | } |
19744 | D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='")); |
19745 | Token * _literal; |
19746 | asdl_seq * _loop0_153_var; |
19747 | expr_ty a; |
19748 | if ( |
19749 | (_loop0_153_var = _loop0_153_rule(p)) // ((star_targets '='))* Branch (19749:13): [True: 785, False: 0]
|
19750 | && |
19751 | (a = star_expressions_rule(p)) // star_expressions Branch (19751:13): [True: 150, False: 635]
|
19752 | && |
19753 | (_literal = _PyPegen_expect_token(p, 22))150 // token='=' Branch (19753:13): [True: 22, False: 128]
|
19754 | ) |
19755 | { |
19756 | D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='")); |
19757 | _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a ); |
19758 | if (_res == NULL && PyErr_Occurred()) { |
19759 | p->error_indicator = 1; |
19760 | p->level--; |
19761 | return NULL; |
19762 | } |
19763 | goto done; |
19764 | } |
19765 | p->mark = _mark; |
19766 | D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', |
19767 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* star_expressions '='")); |
19768 | } |
19769 | { // ((star_targets '='))* yield_expr '=' |
19770 | if (p->error_indicator) { Branch (19770:13): [True: 0, False: 763]
|
19771 | p->level--; |
19772 | return NULL; |
19773 | } |
19774 | D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='")); |
19775 | Token * _literal; |
19776 | asdl_seq * _loop0_154_var; |
19777 | expr_ty a; |
19778 | if ( |
19779 | (_loop0_154_var = _loop0_154_rule(p)) // ((star_targets '='))* Branch (19779:13): [True: 763, False: 0]
|
19780 | && |
19781 | (a = yield_expr_rule(p)) // yield_expr Branch (19781:13): [True: 5, False: 758]
|
19782 | && |
19783 | (_literal = _PyPegen_expect_token(p, 22))5 // token='=' |
19784 | ) |
19785 | { |
19786 | D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='")); |
19787 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" ); |
19788 | if (_res == NULL && PyErr_Occurred()) { |
19789 | p->error_indicator = 1; |
19790 | p->level--; |
19791 | return NULL; |
19792 | } |
19793 | goto done; |
19794 | } |
19795 | p->mark = _mark; |
19796 | D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', |
19797 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* yield_expr '='")); |
19798 | } |
19799 | { // star_expressions augassign (yield_expr | star_expressions) |
19800 | if (p->error_indicator) { Branch (19800:13): [True: 0, False: 760]
|
19801 | p->level--; |
19802 | return NULL; |
19803 | } |
19804 | D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)")); |
19805 | void *_tmp_155_var; |
19806 | expr_ty a; |
19807 | AugOperator* augassign_var; |
19808 | if ( |
19809 | (a = star_expressions_rule(p)) // star_expressions Branch (19809:13): [True: 130, False: 630]
|
19810 | && |
19811 | (augassign_var = augassign_rule(p))130 // augassign Branch (19811:13): [True: 14, False: 116]
|
19812 | && |
19813 | (_tmp_155_var = _tmp_155_rule(p))14 // yield_expr | star_expressions |
19814 | ) |
19815 | { |
19816 | D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)")); |
19817 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) ); |
19818 | if (_res == NULL && PyErr_Occurred()) { |
19819 | p->error_indicator = 1; |
19820 | p->level--; |
19821 | return NULL; |
19822 | } |
19823 | goto done; |
19824 | } |
19825 | p->mark = _mark; |
19826 | D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', |
19827 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)")); |
19828 | } |
19829 | _res = NULL; |
19830 | done: |
19831 | p->level--; |
19832 | return _res; |
19833 | } |
19834 | |
19835 | // invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')' |
19836 | static expr_ty |
19837 | invalid_ann_assign_target_rule(Parser *p) |
19838 | { |
19839 | if (p->level++ == MAXSTACK) { Branch (19839:9): [True: 0, False: 898]
|
19840 | p->error_indicator = 1; |
19841 | PyErr_NoMemory(); |
19842 | } |
19843 | if (p->error_indicator) { Branch (19843:9): [True: 0, False: 898]
|
19844 | p->level--; |
19845 | return NULL; |
19846 | } |
19847 | expr_ty _res = NULL; |
19848 | int _mark = p->mark; |
19849 | { // list |
19850 | if (p->error_indicator) { Branch (19850:13): [True: 0, False: 898]
|
19851 | p->level--; |
19852 | return NULL; |
19853 | } |
19854 | D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); |
19855 | expr_ty list_var; |
19856 | if ( |
19857 | (list_var = list_rule(p)) // list Branch (19857:13): [True: 7, False: 891]
|
19858 | ) |
19859 | { |
19860 | D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); |
19861 | _res = list_var; |
19862 | goto done; |
19863 | } |
19864 | p->mark = _mark; |
19865 | D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', |
19866 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); |
19867 | } |
19868 | { // tuple |
19869 | if (p->error_indicator) { Branch (19869:13): [True: 0, False: 891]
|
19870 | p->level--; |
19871 | return NULL; |
19872 | } |
19873 | D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); |
19874 | expr_ty tuple_var; |
19875 | if ( |
19876 | (tuple_var = tuple_rule(p)) // tuple Branch (19876:13): [True: 10, False: 881]
|
19877 | ) |
19878 | { |
19879 | D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); |
19880 | _res = tuple_var; |
19881 | goto done; |
19882 | } |
19883 | p->mark = _mark; |
19884 | D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', |
19885 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); |
19886 | } |
19887 | { // '(' invalid_ann_assign_target ')' |
19888 | if (p->error_indicator) { Branch (19888:13): [True: 0, False: 881]
|
19889 | p->level--; |
19890 | return NULL; |
19891 | } |
19892 | D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'")); |
19893 | Token * _literal; |
19894 | Token * _literal_1; |
19895 | expr_ty a; |
19896 | if ( |
19897 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (19897:13): [True: 12, False: 869]
|
19898 | && |
19899 | (a = invalid_ann_assign_target_rule(p))12 // invalid_ann_assign_target |
19900 | && |
19901 | (_literal_1 = _PyPegen_expect_token(p, 8))2 // token=')' |
19902 | ) |
19903 | { |
19904 | D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'")); |
19905 | _res = a; |
19906 | if (_res == NULL && PyErr_Occurred()0 ) { |
19907 | p->error_indicator = 1; |
19908 | p->level--; |
19909 | return NULL; |
19910 | } |
19911 | goto done; |
19912 | } |
19913 | p->mark = _mark; |
19914 | D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', |
19915 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' invalid_ann_assign_target ')'")); |
19916 | } |
19917 | _res = NULL; |
19918 | done: |
19919 | p->level--; |
19920 | return _res; |
19921 | } |
19922 | |
19923 | // invalid_del_stmt: 'del' star_expressions |
19924 | static void * |
19925 | invalid_del_stmt_rule(Parser *p) |
19926 | { |
19927 | if (p->level++ == MAXSTACK) { Branch (19927:9): [True: 0, False: 37]
|
19928 | p->error_indicator = 1; |
19929 | PyErr_NoMemory(); |
19930 | } |
19931 | if (p->error_indicator) { Branch (19931:9): [True: 0, False: 37]
|
19932 | p->level--; |
19933 | return NULL; |
19934 | } |
19935 | void * _res = NULL; |
19936 | int _mark = p->mark; |
19937 | { // 'del' star_expressions |
19938 | if (p->error_indicator) { |
19939 | p->level--; |
19940 | return NULL; |
19941 | } |
19942 | D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star_expressions")); |
19943 | Token * _keyword; |
19944 | expr_ty a; |
19945 | if ( |
19946 | (_keyword = _PyPegen_expect_token(p, 603)) // token='del' |
19947 | && |
19948 | (a = star_expressions_rule(p)) // star_expressions |
19949 | ) |
19950 | { |
19951 | D(fprintf(stderr, "%*c+ invalid_del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' star_expressions")); |
19952 | _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a ); |
19953 | if (_res == NULL && PyErr_Occurred()) { |
19954 | p->error_indicator = 1; |
19955 | p->level--; |
19956 | return NULL; |
19957 | } |
19958 | goto done; |
19959 | } |
19960 | p->mark = _mark; |
19961 | D(fprintf(stderr, "%*c%s invalid_del_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
19962 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' star_expressions")); |
19963 | } |
19964 | _res = NULL; |
19965 | done: |
19966 | p->level--; |
19967 | return _res; |
19968 | } |
19969 | |
19970 | // invalid_block: NEWLINE !INDENT |
19971 | static void * |
19972 | invalid_block_rule(Parser *p) |
19973 | { |
19974 | if (p->level++ == MAXSTACK) { Branch (19974:9): [True: 0, False: 135]
|
19975 | p->error_indicator = 1; |
19976 | PyErr_NoMemory(); |
19977 | } |
19978 | if (p->error_indicator) { Branch (19978:9): [True: 0, False: 135]
|
19979 | p->level--; |
19980 | return NULL; |
19981 | } |
19982 | void * _res = NULL; |
19983 | int _mark = p->mark; |
19984 | { // NEWLINE !INDENT |
19985 | if (p->error_indicator) { Branch (19985:13): [True: 0, False: 135]
|
19986 | p->level--; |
19987 | return NULL; |
19988 | } |
19989 | D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT")); |
19990 | Token * newline_var; |
19991 | if ( |
19992 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (19992:13): [True: 49, False: 86]
|
19993 | && |
19994 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 49 INDENT49 ) // token=INDENT |
19995 | ) |
19996 | { |
19997 | D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT")); |
19998 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block" ); |
19999 | if (_res == NULL && PyErr_Occurred()) { |
20000 | p->error_indicator = 1; |
20001 | p->level--; |
20002 | return NULL; |
20003 | } |
20004 | goto done; |
20005 | } |
20006 | p->mark = _mark; |
20007 | D(fprintf(stderr, "%*c%s invalid_block[%d-%d]: %s failed!\n", p->level, ' ', |
20008 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE !INDENT")); |
20009 | } |
20010 | _res = NULL; |
20011 | done: |
20012 | p->level--; |
20013 | return _res; |
20014 | } |
20015 | |
20016 | // invalid_comprehension: |
20017 | // | ('[' | '(' | '{') starred_expression for_if_clauses |
20018 | // | ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses |
20019 | // | ('[' | '{') star_named_expression ',' for_if_clauses |
20020 | static void * |
20021 | invalid_comprehension_rule(Parser *p) |
20022 | { |
20023 | if (p->level++ == MAXSTACK) { Branch (20023:9): [True: 0, False: 2.86k]
|
20024 | p->error_indicator = 1; |
20025 | PyErr_NoMemory(); |
20026 | } |
20027 | if (p->error_indicator) { Branch (20027:9): [True: 0, False: 2.86k]
|
20028 | p->level--; |
20029 | return NULL; |
20030 | } |
20031 | void * _res = NULL; |
20032 | int _mark = p->mark; |
20033 | { // ('[' | '(' | '{') starred_expression for_if_clauses |
20034 | if (p->error_indicator) { Branch (20034:13): [True: 0, False: 2.86k]
|
20035 | p->level--; |
20036 | return NULL; |
20037 | } |
20038 | D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); |
20039 | void *_tmp_156_var; |
20040 | expr_ty a; |
20041 | asdl_comprehension_seq* for_if_clauses_var; |
20042 | if ( |
20043 | (_tmp_156_var = _tmp_156_rule(p)) // '[' | '(' | '{' Branch (20043:13): [True: 418, False: 2.44k]
|
20044 | && |
20045 | (a = starred_expression_rule(p))418 // starred_expression Branch (20045:13): [True: 19, False: 399]
|
20046 | && |
20047 | (for_if_clauses_var = for_if_clauses_rule(p))19 // for_if_clauses |
20048 | ) |
20049 | { |
20050 | D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); |
20051 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" ); |
20052 | if (_res == NULL && PyErr_Occurred()) { |
20053 | p->error_indicator = 1; |
20054 | p->level--; |
20055 | return NULL; |
20056 | } |
20057 | goto done; |
20058 | } |
20059 | p->mark = _mark; |
20060 | D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', |
20061 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); |
20062 | } |
20063 | { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses |
20064 | if (p->error_indicator) { Branch (20064:13): [True: 1, False: 2.86k]
|
20065 | p->level--; |
20066 | return NULL; |
20067 | } |
20068 | D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); |
20069 | Token * _literal; |
20070 | void *_tmp_157_var; |
20071 | expr_ty a; |
20072 | asdl_expr_seq* b; |
20073 | asdl_comprehension_seq* for_if_clauses_var; |
20074 | if ( |
20075 | (_tmp_157_var = _tmp_157_rule(p)) // '[' | '{' Branch (20075:13): [True: 145, False: 2.71k]
|
20076 | && |
20077 | (a = star_named_expression_rule(p))145 // star_named_expression Branch (20077:13): [True: 61, False: 84]
|
20078 | && |
20079 | (_literal = _PyPegen_expect_token(p, 12))61 // token=',' |
20080 | && |
20081 | (b = star_named_expressions_rule(p))5 // star_named_expressions |
20082 | && |
20083 | (for_if_clauses_var = for_if_clauses_rule(p))5 // for_if_clauses |
20084 | ) |
20085 | { |
20086 | D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); |
20087 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" ); |
20088 | if (_res == NULL && PyErr_Occurred()) { |
20089 | p->error_indicator = 1; |
20090 | p->level--; |
20091 | return NULL; |
20092 | } |
20093 | goto done; |
20094 | } |
20095 | p->mark = _mark; |
20096 | D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', |
20097 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); |
20098 | } |
20099 | { // ('[' | '{') star_named_expression ',' for_if_clauses |
20100 | if (p->error_indicator) { Branch (20100:13): [True: 0, False: 2.85k]
|
20101 | p->level--; |
20102 | return NULL; |
20103 | } |
20104 | D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); |
20105 | void *_tmp_158_var; |
20106 | expr_ty a; |
20107 | Token * b; |
20108 | asdl_comprehension_seq* for_if_clauses_var; |
20109 | if ( |
20110 | (_tmp_158_var = _tmp_158_rule(p)) // '[' | '{' Branch (20110:13): [True: 141, False: 2.71k]
|
20111 | && |
20112 | (a = star_named_expression_rule(p))141 // star_named_expression Branch (20112:13): [True: 57, False: 84]
|
20113 | && |
20114 | (b = _PyPegen_expect_token(p, 12))57 // token=',' |
20115 | && |
20116 | (for_if_clauses_var = for_if_clauses_rule(p))1 // for_if_clauses |
20117 | ) |
20118 | { |
20119 | D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); |
20120 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" ); |
20121 | if (_res == NULL && PyErr_Occurred()) { |
20122 | p->error_indicator = 1; |
20123 | p->level--; |
20124 | return NULL; |
20125 | } |
20126 | goto done; |
20127 | } |
20128 | p->mark = _mark; |
20129 | D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', |
20130 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); |
20131 | } |
20132 | _res = NULL; |
20133 | done: |
20134 | p->level--; |
20135 | return _res; |
20136 | } |
20137 | |
20138 | // invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}' |
20139 | static void * |
20140 | invalid_dict_comprehension_rule(Parser *p) |
20141 | { |
20142 | if (p->level++ == MAXSTACK) { Branch (20142:9): [True: 0, False: 37]
|
20143 | p->error_indicator = 1; |
20144 | PyErr_NoMemory(); |
20145 | } |
20146 | if (p->error_indicator) { Branch (20146:9): [True: 0, False: 37]
|
20147 | p->level--; |
20148 | return NULL; |
20149 | } |
20150 | void * _res = NULL; |
20151 | int _mark = p->mark; |
20152 | { // '{' '**' bitwise_or for_if_clauses '}' |
20153 | if (p->error_indicator) { |
20154 | p->level--; |
20155 | return NULL; |
20156 | } |
20157 | D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); |
20158 | Token * _literal; |
20159 | Token * _literal_1; |
20160 | Token * a; |
20161 | expr_ty bitwise_or_var; |
20162 | asdl_comprehension_seq* for_if_clauses_var; |
20163 | if ( |
20164 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' |
20165 | && |
20166 | (a = _PyPegen_expect_token(p, 35)) // token='**' |
20167 | && |
20168 | (bitwise_or_var = bitwise_or_rule(p))1 // bitwise_or |
20169 | && |
20170 | (for_if_clauses_var = for_if_clauses_rule(p))1 // for_if_clauses |
20171 | && |
20172 | (_literal_1 = _PyPegen_expect_token(p, 26))1 // token='}' |
20173 | ) |
20174 | { |
20175 | D(fprintf(stderr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); |
20176 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" ); |
20177 | if (_res == NULL && PyErr_Occurred()) { |
20178 | p->error_indicator = 1; |
20179 | p->level--; |
20180 | return NULL; |
20181 | } |
20182 | goto done; |
20183 | } |
20184 | p->mark = _mark; |
20185 | D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ', |
20186 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); |
20187 | } |
20188 | _res = NULL; |
20189 | done: |
20190 | p->level--; |
20191 | return _res; |
20192 | } |
20193 | |
20194 | // invalid_parameters: |
20195 | // | param_no_default* invalid_parameters_helper param_no_default |
20196 | // | param_no_default* '(' param_no_default+ ','? ')' |
20197 | // | "/" ',' |
20198 | // | (slash_no_default | slash_with_default) param_maybe_default* '/' |
20199 | // | [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/' |
20200 | // | param_maybe_default+ '/' '*' |
20201 | static void * |
20202 | invalid_parameters_rule(Parser *p) |
20203 | { |
20204 | if (p->level++ == MAXSTACK) { Branch (20204:9): [True: 0, False: 300]
|
20205 | p->error_indicator = 1; |
20206 | PyErr_NoMemory(); |
20207 | } |
20208 | if (p->error_indicator) { Branch (20208:9): [True: 0, False: 300]
|
20209 | p->level--; |
20210 | return NULL; |
20211 | } |
20212 | void * _res = NULL; |
20213 | int _mark = p->mark; |
20214 | { // param_no_default* invalid_parameters_helper param_no_default |
20215 | if (p->error_indicator) { Branch (20215:13): [True: 0, False: 300]
|
20216 | p->level--; |
20217 | return NULL; |
20218 | } |
20219 | D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* invalid_parameters_helper param_no_default")); |
20220 | asdl_seq * _loop0_159_var; |
20221 | arg_ty a; |
20222 | void *invalid_parameters_helper_var; |
20223 | if ( |
20224 | (_loop0_159_var = _loop0_159_rule(p)) // param_no_default* Branch (20224:13): [True: 300, False: 0]
|
20225 | && |
20226 | (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper Branch (20226:13): [True: 14, False: 286]
|
20227 | && |
20228 | (a = param_no_default_rule(p))14 // param_no_default |
20229 | ) |
20230 | { |
20231 | D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* invalid_parameters_helper param_no_default")); |
20232 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" ); |
20233 | if (_res == NULL && PyErr_Occurred()) { |
20234 | p->error_indicator = 1; |
20235 | p->level--; |
20236 | return NULL; |
20237 | } |
20238 | goto done; |
20239 | } |
20240 | p->mark = _mark; |
20241 | D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20242 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* invalid_parameters_helper param_no_default")); |
20243 | } |
20244 | { // param_no_default* '(' param_no_default+ ','? ')' |
20245 | if (p->error_indicator) { Branch (20245:13): [True: 8, False: 282]
|
20246 | p->level--; |
20247 | return NULL; |
20248 | } |
20249 | D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'")); |
20250 | asdl_seq * _loop0_160_var; |
20251 | asdl_seq * _loop1_161_var; |
20252 | void *_opt_var; |
20253 | UNUSED(_opt_var); // Silence compiler warnings |
20254 | Token * a; |
20255 | Token * b; |
20256 | if ( |
20257 | (_loop0_160_var = _loop0_160_rule(p)) // param_no_default* Branch (20257:13): [True: 282, False: 0]
|
20258 | && |
20259 | (a = _PyPegen_expect_token(p, 7)) // token='(' Branch (20259:13): [True: 4, False: 278]
|
20260 | && |
20261 | (_loop1_161_var = _loop1_161_rule(p))4 // param_no_default+ |
20262 | && |
20263 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)4 // ','? |
20264 | && |
20265 | (b = _PyPegen_expect_token(p, 8))4 // token=')' |
20266 | ) |
20267 | { |
20268 | D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'")); |
20269 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Function parameters cannot be parenthesized" ); |
20270 | if (_res == NULL && PyErr_Occurred()) { |
20271 | p->error_indicator = 1; |
20272 | p->level--; |
20273 | return NULL; |
20274 | } |
20275 | goto done; |
20276 | } |
20277 | p->mark = _mark; |
20278 | D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20279 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'")); |
20280 | } |
20281 | { // "/" ',' |
20282 | if (p->error_indicator) { Branch (20282:13): [True: 0, False: 278]
|
20283 | p->level--; |
20284 | return NULL; |
20285 | } |
20286 | D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"/\" ','")); |
20287 | Token * _literal; |
20288 | Token * a; |
20289 | if ( |
20290 | (a = _PyPegen_expect_token(p, 17)) // token='/' Branch (20290:13): [True: 9, False: 269]
|
20291 | && |
20292 | (_literal = _PyPegen_expect_token(p, 12))9 // token=',' |
20293 | ) |
20294 | { |
20295 | D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"/\" ','")); |
20296 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" ); |
20297 | if (_res == NULL && PyErr_Occurred()) { |
20298 | p->error_indicator = 1; |
20299 | p->level--; |
20300 | return NULL; |
20301 | } |
20302 | goto done; |
20303 | } |
20304 | p->mark = _mark; |
20305 | D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20306 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','")); |
20307 | } |
20308 | { // (slash_no_default | slash_with_default) param_maybe_default* '/' |
20309 | if (p->error_indicator) { Branch (20309:13): [True: 0, False: 273]
|
20310 | p->level--; |
20311 | return NULL; |
20312 | } |
20313 | D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); |
20314 | asdl_seq * _loop0_163_var; |
20315 | void *_tmp_162_var; |
20316 | Token * a; |
20317 | if ( |
20318 | (_tmp_162_var = _tmp_162_rule(p)) // slash_no_default | slash_with_default Branch (20318:13): [True: 14, False: 259]
|
20319 | && |
20320 | (_loop0_163_var = _loop0_163_rule(p))14 // param_maybe_default* |
20321 | && |
20322 | (a = _PyPegen_expect_token(p, 17))14 // token='/' |
20323 | ) |
20324 | { |
20325 | D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); |
20326 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" ); |
20327 | if (_res == NULL && PyErr_Occurred()) { |
20328 | p->error_indicator = 1; |
20329 | p->level--; |
20330 | return NULL; |
20331 | } |
20332 | goto done; |
20333 | } |
20334 | p->mark = _mark; |
20335 | D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20336 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); |
20337 | } |
20338 | { // [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/' |
20339 | if (p->error_indicator) { Branch (20339:13): [True: 0, False: 263]
|
20340 | p->level--; |
20341 | return NULL; |
20342 | } |
20343 | D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'")); |
20344 | Token * _literal; |
20345 | asdl_seq * _loop0_165_var; |
20346 | asdl_seq * _loop0_167_var; |
20347 | void *_opt_var; |
20348 | UNUSED(_opt_var); // Silence compiler warnings |
20349 | void *_tmp_166_var; |
20350 | Token * a; |
20351 | if ( |
20352 | (_opt_var = _tmp_164_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] Branch (20352:13): [True: 263, False: 0]
|
20353 | && |
20354 | (_loop0_165_var = _loop0_165_rule(p)) // param_maybe_default* Branch (20354:13): [True: 263, False: 0]
|
20355 | && |
20356 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (20356:13): [True: 41, False: 222]
|
20357 | && |
20358 | (_tmp_166_var = _tmp_166_rule(p))41 // ',' | param_no_default |
20359 | && |
20360 | (_loop0_167_var = _loop0_167_rule(p))33 // param_maybe_default* |
20361 | && |
20362 | (a = _PyPegen_expect_token(p, 17))33 // token='/' Branch (20362:13): [True: 12, False: 21]
|
20363 | ) |
20364 | { |
20365 | D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'")); |
20366 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" ); |
20367 | if (_res == NULL && PyErr_Occurred()) { |
20368 | p->error_indicator = 1; |
20369 | p->level--; |
20370 | return NULL; |
20371 | } |
20372 | goto done; |
20373 | } |
20374 | p->mark = _mark; |
20375 | D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20376 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'")); |
20377 | } |
20378 | { // param_maybe_default+ '/' '*' |
20379 | if (p->error_indicator) { Branch (20379:13): [True: 0, False: 251]
|
20380 | p->level--; |
20381 | return NULL; |
20382 | } |
20383 | D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default+ '/' '*'")); |
20384 | Token * _literal; |
20385 | asdl_seq * _loop1_168_var; |
20386 | Token * a; |
20387 | if ( |
20388 | (_loop1_168_var = _loop1_168_rule(p)) // param_maybe_default+ Branch (20388:13): [True: 42, False: 209]
|
20389 | && |
20390 | (_literal = _PyPegen_expect_token(p, 17))42 // token='/' |
20391 | && |
20392 | (a = _PyPegen_expect_token(p, 16))5 // token='*' |
20393 | ) |
20394 | { |
20395 | D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_maybe_default+ '/' '*'")); |
20396 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" ); |
20397 | if (_res == NULL && PyErr_Occurred()) { |
20398 | p->error_indicator = 1; |
20399 | p->level--; |
20400 | return NULL; |
20401 | } |
20402 | goto done; |
20403 | } |
20404 | p->mark = _mark; |
20405 | D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20406 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default+ '/' '*'")); |
20407 | } |
20408 | _res = NULL; |
20409 | done: |
20410 | p->level--; |
20411 | return _res; |
20412 | } |
20413 | |
20414 | // invalid_default: '=' &(')' | ',') |
20415 | static void * |
20416 | invalid_default_rule(Parser *p) |
20417 | { |
20418 | if (p->level++ == MAXSTACK) { Branch (20418:9): [True: 0, False: 1.77k]
|
20419 | p->error_indicator = 1; |
20420 | PyErr_NoMemory(); |
20421 | } |
20422 | if (p->error_indicator) { Branch (20422:9): [True: 0, False: 1.77k]
|
20423 | p->level--; |
20424 | return NULL; |
20425 | } |
20426 | void * _res = NULL; |
20427 | int _mark = p->mark; |
20428 | { // '=' &(')' | ',') |
20429 | if (p->error_indicator) { Branch (20429:13): [True: 0, False: 1.77k]
|
20430 | p->level--; |
20431 | return NULL; |
20432 | } |
20433 | D(fprintf(stderr, "%*c> invalid_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); |
20434 | Token * a; |
20435 | if ( |
20436 | (a = _PyPegen_expect_token(p, 22)) // token='=' Branch (20436:13): [True: 245, False: 1.53k]
|
20437 | && |
20438 | _PyPegen_lookahead(1, _tmp_169_rule, p)245 Branch (20438:13): [True: 5, False: 240]
|
20439 | ) |
20440 | { |
20441 | D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); |
20442 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected default value expression" ); |
20443 | if (_res == NULL && PyErr_Occurred()) { |
20444 | p->error_indicator = 1; |
20445 | p->level--; |
20446 | return NULL; |
20447 | } |
20448 | goto done; |
20449 | } |
20450 | p->mark = _mark; |
20451 | D(fprintf(stderr, "%*c%s invalid_default[%d-%d]: %s failed!\n", p->level, ' ', |
20452 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' &(')' | ',')")); |
20453 | } |
20454 | _res = NULL; |
20455 | done: |
20456 | p->level--; |
20457 | return _res; |
20458 | } |
20459 | |
20460 | // invalid_star_etc: |
20461 | // | '*' (')' | ',' (')' | '**')) |
20462 | // | '*' ',' TYPE_COMMENT |
20463 | // | '*' param '=' |
20464 | // | '*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',') |
20465 | static void * |
20466 | invalid_star_etc_rule(Parser *p) |
20467 | { |
20468 | if (p->level++ == MAXSTACK) { Branch (20468:9): [True: 0, False: 250]
|
20469 | p->error_indicator = 1; |
20470 | PyErr_NoMemory(); |
20471 | } |
20472 | if (p->error_indicator) { Branch (20472:9): [True: 0, False: 250]
|
20473 | p->level--; |
20474 | return NULL; |
20475 | } |
20476 | void * _res = NULL; |
20477 | int _mark = p->mark; |
20478 | { // '*' (')' | ',' (')' | '**')) |
20479 | if (p->error_indicator) { Branch (20479:13): [True: 0, False: 250]
|
20480 | p->level--; |
20481 | return NULL; |
20482 | } |
20483 | D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); |
20484 | void *_tmp_170_var; |
20485 | Token * a; |
20486 | if ( |
20487 | (a = _PyPegen_expect_token(p, 16)) // token='*' Branch (20487:13): [True: 29, False: 221]
|
20488 | && |
20489 | (_tmp_170_var = _tmp_170_rule(p))29 // ')' | ',' (')' | '**') |
20490 | ) |
20491 | { |
20492 | D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); |
20493 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "named arguments must follow bare *" ); |
20494 | if (_res == NULL && PyErr_Occurred()) { |
20495 | p->error_indicator = 1; |
20496 | p->level--; |
20497 | return NULL; |
20498 | } |
20499 | goto done; |
20500 | } |
20501 | p->mark = _mark; |
20502 | D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
20503 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); |
20504 | } |
20505 | { // '*' ',' TYPE_COMMENT |
20506 | if (p->error_indicator) { Branch (20506:13): [True: 0, False: 247]
|
20507 | p->level--; |
20508 | return NULL; |
20509 | } |
20510 | D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT")); |
20511 | Token * _literal; |
20512 | Token * _literal_1; |
20513 | Token * type_comment_var; |
20514 | if ( |
20515 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (20515:13): [True: 26, False: 221]
|
20516 | && |
20517 | (_literal_1 = _PyPegen_expect_token(p, 12))26 // token=',' |
20518 | && |
20519 | (type_comment_var = _PyPegen_expect_token(p, 8 TYPE_COMMENT8 )) // token='TYPE_COMMENT' |
20520 | ) |
20521 | { |
20522 | D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT")); |
20523 | _res = RAISE_SYNTAX_ERROR ( "bare * has associated type comment" ); |
20524 | if (_res == NULL && PyErr_Occurred()) { |
20525 | p->error_indicator = 1; |
20526 | p->level--; |
20527 | return NULL; |
20528 | } |
20529 | goto done; |
20530 | } |
20531 | p->mark = _mark; |
20532 | D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
20533 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' TYPE_COMMENT")); |
20534 | } |
20535 | { // '*' param '=' |
20536 | if (p->error_indicator) { Branch (20536:13): [True: 0, False: 246]
|
20537 | p->level--; |
20538 | return NULL; |
20539 | } |
20540 | D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param '='")); |
20541 | Token * _literal; |
20542 | Token * a; |
20543 | arg_ty param_var; |
20544 | if ( |
20545 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (20545:13): [True: 25, False: 221]
|
20546 | && |
20547 | (param_var = param_rule(p))25 // param |
20548 | && |
20549 | (a = _PyPegen_expect_token(p, 22))16 // token='=' |
20550 | ) |
20551 | { |
20552 | D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param '='")); |
20553 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" ); |
20554 | if (_res == NULL && PyErr_Occurred()) { |
20555 | p->error_indicator = 1; |
20556 | p->level--; |
20557 | return NULL; |
20558 | } |
20559 | goto done; |
20560 | } |
20561 | p->mark = _mark; |
20562 | D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
20563 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param '='")); |
20564 | } |
20565 | { // '*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',') |
20566 | if (p->error_indicator) { Branch (20566:13): [True: 0, False: 244]
|
20567 | p->level--; |
20568 | return NULL; |
20569 | } |
20570 | D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); |
20571 | Token * _literal; |
20572 | asdl_seq * _loop0_172_var; |
20573 | void *_tmp_171_var; |
20574 | void *_tmp_173_var; |
20575 | Token * a; |
20576 | if ( |
20577 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (20577:13): [True: 23, False: 221]
|
20578 | && |
20579 | (_tmp_171_var = _tmp_171_rule(p))23 // param_no_default | ',' |
20580 | && |
20581 | (_loop0_172_var = _loop0_172_rule(p))19 // param_maybe_default* |
20582 | && |
20583 | (a = _PyPegen_expect_token(p, 16))19 // token='*' |
20584 | && |
20585 | (_tmp_173_var = _tmp_173_rule(p))4 // param_no_default | ',' |
20586 | ) |
20587 | { |
20588 | D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); |
20589 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" ); |
20590 | if (_res == NULL && PyErr_Occurred()) { |
20591 | p->error_indicator = 1; |
20592 | p->level--; |
20593 | return NULL; |
20594 | } |
20595 | goto done; |
20596 | } |
20597 | p->mark = _mark; |
20598 | D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
20599 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); |
20600 | } |
20601 | _res = NULL; |
20602 | done: |
20603 | p->level--; |
20604 | return _res; |
20605 | } |
20606 | |
20607 | // invalid_kwds: '**' param '=' | '**' param ',' param | '**' param ',' ('*' | '**' | '/') |
20608 | static void * |
20609 | invalid_kwds_rule(Parser *p) |
20610 | { |
20611 | if (p->level++ == MAXSTACK) { Branch (20611:9): [True: 0, False: 240]
|
20612 | p->error_indicator = 1; |
20613 | PyErr_NoMemory(); |
20614 | } |
20615 | if (p->error_indicator) { Branch (20615:9): [True: 0, False: 240]
|
20616 | p->level--; |
20617 | return NULL; |
20618 | } |
20619 | void * _res = NULL; |
20620 | int _mark = p->mark; |
20621 | { // '**' param '=' |
20622 | if (p->error_indicator) { Branch (20622:13): [True: 0, False: 240]
|
20623 | p->level--; |
20624 | return NULL; |
20625 | } |
20626 | D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param '='")); |
20627 | Token * _literal; |
20628 | Token * a; |
20629 | arg_ty param_var; |
20630 | if ( |
20631 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (20631:13): [True: 17, False: 223]
|
20632 | && |
20633 | (param_var = param_rule(p))17 // param |
20634 | && |
20635 | (a = _PyPegen_expect_token(p, 22))15 // token='=' |
20636 | ) |
20637 | { |
20638 | D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param '='")); |
20639 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" ); |
20640 | if (_res == NULL && PyErr_Occurred()) { |
20641 | p->error_indicator = 1; |
20642 | p->level--; |
20643 | return NULL; |
20644 | } |
20645 | goto done; |
20646 | } |
20647 | p->mark = _mark; |
20648 | D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
20649 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param '='")); |
20650 | } |
20651 | { // '**' param ',' param |
20652 | if (p->error_indicator) { Branch (20652:13): [True: 0, False: 238]
|
20653 | p->level--; |
20654 | return NULL; |
20655 | } |
20656 | D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param ',' param")); |
20657 | Token * _literal; |
20658 | Token * _literal_1; |
20659 | arg_ty a; |
20660 | arg_ty param_var; |
20661 | if ( |
20662 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (20662:13): [True: 15, False: 223]
|
20663 | && |
20664 | (param_var = param_rule(p))15 // param |
20665 | && |
20666 | (_literal_1 = _PyPegen_expect_token(p, 12))13 // token=',' |
20667 | && |
20668 | (a = param_rule(p))7 // param |
20669 | ) |
20670 | { |
20671 | D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' param")); |
20672 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" ); |
20673 | if (_res == NULL && PyErr_Occurred()) { |
20674 | p->error_indicator = 1; |
20675 | p->level--; |
20676 | return NULL; |
20677 | } |
20678 | goto done; |
20679 | } |
20680 | p->mark = _mark; |
20681 | D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
20682 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param ',' param")); |
20683 | } |
20684 | { // '**' param ',' ('*' | '**' | '/') |
20685 | if (p->error_indicator) { Branch (20685:13): [True: 0, False: 236]
|
20686 | p->level--; |
20687 | return NULL; |
20688 | } |
20689 | D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); |
20690 | Token * _literal; |
20691 | Token * _literal_1; |
20692 | Token* a; |
20693 | arg_ty param_var; |
20694 | if ( |
20695 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' Branch (20695:13): [True: 13, False: 223]
|
20696 | && |
20697 | (param_var = param_rule(p))13 // param |
20698 | && |
20699 | (_literal_1 = _PyPegen_expect_token(p, 12))11 // token=',' |
20700 | && |
20701 | (a = (Token*)_tmp_174_rule(p))5 // '*' | '**' | '/' |
20702 | ) |
20703 | { |
20704 | D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); |
20705 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" ); |
20706 | if (_res == NULL && PyErr_Occurred()) { |
20707 | p->error_indicator = 1; |
20708 | p->level--; |
20709 | return NULL; |
20710 | } |
20711 | goto done; |
20712 | } |
20713 | p->mark = _mark; |
20714 | D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
20715 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); |
20716 | } |
20717 | _res = NULL; |
20718 | done: |
20719 | p->level--; |
20720 | return _res; |
20721 | } |
20722 | |
20723 | // invalid_parameters_helper: slash_with_default | param_with_default+ |
20724 | static void * |
20725 | invalid_parameters_helper_rule(Parser *p) |
20726 | { |
20727 | if (p->level++ == MAXSTACK) { Branch (20727:9): [True: 0, False: 300]
|
20728 | p->error_indicator = 1; |
20729 | PyErr_NoMemory(); |
20730 | } |
20731 | if (p->error_indicator) { Branch (20731:9): [True: 5, False: 295]
|
20732 | p->level--; |
20733 | return NULL; |
20734 | } |
20735 | void * _res = NULL; |
20736 | int _mark = p->mark; |
20737 | { // slash_with_default |
20738 | if (p->error_indicator) { Branch (20738:13): [True: 0, False: 295]
|
20739 | p->level--; |
20740 | return NULL; |
20741 | } |
20742 | D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); |
20743 | SlashWithDefault* a; |
20744 | if ( |
20745 | (a = slash_with_default_rule(p)) // slash_with_default Branch (20745:13): [True: 6, False: 289]
|
20746 | ) |
20747 | { |
20748 | D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); |
20749 | _res = _PyPegen_singleton_seq ( p , a ); |
20750 | if (_res == NULL && PyErr_Occurred()0 ) { |
20751 | p->error_indicator = 1; |
20752 | p->level--; |
20753 | return NULL; |
20754 | } |
20755 | goto done; |
20756 | } |
20757 | p->mark = _mark; |
20758 | D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', |
20759 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); |
20760 | } |
20761 | { // param_with_default+ |
20762 | if (p->error_indicator) { Branch (20762:13): [True: 3, False: 286]
|
20763 | p->level--; |
20764 | return NULL; |
20765 | } |
20766 | D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+")); |
20767 | asdl_seq * _loop1_175_var; |
20768 | if ( |
20769 | (_loop1_175_var = _loop1_175_rule(p)) // param_with_default+ Branch (20769:13): [True: 8, False: 278]
|
20770 | ) |
20771 | { |
20772 | D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+")); |
20773 | _res = _loop1_175_var; |
20774 | goto done; |
20775 | } |
20776 | p->mark = _mark; |
20777 | D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', |
20778 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+")); |
20779 | } |
20780 | _res = NULL; |
20781 | done: |
20782 | p->level--; |
20783 | return _res; |
20784 | } |
20785 | |
20786 | // invalid_lambda_parameters: |
20787 | // | lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default |
20788 | // | lambda_param_no_default* '(' ','.lambda_param+ ','? ')' |
20789 | // | "/" ',' |
20790 | // | (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/' |
20791 | // | [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/' |
20792 | // | lambda_param_maybe_default+ '/' '*' |
20793 | static void * |
20794 | invalid_lambda_parameters_rule(Parser *p) |
20795 | { |
20796 | if (p->level++ == MAXSTACK) { Branch (20796:9): [True: 0, False: 52]
|
20797 | p->error_indicator = 1; |
20798 | PyErr_NoMemory(); |
20799 | } |
20800 | if (p->error_indicator) { Branch (20800:9): [True: 0, False: 52]
|
20801 | p->level--; |
20802 | return NULL; |
20803 | } |
20804 | void * _res = NULL; |
20805 | int _mark = p->mark; |
20806 | { // lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default |
20807 | if (p->error_indicator) { |
20808 | p->level--; |
20809 | return NULL; |
20810 | } |
20811 | D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); |
20812 | asdl_seq * _loop0_176_var; |
20813 | arg_ty a; |
20814 | void *invalid_lambda_parameters_helper_var; |
20815 | if ( |
20816 | (_loop0_176_var = _loop0_176_rule(p)) // lambda_param_no_default* |
20817 | && |
20818 | (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper |
20819 | && |
20820 | (a = lambda_param_no_default_rule(p))7 // lambda_param_no_default |
20821 | ) |
20822 | { |
20823 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); |
20824 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" ); |
20825 | if (_res == NULL && PyErr_Occurred()) { |
20826 | p->error_indicator = 1; |
20827 | p->level--; |
20828 | return NULL; |
20829 | } |
20830 | goto done; |
20831 | } |
20832 | p->mark = _mark; |
20833 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20834 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); |
20835 | } |
20836 | { // lambda_param_no_default* '(' ','.lambda_param+ ','? ')' |
20837 | if (p->error_indicator) { |
20838 | p->level--; |
20839 | return NULL; |
20840 | } |
20841 | D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); |
20842 | asdl_seq * _gather_178_var; |
20843 | asdl_seq * _loop0_177_var; |
20844 | void *_opt_var; |
20845 | UNUSED(_opt_var); // Silence compiler warnings |
20846 | Token * a; |
20847 | Token * b; |
20848 | if ( |
20849 | (_loop0_177_var = _loop0_177_rule(p)) // lambda_param_no_default* |
20850 | && |
20851 | (a = _PyPegen_expect_token(p, 7)) // token='(' |
20852 | && |
20853 | (_gather_178_var = _gather_178_rule(p))5 // ','.lambda_param+ |
20854 | && |
20855 | (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)4 // ','? |
20856 | && |
20857 | (b = _PyPegen_expect_token(p, 8))4 // token=')' |
20858 | ) |
20859 | { |
20860 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); |
20861 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Lambda expression parameters cannot be parenthesized" ); |
20862 | if (_res == NULL && PyErr_Occurred()) { |
20863 | p->error_indicator = 1; |
20864 | p->level--; |
20865 | return NULL; |
20866 | } |
20867 | goto done; |
20868 | } |
20869 | p->mark = _mark; |
20870 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20871 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); |
20872 | } |
20873 | { // "/" ',' |
20874 | if (p->error_indicator) { |
20875 | p->level--; |
20876 | return NULL; |
20877 | } |
20878 | D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"/\" ','")); |
20879 | Token * _literal; |
20880 | Token * a; |
20881 | if ( |
20882 | (a = _PyPegen_expect_token(p, 17)) // token='/' |
20883 | && |
20884 | (_literal = _PyPegen_expect_token(p, 12))4 // token=',' |
20885 | ) |
20886 | { |
20887 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"/\" ','")); |
20888 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" ); |
20889 | if (_res == NULL && PyErr_Occurred()) { |
20890 | p->error_indicator = 1; |
20891 | p->level--; |
20892 | return NULL; |
20893 | } |
20894 | goto done; |
20895 | } |
20896 | p->mark = _mark; |
20897 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20898 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','")); |
20899 | } |
20900 | { // (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/' |
20901 | if (p->error_indicator) { |
20902 | p->level--; |
20903 | return NULL; |
20904 | } |
20905 | D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); |
20906 | asdl_seq * _loop0_181_var; |
20907 | void *_tmp_180_var; |
20908 | Token * a; |
20909 | if ( |
20910 | (_tmp_180_var = _tmp_180_rule(p)) // lambda_slash_no_default | lambda_slash_with_default Branch (20910:13): [True: 10, False: 30]
|
20911 | && |
20912 | (_loop0_181_var = _loop0_181_rule(p))10 // lambda_param_maybe_default* |
20913 | && |
20914 | (a = _PyPegen_expect_token(p, 17))10 // token='/' |
20915 | ) |
20916 | { |
20917 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); |
20918 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" ); |
20919 | if (_res == NULL && PyErr_Occurred()) { |
20920 | p->error_indicator = 1; |
20921 | p->level--; |
20922 | return NULL; |
20923 | } |
20924 | goto done; |
20925 | } |
20926 | p->mark = _mark; |
20927 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20928 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); |
20929 | } |
20930 | { // [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/' |
20931 | if (p->error_indicator) { |
20932 | p->level--; |
20933 | return NULL; |
20934 | } |
20935 | D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'")); |
20936 | Token * _literal; |
20937 | asdl_seq * _loop0_183_var; |
20938 | asdl_seq * _loop0_185_var; |
20939 | void *_opt_var; |
20940 | UNUSED(_opt_var); // Silence compiler warnings |
20941 | void *_tmp_184_var; |
20942 | Token * a; |
20943 | if ( |
20944 | (_opt_var = _tmp_182_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] |
20945 | && |
20946 | (_loop0_183_var = _loop0_183_rule(p)) // lambda_param_maybe_default* |
20947 | && |
20948 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (20948:13): [True: 17, False: 16]
|
20949 | && |
20950 | (_tmp_184_var = _tmp_184_rule(p))17 // ',' | lambda_param_no_default |
20951 | && |
20952 | (_loop0_185_var = _loop0_185_rule(p))15 // lambda_param_maybe_default* |
20953 | && |
20954 | (a = _PyPegen_expect_token(p, 17))15 // token='/' |
20955 | ) |
20956 | { |
20957 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'")); |
20958 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" ); |
20959 | if (_res == NULL && PyErr_Occurred()) { |
20960 | p->error_indicator = 1; |
20961 | p->level--; |
20962 | return NULL; |
20963 | } |
20964 | goto done; |
20965 | } |
20966 | p->mark = _mark; |
20967 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20968 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'")); |
20969 | } |
20970 | { // lambda_param_maybe_default+ '/' '*' |
20971 | if (p->error_indicator) { |
20972 | p->level--; |
20973 | return NULL; |
20974 | } |
20975 | D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default+ '/' '*'")); |
20976 | Token * _literal; |
20977 | asdl_seq * _loop1_186_var; |
20978 | Token * a; |
20979 | if ( |
20980 | (_loop1_186_var = _loop1_186_rule(p)) // lambda_param_maybe_default+ Branch (20980:13): [True: 16, False: 10]
|
20981 | && |
20982 | (_literal = _PyPegen_expect_token(p, 17))16 // token='/' |
20983 | && |
20984 | (a = _PyPegen_expect_token(p, 16))4 // token='*' |
20985 | ) |
20986 | { |
20987 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default+ '/' '*'")); |
20988 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" ); |
20989 | if (_res == NULL && PyErr_Occurred()) { |
20990 | p->error_indicator = 1; |
20991 | p->level--; |
20992 | return NULL; |
20993 | } |
20994 | goto done; |
20995 | } |
20996 | p->mark = _mark; |
20997 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', |
20998 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default+ '/' '*'")); |
20999 | } |
21000 | _res = NULL; |
21001 | done: |
21002 | p->level--; |
21003 | return _res; |
21004 | } |
21005 | |
21006 | // invalid_lambda_parameters_helper: |
21007 | // | lambda_slash_with_default |
21008 | // | lambda_param_with_default+ |
21009 | static void * |
21010 | invalid_lambda_parameters_helper_rule(Parser *p) |
21011 | { |
21012 | if (p->level++ == MAXSTACK) { Branch (21012:9): [True: 0, False: 52]
|
21013 | p->error_indicator = 1; |
21014 | PyErr_NoMemory(); |
21015 | } |
21016 | if (p->error_indicator) { Branch (21016:9): [True: 0, False: 52]
|
21017 | p->level--; |
21018 | return NULL; |
21019 | } |
21020 | void * _res = NULL; |
21021 | int _mark = p->mark; |
21022 | { // lambda_slash_with_default |
21023 | if (p->error_indicator) { |
21024 | p->level--; |
21025 | return NULL; |
21026 | } |
21027 | D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); |
21028 | SlashWithDefault* a; |
21029 | if ( |
21030 | (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default |
21031 | ) |
21032 | { |
21033 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); |
21034 | _res = _PyPegen_singleton_seq ( p , a ); |
21035 | if (_res == NULL && PyErr_Occurred()0 ) { |
21036 | p->error_indicator = 1; |
21037 | p->level--; |
21038 | return NULL; |
21039 | } |
21040 | goto done; |
21041 | } |
21042 | p->mark = _mark; |
21043 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', |
21044 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); |
21045 | } |
21046 | { // lambda_param_with_default+ |
21047 | if (p->error_indicator) { |
21048 | p->level--; |
21049 | return NULL; |
21050 | } |
21051 | D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); |
21052 | asdl_seq * _loop1_187_var; |
21053 | if ( |
21054 | (_loop1_187_var = _loop1_187_rule(p)) // lambda_param_with_default+ |
21055 | ) |
21056 | { |
21057 | D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); |
21058 | _res = _loop1_187_var; |
21059 | goto done; |
21060 | } |
21061 | p->mark = _mark; |
21062 | D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ', |
21063 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+")); |
21064 | } |
21065 | _res = NULL; |
21066 | done: |
21067 | p->level--; |
21068 | return _res; |
21069 | } |
21070 | |
21071 | // invalid_lambda_star_etc: |
21072 | // | '*' (':' | ',' (':' | '**')) |
21073 | // | '*' lambda_param '=' |
21074 | // | '*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',') |
21075 | static void * |
21076 | invalid_lambda_star_etc_rule(Parser *p) |
21077 | { |
21078 | if (p->level++ == MAXSTACK) { Branch (21078:9): [True: 0, False: 25]
|
21079 | p->error_indicator = 1; |
21080 | PyErr_NoMemory(); |
21081 | } |
21082 | if (p->error_indicator) { Branch (21082:9): [True: 0, False: 25]
|
21083 | p->level--; |
21084 | return NULL; |
21085 | } |
21086 | void * _res = NULL; |
21087 | int _mark = p->mark; |
21088 | { // '*' (':' | ',' (':' | '**')) |
21089 | if (p->error_indicator) { |
21090 | p->level--; |
21091 | return NULL; |
21092 | } |
21093 | D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); |
21094 | Token * _literal; |
21095 | void *_tmp_188_var; |
21096 | if ( |
21097 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' Branch (21097:13): [True: 10, False: 15]
|
21098 | && |
21099 | (_tmp_188_var = _tmp_188_rule(p))10 // ':' | ',' (':' | '**') |
21100 | ) |
21101 | { |
21102 | D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); |
21103 | _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); |
21104 | if (_res == NULL && PyErr_Occurred()) { |
21105 | p->error_indicator = 1; |
21106 | p->level--; |
21107 | return NULL; |
21108 | } |
21109 | goto done; |
21110 | } |
21111 | p->mark = _mark; |
21112 | D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
21113 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); |
21114 | } |
21115 | { // '*' lambda_param '=' |
21116 | if (p->error_indicator) { |
21117 | p->level--; |
21118 | return NULL; |
21119 | } |
21120 | D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_param '='")); |
21121 | Token * _literal; |
21122 | Token * a; |
21123 | arg_ty lambda_param_var; |
21124 | if ( |
21125 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' |
21126 | && |
21127 | (lambda_param_var = lambda_param_rule(p))9 // lambda_param |
21128 | && |
21129 | (a = _PyPegen_expect_token(p, 22))9 // token='=' |
21130 | ) |
21131 | { |
21132 | D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' lambda_param '='")); |
21133 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" ); |
21134 | if (_res == NULL && PyErr_Occurred()) { |
21135 | p->error_indicator = 1; |
21136 | p->level--; |
21137 | return NULL; |
21138 | } |
21139 | goto done; |
21140 | } |
21141 | p->mark = _mark; |
21142 | D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
21143 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param '='")); |
21144 | } |
21145 | { // '*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',') |
21146 | if (p->error_indicator) { |
21147 | p->level--; |
21148 | return NULL; |
21149 | } |
21150 | D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); |
21151 | Token * _literal; |
21152 | asdl_seq * _loop0_190_var; |
21153 | void *_tmp_189_var; |
21154 | void *_tmp_191_var; |
21155 | Token * a; |
21156 | if ( |
21157 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' |
21158 | && |
21159 | (_tmp_189_var = _tmp_189_rule(p))8 // lambda_param_no_default | ',' |
21160 | && |
21161 | (_loop0_190_var = _loop0_190_rule(p))8 // lambda_param_maybe_default* |
21162 | && |
21163 | (a = _PyPegen_expect_token(p, 16))8 // token='*' |
21164 | && |
21165 | (_tmp_191_var = _tmp_191_rule(p))4 // lambda_param_no_default | ',' |
21166 | ) |
21167 | { |
21168 | D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); |
21169 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" ); |
21170 | if (_res == NULL && PyErr_Occurred()) { |
21171 | p->error_indicator = 1; |
21172 | p->level--; |
21173 | return NULL; |
21174 | } |
21175 | goto done; |
21176 | } |
21177 | p->mark = _mark; |
21178 | D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', |
21179 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); |
21180 | } |
21181 | _res = NULL; |
21182 | done: |
21183 | p->level--; |
21184 | return _res; |
21185 | } |
21186 | |
21187 | // invalid_lambda_kwds: |
21188 | // | '**' lambda_param '=' |
21189 | // | '**' lambda_param ',' lambda_param |
21190 | // | '**' lambda_param ',' ('*' | '**' | '/') |
21191 | static void * |
21192 | invalid_lambda_kwds_rule(Parser *p) |
21193 | { |
21194 | if (p->level++ == MAXSTACK) { Branch (21194:9): [True: 0, False: 19]
|
21195 | p->error_indicator = 1; |
21196 | PyErr_NoMemory(); |
21197 | } |
21198 | if (p->error_indicator) { Branch (21198:9): [True: 0, False: 19]
|
21199 | p->level--; |
21200 | return NULL; |
21201 | } |
21202 | void * _res = NULL; |
21203 | int _mark = p->mark; |
21204 | { // '**' lambda_param '=' |
21205 | if (p->error_indicator) { |
21206 | p->level--; |
21207 | return NULL; |
21208 | } |
21209 | D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param '='")); |
21210 | Token * _literal; |
21211 | Token * a; |
21212 | arg_ty lambda_param_var; |
21213 | if ( |
21214 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
21215 | && |
21216 | (lambda_param_var = lambda_param_rule(p))7 // lambda_param |
21217 | && |
21218 | (a = _PyPegen_expect_token(p, 22))7 // token='=' |
21219 | ) |
21220 | { |
21221 | D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param '='")); |
21222 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" ); |
21223 | if (_res == NULL && PyErr_Occurred()) { |
21224 | p->error_indicator = 1; |
21225 | p->level--; |
21226 | return NULL; |
21227 | } |
21228 | goto done; |
21229 | } |
21230 | p->mark = _mark; |
21231 | D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
21232 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param '='")); |
21233 | } |
21234 | { // '**' lambda_param ',' lambda_param |
21235 | if (p->error_indicator) { |
21236 | p->level--; |
21237 | return NULL; |
21238 | } |
21239 | D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' lambda_param")); |
21240 | Token * _literal; |
21241 | Token * _literal_1; |
21242 | arg_ty a; |
21243 | arg_ty lambda_param_var; |
21244 | if ( |
21245 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
21246 | && |
21247 | (lambda_param_var = lambda_param_rule(p))6 // lambda_param |
21248 | && |
21249 | (_literal_1 = _PyPegen_expect_token(p, 12))6 // token=',' |
21250 | && |
21251 | (a = lambda_param_rule(p))6 // lambda_param |
21252 | ) |
21253 | { |
21254 | D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' lambda_param")); |
21255 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" ); |
21256 | if (_res == NULL && PyErr_Occurred()) { |
21257 | p->error_indicator = 1; |
21258 | p->level--; |
21259 | return NULL; |
21260 | } |
21261 | goto done; |
21262 | } |
21263 | p->mark = _mark; |
21264 | D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
21265 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param ',' lambda_param")); |
21266 | } |
21267 | { // '**' lambda_param ',' ('*' | '**' | '/') |
21268 | if (p->error_indicator) { |
21269 | p->level--; |
21270 | return NULL; |
21271 | } |
21272 | D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); |
21273 | Token * _literal; |
21274 | Token * _literal_1; |
21275 | Token* a; |
21276 | arg_ty lambda_param_var; |
21277 | if ( |
21278 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
21279 | && |
21280 | (lambda_param_var = lambda_param_rule(p))4 // lambda_param |
21281 | && |
21282 | (_literal_1 = _PyPegen_expect_token(p, 12))4 // token=',' |
21283 | && |
21284 | (a = (Token*)_tmp_192_rule(p))4 // '*' | '**' | '/' |
21285 | ) |
21286 | { |
21287 | D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); |
21288 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" ); |
21289 | if (_res == NULL && PyErr_Occurred()) { |
21290 | p->error_indicator = 1; |
21291 | p->level--; |
21292 | return NULL; |
21293 | } |
21294 | goto done; |
21295 | } |
21296 | p->mark = _mark; |
21297 | D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', |
21298 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); |
21299 | } |
21300 | _res = NULL; |
21301 | done: |
21302 | p->level--; |
21303 | return _res; |
21304 | } |
21305 | |
21306 | // invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT |
21307 | static void * |
21308 | invalid_double_type_comments_rule(Parser *p) |
21309 | { |
21310 | if (p->level++ == MAXSTACK) { Branch (21310:9): [True: 0, False: 62]
|
21311 | p->error_indicator = 1; |
21312 | PyErr_NoMemory(); |
21313 | } |
21314 | if (p->error_indicator) { Branch (21314:9): [True: 0, False: 62]
|
21315 | p->level--; |
21316 | return NULL; |
21317 | } |
21318 | void * _res = NULL; |
21319 | int _mark = p->mark; |
21320 | { // TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT |
21321 | if (p->error_indicator) { |
21322 | p->level--; |
21323 | return NULL; |
21324 | } |
21325 | D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT")); |
21326 | Token * indent_var; |
21327 | Token * newline_var; |
21328 | Token * newline_var_1; |
21329 | Token * type_comment_var; |
21330 | Token * type_comment_var_1; |
21331 | if ( |
21332 | (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' |
21333 | && |
21334 | (newline_var = _PyPegen_expect_token(p, 9 NEWLINE9 )) // token='NEWLINE' |
21335 | && |
21336 | (type_comment_var_1 = _PyPegen_expect_token(p, 9 TYPE_COMMENT9 )) // token='TYPE_COMMENT' |
21337 | && |
21338 | (newline_var_1 = _PyPegen_expect_token(p, 9 NEWLINE9 )) // token='NEWLINE' |
21339 | && |
21340 | (indent_var = _PyPegen_expect_token(p, 9 INDENT9 )) // token='INDENT' |
21341 | ) |
21342 | { |
21343 | D(fprintf(stderr, "%*c+ invalid_double_type_comments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT")); |
21344 | _res = RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" ); |
21345 | if (_res == NULL && PyErr_Occurred()) { |
21346 | p->error_indicator = 1; |
21347 | p->level--; |
21348 | return NULL; |
21349 | } |
21350 | goto done; |
21351 | } |
21352 | p->mark = _mark; |
21353 | D(fprintf(stderr, "%*c%s invalid_double_type_comments[%d-%d]: %s failed!\n", p->level, ' ', |
21354 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT")); |
21355 | } |
21356 | _res = NULL; |
21357 | done: |
21358 | p->level--; |
21359 | return _res; |
21360 | } |
21361 | |
21362 | // invalid_with_item: expression 'as' expression &(',' | ')' | ':') |
21363 | static void * |
21364 | invalid_with_item_rule(Parser *p) |
21365 | { |
21366 | if (p->level++ == MAXSTACK) { Branch (21366:9): [True: 0, False: 28]
|
21367 | p->error_indicator = 1; |
21368 | PyErr_NoMemory(); |
21369 | } |
21370 | if (p->error_indicator) { Branch (21370:9): [True: 0, False: 28]
|
21371 | p->level--; |
21372 | return NULL; |
21373 | } |
21374 | void * _res = NULL; |
21375 | int _mark = p->mark; |
21376 | { // expression 'as' expression &(',' | ')' | ':') |
21377 | if (p->error_indicator) { |
21378 | p->level--; |
21379 | return NULL; |
21380 | } |
21381 | D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')")); |
21382 | Token * _keyword; |
21383 | expr_ty a; |
21384 | expr_ty expression_var; |
21385 | if ( |
21386 | (expression_var = expression_rule(p)) // expression |
21387 | && |
21388 | (_keyword = _PyPegen_expect_token(p, 632))24 // token='as' Branch (21388:13): [True: 14, False: 10]
|
21389 | && |
21390 | (a = expression_rule(p))14 // expression |
21391 | && |
21392 | _PyPegen_lookahead(1, _tmp_193_rule, p)14 |
21393 | ) |
21394 | { |
21395 | D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')")); |
21396 | _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a ); |
21397 | if (_res == NULL && PyErr_Occurred()) { |
21398 | p->error_indicator = 1; |
21399 | p->level--; |
21400 | return NULL; |
21401 | } |
21402 | goto done; |
21403 | } |
21404 | p->mark = _mark; |
21405 | D(fprintf(stderr, "%*c%s invalid_with_item[%d-%d]: %s failed!\n", p->level, ' ', |
21406 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')")); |
21407 | } |
21408 | _res = NULL; |
21409 | done: |
21410 | p->level--; |
21411 | return _res; |
21412 | } |
21413 | |
21414 | // invalid_for_target: ASYNC? 'for' star_expressions |
21415 | static void * |
21416 | invalid_for_target_rule(Parser *p) |
21417 | { |
21418 | if (p->level++ == MAXSTACK) { Branch (21418:9): [True: 0, False: 529]
|
21419 | p->error_indicator = 1; |
21420 | PyErr_NoMemory(); |
21421 | } |
21422 | if (p->error_indicator) { Branch (21422:9): [True: 0, False: 529]
|
21423 | p->level--; |
21424 | return NULL; |
21425 | } |
21426 | void * _res = NULL; |
21427 | int _mark = p->mark; |
21428 | { // ASYNC? 'for' star_expressions |
21429 | if (p->error_indicator) { Branch (21429:13): [True: 0, False: 529]
|
21430 | p->level--; |
21431 | return NULL; |
21432 | } |
21433 | D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions")); |
21434 | Token * _keyword; |
21435 | void *_opt_var; |
21436 | UNUSED(_opt_var); // Silence compiler warnings |
21437 | expr_ty a; |
21438 | if ( |
21439 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? Branch (21439:13): [True: 529, False: 0]
|
21440 | && |
21441 | (_keyword = _PyPegen_expect_token(p, 642)) // token='for' Branch (21441:13): [True: 18, False: 511]
|
21442 | && |
21443 | (a = star_expressions_rule(p))18 // star_expressions |
21444 | ) |
21445 | { |
21446 | D(fprintf(stderr, "%*c+ invalid_for_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions")); |
21447 | _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a ); |
21448 | if (_res == NULL && PyErr_Occurred()) { |
21449 | p->error_indicator = 1; |
21450 | p->level--; |
21451 | return NULL; |
21452 | } |
21453 | goto done; |
21454 | } |
21455 | p->mark = _mark; |
21456 | D(fprintf(stderr, "%*c%s invalid_for_target[%d-%d]: %s failed!\n", p->level, ' ', |
21457 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_expressions")); |
21458 | } |
21459 | _res = NULL; |
21460 | done: |
21461 | p->level--; |
21462 | return _res; |
21463 | } |
21464 | |
21465 | // invalid_group: '(' starred_expression ')' | '(' '**' expression ')' |
21466 | static void * |
21467 | invalid_group_rule(Parser *p) |
21468 | { |
21469 | if (p->level++ == MAXSTACK) { Branch (21469:9): [True: 0, False: 50]
|
21470 | p->error_indicator = 1; |
21471 | PyErr_NoMemory(); |
21472 | } |
21473 | if (p->error_indicator) { Branch (21473:9): [True: 0, False: 50]
|
21474 | p->level--; |
21475 | return NULL; |
21476 | } |
21477 | void * _res = NULL; |
21478 | int _mark = p->mark; |
21479 | { // '(' starred_expression ')' |
21480 | if (p->error_indicator) { |
21481 | p->level--; |
21482 | return NULL; |
21483 | } |
21484 | D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'")); |
21485 | Token * _literal; |
21486 | Token * _literal_1; |
21487 | expr_ty a; |
21488 | if ( |
21489 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' |
21490 | && |
21491 | (a = starred_expression_rule(p)) // starred_expression Branch (21491:13): [True: 10, False: 40]
|
21492 | && |
21493 | (_literal_1 = _PyPegen_expect_token(p, 8))10 // token=')' |
21494 | ) |
21495 | { |
21496 | D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'")); |
21497 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use starred expression here" ); |
21498 | if (_res == NULL && PyErr_Occurred()) { |
21499 | p->error_indicator = 1; |
21500 | p->level--; |
21501 | return NULL; |
21502 | } |
21503 | goto done; |
21504 | } |
21505 | p->mark = _mark; |
21506 | D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ', |
21507 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' starred_expression ')'")); |
21508 | } |
21509 | { // '(' '**' expression ')' |
21510 | if (p->error_indicator) { |
21511 | p->level--; |
21512 | return NULL; |
21513 | } |
21514 | D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' '**' expression ')'")); |
21515 | Token * _literal; |
21516 | Token * _literal_1; |
21517 | Token * a; |
21518 | expr_ty expression_var; |
21519 | if ( |
21520 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' |
21521 | && |
21522 | (a = _PyPegen_expect_token(p, 35)) // token='**' |
21523 | && |
21524 | (expression_var = expression_rule(p))1 // expression |
21525 | && |
21526 | (_literal_1 = _PyPegen_expect_token(p, 8))1 // token=')' |
21527 | ) |
21528 | { |
21529 | D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' '**' expression ')'")); |
21530 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use double starred expression here" ); |
21531 | if (_res == NULL && PyErr_Occurred()) { |
21532 | p->error_indicator = 1; |
21533 | p->level--; |
21534 | return NULL; |
21535 | } |
21536 | goto done; |
21537 | } |
21538 | p->mark = _mark; |
21539 | D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ', |
21540 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression ')'")); |
21541 | } |
21542 | _res = NULL; |
21543 | done: |
21544 | p->level--; |
21545 | return _res; |
21546 | } |
21547 | |
21548 | // invalid_import_from_targets: import_from_as_names ',' NEWLINE |
21549 | static void * |
21550 | invalid_import_from_targets_rule(Parser *p) |
21551 | { |
21552 | if (p->level++ == MAXSTACK) { Branch (21552:9): [True: 0, False: 10]
|
21553 | p->error_indicator = 1; |
21554 | PyErr_NoMemory(); |
21555 | } |
21556 | if (p->error_indicator) { Branch (21556:9): [True: 0, False: 10]
|
21557 | p->level--; |
21558 | return NULL; |
21559 | } |
21560 | void * _res = NULL; |
21561 | int _mark = p->mark; |
21562 | { // import_from_as_names ',' NEWLINE |
21563 | if (p->error_indicator) { |
21564 | p->level--; |
21565 | return NULL; |
21566 | } |
21567 | D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE")); |
21568 | Token * _literal; |
21569 | asdl_alias_seq* import_from_as_names_var; |
21570 | Token * newline_var; |
21571 | if ( |
21572 | (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names |
21573 | && |
21574 | (_literal = _PyPegen_expect_token(p, 12))6 // token=',' |
21575 | && |
21576 | (newline_var = _PyPegen_expect_token(p, 6 NEWLINE6 )) // token='NEWLINE' |
21577 | ) |
21578 | { |
21579 | D(fprintf(stderr, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE")); |
21580 | _res = RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" ); |
21581 | if (_res == NULL && PyErr_Occurred()) { |
21582 | p->error_indicator = 1; |
21583 | p->level--; |
21584 | return NULL; |
21585 | } |
21586 | goto done; |
21587 | } |
21588 | p->mark = _mark; |
21589 | D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', |
21590 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names ',' NEWLINE")); |
21591 | } |
21592 | _res = NULL; |
21593 | done: |
21594 | p->level--; |
21595 | return _res; |
21596 | } |
21597 | |
21598 | // invalid_with_stmt: |
21599 | // | ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE |
21600 | // | ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE |
21601 | static void * |
21602 | invalid_with_stmt_rule(Parser *p) |
21603 | { |
21604 | if (p->level++ == MAXSTACK) { Branch (21604:9): [True: 0, False: 45]
|
21605 | p->error_indicator = 1; |
21606 | PyErr_NoMemory(); |
21607 | } |
21608 | if (p->error_indicator) { Branch (21608:9): [True: 0, False: 45]
|
21609 | p->level--; |
21610 | return NULL; |
21611 | } |
21612 | void * _res = NULL; |
21613 | int _mark = p->mark; |
21614 | { // ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE |
21615 | if (p->error_indicator) { |
21616 | p->level--; |
21617 | return NULL; |
21618 | } |
21619 | D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE")); |
21620 | asdl_seq * _gather_194_var; |
21621 | Token * _keyword; |
21622 | void *_opt_var; |
21623 | UNUSED(_opt_var); // Silence compiler warnings |
21624 | Token * newline_var; |
21625 | if ( |
21626 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? |
21627 | && |
21628 | (_keyword = _PyPegen_expect_token(p, 612)) // token='with' Branch (21628:13): [True: 11, False: 34]
|
21629 | && |
21630 | (_gather_194_var = _gather_194_rule(p))11 // ','.(expression ['as' star_target])+ |
21631 | && |
21632 | (newline_var = _PyPegen_expect_token(p, 7 NEWLINE7 )) // token='NEWLINE' |
21633 | ) |
21634 | { |
21635 | D(fprintf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE")); |
21636 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
21637 | if (_res == NULL && PyErr_Occurred()) { |
21638 | p->error_indicator = 1; |
21639 | p->level--; |
21640 | return NULL; |
21641 | } |
21642 | goto done; |
21643 | } |
21644 | p->mark = _mark; |
21645 | D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
21646 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE")); |
21647 | } |
21648 | { // ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE |
21649 | if (p->error_indicator) { |
21650 | p->level--; |
21651 | return NULL; |
21652 | } |
21653 | D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE")); |
21654 | asdl_seq * _gather_196_var; |
21655 | Token * _keyword; |
21656 | Token * _literal; |
21657 | Token * _literal_1; |
21658 | void *_opt_var; |
21659 | UNUSED(_opt_var); // Silence compiler warnings |
21660 | void *_opt_var_1; |
21661 | UNUSED(_opt_var_1); // Silence compiler warnings |
21662 | Token * newline_var; |
21663 | if ( |
21664 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? |
21665 | && |
21666 | (_keyword = _PyPegen_expect_token(p, 612)) // token='with' |
21667 | && |
21668 | (_literal = _PyPegen_expect_token(p, 7))5 // token='(' |
21669 | && |
21670 | (_gather_196_var = _gather_196_rule(p))3 // ','.(expressions ['as' star_target])+ |
21671 | && |
21672 | (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator)3 // ','? |
21673 | && |
21674 | (_literal_1 = _PyPegen_expect_token(p, 8))3 // token=')' |
21675 | && |
21676 | (newline_var = _PyPegen_expect_token(p, 3 NEWLINE3 )) // token='NEWLINE' |
21677 | ) |
21678 | { |
21679 | D(fprintf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE")); |
21680 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
21681 | if (_res == NULL && PyErr_Occurred()) { |
21682 | p->error_indicator = 1; |
21683 | p->level--; |
21684 | return NULL; |
21685 | } |
21686 | goto done; |
21687 | } |
21688 | p->mark = _mark; |
21689 | D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
21690 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE")); |
21691 | } |
21692 | _res = NULL; |
21693 | done: |
21694 | p->level--; |
21695 | return _res; |
21696 | } |
21697 | |
21698 | // invalid_with_stmt_indent: |
21699 | // | ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT |
21700 | // | ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT |
21701 | static void * |
21702 | invalid_with_stmt_indent_rule(Parser *p) |
21703 | { |
21704 | if (p->level++ == MAXSTACK) { Branch (21704:9): [True: 0, False: 63]
|
21705 | p->error_indicator = 1; |
21706 | PyErr_NoMemory(); |
21707 | } |
21708 | if (p->error_indicator) { Branch (21708:9): [True: 0, False: 63]
|
21709 | p->level--; |
21710 | return NULL; |
21711 | } |
21712 | void * _res = NULL; |
21713 | int _mark = p->mark; |
21714 | { // ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT |
21715 | if (p->error_indicator) { |
21716 | p->level--; |
21717 | return NULL; |
21718 | } |
21719 | D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); |
21720 | asdl_seq * _gather_198_var; |
21721 | Token * _literal; |
21722 | void *_opt_var; |
21723 | UNUSED(_opt_var); // Silence compiler warnings |
21724 | Token * a; |
21725 | Token * newline_var; |
21726 | if ( |
21727 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? |
21728 | && |
21729 | (a = _PyPegen_expect_token(p, 612)) // token='with' Branch (21729:13): [True: 29, False: 34]
|
21730 | && |
21731 | (_gather_198_var = _gather_198_rule(p))29 // ','.(expression ['as' star_target])+ |
21732 | && |
21733 | (_literal = _PyPegen_expect_token(p, 11))22 // token=':' |
21734 | && |
21735 | (newline_var = _PyPegen_expect_token(p, 4 NEWLINE4 )) // token='NEWLINE' |
21736 | && |
21737 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 4 INDENT4 ) // token=INDENT |
21738 | ) |
21739 | { |
21740 | D(fprintf(stderr, "%*c+ invalid_with_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); |
21741 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno ); |
21742 | if (_res == NULL && PyErr_Occurred()) { |
21743 | p->error_indicator = 1; |
21744 | p->level--; |
21745 | return NULL; |
21746 | } |
21747 | goto done; |
21748 | } |
21749 | p->mark = _mark; |
21750 | D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', |
21751 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); |
21752 | } |
21753 | { // ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT |
21754 | if (p->error_indicator) { |
21755 | p->level--; |
21756 | return NULL; |
21757 | } |
21758 | D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT")); |
21759 | asdl_seq * _gather_200_var; |
21760 | Token * _literal; |
21761 | Token * _literal_1; |
21762 | Token * _literal_2; |
21763 | void *_opt_var; |
21764 | UNUSED(_opt_var); // Silence compiler warnings |
21765 | void *_opt_var_1; |
21766 | UNUSED(_opt_var_1); // Silence compiler warnings |
21767 | Token * a; |
21768 | Token * newline_var; |
21769 | if ( |
21770 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? |
21771 | && |
21772 | (a = _PyPegen_expect_token(p, 612)) // token='with' Branch (21772:13): [True: 24, False: 34]
|
21773 | && |
21774 | (_literal = _PyPegen_expect_token(p, 7))24 // token='(' |
21775 | && |
21776 | (_gather_200_var = _gather_200_rule(p))6 // ','.(expressions ['as' star_target])+ |
21777 | && |
21778 | (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator)6 // ','? |
21779 | && |
21780 | (_literal_1 = _PyPegen_expect_token(p, 8))6 // token=')' |
21781 | && |
21782 | (_literal_2 = _PyPegen_expect_token(p, 11))6 // token=':' |
21783 | && |
21784 | (newline_var = _PyPegen_expect_token(p, 2 NEWLINE2 )) // token='NEWLINE' |
21785 | && |
21786 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 2 INDENT2 ) // token=INDENT |
21787 | ) |
21788 | { |
21789 | D(fprintf(stderr, "%*c+ invalid_with_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT")); |
21790 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno ); |
21791 | if (_res == NULL && PyErr_Occurred()) { |
21792 | p->error_indicator = 1; |
21793 | p->level--; |
21794 | return NULL; |
21795 | } |
21796 | goto done; |
21797 | } |
21798 | p->mark = _mark; |
21799 | D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', |
21800 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT")); |
21801 | } |
21802 | _res = NULL; |
21803 | done: |
21804 | p->level--; |
21805 | return _res; |
21806 | } |
21807 | |
21808 | // invalid_try_stmt: |
21809 | // | 'try' ':' NEWLINE !INDENT |
21810 | // | 'try' ':' block !('except' | 'finally') |
21811 | // | 'try' ':' block* ((except_block+ except_star_block) | (except_star_block+ except_block)) block* |
21812 | static void * |
21813 | invalid_try_stmt_rule(Parser *p) |
21814 | { |
21815 | if (p->level++ == MAXSTACK) { Branch (21815:9): [True: 0, False: 51]
|
21816 | p->error_indicator = 1; |
21817 | PyErr_NoMemory(); |
21818 | } |
21819 | if (p->error_indicator) { Branch (21819:9): [True: 0, False: 51]
|
21820 | p->level--; |
21821 | return NULL; |
21822 | } |
21823 | void * _res = NULL; |
21824 | int _mark = p->mark; |
21825 | { // 'try' ':' NEWLINE !INDENT |
21826 | if (p->error_indicator) { |
21827 | p->level--; |
21828 | return NULL; |
21829 | } |
21830 | D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' NEWLINE !INDENT")); |
21831 | Token * _literal; |
21832 | Token * a; |
21833 | Token * newline_var; |
21834 | if ( |
21835 | (a = _PyPegen_expect_token(p, 618)) // token='try' |
21836 | && |
21837 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
21838 | && |
21839 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (21839:13): [True: 34, False: 17]
|
21840 | && |
21841 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 34 INDENT34 ) // token=INDENT |
21842 | ) |
21843 | { |
21844 | D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' NEWLINE !INDENT")); |
21845 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'try' statement on line %d" , a -> lineno ); |
21846 | if (_res == NULL && PyErr_Occurred()) { |
21847 | p->error_indicator = 1; |
21848 | p->level--; |
21849 | return NULL; |
21850 | } |
21851 | goto done; |
21852 | } |
21853 | p->mark = _mark; |
21854 | D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
21855 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' NEWLINE !INDENT")); |
21856 | } |
21857 | { // 'try' ':' block !('except' | 'finally') |
21858 | if (p->error_indicator) { |
21859 | p->level--; |
21860 | return NULL; |
21861 | } |
21862 | D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); |
21863 | Token * _keyword; |
21864 | Token * _literal; |
21865 | asdl_stmt_seq* block_var; |
21866 | if ( |
21867 | (_keyword = _PyPegen_expect_token(p, 618)) // token='try' |
21868 | && |
21869 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
21870 | && |
21871 | (block_var = block_rule(p)) // block |
21872 | && |
21873 | _PyPegen_lookahead(0, _tmp_202_rule, p)41 |
21874 | ) |
21875 | { |
21876 | D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); |
21877 | _res = RAISE_SYNTAX_ERROR ( "expected 'except' or 'finally' block" ); |
21878 | if (_res == NULL && PyErr_Occurred()) { |
21879 | p->error_indicator = 1; |
21880 | p->level--; |
21881 | return NULL; |
21882 | } |
21883 | goto done; |
21884 | } |
21885 | p->mark = _mark; |
21886 | D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
21887 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block !('except' | 'finally')")); |
21888 | } |
21889 | { // 'try' ':' block* ((except_block+ except_star_block) | (except_star_block+ except_block)) block* |
21890 | if (p->error_indicator) { |
21891 | p->level--; |
21892 | return NULL; |
21893 | } |
21894 | D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block* ((except_block+ except_star_block) | (except_star_block+ except_block)) block*")); |
21895 | Token * _keyword; |
21896 | Token * _literal; |
21897 | asdl_seq * _loop0_203_var; |
21898 | asdl_seq * _loop0_205_var; |
21899 | void *_tmp_204_var; |
21900 | if ( |
21901 | (_keyword = _PyPegen_expect_token(p, 618)) // token='try' |
21902 | && |
21903 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
21904 | && |
21905 | (_loop0_203_var = _loop0_203_rule(p)) // block* |
21906 | && |
21907 | (_tmp_204_var = _tmp_204_rule(p)) // (except_block+ except_star_block) | (except_star_block+ except_block) Branch (21907:13): [True: 11, False: 38]
|
21908 | && |
21909 | (_loop0_205_var = _loop0_205_rule(p))11 // block* |
21910 | ) |
21911 | { |
21912 | D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block* ((except_block+ except_star_block) | (except_star_block+ except_block)) block*")); |
21913 | _res = RAISE_SYNTAX_ERROR ( "cannot have both 'except' and 'except*' on the same 'try'" ); |
21914 | if (_res == NULL && PyErr_Occurred()) { |
21915 | p->error_indicator = 1; |
21916 | p->level--; |
21917 | return NULL; |
21918 | } |
21919 | goto done; |
21920 | } |
21921 | p->mark = _mark; |
21922 | D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
21923 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block* ((except_block+ except_star_block) | (except_star_block+ except_block)) block*")); |
21924 | } |
21925 | _res = NULL; |
21926 | done: |
21927 | p->level--; |
21928 | return _res; |
21929 | } |
21930 | |
21931 | // invalid_except_stmt: |
21932 | // | 'except' '*'? expression ',' expressions ['as' NAME] ':' |
21933 | // | 'except' '*'? expression ['as' NAME] NEWLINE |
21934 | // | 'except' NEWLINE |
21935 | // | 'except' '*' (NEWLINE | ':') |
21936 | static void * |
21937 | invalid_except_stmt_rule(Parser *p) |
21938 | { |
21939 | if (p->level++ == MAXSTACK) { Branch (21939:9): [True: 0, False: 103]
|
21940 | p->error_indicator = 1; |
21941 | PyErr_NoMemory(); |
21942 | } |
21943 | if (p->error_indicator) { Branch (21943:9): [True: 0, False: 103]
|
21944 | p->level--; |
21945 | return NULL; |
21946 | } |
21947 | void * _res = NULL; |
21948 | int _mark = p->mark; |
21949 | { // 'except' '*'? expression ',' expressions ['as' NAME] ':' |
21950 | if (p->error_indicator) { Branch (21950:13): [True: 0, False: 103]
|
21951 | p->level--; |
21952 | return NULL; |
21953 | } |
21954 | D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ',' expressions ['as' NAME] ':'")); |
21955 | Token * _keyword; |
21956 | Token * _literal; |
21957 | Token * _literal_1; |
21958 | void *_opt_var; |
21959 | UNUSED(_opt_var); // Silence compiler warnings |
21960 | void *_opt_var_1; |
21961 | UNUSED(_opt_var_1); // Silence compiler warnings |
21962 | expr_ty a; |
21963 | expr_ty expressions_var; |
21964 | if ( |
21965 | (_keyword = _PyPegen_expect_token(p, 629)) // token='except' Branch (21965:13): [True: 43, False: 60]
|
21966 | && |
21967 | (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator)43 // '*'? |
21968 | && |
21969 | (a = expression_rule(p))43 // expression |
21970 | && |
21971 | (_literal = _PyPegen_expect_token(p, 12))37 // token=',' |
21972 | && |
21973 | (expressions_var = expressions_rule(p))8 // expressions |
21974 | && |
21975 | (_opt_var_1 = _tmp_206_rule(p), !p->error_indicator)8 // ['as' NAME] |
21976 | && |
21977 | (_literal_1 = _PyPegen_expect_token(p, 11))8 // token=':' |
21978 | ) |
21979 | { |
21980 | D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ',' expressions ['as' NAME] ':'")); |
21981 | _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "multiple exception types must be parenthesized" ); |
21982 | if (_res == NULL && PyErr_Occurred()) { |
21983 | p->error_indicator = 1; |
21984 | p->level--; |
21985 | return NULL; |
21986 | } |
21987 | goto done; |
21988 | } |
21989 | p->mark = _mark; |
21990 | D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
21991 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*'? expression ',' expressions ['as' NAME] ':'")); |
21992 | } |
21993 | { // 'except' '*'? expression ['as' NAME] NEWLINE |
21994 | if (p->error_indicator) { |
21995 | p->level--; |
21996 | return NULL; |
21997 | } |
21998 | D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE")); |
21999 | void *_opt_var; |
22000 | UNUSED(_opt_var); // Silence compiler warnings |
22001 | void *_opt_var_1; |
22002 | UNUSED(_opt_var_1); // Silence compiler warnings |
22003 | Token * a; |
22004 | expr_ty expression_var; |
22005 | Token * newline_var; |
22006 | if ( |
22007 | (a = _PyPegen_expect_token(p, 629)) // token='except' Branch (22007:13): [True: 35, False: 60]
|
22008 | && |
22009 | (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator)35 // '*'? |
22010 | && |
22011 | (expression_var = expression_rule(p))35 // expression |
22012 | && |
22013 | (_opt_var_1 = _tmp_207_rule(p), !p->error_indicator)29 // ['as' NAME] |
22014 | && |
22015 | (newline_var = _PyPegen_expect_token(p, 29 NEWLINE29 )) // token='NEWLINE' |
22016 | ) |
22017 | { |
22018 | D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE")); |
22019 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
22020 | if (_res == NULL && PyErr_Occurred()) { |
22021 | p->error_indicator = 1; |
22022 | p->level--; |
22023 | return NULL; |
22024 | } |
22025 | goto done; |
22026 | } |
22027 | p->mark = _mark; |
22028 | D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22029 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE")); |
22030 | } |
22031 | { // 'except' NEWLINE |
22032 | if (p->error_indicator) { |
22033 | p->level--; |
22034 | return NULL; |
22035 | } |
22036 | D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' NEWLINE")); |
22037 | Token * a; |
22038 | Token * newline_var; |
22039 | if ( |
22040 | (a = _PyPegen_expect_token(p, 629)) // token='except' Branch (22040:13): [True: 35, False: 60]
|
22041 | && |
22042 | (newline_var = _PyPegen_expect_token(p, 35 NEWLINE35 )) // token='NEWLINE' |
22043 | ) |
22044 | { |
22045 | D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' NEWLINE")); |
22046 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
22047 | if (_res == NULL && PyErr_Occurred()) { |
22048 | p->error_indicator = 1; |
22049 | p->level--; |
22050 | return NULL; |
22051 | } |
22052 | goto done; |
22053 | } |
22054 | p->mark = _mark; |
22055 | D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22056 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' NEWLINE")); |
22057 | } |
22058 | { // 'except' '*' (NEWLINE | ':') |
22059 | if (p->error_indicator) { |
22060 | p->level--; |
22061 | return NULL; |
22062 | } |
22063 | D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); |
22064 | Token * _literal; |
22065 | void *_tmp_208_var; |
22066 | Token * a; |
22067 | if ( |
22068 | (a = _PyPegen_expect_token(p, 629)) // token='except' Branch (22068:13): [True: 34, False: 60]
|
22069 | && |
22070 | (_literal = _PyPegen_expect_token(p, 16))34 // token='*' Branch (22070:13): [True: 23, False: 11]
|
22071 | && |
22072 | (_tmp_208_var = _tmp_208_rule(p))23 // NEWLINE | ':' |
22073 | ) |
22074 | { |
22075 | D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); |
22076 | _res = RAISE_SYNTAX_ERROR ( "expected one or more exception types" ); |
22077 | if (_res == NULL && PyErr_Occurred()) { |
22078 | p->error_indicator = 1; |
22079 | p->level--; |
22080 | return NULL; |
22081 | } |
22082 | goto done; |
22083 | } |
22084 | p->mark = _mark; |
22085 | D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22086 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' (NEWLINE | ':')")); |
22087 | } |
22088 | _res = NULL; |
22089 | done: |
22090 | p->level--; |
22091 | return _res; |
22092 | } |
22093 | |
22094 | // invalid_finally_stmt: 'finally' ':' NEWLINE !INDENT |
22095 | static void * |
22096 | invalid_finally_stmt_rule(Parser *p) |
22097 | { |
22098 | if (p->level++ == MAXSTACK) { Branch (22098:9): [True: 0, False: 15]
|
22099 | p->error_indicator = 1; |
22100 | PyErr_NoMemory(); |
22101 | } |
22102 | if (p->error_indicator) { Branch (22102:9): [True: 0, False: 15]
|
22103 | p->level--; |
22104 | return NULL; |
22105 | } |
22106 | void * _res = NULL; |
22107 | int _mark = p->mark; |
22108 | { // 'finally' ':' NEWLINE !INDENT |
22109 | if (p->error_indicator) { |
22110 | p->level--; |
22111 | return NULL; |
22112 | } |
22113 | D(fprintf(stderr, "%*c> invalid_finally_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' ':' NEWLINE !INDENT")); |
22114 | Token * _literal; |
22115 | Token * a; |
22116 | Token * newline_var; |
22117 | if ( |
22118 | (a = _PyPegen_expect_token(p, 625)) // token='finally' |
22119 | && |
22120 | (_literal = _PyPegen_expect_token(p, 11))11 // token=':' |
22121 | && |
22122 | (newline_var = _PyPegen_expect_token(p, 11 NEWLINE11 )) // token='NEWLINE' |
22123 | && |
22124 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 2 INDENT2 ) // token=INDENT |
22125 | ) |
22126 | { |
22127 | D(fprintf(stderr, "%*c+ invalid_finally_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' ':' NEWLINE !INDENT")); |
22128 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'finally' statement on line %d" , a -> lineno ); |
22129 | if (_res == NULL && PyErr_Occurred()) { |
22130 | p->error_indicator = 1; |
22131 | p->level--; |
22132 | return NULL; |
22133 | } |
22134 | goto done; |
22135 | } |
22136 | p->mark = _mark; |
22137 | D(fprintf(stderr, "%*c%s invalid_finally_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22138 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' ':' NEWLINE !INDENT")); |
22139 | } |
22140 | _res = NULL; |
22141 | done: |
22142 | p->level--; |
22143 | return _res; |
22144 | } |
22145 | |
22146 | // invalid_except_stmt_indent: |
22147 | // | 'except' expression ['as' NAME] ':' NEWLINE !INDENT |
22148 | // | 'except' ':' NEWLINE !INDENT |
22149 | static void * |
22150 | invalid_except_stmt_indent_rule(Parser *p) |
22151 | { |
22152 | if (p->level++ == MAXSTACK) { Branch (22152:9): [True: 0, False: 78]
|
22153 | p->error_indicator = 1; |
22154 | PyErr_NoMemory(); |
22155 | } |
22156 | if (p->error_indicator) { Branch (22156:9): [True: 0, False: 78]
|
22157 | p->level--; |
22158 | return NULL; |
22159 | } |
22160 | void * _res = NULL; |
22161 | int _mark = p->mark; |
22162 | { // 'except' expression ['as' NAME] ':' NEWLINE !INDENT |
22163 | if (p->error_indicator) { |
22164 | p->level--; |
22165 | return NULL; |
22166 | } |
22167 | D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE !INDENT")); |
22168 | Token * _literal; |
22169 | void *_opt_var; |
22170 | UNUSED(_opt_var); // Silence compiler warnings |
22171 | Token * a; |
22172 | expr_ty expression_var; |
22173 | Token * newline_var; |
22174 | if ( |
22175 | (a = _PyPegen_expect_token(p, 629)) // token='except' Branch (22175:13): [True: 48, False: 30]
|
22176 | && |
22177 | (expression_var = expression_rule(p))48 // expression Branch (22177:13): [True: 21, False: 27]
|
22178 | && |
22179 | (_opt_var = _tmp_209_rule(p), !p->error_indicator)21 // ['as' NAME] |
22180 | && |
22181 | (_literal = _PyPegen_expect_token(p, 11))21 // token=':' |
22182 | && |
22183 | (newline_var = _PyPegen_expect_token(p, 15 NEWLINE15 )) // token='NEWLINE' |
22184 | && |
22185 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 8 INDENT8 ) // token=INDENT |
22186 | ) |
22187 | { |
22188 | D(fprintf(stderr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE !INDENT")); |
22189 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno ); |
22190 | if (_res == NULL && PyErr_Occurred()) { |
22191 | p->error_indicator = 1; |
22192 | p->level--; |
22193 | return NULL; |
22194 | } |
22195 | goto done; |
22196 | } |
22197 | p->mark = _mark; |
22198 | D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', |
22199 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE !INDENT")); |
22200 | } |
22201 | { // 'except' ':' NEWLINE !INDENT |
22202 | if (p->error_indicator) { |
22203 | p->level--; |
22204 | return NULL; |
22205 | } |
22206 | D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' NEWLINE !INDENT")); |
22207 | Token * _literal; |
22208 | Token * a; |
22209 | Token * newline_var; |
22210 | if ( |
22211 | (a = _PyPegen_expect_token(p, 629)) // token='except' Branch (22211:13): [True: 47, False: 30]
|
22212 | && |
22213 | (_literal = _PyPegen_expect_token(p, 11))47 // token=':' |
22214 | && |
22215 | (newline_var = _PyPegen_expect_token(p, 2 NEWLINE2 )) // token='NEWLINE' |
22216 | && |
22217 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 1 INDENT1 ) // token=INDENT |
22218 | ) |
22219 | { |
22220 | D(fprintf(stderr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' NEWLINE !INDENT")); |
22221 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno ); |
22222 | if (_res == NULL && PyErr_Occurred()) { |
22223 | p->error_indicator = 1; |
22224 | p->level--; |
22225 | return NULL; |
22226 | } |
22227 | goto done; |
22228 | } |
22229 | p->mark = _mark; |
22230 | D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', |
22231 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' NEWLINE !INDENT")); |
22232 | } |
22233 | _res = NULL; |
22234 | done: |
22235 | p->level--; |
22236 | return _res; |
22237 | } |
22238 | |
22239 | // invalid_except_star_stmt_indent: |
22240 | // | 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT |
22241 | static void * |
22242 | invalid_except_star_stmt_indent_rule(Parser *p) |
22243 | { |
22244 | if (p->level++ == MAXSTACK) { Branch (22244:9): [True: 0, False: 58]
|
22245 | p->error_indicator = 1; |
22246 | PyErr_NoMemory(); |
22247 | } |
22248 | if (p->error_indicator) { Branch (22248:9): [True: 0, False: 58]
|
22249 | p->level--; |
22250 | return NULL; |
22251 | } |
22252 | void * _res = NULL; |
22253 | int _mark = p->mark; |
22254 | { // 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT |
22255 | if (p->error_indicator) { |
22256 | p->level--; |
22257 | return NULL; |
22258 | } |
22259 | D(fprintf(stderr, "%*c> invalid_except_star_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT")); |
22260 | Token * _literal; |
22261 | Token * _literal_1; |
22262 | void *_opt_var; |
22263 | UNUSED(_opt_var); // Silence compiler warnings |
22264 | Token * a; |
22265 | expr_ty expression_var; |
22266 | Token * newline_var; |
22267 | if ( |
22268 | (a = _PyPegen_expect_token(p, 629)) // token='except' Branch (22268:13): [True: 28, False: 30]
|
22269 | && |
22270 | (_literal = _PyPegen_expect_token(p, 16))28 // token='*' |
22271 | && |
22272 | (expression_var = expression_rule(p))19 // expression |
22273 | && |
22274 | (_opt_var = _tmp_210_rule(p), !p->error_indicator)18 // ['as' NAME] |
22275 | && |
22276 | (_literal_1 = _PyPegen_expect_token(p, 11))18 // token=':' |
22277 | && |
22278 | (newline_var = _PyPegen_expect_token(p, 16 NEWLINE16 )) // token='NEWLINE' |
22279 | && |
22280 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 9 INDENT9 ) // token=INDENT |
22281 | ) |
22282 | { |
22283 | D(fprintf(stderr, "%*c+ invalid_except_star_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT")); |
22284 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except*' statement on line %d" , a -> lineno ); |
22285 | if (_res == NULL && PyErr_Occurred()) { |
22286 | p->error_indicator = 1; |
22287 | p->level--; |
22288 | return NULL; |
22289 | } |
22290 | goto done; |
22291 | } |
22292 | p->mark = _mark; |
22293 | D(fprintf(stderr, "%*c%s invalid_except_star_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ', |
22294 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT")); |
22295 | } |
22296 | _res = NULL; |
22297 | done: |
22298 | p->level--; |
22299 | return _res; |
22300 | } |
22301 | |
22302 | // invalid_match_stmt: |
22303 | // | "match" subject_expr NEWLINE |
22304 | // | "match" subject_expr ':' NEWLINE !INDENT |
22305 | static void * |
22306 | invalid_match_stmt_rule(Parser *p) |
22307 | { |
22308 | if (p->level++ == MAXSTACK) { Branch (22308:9): [True: 0, False: 815]
|
22309 | p->error_indicator = 1; |
22310 | PyErr_NoMemory(); |
22311 | } |
22312 | if (p->error_indicator) { Branch (22312:9): [True: 0, False: 815]
|
22313 | p->level--; |
22314 | return NULL; |
22315 | } |
22316 | void * _res = NULL; |
22317 | int _mark = p->mark; |
22318 | { // "match" subject_expr NEWLINE |
22319 | if (p->error_indicator) { Branch (22319:13): [True: 0, False: 815]
|
22320 | p->level--; |
22321 | return NULL; |
22322 | } |
22323 | D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr NEWLINE")); |
22324 | expr_ty _keyword; |
22325 | Token * newline_var; |
22326 | expr_ty subject_expr_var; |
22327 | if ( |
22328 | (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' Branch (22328:13): [True: 12, False: 803]
|
22329 | && |
22330 | (subject_expr_var = subject_expr_rule(p))12 // subject_expr |
22331 | && |
22332 | (newline_var = _PyPegen_expect_token(p, 12 NEWLINE12 )) // token='NEWLINE' |
22333 | ) |
22334 | { |
22335 | D(fprintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr NEWLINE")); |
22336 | _res = CHECK_VERSION ( void* , 10 , "Pattern matching is" , RAISE_SYNTAX_ERROR ( "expected ':'" ) ); |
22337 | if (_res == NULL && PyErr_Occurred()) { |
22338 | p->error_indicator = 1; |
22339 | p->level--; |
22340 | return NULL; |
22341 | } |
22342 | goto done; |
22343 | } |
22344 | p->mark = _mark; |
22345 | D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22346 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr NEWLINE")); |
22347 | } |
22348 | { // "match" subject_expr ':' NEWLINE !INDENT |
22349 | if (p->error_indicator) { Branch (22349:13): [True: 0, False: 814]
|
22350 | p->level--; |
22351 | return NULL; |
22352 | } |
22353 | D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT")); |
22354 | Token * _literal; |
22355 | expr_ty a; |
22356 | Token * newline_var; |
22357 | expr_ty subject; |
22358 | if ( |
22359 | (a = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"' Branch (22359:13): [True: 11, False: 803]
|
22360 | && |
22361 | (subject = subject_expr_rule(p))11 // subject_expr |
22362 | && |
22363 | (_literal = _PyPegen_expect_token(p, 11))11 // token=':' |
22364 | && |
22365 | (newline_var = _PyPegen_expect_token(p, 10 NEWLINE10 )) // token='NEWLINE' |
22366 | && |
22367 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 10 INDENT10 ) // token=INDENT |
22368 | ) |
22369 | { |
22370 | D(fprintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT")); |
22371 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'match' statement on line %d" , a -> lineno ); |
22372 | if (_res == NULL && PyErr_Occurred()) { |
22373 | p->error_indicator = 1; |
22374 | p->level--; |
22375 | return NULL; |
22376 | } |
22377 | goto done; |
22378 | } |
22379 | p->mark = _mark; |
22380 | D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22381 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT")); |
22382 | } |
22383 | _res = NULL; |
22384 | done: |
22385 | p->level--; |
22386 | return _res; |
22387 | } |
22388 | |
22389 | // invalid_case_block: |
22390 | // | "case" patterns guard? NEWLINE |
22391 | // | "case" patterns guard? ':' NEWLINE !INDENT |
22392 | static void * |
22393 | invalid_case_block_rule(Parser *p) |
22394 | { |
22395 | if (p->level++ == MAXSTACK) { Branch (22395:9): [True: 0, False: 21]
|
22396 | p->error_indicator = 1; |
22397 | PyErr_NoMemory(); |
22398 | } |
22399 | if (p->error_indicator) { Branch (22399:9): [True: 0, False: 21]
|
22400 | p->level--; |
22401 | return NULL; |
22402 | } |
22403 | void * _res = NULL; |
22404 | int _mark = p->mark; |
22405 | { // "case" patterns guard? NEWLINE |
22406 | if (p->error_indicator) { |
22407 | p->level--; |
22408 | return NULL; |
22409 | } |
22410 | D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? NEWLINE")); |
22411 | expr_ty _keyword; |
22412 | void *_opt_var; |
22413 | UNUSED(_opt_var); // Silence compiler warnings |
22414 | Token * newline_var; |
22415 | pattern_ty patterns_var; |
22416 | if ( |
22417 | (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' |
22418 | && |
22419 | (patterns_var = patterns_rule(p))20 // patterns |
22420 | && |
22421 | (_opt_var = guard_rule(p), !p->error_indicator)6 // guard? |
22422 | && |
22423 | (newline_var = _PyPegen_expect_token(p, 6 NEWLINE6 )) // token='NEWLINE' |
22424 | ) |
22425 | { |
22426 | D(fprintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? NEWLINE")); |
22427 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
22428 | if (_res == NULL && PyErr_Occurred()) { |
22429 | p->error_indicator = 1; |
22430 | p->level--; |
22431 | return NULL; |
22432 | } |
22433 | goto done; |
22434 | } |
22435 | p->mark = _mark; |
22436 | D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ', |
22437 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? NEWLINE")); |
22438 | } |
22439 | { // "case" patterns guard? ':' NEWLINE !INDENT |
22440 | if (p->error_indicator) { |
22441 | p->level--; |
22442 | return NULL; |
22443 | } |
22444 | D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT")); |
22445 | Token * _literal; |
22446 | void *_opt_var; |
22447 | UNUSED(_opt_var); // Silence compiler warnings |
22448 | expr_ty a; |
22449 | Token * newline_var; |
22450 | pattern_ty patterns_var; |
22451 | if ( |
22452 | (a = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"' |
22453 | && |
22454 | (patterns_var = patterns_rule(p))11 // patterns |
22455 | && |
22456 | (_opt_var = guard_rule(p), !p->error_indicator)4 // guard? |
22457 | && |
22458 | (_literal = _PyPegen_expect_token(p, 11))4 // token=':' |
22459 | && |
22460 | (newline_var = _PyPegen_expect_token(p, 4 NEWLINE4 )) // token='NEWLINE' |
22461 | && |
22462 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 4 INDENT4 ) // token=INDENT |
22463 | ) |
22464 | { |
22465 | D(fprintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT")); |
22466 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'case' statement on line %d" , a -> lineno ); |
22467 | if (_res == NULL && PyErr_Occurred()) { |
22468 | p->error_indicator = 1; |
22469 | p->level--; |
22470 | return NULL; |
22471 | } |
22472 | goto done; |
22473 | } |
22474 | p->mark = _mark; |
22475 | D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ', |
22476 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT")); |
22477 | } |
22478 | _res = NULL; |
22479 | done: |
22480 | p->level--; |
22481 | return _res; |
22482 | } |
22483 | |
22484 | // invalid_as_pattern: or_pattern 'as' "_" | or_pattern 'as' !NAME expression |
22485 | static void * |
22486 | invalid_as_pattern_rule(Parser *p) |
22487 | { |
22488 | if (p->level++ == MAXSTACK) { Branch (22488:9): [True: 0, False: 107]
|
22489 | p->error_indicator = 1; |
22490 | PyErr_NoMemory(); |
22491 | } |
22492 | if (p->error_indicator) { Branch (22492:9): [True: 0, False: 107]
|
22493 | p->level--; |
22494 | return NULL; |
22495 | } |
22496 | void * _res = NULL; |
22497 | int _mark = p->mark; |
22498 | { // or_pattern 'as' "_" |
22499 | if (p->error_indicator) { Branch (22499:13): [True: 0, False: 107]
|
22500 | p->level--; |
22501 | return NULL; |
22502 | } |
22503 | D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' \"_\"")); |
22504 | Token * _keyword; |
22505 | expr_ty a; |
22506 | pattern_ty or_pattern_var; |
22507 | if ( |
22508 | (or_pattern_var = or_pattern_rule(p)) // or_pattern Branch (22508:13): [True: 49, False: 58]
|
22509 | && |
22510 | (_keyword = _PyPegen_expect_token(p, 632))49 // token='as' |
22511 | && |
22512 | (a = _PyPegen_expect_soft_keyword(p, "_"))3 // soft_keyword='"_"' |
22513 | ) |
22514 | { |
22515 | D(fprintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' \"_\"")); |
22516 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use '_' as a target" ); |
22517 | if (_res == NULL && PyErr_Occurred()) { |
22518 | p->error_indicator = 1; |
22519 | p->level--; |
22520 | return NULL; |
22521 | } |
22522 | goto done; |
22523 | } |
22524 | p->mark = _mark; |
22525 | D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
22526 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' \"_\"")); |
22527 | } |
22528 | { // or_pattern 'as' !NAME expression |
22529 | if (p->error_indicator) { Branch (22529:13): [True: 0, False: 105]
|
22530 | p->level--; |
22531 | return NULL; |
22532 | } |
22533 | D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' !NAME expression")); |
22534 | Token * _keyword; |
22535 | expr_ty a; |
22536 | pattern_ty or_pattern_var; |
22537 | if ( |
22538 | (or_pattern_var = or_pattern_rule(p)) // or_pattern Branch (22538:13): [True: 47, False: 58]
|
22539 | && |
22540 | (_keyword = _PyPegen_expect_token(p, 632))47 // token='as' |
22541 | && |
22542 | _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p)1 |
22543 | && |
22544 | (a = expression_rule(p))1 // expression |
22545 | ) |
22546 | { |
22547 | D(fprintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' !NAME expression")); |
22548 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid pattern target" ); |
22549 | if (_res == NULL && PyErr_Occurred()) { |
22550 | p->error_indicator = 1; |
22551 | p->level--; |
22552 | return NULL; |
22553 | } |
22554 | goto done; |
22555 | } |
22556 | p->mark = _mark; |
22557 | D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
22558 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' !NAME expression")); |
22559 | } |
22560 | _res = NULL; |
22561 | done: |
22562 | p->level--; |
22563 | return _res; |
22564 | } |
22565 | |
22566 | // invalid_class_pattern: name_or_attr '(' invalid_class_argument_pattern |
22567 | static void * |
22568 | invalid_class_pattern_rule(Parser *p) |
22569 | { |
22570 | if (p->level++ == MAXSTACK) { Branch (22570:9): [True: 0, False: 19]
|
22571 | p->error_indicator = 1; |
22572 | PyErr_NoMemory(); |
22573 | } |
22574 | if (p->error_indicator) { Branch (22574:9): [True: 0, False: 19]
|
22575 | p->level--; |
22576 | return NULL; |
22577 | } |
22578 | void * _res = NULL; |
22579 | int _mark = p->mark; |
22580 | { // name_or_attr '(' invalid_class_argument_pattern |
22581 | if (p->error_indicator) { |
22582 | p->level--; |
22583 | return NULL; |
22584 | } |
22585 | D(fprintf(stderr, "%*c> invalid_class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' invalid_class_argument_pattern")); |
22586 | Token * _literal; |
22587 | asdl_pattern_seq* a; |
22588 | expr_ty name_or_attr_var; |
22589 | if ( |
22590 | (name_or_attr_var = name_or_attr_rule(p)) // name_or_attr |
22591 | && |
22592 | (_literal = _PyPegen_expect_token(p, 7))10 // token='(' |
22593 | && |
22594 | (a = invalid_class_argument_pattern_rule(p))4 // invalid_class_argument_pattern |
22595 | ) |
22596 | { |
22597 | D(fprintf(stderr, "%*c+ invalid_class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' invalid_class_argument_pattern")); |
22598 | _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( PyPegen_first_item ( a , pattern_ty ) , PyPegen_last_item ( a , pattern_ty ) , "positional patterns follow keyword patterns" ); |
22599 | if (_res == NULL && PyErr_Occurred()) { |
22600 | p->error_indicator = 1; |
22601 | p->level--; |
22602 | return NULL; |
22603 | } |
22604 | goto done; |
22605 | } |
22606 | p->mark = _mark; |
22607 | D(fprintf(stderr, "%*c%s invalid_class_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
22608 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' invalid_class_argument_pattern")); |
22609 | } |
22610 | _res = NULL; |
22611 | done: |
22612 | p->level--; |
22613 | return _res; |
22614 | } |
22615 | |
22616 | // invalid_class_argument_pattern: |
22617 | // | [positional_patterns ','] keyword_patterns ',' positional_patterns |
22618 | static asdl_pattern_seq* |
22619 | invalid_class_argument_pattern_rule(Parser *p) |
22620 | { |
22621 | if (p->level++ == MAXSTACK) { Branch (22621:9): [True: 0, False: 4]
|
22622 | p->error_indicator = 1; |
22623 | PyErr_NoMemory(); |
22624 | } |
22625 | if (p->error_indicator) { Branch (22625:9): [True: 0, False: 4]
|
22626 | p->level--; |
22627 | return NULL; |
22628 | } |
22629 | asdl_pattern_seq* _res = NULL; |
22630 | int _mark = p->mark; |
22631 | { // [positional_patterns ','] keyword_patterns ',' positional_patterns |
22632 | if (p->error_indicator) { |
22633 | p->level--; |
22634 | return NULL; |
22635 | } |
22636 | D(fprintf(stderr, "%*c> invalid_class_argument_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[positional_patterns ','] keyword_patterns ',' positional_patterns")); |
22637 | Token * _literal; |
22638 | void *_opt_var; |
22639 | UNUSED(_opt_var); // Silence compiler warnings |
22640 | asdl_pattern_seq* a; |
22641 | asdl_seq* keyword_patterns_var; |
22642 | if ( |
22643 | (_opt_var = _tmp_211_rule(p), !p->error_indicator) // [positional_patterns ','] |
22644 | && |
22645 | (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns |
22646 | && |
22647 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
22648 | && |
22649 | (a = positional_patterns_rule(p)) // positional_patterns |
22650 | ) |
22651 | { |
22652 | D(fprintf(stderr, "%*c+ invalid_class_argument_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[positional_patterns ','] keyword_patterns ',' positional_patterns")); |
22653 | _res = a; |
22654 | if (_res == NULL && PyErr_Occurred()0 ) { |
22655 | p->error_indicator = 1; |
22656 | p->level--; |
22657 | return NULL; |
22658 | } |
22659 | goto done; |
22660 | } |
22661 | p->mark = _mark; |
22662 | D(fprintf(stderr, "%*c%s invalid_class_argument_pattern[%d-%d]: %s failed!\n", p->level, ' ', |
22663 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[positional_patterns ','] keyword_patterns ',' positional_patterns")); |
22664 | } |
22665 | _res = NULL; |
22666 | done: |
22667 | p->level--; |
22668 | return _res; |
22669 | } |
22670 | |
22671 | // invalid_if_stmt: |
22672 | // | 'if' named_expression NEWLINE |
22673 | // | 'if' named_expression ':' NEWLINE !INDENT |
22674 | static void * |
22675 | invalid_if_stmt_rule(Parser *p) |
22676 | { |
22677 | if (p->level++ == MAXSTACK) { Branch (22677:9): [True: 0, False: 37]
|
22678 | p->error_indicator = 1; |
22679 | PyErr_NoMemory(); |
22680 | } |
22681 | if (p->error_indicator) { Branch (22681:9): [True: 0, False: 37]
|
22682 | p->level--; |
22683 | return NULL; |
22684 | } |
22685 | void * _res = NULL; |
22686 | int _mark = p->mark; |
22687 | { // 'if' named_expression NEWLINE |
22688 | if (p->error_indicator) { |
22689 | p->level--; |
22690 | return NULL; |
22691 | } |
22692 | D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression NEWLINE")); |
22693 | Token * _keyword; |
22694 | expr_ty named_expression_var; |
22695 | Token * newline_var; |
22696 | if ( |
22697 | (_keyword = _PyPegen_expect_token(p, 634)) // token='if' |
22698 | && |
22699 | (named_expression_var = named_expression_rule(p)) // named_expression |
22700 | && |
22701 | (newline_var = _PyPegen_expect_token(p, 32 NEWLINE32 )) // token='NEWLINE' |
22702 | ) |
22703 | { |
22704 | D(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression NEWLINE")); |
22705 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
22706 | if (_res == NULL && PyErr_Occurred()) { |
22707 | p->error_indicator = 1; |
22708 | p->level--; |
22709 | return NULL; |
22710 | } |
22711 | goto done; |
22712 | } |
22713 | p->mark = _mark; |
22714 | D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22715 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression NEWLINE")); |
22716 | } |
22717 | { // 'if' named_expression ':' NEWLINE !INDENT |
22718 | if (p->error_indicator) { |
22719 | p->level--; |
22720 | return NULL; |
22721 | } |
22722 | D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT")); |
22723 | Token * _literal; |
22724 | Token * a; |
22725 | expr_ty a_1; |
22726 | Token * newline_var; |
22727 | if ( |
22728 | (a = _PyPegen_expect_token(p, 634)) // token='if' |
22729 | && |
22730 | (a_1 = named_expression_rule(p)) // named_expression |
22731 | && |
22732 | (_literal = _PyPegen_expect_token(p, 11))31 // token=':' |
22733 | && |
22734 | (newline_var = _PyPegen_expect_token(p, 31 NEWLINE31 )) // token='NEWLINE' |
22735 | && |
22736 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 23 INDENT23 ) // token=INDENT |
22737 | ) |
22738 | { |
22739 | D(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT")); |
22740 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'if' statement on line %d" , a -> lineno ); |
22741 | if (_res == NULL && PyErr_Occurred()) { |
22742 | p->error_indicator = 1; |
22743 | p->level--; |
22744 | return NULL; |
22745 | } |
22746 | goto done; |
22747 | } |
22748 | p->mark = _mark; |
22749 | D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22750 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT")); |
22751 | } |
22752 | _res = NULL; |
22753 | done: |
22754 | p->level--; |
22755 | return _res; |
22756 | } |
22757 | |
22758 | // invalid_elif_stmt: |
22759 | // | 'elif' named_expression NEWLINE |
22760 | // | 'elif' named_expression ':' NEWLINE !INDENT |
22761 | static void * |
22762 | invalid_elif_stmt_rule(Parser *p) |
22763 | { |
22764 | if (p->level++ == MAXSTACK) { Branch (22764:9): [True: 0, False: 8]
|
22765 | p->error_indicator = 1; |
22766 | PyErr_NoMemory(); |
22767 | } |
22768 | if (p->error_indicator) { Branch (22768:9): [True: 0, False: 8]
|
22769 | p->level--; |
22770 | return NULL; |
22771 | } |
22772 | void * _res = NULL; |
22773 | int _mark = p->mark; |
22774 | { // 'elif' named_expression NEWLINE |
22775 | if (p->error_indicator) { |
22776 | p->level--; |
22777 | return NULL; |
22778 | } |
22779 | D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression NEWLINE")); |
22780 | Token * _keyword; |
22781 | expr_ty named_expression_var; |
22782 | Token * newline_var; |
22783 | if ( |
22784 | (_keyword = _PyPegen_expect_token(p, 636)) // token='elif' |
22785 | && |
22786 | (named_expression_var = named_expression_rule(p))6 // named_expression |
22787 | && |
22788 | (newline_var = _PyPegen_expect_token(p, 6 NEWLINE6 )) // token='NEWLINE' |
22789 | ) |
22790 | { |
22791 | D(fprintf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression NEWLINE")); |
22792 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
22793 | if (_res == NULL && PyErr_Occurred()) { |
22794 | p->error_indicator = 1; |
22795 | p->level--; |
22796 | return NULL; |
22797 | } |
22798 | goto done; |
22799 | } |
22800 | p->mark = _mark; |
22801 | D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22802 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression NEWLINE")); |
22803 | } |
22804 | { // 'elif' named_expression ':' NEWLINE !INDENT |
22805 | if (p->error_indicator) { |
22806 | p->level--; |
22807 | return NULL; |
22808 | } |
22809 | D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT")); |
22810 | Token * _literal; |
22811 | Token * a; |
22812 | expr_ty named_expression_var; |
22813 | Token * newline_var; |
22814 | if ( |
22815 | (a = _PyPegen_expect_token(p, 636)) // token='elif' |
22816 | && |
22817 | (named_expression_var = named_expression_rule(p))5 // named_expression |
22818 | && |
22819 | (_literal = _PyPegen_expect_token(p, 11))5 // token=':' |
22820 | && |
22821 | (newline_var = _PyPegen_expect_token(p, 5 NEWLINE5 )) // token='NEWLINE' |
22822 | && |
22823 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 5 INDENT5 ) // token=INDENT |
22824 | ) |
22825 | { |
22826 | D(fprintf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT")); |
22827 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'elif' statement on line %d" , a -> lineno ); |
22828 | if (_res == NULL && PyErr_Occurred()) { |
22829 | p->error_indicator = 1; |
22830 | p->level--; |
22831 | return NULL; |
22832 | } |
22833 | goto done; |
22834 | } |
22835 | p->mark = _mark; |
22836 | D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22837 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT")); |
22838 | } |
22839 | _res = NULL; |
22840 | done: |
22841 | p->level--; |
22842 | return _res; |
22843 | } |
22844 | |
22845 | // invalid_else_stmt: 'else' ':' NEWLINE !INDENT |
22846 | static void * |
22847 | invalid_else_stmt_rule(Parser *p) |
22848 | { |
22849 | if (p->level++ == MAXSTACK) { Branch (22849:9): [True: 0, False: 6]
|
22850 | p->error_indicator = 1; |
22851 | PyErr_NoMemory(); |
22852 | } |
22853 | if (p->error_indicator) { Branch (22853:9): [True: 0, False: 6]
|
22854 | p->level--; |
22855 | return NULL; |
22856 | } |
22857 | void * _res = NULL; |
22858 | int _mark = p->mark; |
22859 | { // 'else' ':' NEWLINE !INDENT |
22860 | if (p->error_indicator) { |
22861 | p->level--; |
22862 | return NULL; |
22863 | } |
22864 | D(fprintf(stderr, "%*c> invalid_else_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':' NEWLINE !INDENT")); |
22865 | Token * _literal; |
22866 | Token * a; |
22867 | Token * newline_var; |
22868 | if ( |
22869 | (a = _PyPegen_expect_token(p, 637)) // token='else' |
22870 | && |
22871 | (_literal = _PyPegen_expect_token(p, 11))4 // token=':' |
22872 | && |
22873 | (newline_var = _PyPegen_expect_token(p, 4 NEWLINE4 )) // token='NEWLINE' |
22874 | && |
22875 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 4 INDENT4 ) // token=INDENT |
22876 | ) |
22877 | { |
22878 | D(fprintf(stderr, "%*c+ invalid_else_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' ':' NEWLINE !INDENT")); |
22879 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'else' statement on line %d" , a -> lineno ); |
22880 | if (_res == NULL && PyErr_Occurred()) { |
22881 | p->error_indicator = 1; |
22882 | p->level--; |
22883 | return NULL; |
22884 | } |
22885 | goto done; |
22886 | } |
22887 | p->mark = _mark; |
22888 | D(fprintf(stderr, "%*c%s invalid_else_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22889 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' ':' NEWLINE !INDENT")); |
22890 | } |
22891 | _res = NULL; |
22892 | done: |
22893 | p->level--; |
22894 | return _res; |
22895 | } |
22896 | |
22897 | // invalid_while_stmt: |
22898 | // | 'while' named_expression NEWLINE |
22899 | // | 'while' named_expression ':' NEWLINE !INDENT |
22900 | static void * |
22901 | invalid_while_stmt_rule(Parser *p) |
22902 | { |
22903 | if (p->level++ == MAXSTACK) { Branch (22903:9): [True: 0, False: 23]
|
22904 | p->error_indicator = 1; |
22905 | PyErr_NoMemory(); |
22906 | } |
22907 | if (p->error_indicator) { Branch (22907:9): [True: 0, False: 23]
|
22908 | p->level--; |
22909 | return NULL; |
22910 | } |
22911 | void * _res = NULL; |
22912 | int _mark = p->mark; |
22913 | { // 'while' named_expression NEWLINE |
22914 | if (p->error_indicator) { |
22915 | p->level--; |
22916 | return NULL; |
22917 | } |
22918 | D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression NEWLINE")); |
22919 | Token * _keyword; |
22920 | expr_ty named_expression_var; |
22921 | Token * newline_var; |
22922 | if ( |
22923 | (_keyword = _PyPegen_expect_token(p, 639)) // token='while' |
22924 | && |
22925 | (named_expression_var = named_expression_rule(p)) // named_expression |
22926 | && |
22927 | (newline_var = _PyPegen_expect_token(p, 20 NEWLINE20 )) // token='NEWLINE' |
22928 | ) |
22929 | { |
22930 | D(fprintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression NEWLINE")); |
22931 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
22932 | if (_res == NULL && PyErr_Occurred()) { |
22933 | p->error_indicator = 1; |
22934 | p->level--; |
22935 | return NULL; |
22936 | } |
22937 | goto done; |
22938 | } |
22939 | p->mark = _mark; |
22940 | D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22941 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression NEWLINE")); |
22942 | } |
22943 | { // 'while' named_expression ':' NEWLINE !INDENT |
22944 | if (p->error_indicator) { |
22945 | p->level--; |
22946 | return NULL; |
22947 | } |
22948 | D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT")); |
22949 | Token * _literal; |
22950 | Token * a; |
22951 | expr_ty named_expression_var; |
22952 | Token * newline_var; |
22953 | if ( |
22954 | (a = _PyPegen_expect_token(p, 639)) // token='while' |
22955 | && |
22956 | (named_expression_var = named_expression_rule(p)) // named_expression |
22957 | && |
22958 | (_literal = _PyPegen_expect_token(p, 11))19 // token=':' |
22959 | && |
22960 | (newline_var = _PyPegen_expect_token(p, 19 NEWLINE19 )) // token='NEWLINE' |
22961 | && |
22962 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 10 INDENT10 ) // token=INDENT |
22963 | ) |
22964 | { |
22965 | D(fprintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT")); |
22966 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'while' statement on line %d" , a -> lineno ); |
22967 | if (_res == NULL && PyErr_Occurred()) { |
22968 | p->error_indicator = 1; |
22969 | p->level--; |
22970 | return NULL; |
22971 | } |
22972 | goto done; |
22973 | } |
22974 | p->mark = _mark; |
22975 | D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
22976 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT")); |
22977 | } |
22978 | _res = NULL; |
22979 | done: |
22980 | p->level--; |
22981 | return _res; |
22982 | } |
22983 | |
22984 | // invalid_for_stmt: |
22985 | // | ASYNC? 'for' star_targets 'in' star_expressions NEWLINE |
22986 | // | ASYNC? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT |
22987 | static void * |
22988 | invalid_for_stmt_rule(Parser *p) |
22989 | { |
22990 | if (p->level++ == MAXSTACK) { Branch (22990:9): [True: 0, False: 54]
|
22991 | p->error_indicator = 1; |
22992 | PyErr_NoMemory(); |
22993 | } |
22994 | if (p->error_indicator) { Branch (22994:9): [True: 0, False: 54]
|
22995 | p->level--; |
22996 | return NULL; |
22997 | } |
22998 | void * _res = NULL; |
22999 | int _mark = p->mark; |
23000 | { // ASYNC? 'for' star_targets 'in' star_expressions NEWLINE |
23001 | if (p->error_indicator) { |
23002 | p->level--; |
23003 | return NULL; |
23004 | } |
23005 | D(fprintf(stderr, "%*c> invalid_for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressions NEWLINE")); |
23006 | Token * _keyword; |
23007 | Token * _keyword_1; |
23008 | void *_opt_var; |
23009 | UNUSED(_opt_var); // Silence compiler warnings |
23010 | Token * newline_var; |
23011 | expr_ty star_expressions_var; |
23012 | expr_ty star_targets_var; |
23013 | if ( |
23014 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? |
23015 | && |
23016 | (_keyword = _PyPegen_expect_token(p, 642)) // token='for' Branch (23016:13): [True: 22, False: 32]
|
23017 | && |
23018 | (star_targets_var = star_targets_rule(p))22 // star_targets |
23019 | && |
23020 | (_keyword_1 = _PyPegen_expect_token(p, 643))13 // token='in' |
23021 | && |
23022 | (star_expressions_var = star_expressions_rule(p))7 // star_expressions |
23023 | && |
23024 | (newline_var = _PyPegen_expect_token(p, 7 NEWLINE7 )) // token='NEWLINE' |
23025 | ) |
23026 | { |
23027 | D(fprintf(stderr, "%*c+ invalid_for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressions NEWLINE")); |
23028 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
23029 | if (_res == NULL && PyErr_Occurred()) { |
23030 | p->error_indicator = 1; |
23031 | p->level--; |
23032 | return NULL; |
23033 | } |
23034 | goto done; |
23035 | } |
23036 | p->mark = _mark; |
23037 | D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
23038 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressions NEWLINE")); |
23039 | } |
23040 | { // ASYNC? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT |
23041 | if (p->error_indicator) { |
23042 | p->level--; |
23043 | return NULL; |
23044 | } |
23045 | D(fprintf(stderr, "%*c> invalid_for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT")); |
23046 | Token * _keyword; |
23047 | Token * _literal; |
23048 | void *_opt_var; |
23049 | UNUSED(_opt_var); // Silence compiler warnings |
23050 | Token * a; |
23051 | Token * newline_var; |
23052 | expr_ty star_expressions_var; |
23053 | expr_ty star_targets_var; |
23054 | if ( |
23055 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? |
23056 | && |
23057 | (a = _PyPegen_expect_token(p, 642)) // token='for' Branch (23057:13): [True: 21, False: 32]
|
23058 | && |
23059 | (star_targets_var = star_targets_rule(p))21 // star_targets |
23060 | && |
23061 | (_keyword = _PyPegen_expect_token(p, 643))12 // token='in' |
23062 | && |
23063 | (star_expressions_var = star_expressions_rule(p))6 // star_expressions |
23064 | && |
23065 | (_literal = _PyPegen_expect_token(p, 11))6 // token=':' |
23066 | && |
23067 | (newline_var = _PyPegen_expect_token(p, 5 NEWLINE5 )) // token='NEWLINE' |
23068 | && |
23069 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 4 INDENT4 ) // token=INDENT |
23070 | ) |
23071 | { |
23072 | D(fprintf(stderr, "%*c+ invalid_for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT")); |
23073 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'for' statement on line %d" , a -> lineno ); |
23074 | if (_res == NULL && PyErr_Occurred()) { |
23075 | p->error_indicator = 1; |
23076 | p->level--; |
23077 | return NULL; |
23078 | } |
23079 | goto done; |
23080 | } |
23081 | p->mark = _mark; |
23082 | D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ', |
23083 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT")); |
23084 | } |
23085 | _res = NULL; |
23086 | done: |
23087 | p->level--; |
23088 | return _res; |
23089 | } |
23090 | |
23091 | // invalid_def_raw: |
23092 | // | ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT |
23093 | static void * |
23094 | invalid_def_raw_rule(Parser *p) |
23095 | { |
23096 | if (p->level++ == MAXSTACK) { Branch (23096:9): [True: 0, False: 216]
|
23097 | p->error_indicator = 1; |
23098 | PyErr_NoMemory(); |
23099 | } |
23100 | if (p->error_indicator) { Branch (23100:9): [True: 0, False: 216]
|
23101 | p->level--; |
23102 | return NULL; |
23103 | } |
23104 | void * _res = NULL; |
23105 | int _mark = p->mark; |
23106 | { // ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT |
23107 | if (p->error_indicator) { Branch (23107:13): [True: 0, False: 216]
|
23108 | p->level--; |
23109 | return NULL; |
23110 | } |
23111 | D(fprintf(stderr, "%*c> invalid_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT")); |
23112 | Token * _literal; |
23113 | Token * _literal_1; |
23114 | Token * _literal_2; |
23115 | void *_opt_var; |
23116 | UNUSED(_opt_var); // Silence compiler warnings |
23117 | void *_opt_var_1; |
23118 | UNUSED(_opt_var_1); // Silence compiler warnings |
23119 | void *_opt_var_2; |
23120 | UNUSED(_opt_var_2); // Silence compiler warnings |
23121 | Token * a; |
23122 | expr_ty name_var; |
23123 | Token * newline_var; |
23124 | if ( |
23125 | (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC? Branch (23125:13): [True: 216, False: 0]
|
23126 | && |
23127 | (a = _PyPegen_expect_token(p, 644)) // token='def' Branch (23127:13): [True: 195, False: 21]
|
23128 | && |
23129 | (name_var = _PyPegen_name_token(p))195 // NAME Branch (23129:13): [True: 186, False: 9]
|
23130 | && |
23131 | (_literal = _PyPegen_expect_token(p, 7))186 // token='(' Branch (23131:13): [True: 186, False: 0]
|
23132 | && |
23133 | (_opt_var_1 = params_rule(p), !p->error_indicator)186 // params? Branch (23133:13): [True: 117, False: 69]
|
23134 | && |
23135 | (_literal_1 = _PyPegen_expect_token(p, 8))117 // token=')' Branch (23135:13): [True: 65, False: 52]
|
23136 | && |
23137 | (_opt_var_2 = _tmp_212_rule(p), !p->error_indicator)65 // ['->' expression] |
23138 | && |
23139 | (_literal_2 = _PyPegen_expect_token(p, 11))65 // token=':' |
23140 | && |
23141 | (newline_var = _PyPegen_expect_token(p, 65 NEWLINE65 )) // token='NEWLINE' Branch (23141:13): [True: 38, False: 27]
|
23142 | && |
23143 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 38 INDENT38 ) // token=INDENT |
23144 | ) |
23145 | { |
23146 | D(fprintf(stderr, "%*c+ invalid_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT")); |
23147 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after function definition on line %d" , a -> lineno ); |
23148 | if (_res == NULL && PyErr_Occurred()) { |
23149 | p->error_indicator = 1; |
23150 | p->level--; |
23151 | return NULL; |
23152 | } |
23153 | goto done; |
23154 | } |
23155 | p->mark = _mark; |
23156 | D(fprintf(stderr, "%*c%s invalid_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
23157 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT")); |
23158 | } |
23159 | _res = NULL; |
23160 | done: |
23161 | p->level--; |
23162 | return _res; |
23163 | } |
23164 | |
23165 | // invalid_class_def_raw: |
23166 | // | 'class' NAME ['(' arguments? ')'] NEWLINE |
23167 | // | 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT |
23168 | static void * |
23169 | invalid_class_def_raw_rule(Parser *p) |
23170 | { |
23171 | if (p->level++ == MAXSTACK) { Branch (23171:9): [True: 0, False: 15]
|
23172 | p->error_indicator = 1; |
23173 | PyErr_NoMemory(); |
23174 | } |
23175 | if (p->error_indicator) { Branch (23175:9): [True: 0, False: 15]
|
23176 | p->level--; |
23177 | return NULL; |
23178 | } |
23179 | void * _res = NULL; |
23180 | int _mark = p->mark; |
23181 | { // 'class' NAME ['(' arguments? ')'] NEWLINE |
23182 | if (p->error_indicator) { |
23183 | p->level--; |
23184 | return NULL; |
23185 | } |
23186 | D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] NEWLINE")); |
23187 | Token * _keyword; |
23188 | void *_opt_var; |
23189 | UNUSED(_opt_var); // Silence compiler warnings |
23190 | expr_ty name_var; |
23191 | Token * newline_var; |
23192 | if ( |
23193 | (_keyword = _PyPegen_expect_token(p, 646)) // token='class' |
23194 | && |
23195 | (name_var = _PyPegen_name_token(p))11 // NAME |
23196 | && |
23197 | (_opt_var = _tmp_213_rule(p), !p->error_indicator)6 // ['(' arguments? ')'] |
23198 | && |
23199 | (newline_var = _PyPegen_expect_token(p, 6 NEWLINE6 )) // token='NEWLINE' |
23200 | ) |
23201 | { |
23202 | D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] NEWLINE")); |
23203 | _res = RAISE_SYNTAX_ERROR ( "expected ':'" ); |
23204 | if (_res == NULL && PyErr_Occurred()) { |
23205 | p->error_indicator = 1; |
23206 | p->level--; |
23207 | return NULL; |
23208 | } |
23209 | goto done; |
23210 | } |
23211 | p->mark = _mark; |
23212 | D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
23213 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] NEWLINE")); |
23214 | } |
23215 | { // 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT |
23216 | if (p->error_indicator) { |
23217 | p->level--; |
23218 | return NULL; |
23219 | } |
23220 | D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT")); |
23221 | Token * _literal; |
23222 | void *_opt_var; |
23223 | UNUSED(_opt_var); // Silence compiler warnings |
23224 | Token * a; |
23225 | expr_ty name_var; |
23226 | Token * newline_var; |
23227 | if ( |
23228 | (a = _PyPegen_expect_token(p, 646)) // token='class' |
23229 | && |
23230 | (name_var = _PyPegen_name_token(p))10 // NAME |
23231 | && |
23232 | (_opt_var = _tmp_214_rule(p), !p->error_indicator)5 // ['(' arguments? ')'] |
23233 | && |
23234 | (_literal = _PyPegen_expect_token(p, 11))5 // token=':' |
23235 | && |
23236 | (newline_var = _PyPegen_expect_token(p, 3 NEWLINE3 )) // token='NEWLINE' |
23237 | && |
23238 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 3 INDENT3 ) // token=INDENT |
23239 | ) |
23240 | { |
23241 | D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT")); |
23242 | _res = RAISE_INDENTATION_ERROR ( "expected an indented block after class definition on line %d" , a -> lineno ); |
23243 | if (_res == NULL && PyErr_Occurred()) { |
23244 | p->error_indicator = 1; |
23245 | p->level--; |
23246 | return NULL; |
23247 | } |
23248 | goto done; |
23249 | } |
23250 | p->mark = _mark; |
23251 | D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', |
23252 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT")); |
23253 | } |
23254 | _res = NULL; |
23255 | done: |
23256 | p->level--; |
23257 | return _res; |
23258 | } |
23259 | |
23260 | // invalid_double_starred_kvpairs: |
23261 | // | ','.double_starred_kvpair+ ',' invalid_kvpair |
23262 | // | expression ':' '*' bitwise_or |
23263 | // | expression ':' &('}' | ',') |
23264 | static void * |
23265 | invalid_double_starred_kvpairs_rule(Parser *p) |
23266 | { |
23267 | if (p->level++ == MAXSTACK) { Branch (23267:9): [True: 0, False: 1.81k]
|
23268 | p->error_indicator = 1; |
23269 | PyErr_NoMemory(); |
23270 | } |
23271 | if (p->error_indicator) { Branch (23271:9): [True: 0, False: 1.81k]
|
23272 | p->level--; |
23273 | return NULL; |
23274 | } |
23275 | void * _res = NULL; |
23276 | int _mark = p->mark; |
23277 | { // ','.double_starred_kvpair+ ',' invalid_kvpair |
23278 | if (p->error_indicator) { Branch (23278:13): [True: 0, False: 1.81k]
|
23279 | p->level--; |
23280 | return NULL; |
23281 | } |
23282 | D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); |
23283 | asdl_seq * _gather_215_var; |
23284 | Token * _literal; |
23285 | void *invalid_kvpair_var; |
23286 | if ( |
23287 | (_gather_215_var = _gather_215_rule(p)) // ','.double_starred_kvpair+ Branch (23287:13): [True: 377, False: 1.44k]
|
23288 | && |
23289 | (_literal = _PyPegen_expect_token(p, 12))377 // token=',' Branch (23289:13): [True: 3, False: 374]
|
23290 | && |
23291 | (invalid_kvpair_var = invalid_kvpair_rule(p))3 // invalid_kvpair |
23292 | ) |
23293 | { |
23294 | D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); |
23295 | _res = _PyPegen_dummy_name(p, _gather_215_var, _literal, invalid_kvpair_var); |
23296 | goto done; |
23297 | } |
23298 | p->mark = _mark; |
23299 | D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', |
23300 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); |
23301 | } |
23302 | { // expression ':' '*' bitwise_or |
23303 | if (p->error_indicator) { Branch (23303:13): [True: 3, False: 1.81k]
|
23304 | p->level--; |
23305 | return NULL; |
23306 | } |
23307 | D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); |
23308 | Token * _literal; |
23309 | Token * a; |
23310 | expr_ty bitwise_or_var; |
23311 | expr_ty expression_var; |
23312 | if ( |
23313 | (expression_var = expression_rule(p)) // expression Branch (23313:13): [True: 1.74k, False: 67]
|
23314 | && |
23315 | (_literal = _PyPegen_expect_token(p, 11))1.74k // token=':' Branch (23315:13): [True: 386, False: 1.36k]
|
23316 | && |
23317 | (a = _PyPegen_expect_token(p, 16))386 // token='*' Branch (23317:13): [True: 2, False: 384]
|
23318 | && |
23319 | (bitwise_or_var = bitwise_or_rule(p))2 // bitwise_or |
23320 | ) |
23321 | { |
23322 | D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); |
23323 | _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" ); |
23324 | if (_res == NULL && PyErr_Occurred()) { |
23325 | p->error_indicator = 1; |
23326 | p->level--; |
23327 | return NULL; |
23328 | } |
23329 | goto done; |
23330 | } |
23331 | p->mark = _mark; |
23332 | D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', |
23333 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or")); |
23334 | } |
23335 | { // expression ':' &('}' | ',') |
23336 | if (p->error_indicator) { Branch (23336:13): [True: 0, False: 1.81k]
|
23337 | p->level--; |
23338 | return NULL; |
23339 | } |
23340 | D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); |
23341 | Token * a; |
23342 | expr_ty expression_var; |
23343 | if ( |
23344 | (expression_var = expression_rule(p)) // expression Branch (23344:13): [True: 1.74k, False: 67]
|
23345 | && |
23346 | (a = _PyPegen_expect_token(p, 11))1.74k // token=':' Branch (23346:13): [True: 384, False: 1.36k]
|
23347 | && |
23348 | _PyPegen_lookahead(1, _tmp_217_rule, p)384 Branch (23348:13): [True: 1, False: 383]
|
23349 | ) |
23350 | { |
23351 | D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); |
23352 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" ); |
23353 | if (_res == NULL && PyErr_Occurred()) { |
23354 | p->error_indicator = 1; |
23355 | p->level--; |
23356 | return NULL; |
23357 | } |
23358 | goto done; |
23359 | } |
23360 | p->mark = _mark; |
23361 | D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', |
23362 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')")); |
23363 | } |
23364 | _res = NULL; |
23365 | done: |
23366 | p->level--; |
23367 | return _res; |
23368 | } |
23369 | |
23370 | // invalid_kvpair: |
23371 | // | expression !(':') |
23372 | // | expression ':' '*' bitwise_or |
23373 | // | expression ':' &('}' | ',') |
23374 | static void * |
23375 | invalid_kvpair_rule(Parser *p) |
23376 | { |
23377 | if (p->level++ == MAXSTACK) { Branch (23377:9): [True: 0, False: 3]
|
23378 | p->error_indicator = 1; |
23379 | PyErr_NoMemory(); |
23380 | } |
23381 | if (p->error_indicator) { Branch (23381:9): [True: 0, False: 3]
|
23382 | p->level--; |
23383 | return NULL; |
23384 | } |
23385 | void * _res = NULL; |
23386 | int _mark = p->mark; |
23387 | { // expression !(':') |
23388 | if (p->error_indicator) { |
23389 | p->level--; |
23390 | return NULL; |
23391 | } |
23392 | D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !(':')")); |
23393 | expr_ty a; |
23394 | if ( |
23395 | (a = expression_rule(p)) // expression |
23396 | && |
23397 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 11) // token=(':') |
23398 | ) |
23399 | { |
23400 | D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !(':')")); |
23401 | _res = RAISE_ERROR_KNOWN_LOCATION ( p , PyExc_SyntaxError , a -> lineno , a -> end_col_offset - 1 , a -> end_lineno , - 1 , "':' expected after dictionary key" ); |
23402 | if (_res == NULL && PyErr_Occurred()) { |
23403 | p->error_indicator = 1; |
23404 | p->level--; |
23405 | return NULL; |
23406 | } |
23407 | goto done; |
23408 | } |
23409 | p->mark = _mark; |
23410 | D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', |
23411 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !(':')")); |
23412 | } |
23413 | { // expression ':' '*' bitwise_or |
23414 | if (p->error_indicator) { |
23415 | p->level--; |
23416 | return NULL; |
23417 | } |
23418 | D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); |
23419 | Token * _literal; |
23420 | Token * a; |
23421 | expr_ty bitwise_or_var; |
23422 | expr_ty expression_var; |
23423 | if ( |
23424 | (expression_var = expression_rule(p)) // expression |
23425 | && |
23426 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
23427 | && |
23428 | (a = _PyPegen_expect_token(p, 16)) // token='*' |
23429 | && |
23430 | (bitwise_or_var = bitwise_or_rule(p))1 // bitwise_or |
23431 | ) |
23432 | { |
23433 | D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); |
23434 | _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" ); |
23435 | if (_res == NULL && PyErr_Occurred()) { |
23436 | p->error_indicator = 1; |
23437 | p->level--; |
23438 | return NULL; |
23439 | } |
23440 | goto done; |
23441 | } |
23442 | p->mark = _mark; |
23443 | D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', |
23444 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or")); |
23445 | } |
23446 | { // expression ':' &('}' | ',') |
23447 | if (p->error_indicator) { |
23448 | p->level--; |
23449 | return NULL; |
23450 | } |
23451 | D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); |
23452 | Token * a; |
23453 | expr_ty expression_var; |
23454 | if ( |
23455 | (expression_var = expression_rule(p)) // expression |
23456 | && |
23457 | (a = _PyPegen_expect_token(p, 11)) // token=':' |
23458 | && |
23459 | _PyPegen_lookahead(1, _tmp_218_rule, p) |
23460 | ) |
23461 | { |
23462 | D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); |
23463 | _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" ); |
23464 | if (_res == NULL && PyErr_Occurred()) { |
23465 | p->error_indicator = 1; |
23466 | p->level--; |
23467 | return NULL; |
23468 | } |
23469 | goto done; |
23470 | } |
23471 | p->mark = _mark; |
23472 | D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', |
23473 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')")); |
23474 | } |
23475 | _res = NULL; |
23476 | done: |
23477 | p->level--; |
23478 | return _res; |
23479 | } |
23480 | |
23481 | // _loop0_1: NEWLINE |
23482 | static asdl_seq * |
23483 | _loop0_1_rule(Parser *p) |
23484 | { |
23485 | if (p->level++ == MAXSTACK) { Branch (23485:9): [True: 0, False: 36.6k]
|
23486 | p->error_indicator = 1; |
23487 | PyErr_NoMemory(); |
23488 | } |
23489 | if (p->error_indicator) { Branch (23489:9): [True: 0, False: 36.6k]
|
23490 | p->level--; |
23491 | return NULL; |
23492 | } |
23493 | void *_res = NULL; |
23494 | int _mark = p->mark; |
23495 | int _start_mark = p->mark; |
23496 | void **_children = PyMem_Malloc(sizeof(void *)); |
23497 | if (!_children) { Branch (23497:9): [True: 0, False: 36.6k]
|
23498 | p->error_indicator = 1; |
23499 | PyErr_NoMemory(); |
23500 | p->level--; |
23501 | return NULL; |
23502 | } |
23503 | Py_ssize_t _children_capacity = 1; |
23504 | Py_ssize_t _n = 0; |
23505 | { // NEWLINE |
23506 | if (p->error_indicator) { Branch (23506:13): [True: 0, False: 36.6k]
|
23507 | p->level--; |
23508 | return NULL; |
23509 | } |
23510 | D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
23511 | Token * newline_var; |
23512 | while ( |
23513 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (23513:13): [True: 16, False: 36.6k]
|
23514 | ) |
23515 | { |
23516 | _res = newline_var; |
23517 | if (_n == _children_capacity) { |
23518 | _children_capacity *= 2; |
23519 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
23520 | if (!_new_children) { |
23521 | p->error_indicator = 1; |
23522 | PyErr_NoMemory(); |
23523 | p->level--; |
23524 | return NULL; |
23525 | } |
23526 | _children = _new_children; |
23527 | } |
23528 | _children[_n++] = _res; |
23529 | _mark = p->mark; |
23530 | } |
23531 | p->mark = _mark; |
23532 | D(fprintf(stderr, "%*c%s _loop0_1[%d-%d]: %s failed!\n", p->level, ' ', |
23533 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); |
23534 | } |
23535 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
23536 | if (!_seq) { Branch (23536:9): [True: 0, False: 36.6k]
|
23537 | PyMem_Free(_children); |
23538 | p->error_indicator = 1; |
23539 | PyErr_NoMemory(); |
23540 | p->level--; |
23541 | return NULL; |
23542 | } |
23543 | for (int i = 0; 36.6k i < _n; i++16 ) asdl_seq_SET_UNTYPED36.6k (_seq, i, _children[i]); Branch (23543:21): [True: 16, False: 36.6k]
|
23544 | PyMem_Free(_children); |
23545 | _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq); |
23546 | p->level--; |
23547 | return _seq; |
23548 | } |
23549 | |
23550 | // _loop0_2: NEWLINE |
23551 | static asdl_seq * |
23552 | _loop0_2_rule(Parser *p) |
23553 | { |
23554 | if (p->level++ == MAXSTACK) { Branch (23554:9): [True: 0, False: 12]
|
23555 | p->error_indicator = 1; |
23556 | PyErr_NoMemory(); |
23557 | } |
23558 | if (p->error_indicator) { Branch (23558:9): [True: 0, False: 12]
|
23559 | p->level--; |
23560 | return NULL; |
23561 | } |
23562 | void *_res = NULL; |
23563 | int _mark = p->mark; |
23564 | int _start_mark = p->mark; |
23565 | void **_children = PyMem_Malloc(sizeof(void *)); |
23566 | if (!_children) { Branch (23566:9): [True: 0, False: 12]
|
23567 | p->error_indicator = 1; |
23568 | PyErr_NoMemory(); |
23569 | p->level--; |
23570 | return NULL; |
23571 | } |
23572 | Py_ssize_t _children_capacity = 1; |
23573 | Py_ssize_t _n = 0; |
23574 | { // NEWLINE |
23575 | if (p->error_indicator) { |
23576 | p->level--; |
23577 | return NULL; |
23578 | } |
23579 | D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
23580 | Token * newline_var; |
23581 | while ( |
23582 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' |
23583 | ) |
23584 | { |
23585 | _res = newline_var; |
23586 | if (_n == _children_capacity) { |
23587 | _children_capacity *= 2; |
23588 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
23589 | if (!_new_children) { |
23590 | p->error_indicator = 1; |
23591 | PyErr_NoMemory(); |
23592 | p->level--; |
23593 | return NULL; |
23594 | } |
23595 | _children = _new_children; |
23596 | } |
23597 | _children[_n++] = _res; |
23598 | _mark = p->mark; |
23599 | } |
23600 | p->mark = _mark; |
23601 | D(fprintf(stderr, "%*c%s _loop0_2[%d-%d]: %s failed!\n", p->level, ' ', |
23602 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); |
23603 | } |
23604 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
23605 | if (!_seq) { Branch (23605:9): [True: 0, False: 12]
|
23606 | PyMem_Free(_children); |
23607 | p->error_indicator = 1; |
23608 | PyErr_NoMemory(); |
23609 | p->level--; |
23610 | return NULL; |
23611 | } |
23612 | for (int i = 0; i < _n; i++0 ) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); |
23613 | PyMem_Free(_children); |
23614 | _PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq); |
23615 | p->level--; |
23616 | return _seq; |
23617 | } |
23618 | |
23619 | // _loop1_3: statement |
23620 | static asdl_seq * |
23621 | _loop1_3_rule(Parser *p) |
23622 | { |
23623 | if (p->level++ == MAXSTACK) { Branch (23623:9): [True: 0, False: 98.7k]
|
23624 | p->error_indicator = 1; |
23625 | PyErr_NoMemory(); |
23626 | } |
23627 | if (p->error_indicator) { Branch (23627:9): [True: 0, False: 98.7k]
|
23628 | p->level--; |
23629 | return NULL; |
23630 | } |
23631 | void *_res = NULL; |
23632 | int _mark = p->mark; |
23633 | int _start_mark = p->mark; |
23634 | void **_children = PyMem_Malloc(sizeof(void *)); |
23635 | if (!_children) { Branch (23635:9): [True: 0, False: 98.7k]
|
23636 | p->error_indicator = 1; |
23637 | PyErr_NoMemory(); |
23638 | p->level--; |
23639 | return NULL; |
23640 | } |
23641 | Py_ssize_t _children_capacity = 1; |
23642 | Py_ssize_t _n = 0; |
23643 | { // statement |
23644 | if (p->error_indicator) { Branch (23644:13): [True: 0, False: 98.7k]
|
23645 | p->level--; |
23646 | return NULL; |
23647 | } |
23648 | D(fprintf(stderr, "%*c> _loop1_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement")); |
23649 | asdl_stmt_seq* statement_var; |
23650 | while ( |
23651 | (statement_var = statement_rule(p)) // statement Branch (23651:13): [True: 442k, False: 98.7k]
|
23652 | ) |
23653 | { |
23654 | _res = statement_var; |
23655 | if (_n == _children_capacity) { Branch (23655:17): [True: 67.5k, False: 374k]
|
23656 | _children_capacity *= 2; |
23657 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
23658 | if (!_new_children) { Branch (23658:21): [True: 0, False: 67.5k]
|
23659 | p->error_indicator = 1; |
23660 | PyErr_NoMemory(); |
23661 | p->level--; |
23662 | return NULL; |
23663 | } |
23664 | _children = _new_children; |
23665 | } |
23666 | _children[_n++] = _res; |
23667 | _mark = p->mark; |
23668 | } |
23669 | p->mark = _mark; |
23670 | D(fprintf(stderr, "%*c%s _loop1_3[%d-%d]: %s failed!\n", p->level, ' ', |
23671 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement")); |
23672 | } |
23673 | if (_n == 0 || p->error_indicator97.1k ) { Branch (23673:9): [True: 1.54k, False: 97.1k]
Branch (23673:20): [True: 17, False: 97.1k]
|
23674 | PyMem_Free(_children); |
23675 | p->level--; |
23676 | return NULL; |
23677 | } |
23678 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
23679 | if (!_seq) { Branch (23679:9): [True: 0, False: 97.1k]
|
23680 | PyMem_Free(_children); |
23681 | p->error_indicator = 1; |
23682 | PyErr_NoMemory(); |
23683 | p->level--; |
23684 | return NULL; |
23685 | } |
23686 | for (int i = 0; 97.1k i < _n; i++442k ) asdl_seq_SET_UNTYPED97.1k (_seq, i, _children[i]); Branch (23686:21): [True: 442k, False: 97.1k]
|
23687 | PyMem_Free(_children); |
23688 | _PyPegen_insert_memo(p, _start_mark, _loop1_3_type, _seq); |
23689 | p->level--; |
23690 | return _seq; |
23691 | } |
23692 | |
23693 | // _loop0_5: ';' simple_stmt |
23694 | static asdl_seq * |
23695 | _loop0_5_rule(Parser *p) |
23696 | { |
23697 | if (p->level++ == MAXSTACK) { Branch (23697:9): [True: 0, False: 896]
|
23698 | p->error_indicator = 1; |
23699 | PyErr_NoMemory(); |
23700 | } |
23701 | if (p->error_indicator) { Branch (23701:9): [True: 0, False: 896]
|
23702 | p->level--; |
23703 | return NULL; |
23704 | } |
23705 | void *_res = NULL; |
23706 | int _mark = p->mark; |
23707 | int _start_mark = p->mark; |
23708 | void **_children = PyMem_Malloc(sizeof(void *)); |
23709 | if (!_children) { Branch (23709:9): [True: 0, False: 896]
|
23710 | p->error_indicator = 1; |
23711 | PyErr_NoMemory(); |
23712 | p->level--; |
23713 | return NULL; |
23714 | } |
23715 | Py_ssize_t _children_capacity = 1; |
23716 | Py_ssize_t _n = 0; |
23717 | { // ';' simple_stmt |
23718 | if (p->error_indicator) { Branch (23718:13): [True: 0, False: 896]
|
23719 | p->level--; |
23720 | return NULL; |
23721 | } |
23722 | D(fprintf(stderr, "%*c> _loop0_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' simple_stmt")); |
23723 | Token * _literal; |
23724 | stmt_ty elem; |
23725 | while ( |
23726 | (_literal = _PyPegen_expect_token(p, 13)) // token=';' Branch (23726:13): [True: 4.47k, False: 884]
|
23727 | && |
23728 | (elem = simple_stmt_rule(p))4.47k // simple_stmt Branch (23728:13): [True: 4.45k, False: 12]
|
23729 | ) |
23730 | { |
23731 | _res = elem; |
23732 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (23732:17): [True: 0, False: 4.45k]
Branch (23732:33): [True: 0, False: 0]
|
23733 | p->error_indicator = 1; |
23734 | PyMem_Free(_children); |
23735 | p->level--; |
23736 | return NULL; |
23737 | } |
23738 | if (_n == _children_capacity) { Branch (23738:17): [True: 152, False: 4.30k]
|
23739 | _children_capacity *= 2; |
23740 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
23741 | if (!_new_children) { Branch (23741:21): [True: 0, False: 152]
|
23742 | p->error_indicator = 1; |
23743 | PyErr_NoMemory(); |
23744 | p->level--; |
23745 | return NULL; |
23746 | } |
23747 | _children = _new_children; |
23748 | } |
23749 | _children[_n++] = _res; |
23750 | _mark = p->mark; |
23751 | } |
23752 | p->mark = _mark; |
23753 | D(fprintf(stderr, "%*c%s _loop0_5[%d-%d]: %s failed!\n", p->level, ' ', |
23754 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';' simple_stmt")); |
23755 | } |
23756 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
23757 | if (!_seq) { Branch (23757:9): [True: 0, False: 896]
|
23758 | PyMem_Free(_children); |
23759 | p->error_indicator = 1; |
23760 | PyErr_NoMemory(); |
23761 | p->level--; |
23762 | return NULL; |
23763 | } |
23764 | for (int i = 0; 896 i < _n; i++4.45k ) asdl_seq_SET_UNTYPED896 (_seq, i, _children[i]); Branch (23764:21): [True: 4.45k, False: 896]
|
23765 | PyMem_Free(_children); |
23766 | _PyPegen_insert_memo(p, _start_mark, _loop0_5_type, _seq); |
23767 | p->level--; |
23768 | return _seq; |
23769 | } |
23770 | |
23771 | // _gather_4: simple_stmt _loop0_5 |
23772 | static asdl_seq * |
23773 | _gather_4_rule(Parser *p) |
23774 | { |
23775 | if (p->level++ == MAXSTACK) { Branch (23775:9): [True: 0, False: 99.4k]
|
23776 | p->error_indicator = 1; |
23777 | PyErr_NoMemory(); |
23778 | } |
23779 | if (p->error_indicator) { Branch (23779:9): [True: 0, False: 99.4k]
|
23780 | p->level--; |
23781 | return NULL; |
23782 | } |
23783 | asdl_seq * _res = NULL; |
23784 | int _mark = p->mark; |
23785 | { // simple_stmt _loop0_5 |
23786 | if (p->error_indicator) { Branch (23786:13): [True: 0, False: 99.4k]
|
23787 | p->level--; |
23788 | return NULL; |
23789 | } |
23790 | D(fprintf(stderr, "%*c> _gather_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop0_5")); |
23791 | stmt_ty elem; |
23792 | asdl_seq * seq; |
23793 | if ( |
23794 | (elem = simple_stmt_rule(p)) // simple_stmt Branch (23794:13): [True: 896, False: 98.6k]
|
23795 | && |
23796 | (seq = _loop0_5_rule(p))896 // _loop0_5 Branch (23796:13): [True: 896, False: 0]
|
23797 | ) |
23798 | { |
23799 | D(fprintf(stderr, "%*c+ _gather_4[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop0_5")); |
23800 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
23801 | goto done; |
23802 | } |
23803 | p->mark = _mark; |
23804 | D(fprintf(stderr, "%*c%s _gather_4[%d-%d]: %s failed!\n", p->level, ' ', |
23805 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt _loop0_5")); |
23806 | } |
23807 | _res = NULL; |
23808 | done: |
23809 | p->level--; |
23810 | return _res; |
23811 | } |
23812 | |
23813 | // _tmp_6: 'import' | 'from' |
23814 | static void * |
23815 | _tmp_6_rule(Parser *p) |
23816 | { |
23817 | if (p->level++ == MAXSTACK) { Branch (23817:9): [True: 0, False: 121k]
|
23818 | p->error_indicator = 1; |
23819 | PyErr_NoMemory(); |
23820 | } |
23821 | if (p->error_indicator) { Branch (23821:9): [True: 0, False: 121k]
|
23822 | p->level--; |
23823 | return NULL; |
23824 | } |
23825 | void * _res = NULL; |
23826 | int _mark = p->mark; |
23827 | { // 'import' |
23828 | if (p->error_indicator) { Branch (23828:13): [True: 0, False: 121k]
|
23829 | p->level--; |
23830 | return NULL; |
23831 | } |
23832 | D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'")); |
23833 | Token * _keyword; |
23834 | if ( |
23835 | (_keyword = _PyPegen_expect_token(p, 531)) // token='import' Branch (23835:13): [True: 4.18k, False: 117k]
|
23836 | ) |
23837 | { |
23838 | D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'")); |
23839 | _res = _keyword; |
23840 | goto done; |
23841 | } |
23842 | p->mark = _mark; |
23843 | D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', |
23844 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'")); |
23845 | } |
23846 | { // 'from' |
23847 | if (p->error_indicator) { Branch (23847:13): [True: 0, False: 117k]
|
23848 | p->level--; |
23849 | return NULL; |
23850 | } |
23851 | D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'")); |
23852 | Token * _keyword; |
23853 | if ( |
23854 | (_keyword = _PyPegen_expect_token(p, 572)) // token='from' Branch (23854:13): [True: 2.07k, False: 114k]
|
23855 | ) |
23856 | { |
23857 | D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'")); |
23858 | _res = _keyword; |
23859 | goto done; |
23860 | } |
23861 | p->mark = _mark; |
23862 | D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', |
23863 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'")); |
23864 | } |
23865 | _res = NULL; |
23866 | done: |
23867 | p->level--; |
23868 | return _res; |
23869 | } |
23870 | |
23871 | // _tmp_7: 'def' | '@' | ASYNC |
23872 | static void * |
23873 | _tmp_7_rule(Parser *p) |
23874 | { |
23875 | if (p->level++ == MAXSTACK) { Branch (23875:9): [True: 0, False: 546k]
|
23876 | p->error_indicator = 1; |
23877 | PyErr_NoMemory(); |
23878 | } |
23879 | if (p->error_indicator) { Branch (23879:9): [True: 0, False: 546k]
|
23880 | p->level--; |
23881 | return NULL; |
23882 | } |
23883 | void * _res = NULL; |
23884 | int _mark = p->mark; |
23885 | { // 'def' |
23886 | if (p->error_indicator) { Branch (23886:13): [True: 0, False: 546k]
|
23887 | p->level--; |
23888 | return NULL; |
23889 | } |
23890 | D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'")); |
23891 | Token * _keyword; |
23892 | if ( |
23893 | (_keyword = _PyPegen_expect_token(p, 644)) // token='def' Branch (23893:13): [True: 30.4k, False: 515k]
|
23894 | ) |
23895 | { |
23896 | D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'")); |
23897 | _res = _keyword; |
23898 | goto done; |
23899 | } |
23900 | p->mark = _mark; |
23901 | D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', |
23902 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'")); |
23903 | } |
23904 | { // '@' |
23905 | if (p->error_indicator) { Branch (23905:13): [True: 70, False: 515k]
|
23906 | p->level--; |
23907 | return NULL; |
23908 | } |
23909 | D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); |
23910 | Token * _literal; |
23911 | if ( |
23912 | (_literal = _PyPegen_expect_token(p, 49)) // token='@' Branch (23912:13): [True: 2.39k, False: 513k]
|
23913 | ) |
23914 | { |
23915 | D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); |
23916 | _res = _literal; |
23917 | goto done; |
23918 | } |
23919 | p->mark = _mark; |
23920 | D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', |
23921 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); |
23922 | } |
23923 | { // ASYNC |
23924 | if (p->error_indicator) { Branch (23924:13): [True: 0, False: 513k]
|
23925 | p->level--; |
23926 | return NULL; |
23927 | } |
23928 | D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); |
23929 | Token * async_var; |
23930 | if ( |
23931 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (23931:13): [True: 893, False: 512k]
|
23932 | ) |
23933 | { |
23934 | D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); |
23935 | _res = async_var; |
23936 | goto done; |
23937 | } |
23938 | p->mark = _mark; |
23939 | D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', |
23940 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); |
23941 | } |
23942 | _res = NULL; |
23943 | done: |
23944 | p->level--; |
23945 | return _res; |
23946 | } |
23947 | |
23948 | // _tmp_8: 'class' | '@' |
23949 | static void * |
23950 | _tmp_8_rule(Parser *p) |
23951 | { |
23952 | if (p->level++ == MAXSTACK) { Branch (23952:9): [True: 0, False: 289k]
|
23953 | p->error_indicator = 1; |
23954 | PyErr_NoMemory(); |
23955 | } |
23956 | if (p->error_indicator) { Branch (23956:9): [True: 0, False: 289k]
|
23957 | p->level--; |
23958 | return NULL; |
23959 | } |
23960 | void * _res = NULL; |
23961 | int _mark = p->mark; |
23962 | { // 'class' |
23963 | if (p->error_indicator) { Branch (23963:13): [True: 0, False: 289k]
|
23964 | p->level--; |
23965 | return NULL; |
23966 | } |
23967 | D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'")); |
23968 | Token * _keyword; |
23969 | if ( |
23970 | (_keyword = _PyPegen_expect_token(p, 646)) // token='class' Branch (23970:13): [True: 4.30k, False: 285k]
|
23971 | ) |
23972 | { |
23973 | D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'")); |
23974 | _res = _keyword; |
23975 | goto done; |
23976 | } |
23977 | p->mark = _mark; |
23978 | D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ', |
23979 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'")); |
23980 | } |
23981 | { // '@' |
23982 | if (p->error_indicator) { Branch (23982:13): [True: 0, False: 285k]
|
23983 | p->level--; |
23984 | return NULL; |
23985 | } |
23986 | D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); |
23987 | Token * _literal; |
23988 | if ( |
23989 | (_literal = _PyPegen_expect_token(p, 49)) // token='@' Branch (23989:13): [True: 217, False: 284k]
|
23990 | ) |
23991 | { |
23992 | D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); |
23993 | _res = _literal; |
23994 | goto done; |
23995 | } |
23996 | p->mark = _mark; |
23997 | D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ', |
23998 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); |
23999 | } |
24000 | _res = NULL; |
24001 | done: |
24002 | p->level--; |
24003 | return _res; |
24004 | } |
24005 | |
24006 | // _tmp_9: 'with' | ASYNC |
24007 | static void * |
24008 | _tmp_9_rule(Parser *p) |
24009 | { |
24010 | if (p->level++ == MAXSTACK) { Branch (24010:9): [True: 0, False: 284k]
|
24011 | p->error_indicator = 1; |
24012 | PyErr_NoMemory(); |
24013 | } |
24014 | if (p->error_indicator) { Branch (24014:9): [True: 0, False: 284k]
|
24015 | p->level--; |
24016 | return NULL; |
24017 | } |
24018 | void * _res = NULL; |
24019 | int _mark = p->mark; |
24020 | { // 'with' |
24021 | if (p->error_indicator) { Branch (24021:13): [True: 0, False: 284k]
|
24022 | p->level--; |
24023 | return NULL; |
24024 | } |
24025 | D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'")); |
24026 | Token * _keyword; |
24027 | if ( |
24028 | (_keyword = _PyPegen_expect_token(p, 612)) // token='with' Branch (24028:13): [True: 1.91k, False: 283k]
|
24029 | ) |
24030 | { |
24031 | D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'")); |
24032 | _res = _keyword; |
24033 | goto done; |
24034 | } |
24035 | p->mark = _mark; |
24036 | D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ', |
24037 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'")); |
24038 | } |
24039 | { // ASYNC |
24040 | if (p->error_indicator) { Branch (24040:13): [True: 0, False: 283k]
|
24041 | p->level--; |
24042 | return NULL; |
24043 | } |
24044 | D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); |
24045 | Token * async_var; |
24046 | if ( |
24047 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (24047:13): [True: 225, False: 282k]
|
24048 | ) |
24049 | { |
24050 | D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); |
24051 | _res = async_var; |
24052 | goto done; |
24053 | } |
24054 | p->mark = _mark; |
24055 | D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ', |
24056 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); |
24057 | } |
24058 | _res = NULL; |
24059 | done: |
24060 | p->level--; |
24061 | return _res; |
24062 | } |
24063 | |
24064 | // _tmp_10: 'for' | ASYNC |
24065 | static void * |
24066 | _tmp_10_rule(Parser *p) |
24067 | { |
24068 | if (p->level++ == MAXSTACK) { Branch (24068:9): [True: 0, False: 283k]
|
24069 | p->error_indicator = 1; |
24070 | PyErr_NoMemory(); |
24071 | } |
24072 | if (p->error_indicator) { Branch (24072:9): [True: 0, False: 283k]
|
24073 | p->level--; |
24074 | return NULL; |
24075 | } |
24076 | void * _res = NULL; |
24077 | int _mark = p->mark; |
24078 | { // 'for' |
24079 | if (p->error_indicator) { Branch (24079:13): [True: 0, False: 283k]
|
24080 | p->level--; |
24081 | return NULL; |
24082 | } |
24083 | D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'")); |
24084 | Token * _keyword; |
24085 | if ( |
24086 | (_keyword = _PyPegen_expect_token(p, 642)) // token='for' Branch (24086:13): [True: 4.30k, False: 278k]
|
24087 | ) |
24088 | { |
24089 | D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'")); |
24090 | _res = _keyword; |
24091 | goto done; |
24092 | } |
24093 | p->mark = _mark; |
24094 | D(fprintf(stderr, "%*c%s _tmp_10[%d-%d]: %s failed!\n", p->level, ' ', |
24095 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'")); |
24096 | } |
24097 | { // ASYNC |
24098 | if (p->error_indicator) { Branch (24098:13): [True: 0, False: 278k]
|
24099 | p->level--; |
24100 | return NULL; |
24101 | } |
24102 | D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); |
24103 | Token * async_var; |
24104 | if ( |
24105 | (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' Branch (24105:13): [True: 155, False: 278k]
|
24106 | ) |
24107 | { |
24108 | D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); |
24109 | _res = async_var; |
24110 | goto done; |
24111 | } |
24112 | p->mark = _mark; |
24113 | D(fprintf(stderr, "%*c%s _tmp_10[%d-%d]: %s failed!\n", p->level, ' ', |
24114 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); |
24115 | } |
24116 | _res = NULL; |
24117 | done: |
24118 | p->level--; |
24119 | return _res; |
24120 | } |
24121 | |
24122 | // _tmp_11: '=' annotated_rhs |
24123 | static void * |
24124 | _tmp_11_rule(Parser *p) |
24125 | { |
24126 | if (p->level++ == MAXSTACK) { Branch (24126:9): [True: 0, False: 671]
|
24127 | p->error_indicator = 1; |
24128 | PyErr_NoMemory(); |
24129 | } |
24130 | if (p->error_indicator) { Branch (24130:9): [True: 0, False: 671]
|
24131 | p->level--; |
24132 | return NULL; |
24133 | } |
24134 | void * _res = NULL; |
24135 | int _mark = p->mark; |
24136 | { // '=' annotated_rhs |
24137 | if (p->error_indicator) { Branch (24137:13): [True: 0, False: 671]
|
24138 | p->level--; |
24139 | return NULL; |
24140 | } |
24141 | D(fprintf(stderr, "%*c> _tmp_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); |
24142 | Token * _literal; |
24143 | expr_ty d; |
24144 | if ( |
24145 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' Branch (24145:13): [True: 226, False: 445]
|
24146 | && |
24147 | (d = annotated_rhs_rule(p))226 // annotated_rhs Branch (24147:13): [True: 226, False: 0]
|
24148 | ) |
24149 | { |
24150 | D(fprintf(stderr, "%*c+ _tmp_11[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); |
24151 | _res = d; |
24152 | if (_res == NULL && PyErr_Occurred()0 ) { |
24153 | p->error_indicator = 1; |
24154 | p->level--; |
24155 | return NULL; |
24156 | } |
24157 | goto done; |
24158 | } |
24159 | p->mark = _mark; |
24160 | D(fprintf(stderr, "%*c%s _tmp_11[%d-%d]: %s failed!\n", p->level, ' ', |
24161 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs")); |
24162 | } |
24163 | _res = NULL; |
24164 | done: |
24165 | p->level--; |
24166 | return _res; |
24167 | } |
24168 | |
24169 | // _tmp_12: '(' single_target ')' | single_subscript_attribute_target |
24170 | static void * |
24171 | _tmp_12_rule(Parser *p) |
24172 | { |
24173 | if (p->level++ == MAXSTACK) { Branch (24173:9): [True: 0, False: 481k]
|
24174 | p->error_indicator = 1; |
24175 | PyErr_NoMemory(); |
24176 | } |
24177 | if (p->error_indicator) { Branch (24177:9): [True: 0, False: 481k]
|
24178 | p->level--; |
24179 | return NULL; |
24180 | } |
24181 | void * _res = NULL; |
24182 | int _mark = p->mark; |
24183 | { // '(' single_target ')' |
24184 | if (p->error_indicator) { Branch (24184:13): [True: 0, False: 481k]
|
24185 | p->level--; |
24186 | return NULL; |
24187 | } |
24188 | D(fprintf(stderr, "%*c> _tmp_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); |
24189 | Token * _literal; |
24190 | Token * _literal_1; |
24191 | expr_ty b; |
24192 | if ( |
24193 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (24193:13): [True: 309, False: 481k]
|
24194 | && |
24195 | (b = single_target_rule(p))309 // single_target Branch (24195:13): [True: 216, False: 93]
|
24196 | && |
24197 | (_literal_1 = _PyPegen_expect_token(p, 8))216 // token=')' Branch (24197:13): [True: 15, False: 201]
|
24198 | ) |
24199 | { |
24200 | D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); |
24201 | _res = b; |
24202 | if (_res == NULL && PyErr_Occurred()0 ) { |
24203 | p->error_indicator = 1; |
24204 | p->level--; |
24205 | return NULL; |
24206 | } |
24207 | goto done; |
24208 | } |
24209 | p->mark = _mark; |
24210 | D(fprintf(stderr, "%*c%s _tmp_12[%d-%d]: %s failed!\n", p->level, ' ', |
24211 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); |
24212 | } |
24213 | { // single_subscript_attribute_target |
24214 | if (p->error_indicator) { Branch (24214:13): [True: 7, False: 481k]
|
24215 | p->level--; |
24216 | return NULL; |
24217 | } |
24218 | D(fprintf(stderr, "%*c> _tmp_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); |
24219 | expr_ty single_subscript_attribute_target_var; |
24220 | if ( |
24221 | (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target Branch (24221:13): [True: 12.6k, False: 469k]
|
24222 | ) |
24223 | { |
24224 | D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); |
24225 | _res = single_subscript_attribute_target_var; |
24226 | goto done; |
24227 | } |
24228 | p->mark = _mark; |
24229 | D(fprintf(stderr, "%*c%s _tmp_12[%d-%d]: %s failed!\n", p->level, ' ', |
24230 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target")); |
24231 | } |
24232 | _res = NULL; |
24233 | done: |
24234 | p->level--; |
24235 | return _res; |
24236 | } |
24237 | |
24238 | // _tmp_13: '=' annotated_rhs |
24239 | static void * |
24240 | _tmp_13_rule(Parser *p) |
24241 | { |
24242 | if (p->level++ == MAXSTACK) { Branch (24242:9): [True: 0, False: 381]
|
24243 | p->error_indicator = 1; |
24244 | PyErr_NoMemory(); |
24245 | } |
24246 | if (p->error_indicator) { Branch (24246:9): [True: 0, False: 381]
|
24247 | p->level--; |
24248 | return NULL; |
24249 | } |
24250 | void * _res = NULL; |
24251 | int _mark = p->mark; |
24252 | { // '=' annotated_rhs |
24253 | if (p->error_indicator) { Branch (24253:13): [True: 0, False: 381]
|
24254 | p->level--; |
24255 | return NULL; |
24256 | } |
24257 | D(fprintf(stderr, "%*c> _tmp_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); |
24258 | Token * _literal; |
24259 | expr_ty d; |
24260 | if ( |
24261 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' Branch (24261:13): [True: 25, False: 356]
|
24262 | && |
24263 | (d = annotated_rhs_rule(p))25 // annotated_rhs |
24264 | ) |
24265 | { |
24266 | D(fprintf(stderr, "%*c+ _tmp_13[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); |
24267 | _res = d; |
24268 | if (_res == NULL && PyErr_Occurred()0 ) { |
24269 | p->error_indicator = 1; |
24270 | p->level--; |
24271 | return NULL; |
24272 | } |
24273 | goto done; |
24274 | } |
24275 | p->mark = _mark; |
24276 | D(fprintf(stderr, "%*c%s _tmp_13[%d-%d]: %s failed!\n", p->level, ' ', |
24277 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs")); |
24278 | } |
24279 | _res = NULL; |
24280 | done: |
24281 | p->level--; |
24282 | return _res; |
24283 | } |
24284 | |
24285 | // _loop1_14: (star_targets '=') |
24286 | static asdl_seq * |
24287 | _loop1_14_rule(Parser *p) |
24288 | { |
24289 | if (p->level++ == MAXSTACK) { Branch (24289:9): [True: 0, False: 481k]
|
24290 | p->error_indicator = 1; |
24291 | PyErr_NoMemory(); |
24292 | } |
24293 | if (p->error_indicator) { Branch (24293:9): [True: 0, False: 481k]
|
24294 | p->level--; |
24295 | return NULL; |
24296 | } |
24297 | void *_res = NULL; |
24298 | int _mark = p->mark; |
24299 | int _start_mark = p->mark; |
24300 | void **_children = PyMem_Malloc(sizeof(void *)); |
24301 | if (!_children) { Branch (24301:9): [True: 0, False: 481k]
|
24302 | p->error_indicator = 1; |
24303 | PyErr_NoMemory(); |
24304 | p->level--; |
24305 | return NULL; |
24306 | } |
24307 | Py_ssize_t _children_capacity = 1; |
24308 | Py_ssize_t _n = 0; |
24309 | { // (star_targets '=') |
24310 | if (p->error_indicator) { Branch (24310:13): [True: 0, False: 481k]
|
24311 | p->level--; |
24312 | return NULL; |
24313 | } |
24314 | D(fprintf(stderr, "%*c> _loop1_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); |
24315 | void *_tmp_219_var; |
24316 | while ( |
24317 | (_tmp_219_var = _tmp_219_rule(p)) // star_targets '=' Branch (24317:13): [True: 85.1k, False: 481k]
|
24318 | ) |
24319 | { |
24320 | _res = _tmp_219_var; |
24321 | if (_n == _children_capacity) { Branch (24321:17): [True: 675, False: 84.5k]
|
24322 | _children_capacity *= 2; |
24323 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
24324 | if (!_new_children) { Branch (24324:21): [True: 0, False: 675]
|
24325 | p->error_indicator = 1; |
24326 | PyErr_NoMemory(); |
24327 | p->level--; |
24328 | return NULL; |
24329 | } |
24330 | _children = _new_children; |
24331 | } |
24332 | _children[_n++] = _res; |
24333 | _mark = p->mark; |
24334 | } |
24335 | p->mark = _mark; |
24336 | D(fprintf(stderr, "%*c%s _loop1_14[%d-%d]: %s failed!\n", p->level, ' ', |
24337 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); |
24338 | } |
24339 | if (_n == 0 || p->error_indicator84.4k ) { Branch (24339:9): [True: 396k, False: 84.4k]
Branch (24339:20): [True: 31, False: 84.4k]
|
24340 | PyMem_Free(_children); |
24341 | p->level--; |
24342 | return NULL; |
24343 | } |
24344 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
24345 | if (!_seq) { Branch (24345:9): [True: 0, False: 84.4k]
|
24346 | PyMem_Free(_children); |
24347 | p->error_indicator = 1; |
24348 | PyErr_NoMemory(); |
24349 | p->level--; |
24350 | return NULL; |
24351 | } |
24352 | for (int i = 0; 84.4k i < _n; i++85.1k ) asdl_seq_SET_UNTYPED84.4k (_seq, i, _children[i]); Branch (24352:21): [True: 85.1k, False: 84.4k]
|
24353 | PyMem_Free(_children); |
24354 | _PyPegen_insert_memo(p, _start_mark, _loop1_14_type, _seq); |
24355 | p->level--; |
24356 | return _seq; |
24357 | } |
24358 | |
24359 | // _tmp_15: yield_expr | star_expressions |
24360 | static void * |
24361 | _tmp_15_rule(Parser *p) |
24362 | { |
24363 | if (p->level++ == MAXSTACK) { Branch (24363:9): [True: 0, False: 84.4k]
|
24364 | p->error_indicator = 1; |
24365 | PyErr_NoMemory(); |
24366 | } |
24367 | if (p->error_indicator) { Branch (24367:9): [True: 0, False: 84.4k]
|
24368 | p->level--; |
24369 | return NULL; |
24370 | } |
24371 | void * _res = NULL; |
24372 | int _mark = p->mark; |
24373 | { // yield_expr |
24374 | if (p->error_indicator) { Branch (24374:13): [True: 0, False: 84.4k]
|
24375 | p->level--; |
24376 | return NULL; |
24377 | } |
24378 | D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
24379 | expr_ty yield_expr_var; |
24380 | if ( |
24381 | (yield_expr_var = yield_expr_rule(p)) // yield_expr Branch (24381:13): [True: 14, False: 84.4k]
|
24382 | ) |
24383 | { |
24384 | D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
24385 | _res = yield_expr_var; |
24386 | goto done; |
24387 | } |
24388 | p->mark = _mark; |
24389 | D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', |
24390 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); |
24391 | } |
24392 | { // star_expressions |
24393 | if (p->error_indicator) { Branch (24393:13): [True: 0, False: 84.4k]
|
24394 | p->level--; |
24395 | return NULL; |
24396 | } |
24397 | D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
24398 | expr_ty star_expressions_var; |
24399 | if ( |
24400 | (star_expressions_var = star_expressions_rule(p)) // star_expressions Branch (24400:13): [True: 84.4k, False: 16]
|
24401 | ) |
24402 | { |
24403 | D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
24404 | _res = star_expressions_var; |
24405 | goto done; |
24406 | } |
24407 | p->mark = _mark; |
24408 | D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', |
24409 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); |
24410 | } |
24411 | _res = NULL; |
24412 | done: |
24413 | p->level--; |
24414 | return _res; |
24415 | } |
24416 | |
24417 | // _tmp_16: yield_expr | star_expressions |
24418 | static void * |
24419 | _tmp_16_rule(Parser *p) |
24420 | { |
24421 | if (p->level++ == MAXSTACK) { Branch (24421:9): [True: 0, False: 2.15k]
|
24422 | p->error_indicator = 1; |
24423 | PyErr_NoMemory(); |
24424 | } |
24425 | if (p->error_indicator) { Branch (24425:9): [True: 0, False: 2.15k]
|
24426 | p->level--; |
24427 | return NULL; |
24428 | } |
24429 | void * _res = NULL; |
24430 | int _mark = p->mark; |
24431 | { // yield_expr |
24432 | if (p->error_indicator) { Branch (24432:13): [True: 0, False: 2.15k]
|
24433 | p->level--; |
24434 | return NULL; |
24435 | } |
24436 | D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
24437 | expr_ty yield_expr_var; |
24438 | if ( |
24439 | (yield_expr_var = yield_expr_rule(p)) // yield_expr Branch (24439:13): [True: 2, False: 2.15k]
|
24440 | ) |
24441 | { |
24442 | D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
24443 | _res = yield_expr_var; |
24444 | goto done; |
24445 | } |
24446 | p->mark = _mark; |
24447 | D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ', |
24448 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); |
24449 | } |
24450 | { // star_expressions |
24451 | if (p->error_indicator) { Branch (24451:13): [True: 0, False: 2.15k]
|
24452 | p->level--; |
24453 | return NULL; |
24454 | } |
24455 | D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
24456 | expr_ty star_expressions_var; |
24457 | if ( |
24458 | (star_expressions_var = star_expressions_rule(p)) // star_expressions Branch (24458:13): [True: 2.15k, False: 0]
|
24459 | ) |
24460 | { |
24461 | D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
24462 | _res = star_expressions_var; |
24463 | goto done; |
24464 | } |
24465 | p->mark = _mark; |
24466 | D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ', |
24467 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); |
24468 | } |
24469 | _res = NULL; |
24470 | done: |
24471 | p->level--; |
24472 | return _res; |
24473 | } |
24474 | |
24475 | // _tmp_17: 'from' expression |
24476 | static void * |
24477 | _tmp_17_rule(Parser *p) |
24478 | { |
24479 | if (p->level++ == MAXSTACK) { Branch (24479:9): [True: 0, False: 5.07k]
|
24480 | p->error_indicator = 1; |
24481 | PyErr_NoMemory(); |
24482 | } |
24483 | if (p->error_indicator) { Branch (24483:9): [True: 0, False: 5.07k]
|
24484 | p->level--; |
24485 | return NULL; |
24486 | } |
24487 | void * _res = NULL; |
24488 | int _mark = p->mark; |
24489 | { // 'from' expression |
24490 | if (p->error_indicator) { Branch (24490:13): [True: 0, False: 5.07k]
|
24491 | p->level--; |
24492 | return NULL; |
24493 | } |
24494 | D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression")); |
24495 | Token * _keyword; |
24496 | expr_ty z; |
24497 | if ( |
24498 | (_keyword = _PyPegen_expect_token(p, 572)) // token='from' Branch (24498:13): [True: 320, False: 4.75k]
|
24499 | && |
24500 | (z = expression_rule(p))320 // expression Branch (24500:13): [True: 320, False: 0]
|
24501 | ) |
24502 | { |
24503 | D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' expression")); |
24504 | _res = z; |
24505 | if (_res == NULL && PyErr_Occurred()0 ) { |
24506 | p->error_indicator = 1; |
24507 | p->level--; |
24508 | return NULL; |
24509 | } |
24510 | goto done; |
24511 | } |
24512 | p->mark = _mark; |
24513 | D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ', |
24514 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' expression")); |
24515 | } |
24516 | _res = NULL; |
24517 | done: |
24518 | p->level--; |
24519 | return _res; |
24520 | } |
24521 | |
24522 | // _loop0_19: ',' NAME |
24523 | static asdl_seq * |
24524 | _loop0_19_rule(Parser *p) |
24525 | { |
24526 | if (p->level++ == MAXSTACK) { Branch (24526:9): [True: 0, False: 166]
|
24527 | p->error_indicator = 1; |
24528 | PyErr_NoMemory(); |
24529 | } |
24530 | if (p->error_indicator) { Branch (24530:9): [True: 0, False: 166]
|
24531 | p->level--; |
24532 | return NULL; |
24533 | } |
24534 | void *_res = NULL; |
24535 | int _mark = p->mark; |
24536 | int _start_mark = p->mark; |
24537 | void **_children = PyMem_Malloc(sizeof(void *)); |
24538 | if (!_children) { Branch (24538:9): [True: 0, False: 166]
|
24539 | p->error_indicator = 1; |
24540 | PyErr_NoMemory(); |
24541 | p->level--; |
24542 | return NULL; |
24543 | } |
24544 | Py_ssize_t _children_capacity = 1; |
24545 | Py_ssize_t _n = 0; |
24546 | { // ',' NAME |
24547 | if (p->error_indicator) { Branch (24547:13): [True: 0, False: 166]
|
24548 | p->level--; |
24549 | return NULL; |
24550 | } |
24551 | D(fprintf(stderr, "%*c> _loop0_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME")); |
24552 | Token * _literal; |
24553 | expr_ty elem; |
24554 | while ( |
24555 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (24555:13): [True: 64, False: 166]
|
24556 | && |
24557 | (elem = _PyPegen_name_token(p))64 // NAME |
24558 | ) |
24559 | { |
24560 | _res = elem; |
24561 | if (_res == NULL && PyErr_Occurred()0 ) { |
24562 | p->error_indicator = 1; |
24563 | PyMem_Free(_children); |
24564 | p->level--; |
24565 | return NULL; |
24566 | } |
24567 | if (_n == _children_capacity) { Branch (24567:17): [True: 21, False: 43]
|
24568 | _children_capacity *= 2; |
24569 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
24570 | if (!_new_children) { |
24571 | p->error_indicator = 1; |
24572 | PyErr_NoMemory(); |
24573 | p->level--; |
24574 | return NULL; |
24575 | } |
24576 | _children = _new_children; |
24577 | } |
24578 | _children[_n++] = _res; |
24579 | _mark = p->mark; |
24580 | } |
24581 | p->mark = _mark; |
24582 | D(fprintf(stderr, "%*c%s _loop0_19[%d-%d]: %s failed!\n", p->level, ' ', |
24583 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME")); |
24584 | } |
24585 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
24586 | if (!_seq) { Branch (24586:9): [True: 0, False: 166]
|
24587 | PyMem_Free(_children); |
24588 | p->error_indicator = 1; |
24589 | PyErr_NoMemory(); |
24590 | p->level--; |
24591 | return NULL; |
24592 | } |
24593 | for (int i = 0; 166 i < _n; i++64 ) asdl_seq_SET_UNTYPED166 (_seq, i, _children[i]); Branch (24593:21): [True: 64, False: 166]
|
24594 | PyMem_Free(_children); |
24595 | _PyPegen_insert_memo(p, _start_mark, _loop0_19_type, _seq); |
24596 | p->level--; |
24597 | return _seq; |
24598 | } |
24599 | |
24600 | // _gather_18: NAME _loop0_19 |
24601 | static asdl_seq * |
24602 | _gather_18_rule(Parser *p) |
24603 | { |
24604 | if (p->level++ == MAXSTACK) { Branch (24604:9): [True: 0, False: 168]
|
24605 | p->error_indicator = 1; |
24606 | PyErr_NoMemory(); |
24607 | } |
24608 | if (p->error_indicator) { Branch (24608:9): [True: 0, False: 168]
|
24609 | p->level--; |
24610 | return NULL; |
24611 | } |
24612 | asdl_seq * _res = NULL; |
24613 | int _mark = p->mark; |
24614 | { // NAME _loop0_19 |
24615 | if (p->error_indicator) { Branch (24615:13): [True: 0, False: 168]
|
24616 | p->level--; |
24617 | return NULL; |
24618 | } |
24619 | D(fprintf(stderr, "%*c> _gather_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19")); |
24620 | expr_ty elem; |
24621 | asdl_seq * seq; |
24622 | if ( |
24623 | (elem = _PyPegen_name_token(p)) // NAME Branch (24623:13): [True: 166, False: 2]
|
24624 | && |
24625 | (seq = _loop0_19_rule(p))166 // _loop0_19 Branch (24625:13): [True: 166, False: 0]
|
24626 | ) |
24627 | { |
24628 | D(fprintf(stderr, "%*c+ _gather_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19")); |
24629 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
24630 | goto done; |
24631 | } |
24632 | p->mark = _mark; |
24633 | D(fprintf(stderr, "%*c%s _gather_18[%d-%d]: %s failed!\n", p->level, ' ', |
24634 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_19")); |
24635 | } |
24636 | _res = NULL; |
24637 | done: |
24638 | p->level--; |
24639 | return _res; |
24640 | } |
24641 | |
24642 | // _loop0_21: ',' NAME |
24643 | static asdl_seq * |
24644 | _loop0_21_rule(Parser *p) |
24645 | { |
24646 | if (p->level++ == MAXSTACK) { Branch (24646:9): [True: 0, False: 110]
|
24647 | p->error_indicator = 1; |
24648 | PyErr_NoMemory(); |
24649 | } |
24650 | if (p->error_indicator) { Branch (24650:9): [True: 0, False: 110]
|
24651 | p->level--; |
24652 | return NULL; |
24653 | } |
24654 | void *_res = NULL; |
24655 | int _mark = p->mark; |
24656 | int _start_mark = p->mark; |
24657 | void **_children = PyMem_Malloc(sizeof(void *)); |
24658 | if (!_children) { Branch (24658:9): [True: 0, False: 110]
|
24659 | p->error_indicator = 1; |
24660 | PyErr_NoMemory(); |
24661 | p->level--; |
24662 | return NULL; |
24663 | } |
24664 | Py_ssize_t _children_capacity = 1; |
24665 | Py_ssize_t _n = 0; |
24666 | { // ',' NAME |
24667 | if (p->error_indicator) { Branch (24667:13): [True: 0, False: 110]
|
24668 | p->level--; |
24669 | return NULL; |
24670 | } |
24671 | D(fprintf(stderr, "%*c> _loop0_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME")); |
24672 | Token * _literal; |
24673 | expr_ty elem; |
24674 | while ( |
24675 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (24675:13): [True: 43, False: 110]
|
24676 | && |
24677 | (elem = _PyPegen_name_token(p))43 // NAME |
24678 | ) |
24679 | { |
24680 | _res = elem; |
24681 | if (_res == NULL && PyErr_Occurred()0 ) { |
24682 | p->error_indicator = 1; |
24683 | PyMem_Free(_children); |
24684 | p->level--; |
24685 | return NULL; |
24686 | } |
24687 | if (_n == _children_capacity) { Branch (24687:17): [True: 19, False: 24]
|
24688 | _children_capacity *= 2; |
24689 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
24690 | if (!_new_children) { |
24691 | p->error_indicator = 1; |
24692 | PyErr_NoMemory(); |
24693 | p->level--; |
24694 | return NULL; |
24695 | } |
24696 | _children = _new_children; |
24697 | } |
24698 | _children[_n++] = _res; |
24699 | _mark = p->mark; |
24700 | } |
24701 | p->mark = _mark; |
24702 | D(fprintf(stderr, "%*c%s _loop0_21[%d-%d]: %s failed!\n", p->level, ' ', |
24703 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME")); |
24704 | } |
24705 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
24706 | if (!_seq) { Branch (24706:9): [True: 0, False: 110]
|
24707 | PyMem_Free(_children); |
24708 | p->error_indicator = 1; |
24709 | PyErr_NoMemory(); |
24710 | p->level--; |
24711 | return NULL; |
24712 | } |
24713 | for (int i = 0; 110 i < _n; i++43 ) asdl_seq_SET_UNTYPED110 (_seq, i, _children[i]); Branch (24713:21): [True: 43, False: 110]
|
24714 | PyMem_Free(_children); |
24715 | _PyPegen_insert_memo(p, _start_mark, _loop0_21_type, _seq); |
24716 | p->level--; |
24717 | return _seq; |
24718 | } |
24719 | |
24720 | // _gather_20: NAME _loop0_21 |
24721 | static asdl_seq * |
24722 | _gather_20_rule(Parser *p) |
24723 | { |
24724 | if (p->level++ == MAXSTACK) { Branch (24724:9): [True: 0, False: 112]
|
24725 | p->error_indicator = 1; |
24726 | PyErr_NoMemory(); |
24727 | } |
24728 | if (p->error_indicator) { Branch (24728:9): [True: 0, False: 112]
|
24729 | p->level--; |
24730 | return NULL; |
24731 | } |
24732 | asdl_seq * _res = NULL; |
24733 | int _mark = p->mark; |
24734 | { // NAME _loop0_21 |
24735 | if (p->error_indicator) { Branch (24735:13): [True: 0, False: 112]
|
24736 | p->level--; |
24737 | return NULL; |
24738 | } |
24739 | D(fprintf(stderr, "%*c> _gather_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21")); |
24740 | expr_ty elem; |
24741 | asdl_seq * seq; |
24742 | if ( |
24743 | (elem = _PyPegen_name_token(p)) // NAME Branch (24743:13): [True: 110, False: 2]
|
24744 | && |
24745 | (seq = _loop0_21_rule(p))110 // _loop0_21 Branch (24745:13): [True: 110, False: 0]
|
24746 | ) |
24747 | { |
24748 | D(fprintf(stderr, "%*c+ _gather_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21")); |
24749 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
24750 | goto done; |
24751 | } |
24752 | p->mark = _mark; |
24753 | D(fprintf(stderr, "%*c%s _gather_20[%d-%d]: %s failed!\n", p->level, ' ', |
24754 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_21")); |
24755 | } |
24756 | _res = NULL; |
24757 | done: |
24758 | p->level--; |
24759 | return _res; |
24760 | } |
24761 | |
24762 | // _tmp_22: ';' | NEWLINE |
24763 | static void * |
24764 | _tmp_22_rule(Parser *p) |
24765 | { |
24766 | if (p->level++ == MAXSTACK) { Branch (24766:9): [True: 0, False: 782]
|
24767 | p->error_indicator = 1; |
24768 | PyErr_NoMemory(); |
24769 | } |
24770 | if (p->error_indicator) { Branch (24770:9): [True: 0, False: 782]
|
24771 | p->level--; |
24772 | return NULL; |
24773 | } |
24774 | void * _res = NULL; |
24775 | int _mark = p->mark; |
24776 | { // ';' |
24777 | if (p->error_indicator) { Branch (24777:13): [True: 0, False: 782]
|
24778 | p->level--; |
24779 | return NULL; |
24780 | } |
24781 | D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); |
24782 | Token * _literal; |
24783 | if ( |
24784 | (_literal = _PyPegen_expect_token(p, 13)) // token=';' Branch (24784:13): [True: 31, False: 751]
|
24785 | ) |
24786 | { |
24787 | D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); |
24788 | _res = _literal; |
24789 | goto done; |
24790 | } |
24791 | p->mark = _mark; |
24792 | D(fprintf(stderr, "%*c%s _tmp_22[%d-%d]: %s failed!\n", p->level, ' ', |
24793 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); |
24794 | } |
24795 | { // NEWLINE |
24796 | if (p->error_indicator) { Branch (24796:13): [True: 0, False: 751]
|
24797 | p->level--; |
24798 | return NULL; |
24799 | } |
24800 | D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
24801 | Token * newline_var; |
24802 | if ( |
24803 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' Branch (24803:13): [True: 717, False: 34]
|
24804 | ) |
24805 | { |
24806 | D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
24807 | _res = newline_var; |
24808 | goto done; |
24809 | } |
24810 | p->mark = _mark; |
24811 | D(fprintf(stderr, "%*c%s _tmp_22[%d-%d]: %s failed!\n", p->level, ' ', |
24812 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); |
24813 | } |
24814 | _res = NULL; |
24815 | done: |
24816 | p->level--; |
24817 | return _res; |
24818 | } |
24819 | |
24820 | // _tmp_23: ',' expression |
24821 | static void * |
24822 | _tmp_23_rule(Parser *p) |
24823 | { |
24824 | if (p->level++ == MAXSTACK) { Branch (24824:9): [True: 0, False: 550]
|
24825 | p->error_indicator = 1; |
24826 | PyErr_NoMemory(); |
24827 | } |
24828 | if (p->error_indicator) { Branch (24828:9): [True: 0, False: 550]
|
24829 | p->level--; |
24830 | return NULL; |
24831 | } |
24832 | void * _res = NULL; |
24833 | int _mark = p->mark; |
24834 | { // ',' expression |
24835 | if (p->error_indicator) { Branch (24835:13): [True: 0, False: 550]
|
24836 | p->level--; |
24837 | return NULL; |
24838 | } |
24839 | D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); |
24840 | Token * _literal; |
24841 | expr_ty z; |
24842 | if ( |
24843 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (24843:13): [True: 120, False: 430]
|
24844 | && |
24845 | (z = expression_rule(p))120 // expression Branch (24845:13): [True: 120, False: 0]
|
24846 | ) |
24847 | { |
24848 | D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression")); |
24849 | _res = z; |
24850 | if (_res == NULL && PyErr_Occurred()0 ) { |
24851 | p->error_indicator = 1; |
24852 | p->level--; |
24853 | return NULL; |
24854 | } |
24855 | goto done; |
24856 | } |
24857 | p->mark = _mark; |
24858 | D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ', |
24859 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); |
24860 | } |
24861 | _res = NULL; |
24862 | done: |
24863 | p->level--; |
24864 | return _res; |
24865 | } |
24866 | |
24867 | // _loop0_24: ('.' | '...') |
24868 | static asdl_seq * |
24869 | _loop0_24_rule(Parser *p) |
24870 | { |
24871 | if (p->level++ == MAXSTACK) { Branch (24871:9): [True: 0, False: 2.07k]
|
24872 | p->error_indicator = 1; |
24873 | PyErr_NoMemory(); |
24874 | } |
24875 | if (p->error_indicator) { Branch (24875:9): [True: 0, False: 2.07k]
|
24876 | p->level--; |
24877 | return NULL; |
24878 | } |
24879 | void *_res = NULL; |
24880 | int _mark = p->mark; |
24881 | int _start_mark = p->mark; |
24882 | void **_children = PyMem_Malloc(sizeof(void *)); |
24883 | if (!_children) { Branch (24883:9): [True: 0, False: 2.07k]
|
24884 | p->error_indicator = 1; |
24885 | PyErr_NoMemory(); |
24886 | p->level--; |
24887 | return NULL; |
24888 | } |
24889 | Py_ssize_t _children_capacity = 1; |
24890 | Py_ssize_t _n = 0; |
24891 | { // ('.' | '...') |
24892 | if (p->error_indicator) { Branch (24892:13): [True: 0, False: 2.07k]
|
24893 | p->level--; |
24894 | return NULL; |
24895 | } |
24896 | D(fprintf(stderr, "%*c> _loop0_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); |
24897 | void *_tmp_220_var; |
24898 | while ( |
24899 | (_tmp_220_var = _tmp_220_rule(p)) // '.' | '...' Branch (24899:13): [True: 147, False: 2.07k]
|
24900 | ) |
24901 | { |
24902 | _res = _tmp_220_var; |
24903 | if (_n == _children_capacity) { Branch (24903:17): [True: 14, False: 133]
|
24904 | _children_capacity *= 2; |
24905 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
24906 | if (!_new_children) { |
24907 | p->error_indicator = 1; |
24908 | PyErr_NoMemory(); |
24909 | p->level--; |
24910 | return NULL; |
24911 | } |
24912 | _children = _new_children; |
24913 | } |
24914 | _children[_n++] = _res; |
24915 | _mark = p->mark; |
24916 | } |
24917 | p->mark = _mark; |
24918 | D(fprintf(stderr, "%*c%s _loop0_24[%d-%d]: %s failed!\n", p->level, ' ', |
24919 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')")); |
24920 | } |
24921 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
24922 | if (!_seq) { Branch (24922:9): [True: 0, False: 2.07k]
|
24923 | PyMem_Free(_children); |
24924 | p->error_indicator = 1; |
24925 | PyErr_NoMemory(); |
24926 | p->level--; |
24927 | return NULL; |
24928 | } |
24929 | for (int i = 0; 2.07k i < _n; i++147 ) asdl_seq_SET_UNTYPED2.07k (_seq, i, _children[i]); Branch (24929:21): [True: 147, False: 2.07k]
|
24930 | PyMem_Free(_children); |
24931 | _PyPegen_insert_memo(p, _start_mark, _loop0_24_type, _seq); |
24932 | p->level--; |
24933 | return _seq; |
24934 | } |
24935 | |
24936 | // _loop1_25: ('.' | '...') |
24937 | static asdl_seq * |
24938 | _loop1_25_rule(Parser *p) |
24939 | { |
24940 | if (p->level++ == MAXSTACK) { Branch (24940:9): [True: 0, False: 71]
|
24941 | p->error_indicator = 1; |
24942 | PyErr_NoMemory(); |
24943 | } |
24944 | if (p->error_indicator) { Branch (24944:9): [True: 0, False: 71]
|
24945 | p->level--; |
24946 | return NULL; |
24947 | } |
24948 | void *_res = NULL; |
24949 | int _mark = p->mark; |
24950 | int _start_mark = p->mark; |
24951 | void **_children = PyMem_Malloc(sizeof(void *)); |
24952 | if (!_children) { Branch (24952:9): [True: 0, False: 71]
|
24953 | p->error_indicator = 1; |
24954 | PyErr_NoMemory(); |
24955 | p->level--; |
24956 | return NULL; |
24957 | } |
24958 | Py_ssize_t _children_capacity = 1; |
24959 | Py_ssize_t _n = 0; |
24960 | { // ('.' | '...') |
24961 | if (p->error_indicator) { |
24962 | p->level--; |
24963 | return NULL; |
24964 | } |
24965 | D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); |
24966 | void *_tmp_221_var; |
24967 | while ( |
24968 | (_tmp_221_var = _tmp_221_rule(p)) // '.' | '...' Branch (24968:13): [True: 55, False: 71]
|
24969 | ) |
24970 | { |
24971 | _res = _tmp_221_var; |
24972 | if (_n == _children_capacity) { |
24973 | _children_capacity *= 2; |
24974 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
24975 | if (!_new_children) { |
24976 | p->error_indicator = 1; |
24977 | PyErr_NoMemory(); |
24978 | p->level--; |
24979 | return NULL; |
24980 | } |
24981 | _children = _new_children; |
24982 | } |
24983 | _children[_n++] = _res; |
24984 | _mark = p->mark; |
24985 | } |
24986 | p->mark = _mark; |
24987 | D(fprintf(stderr, "%*c%s _loop1_25[%d-%d]: %s failed!\n", p->level, ' ', |
24988 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')")); |
24989 | } |
24990 | if (_n == 0 || p->error_indicator52 ) { Branch (24990:9): [True: 19, False: 52]
Branch (24990:20): [True: 0, False: 52]
|
24991 | PyMem_Free(_children); |
24992 | p->level--; |
24993 | return NULL; |
24994 | } |
24995 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
24996 | if (!_seq) { Branch (24996:9): [True: 0, False: 52]
|
24997 | PyMem_Free(_children); |
24998 | p->error_indicator = 1; |
24999 | PyErr_NoMemory(); |
25000 | p->level--; |
25001 | return NULL; |
25002 | } |
25003 | for (int i = 0; 52 i < _n; i++55 ) asdl_seq_SET_UNTYPED52 (_seq, i, _children[i]); Branch (25003:21): [True: 55, False: 52]
|
25004 | PyMem_Free(_children); |
25005 | _PyPegen_insert_memo(p, _start_mark, _loop1_25_type, _seq); |
25006 | p->level--; |
25007 | return _seq; |
25008 | } |
25009 | |
25010 | // _loop0_27: ',' import_from_as_name |
25011 | static asdl_seq * |
25012 | _loop0_27_rule(Parser *p) |
25013 | { |
25014 | if (p->level++ == MAXSTACK) { Branch (25014:9): [True: 0, False: 1.65k]
|
25015 | p->error_indicator = 1; |
25016 | PyErr_NoMemory(); |
25017 | } |
25018 | if (p->error_indicator) { Branch (25018:9): [True: 0, False: 1.65k]
|
25019 | p->level--; |
25020 | return NULL; |
25021 | } |
25022 | void *_res = NULL; |
25023 | int _mark = p->mark; |
25024 | int _start_mark = p->mark; |
25025 | void **_children = PyMem_Malloc(sizeof(void *)); |
25026 | if (!_children) { Branch (25026:9): [True: 0, False: 1.65k]
|
25027 | p->error_indicator = 1; |
25028 | PyErr_NoMemory(); |
25029 | p->level--; |
25030 | return NULL; |
25031 | } |
25032 | Py_ssize_t _children_capacity = 1; |
25033 | Py_ssize_t _n = 0; |
25034 | { // ',' import_from_as_name |
25035 | if (p->error_indicator) { Branch (25035:13): [True: 0, False: 1.65k]
|
25036 | p->level--; |
25037 | return NULL; |
25038 | } |
25039 | D(fprintf(stderr, "%*c> _loop0_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_as_name")); |
25040 | Token * _literal; |
25041 | alias_ty elem; |
25042 | while ( |
25043 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (25043:13): [True: 801, False: 1.62k]
|
25044 | && |
25045 | (elem = import_from_as_name_rule(p))801 // import_from_as_name Branch (25045:13): [True: 767, False: 34]
|
25046 | ) |
25047 | { |
25048 | _res = elem; |
25049 | if (_res == NULL && PyErr_Occurred()0 ) { |
25050 | p->error_indicator = 1; |
25051 | PyMem_Free(_children); |
25052 | p->level--; |
25053 | return NULL; |
25054 | } |
25055 | if (_n == _children_capacity) { Branch (25055:17): [True: 276, False: 491]
|
25056 | _children_capacity *= 2; |
25057 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25058 | if (!_new_children) { Branch (25058:21): [True: 0, False: 276]
|
25059 | p->error_indicator = 1; |
25060 | PyErr_NoMemory(); |
25061 | p->level--; |
25062 | return NULL; |
25063 | } |
25064 | _children = _new_children; |
25065 | } |
25066 | _children[_n++] = _res; |
25067 | _mark = p->mark; |
25068 | } |
25069 | p->mark = _mark; |
25070 | D(fprintf(stderr, "%*c%s _loop0_27[%d-%d]: %s failed!\n", p->level, ' ', |
25071 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' import_from_as_name")); |
25072 | } |
25073 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25074 | if (!_seq) { Branch (25074:9): [True: 0, False: 1.65k]
|
25075 | PyMem_Free(_children); |
25076 | p->error_indicator = 1; |
25077 | PyErr_NoMemory(); |
25078 | p->level--; |
25079 | return NULL; |
25080 | } |
25081 | for (int i = 0; 1.65k i < _n; i++767 ) asdl_seq_SET_UNTYPED1.65k (_seq, i, _children[i]); Branch (25081:21): [True: 767, False: 1.65k]
|
25082 | PyMem_Free(_children); |
25083 | _PyPegen_insert_memo(p, _start_mark, _loop0_27_type, _seq); |
25084 | p->level--; |
25085 | return _seq; |
25086 | } |
25087 | |
25088 | // _gather_26: import_from_as_name _loop0_27 |
25089 | static asdl_seq * |
25090 | _gather_26_rule(Parser *p) |
25091 | { |
25092 | if (p->level++ == MAXSTACK) { Branch (25092:9): [True: 0, False: 2.08k]
|
25093 | p->error_indicator = 1; |
25094 | PyErr_NoMemory(); |
25095 | } |
25096 | if (p->error_indicator) { Branch (25096:9): [True: 0, False: 2.08k]
|
25097 | p->level--; |
25098 | return NULL; |
25099 | } |
25100 | asdl_seq * _res = NULL; |
25101 | int _mark = p->mark; |
25102 | { // import_from_as_name _loop0_27 |
25103 | if (p->error_indicator) { Branch (25103:13): [True: 0, False: 2.08k]
|
25104 | p->level--; |
25105 | return NULL; |
25106 | } |
25107 | D(fprintf(stderr, "%*c> _gather_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_27")); |
25108 | alias_ty elem; |
25109 | asdl_seq * seq; |
25110 | if ( |
25111 | (elem = import_from_as_name_rule(p)) // import_from_as_name Branch (25111:13): [True: 1.65k, False: 431]
|
25112 | && |
25113 | (seq = _loop0_27_rule(p))1.65k // _loop0_27 Branch (25113:13): [True: 1.65k, False: 0]
|
25114 | ) |
25115 | { |
25116 | D(fprintf(stderr, "%*c+ _gather_26[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_27")); |
25117 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
25118 | goto done; |
25119 | } |
25120 | p->mark = _mark; |
25121 | D(fprintf(stderr, "%*c%s _gather_26[%d-%d]: %s failed!\n", p->level, ' ', |
25122 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_name _loop0_27")); |
25123 | } |
25124 | _res = NULL; |
25125 | done: |
25126 | p->level--; |
25127 | return _res; |
25128 | } |
25129 | |
25130 | // _tmp_28: 'as' NAME |
25131 | static void * |
25132 | _tmp_28_rule(Parser *p) |
25133 | { |
25134 | if (p->level++ == MAXSTACK) { Branch (25134:9): [True: 0, False: 2.43k]
|
25135 | p->error_indicator = 1; |
25136 | PyErr_NoMemory(); |
25137 | } |
25138 | if (p->error_indicator) { Branch (25138:9): [True: 0, False: 2.43k]
|
25139 | p->level--; |
25140 | return NULL; |
25141 | } |
25142 | void * _res = NULL; |
25143 | int _mark = p->mark; |
25144 | { // 'as' NAME |
25145 | if (p->error_indicator) { Branch (25145:13): [True: 0, False: 2.43k]
|
25146 | p->level--; |
25147 | return NULL; |
25148 | } |
25149 | D(fprintf(stderr, "%*c> _tmp_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
25150 | Token * _keyword; |
25151 | expr_ty z; |
25152 | if ( |
25153 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' Branch (25153:13): [True: 255, False: 2.17k]
|
25154 | && |
25155 | (z = _PyPegen_name_token(p))255 // NAME Branch (25155:13): [True: 251, False: 4]
|
25156 | ) |
25157 | { |
25158 | D(fprintf(stderr, "%*c+ _tmp_28[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
25159 | _res = z; |
25160 | if (_res == NULL && PyErr_Occurred()0 ) { |
25161 | p->error_indicator = 1; |
25162 | p->level--; |
25163 | return NULL; |
25164 | } |
25165 | goto done; |
25166 | } |
25167 | p->mark = _mark; |
25168 | D(fprintf(stderr, "%*c%s _tmp_28[%d-%d]: %s failed!\n", p->level, ' ', |
25169 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
25170 | } |
25171 | _res = NULL; |
25172 | done: |
25173 | p->level--; |
25174 | return _res; |
25175 | } |
25176 | |
25177 | // _loop0_30: ',' dotted_as_name |
25178 | static asdl_seq * |
25179 | _loop0_30_rule(Parser *p) |
25180 | { |
25181 | if (p->level++ == MAXSTACK) { Branch (25181:9): [True: 0, False: 4.16k]
|
25182 | p->error_indicator = 1; |
25183 | PyErr_NoMemory(); |
25184 | } |
25185 | if (p->error_indicator) { Branch (25185:9): [True: 0, False: 4.16k]
|
25186 | p->level--; |
25187 | return NULL; |
25188 | } |
25189 | void *_res = NULL; |
25190 | int _mark = p->mark; |
25191 | int _start_mark = p->mark; |
25192 | void **_children = PyMem_Malloc(sizeof(void *)); |
25193 | if (!_children) { Branch (25193:9): [True: 0, False: 4.16k]
|
25194 | p->error_indicator = 1; |
25195 | PyErr_NoMemory(); |
25196 | p->level--; |
25197 | return NULL; |
25198 | } |
25199 | Py_ssize_t _children_capacity = 1; |
25200 | Py_ssize_t _n = 0; |
25201 | { // ',' dotted_as_name |
25202 | if (p->error_indicator) { Branch (25202:13): [True: 0, False: 4.16k]
|
25203 | p->level--; |
25204 | return NULL; |
25205 | } |
25206 | D(fprintf(stderr, "%*c> _loop0_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_name")); |
25207 | Token * _literal; |
25208 | alias_ty elem; |
25209 | while ( |
25210 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (25210:13): [True: 123, False: 4.16k]
|
25211 | && |
25212 | (elem = dotted_as_name_rule(p))123 // dotted_as_name Branch (25212:13): [True: 123, False: 0]
|
25213 | ) |
25214 | { |
25215 | _res = elem; |
25216 | if (_res == NULL && PyErr_Occurred()0 ) { |
25217 | p->error_indicator = 1; |
25218 | PyMem_Free(_children); |
25219 | p->level--; |
25220 | return NULL; |
25221 | } |
25222 | if (_n == _children_capacity) { Branch (25222:17): [True: 14, False: 109]
|
25223 | _children_capacity *= 2; |
25224 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25225 | if (!_new_children) { |
25226 | p->error_indicator = 1; |
25227 | PyErr_NoMemory(); |
25228 | p->level--; |
25229 | return NULL; |
25230 | } |
25231 | _children = _new_children; |
25232 | } |
25233 | _children[_n++] = _res; |
25234 | _mark = p->mark; |
25235 | } |
25236 | p->mark = _mark; |
25237 | D(fprintf(stderr, "%*c%s _loop0_30[%d-%d]: %s failed!\n", p->level, ' ', |
25238 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_as_name")); |
25239 | } |
25240 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25241 | if (!_seq) { Branch (25241:9): [True: 0, False: 4.16k]
|
25242 | PyMem_Free(_children); |
25243 | p->error_indicator = 1; |
25244 | PyErr_NoMemory(); |
25245 | p->level--; |
25246 | return NULL; |
25247 | } |
25248 | for (int i = 0; 4.16k i < _n; i++123 ) asdl_seq_SET_UNTYPED4.16k (_seq, i, _children[i]); Branch (25248:21): [True: 123, False: 4.16k]
|
25249 | PyMem_Free(_children); |
25250 | _PyPegen_insert_memo(p, _start_mark, _loop0_30_type, _seq); |
25251 | p->level--; |
25252 | return _seq; |
25253 | } |
25254 | |
25255 | // _gather_29: dotted_as_name _loop0_30 |
25256 | static asdl_seq * |
25257 | _gather_29_rule(Parser *p) |
25258 | { |
25259 | if (p->level++ == MAXSTACK) { Branch (25259:9): [True: 0, False: 4.18k]
|
25260 | p->error_indicator = 1; |
25261 | PyErr_NoMemory(); |
25262 | } |
25263 | if (p->error_indicator) { Branch (25263:9): [True: 0, False: 4.18k]
|
25264 | p->level--; |
25265 | return NULL; |
25266 | } |
25267 | asdl_seq * _res = NULL; |
25268 | int _mark = p->mark; |
25269 | { // dotted_as_name _loop0_30 |
25270 | if (p->error_indicator) { Branch (25270:13): [True: 0, False: 4.18k]
|
25271 | p->level--; |
25272 | return NULL; |
25273 | } |
25274 | D(fprintf(stderr, "%*c> _gather_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_30")); |
25275 | alias_ty elem; |
25276 | asdl_seq * seq; |
25277 | if ( |
25278 | (elem = dotted_as_name_rule(p)) // dotted_as_name Branch (25278:13): [True: 4.16k, False: 18]
|
25279 | && |
25280 | (seq = _loop0_30_rule(p))4.16k // _loop0_30 Branch (25280:13): [True: 4.16k, False: 0]
|
25281 | ) |
25282 | { |
25283 | D(fprintf(stderr, "%*c+ _gather_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_30")); |
25284 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
25285 | goto done; |
25286 | } |
25287 | p->mark = _mark; |
25288 | D(fprintf(stderr, "%*c%s _gather_29[%d-%d]: %s failed!\n", p->level, ' ', |
25289 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_as_name _loop0_30")); |
25290 | } |
25291 | _res = NULL; |
25292 | done: |
25293 | p->level--; |
25294 | return _res; |
25295 | } |
25296 | |
25297 | // _tmp_31: 'as' NAME |
25298 | static void * |
25299 | _tmp_31_rule(Parser *p) |
25300 | { |
25301 | if (p->level++ == MAXSTACK) { Branch (25301:9): [True: 0, False: 4.28k]
|
25302 | p->error_indicator = 1; |
25303 | PyErr_NoMemory(); |
25304 | } |
25305 | if (p->error_indicator) { Branch (25305:9): [True: 0, False: 4.28k]
|
25306 | p->level--; |
25307 | return NULL; |
25308 | } |
25309 | void * _res = NULL; |
25310 | int _mark = p->mark; |
25311 | { // 'as' NAME |
25312 | if (p->error_indicator) { Branch (25312:13): [True: 0, False: 4.28k]
|
25313 | p->level--; |
25314 | return NULL; |
25315 | } |
25316 | D(fprintf(stderr, "%*c> _tmp_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
25317 | Token * _keyword; |
25318 | expr_ty z; |
25319 | if ( |
25320 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' Branch (25320:13): [True: 146, False: 4.14k]
|
25321 | && |
25322 | (z = _PyPegen_name_token(p))146 // NAME Branch (25322:13): [True: 140, False: 6]
|
25323 | ) |
25324 | { |
25325 | D(fprintf(stderr, "%*c+ _tmp_31[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
25326 | _res = z; |
25327 | if (_res == NULL && PyErr_Occurred()0 ) { |
25328 | p->error_indicator = 1; |
25329 | p->level--; |
25330 | return NULL; |
25331 | } |
25332 | goto done; |
25333 | } |
25334 | p->mark = _mark; |
25335 | D(fprintf(stderr, "%*c%s _tmp_31[%d-%d]: %s failed!\n", p->level, ' ', |
25336 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
25337 | } |
25338 | _res = NULL; |
25339 | done: |
25340 | p->level--; |
25341 | return _res; |
25342 | } |
25343 | |
25344 | // _loop1_32: ('@' named_expression NEWLINE) |
25345 | static asdl_seq * |
25346 | _loop1_32_rule(Parser *p) |
25347 | { |
25348 | if (p->level++ == MAXSTACK) { Branch (25348:9): [True: 0, False: 38.2k]
|
25349 | p->error_indicator = 1; |
25350 | PyErr_NoMemory(); |
25351 | } |
25352 | if (p->error_indicator) { Branch (25352:9): [True: 0, False: 38.2k]
|
25353 | p->level--; |
25354 | return NULL; |
25355 | } |
25356 | void *_res = NULL; |
25357 | int _mark = p->mark; |
25358 | int _start_mark = p->mark; |
25359 | void **_children = PyMem_Malloc(sizeof(void *)); |
25360 | if (!_children) { Branch (25360:9): [True: 0, False: 38.2k]
|
25361 | p->error_indicator = 1; |
25362 | PyErr_NoMemory(); |
25363 | p->level--; |
25364 | return NULL; |
25365 | } |
25366 | Py_ssize_t _children_capacity = 1; |
25367 | Py_ssize_t _n = 0; |
25368 | { // ('@' named_expression NEWLINE) |
25369 | if (p->error_indicator) { Branch (25369:13): [True: 0, False: 38.2k]
|
25370 | p->level--; |
25371 | return NULL; |
25372 | } |
25373 | D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); |
25374 | void *_tmp_222_var; |
25375 | while ( |
25376 | (_tmp_222_var = _tmp_222_rule(p)) // '@' named_expression NEWLINE Branch (25376:13): [True: 2.91k, False: 38.2k]
|
25377 | ) |
25378 | { |
25379 | _res = _tmp_222_var; |
25380 | if (_n == _children_capacity) { Branch (25380:17): [True: 339, False: 2.57k]
|
25381 | _children_capacity *= 2; |
25382 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25383 | if (!_new_children) { Branch (25383:21): [True: 0, False: 339]
|
25384 | p->error_indicator = 1; |
25385 | PyErr_NoMemory(); |
25386 | p->level--; |
25387 | return NULL; |
25388 | } |
25389 | _children = _new_children; |
25390 | } |
25391 | _children[_n++] = _res; |
25392 | _mark = p->mark; |
25393 | } |
25394 | p->mark = _mark; |
25395 | D(fprintf(stderr, "%*c%s _loop1_32[%d-%d]: %s failed!\n", p->level, ' ', |
25396 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('@' named_expression NEWLINE)")); |
25397 | } |
25398 | if (_n == 0 || p->error_indicator2.57k ) { Branch (25398:9): [True: 35.6k, False: 2.57k]
Branch (25398:20): [True: 0, False: 2.57k]
|
25399 | PyMem_Free(_children); |
25400 | p->level--; |
25401 | return NULL; |
25402 | } |
25403 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25404 | if (!_seq) { Branch (25404:9): [True: 0, False: 2.57k]
|
25405 | PyMem_Free(_children); |
25406 | p->error_indicator = 1; |
25407 | PyErr_NoMemory(); |
25408 | p->level--; |
25409 | return NULL; |
25410 | } |
25411 | for (int i = 0; 2.57k i < _n; i++2.91k ) asdl_seq_SET_UNTYPED2.57k (_seq, i, _children[i]); Branch (25411:21): [True: 2.91k, False: 2.57k]
|
25412 | PyMem_Free(_children); |
25413 | _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq); |
25414 | p->level--; |
25415 | return _seq; |
25416 | } |
25417 | |
25418 | // _tmp_33: '(' arguments? ')' |
25419 | static void * |
25420 | _tmp_33_rule(Parser *p) |
25421 | { |
25422 | if (p->level++ == MAXSTACK) { Branch (25422:9): [True: 0, False: 4.50k]
|
25423 | p->error_indicator = 1; |
25424 | PyErr_NoMemory(); |
25425 | } |
25426 | if (p->error_indicator) { Branch (25426:9): [True: 0, False: 4.50k]
|
25427 | p->level--; |
25428 | return NULL; |
25429 | } |
25430 | void * _res = NULL; |
25431 | int _mark = p->mark; |
25432 | { // '(' arguments? ')' |
25433 | if (p->error_indicator) { Branch (25433:13): [True: 0, False: 4.50k]
|
25434 | p->level--; |
25435 | return NULL; |
25436 | } |
25437 | D(fprintf(stderr, "%*c> _tmp_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); |
25438 | Token * _literal; |
25439 | Token * _literal_1; |
25440 | void *z; |
25441 | if ( |
25442 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (25442:13): [True: 2.46k, False: 2.04k]
|
25443 | && |
25444 | (z = arguments_rule(p), !p->error_indicator)2.46k // arguments? Branch (25444:13): [True: 2.45k, False: 6]
|
25445 | && |
25446 | (_literal_1 = _PyPegen_expect_token(p, 8))2.45k // token=')' Branch (25446:13): [True: 2.45k, False: 2]
|
25447 | ) |
25448 | { |
25449 | D(fprintf(stderr, "%*c+ _tmp_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); |
25450 | _res = z; |
25451 | if (_res == NULL && PyErr_Occurred()9 ) { Branch (25451:17): [True: 9, False: 2.44k]
Branch (25451:33): [True: 0, False: 9]
|
25452 | p->error_indicator = 1; |
25453 | p->level--; |
25454 | return NULL; |
25455 | } |
25456 | goto done; |
25457 | } |
25458 | p->mark = _mark; |
25459 | D(fprintf(stderr, "%*c%s _tmp_33[%d-%d]: %s failed!\n", p->level, ' ', |
25460 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); |
25461 | } |
25462 | _res = NULL; |
25463 | done: |
25464 | p->level--; |
25465 | return _res; |
25466 | } |
25467 | |
25468 | // _tmp_34: '->' expression |
25469 | static void * |
25470 | _tmp_34_rule(Parser *p) |
25471 | { |
25472 | if (p->level++ == MAXSTACK) { Branch (25472:9): [True: 0, False: 32.3k]
|
25473 | p->error_indicator = 1; |
25474 | PyErr_NoMemory(); |
25475 | } |
25476 | if (p->error_indicator) { Branch (25476:9): [True: 0, False: 32.3k]
|
25477 | p->level--; |
25478 | return NULL; |
25479 | } |
25480 | void * _res = NULL; |
25481 | int _mark = p->mark; |
25482 | { // '->' expression |
25483 | if (p->error_indicator) { Branch (25483:13): [True: 0, False: 32.3k]
|
25484 | p->level--; |
25485 | return NULL; |
25486 | } |
25487 | D(fprintf(stderr, "%*c> _tmp_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); |
25488 | Token * _literal; |
25489 | expr_ty z; |
25490 | if ( |
25491 | (_literal = _PyPegen_expect_token(p, 51)) // token='->' Branch (25491:13): [True: 1.01k, False: 31.3k]
|
25492 | && |
25493 | (z = expression_rule(p))1.01k // expression Branch (25493:13): [True: 1.01k, False: 0]
|
25494 | ) |
25495 | { |
25496 | D(fprintf(stderr, "%*c+ _tmp_34[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression")); |
25497 | _res = z; |
25498 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (25498:17): [True: 0, False: 1.01k]
Branch (25498:33): [True: 0, False: 0]
|
25499 | p->error_indicator = 1; |
25500 | p->level--; |
25501 | return NULL; |
25502 | } |
25503 | goto done; |
25504 | } |
25505 | p->mark = _mark; |
25506 | D(fprintf(stderr, "%*c%s _tmp_34[%d-%d]: %s failed!\n", p->level, ' ', |
25507 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); |
25508 | } |
25509 | _res = NULL; |
25510 | done: |
25511 | p->level--; |
25512 | return _res; |
25513 | } |
25514 | |
25515 | // _tmp_35: '->' expression |
25516 | static void * |
25517 | _tmp_35_rule(Parser *p) |
25518 | { |
25519 | if (p->level++ == MAXSTACK) { Branch (25519:9): [True: 0, False: 701]
|
25520 | p->error_indicator = 1; |
25521 | PyErr_NoMemory(); |
25522 | } |
25523 | if (p->error_indicator) { Branch (25523:9): [True: 0, False: 701]
|
25524 | p->level--; |
25525 | return NULL; |
25526 | } |
25527 | void * _res = NULL; |
25528 | int _mark = p->mark; |
25529 | { // '->' expression |
25530 | if (p->error_indicator) { Branch (25530:13): [True: 0, False: 701]
|
25531 | p->level--; |
25532 | return NULL; |
25533 | } |
25534 | D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); |
25535 | Token * _literal; |
25536 | expr_ty z; |
25537 | if ( |
25538 | (_literal = _PyPegen_expect_token(p, 51)) // token='->' Branch (25538:13): [True: 362, False: 339]
|
25539 | && |
25540 | (z = expression_rule(p))362 // expression Branch (25540:13): [True: 362, False: 0]
|
25541 | ) |
25542 | { |
25543 | D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression")); |
25544 | _res = z; |
25545 | if (_res == NULL && PyErr_Occurred()0 ) { |
25546 | p->error_indicator = 1; |
25547 | p->level--; |
25548 | return NULL; |
25549 | } |
25550 | goto done; |
25551 | } |
25552 | p->mark = _mark; |
25553 | D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ', |
25554 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); |
25555 | } |
25556 | _res = NULL; |
25557 | done: |
25558 | p->level--; |
25559 | return _res; |
25560 | } |
25561 | |
25562 | // _loop0_36: param_no_default |
25563 | static asdl_seq * |
25564 | _loop0_36_rule(Parser *p) |
25565 | { |
25566 | if (p->level++ == MAXSTACK) { Branch (25566:9): [True: 0, False: 380]
|
25567 | p->error_indicator = 1; |
25568 | PyErr_NoMemory(); |
25569 | } |
25570 | if (p->error_indicator) { Branch (25570:9): [True: 0, False: 380]
|
25571 | p->level--; |
25572 | return NULL; |
25573 | } |
25574 | void *_res = NULL; |
25575 | int _mark = p->mark; |
25576 | int _start_mark = p->mark; |
25577 | void **_children = PyMem_Malloc(sizeof(void *)); |
25578 | if (!_children) { Branch (25578:9): [True: 0, False: 380]
|
25579 | p->error_indicator = 1; |
25580 | PyErr_NoMemory(); |
25581 | p->level--; |
25582 | return NULL; |
25583 | } |
25584 | Py_ssize_t _children_capacity = 1; |
25585 | Py_ssize_t _n = 0; |
25586 | { // param_no_default |
25587 | if (p->error_indicator) { Branch (25587:13): [True: 0, False: 380]
|
25588 | p->level--; |
25589 | return NULL; |
25590 | } |
25591 | D(fprintf(stderr, "%*c> _loop0_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
25592 | arg_ty param_no_default_var; |
25593 | while ( |
25594 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (25594:13): [True: 147, False: 380]
|
25595 | ) |
25596 | { |
25597 | _res = param_no_default_var; |
25598 | if (_n == _children_capacity) { Branch (25598:17): [True: 58, False: 89]
|
25599 | _children_capacity *= 2; |
25600 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25601 | if (!_new_children) { |
25602 | p->error_indicator = 1; |
25603 | PyErr_NoMemory(); |
25604 | p->level--; |
25605 | return NULL; |
25606 | } |
25607 | _children = _new_children; |
25608 | } |
25609 | _children[_n++] = _res; |
25610 | _mark = p->mark; |
25611 | } |
25612 | p->mark = _mark; |
25613 | D(fprintf(stderr, "%*c%s _loop0_36[%d-%d]: %s failed!\n", p->level, ' ', |
25614 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
25615 | } |
25616 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25617 | if (!_seq) { Branch (25617:9): [True: 0, False: 380]
|
25618 | PyMem_Free(_children); |
25619 | p->error_indicator = 1; |
25620 | PyErr_NoMemory(); |
25621 | p->level--; |
25622 | return NULL; |
25623 | } |
25624 | for (int i = 0; 380 i < _n; i++147 ) asdl_seq_SET_UNTYPED380 (_seq, i, _children[i]); Branch (25624:21): [True: 147, False: 380]
|
25625 | PyMem_Free(_children); |
25626 | _PyPegen_insert_memo(p, _start_mark, _loop0_36_type, _seq); |
25627 | p->level--; |
25628 | return _seq; |
25629 | } |
25630 | |
25631 | // _loop0_37: param_with_default |
25632 | static asdl_seq * |
25633 | _loop0_37_rule(Parser *p) |
25634 | { |
25635 | if (p->level++ == MAXSTACK) { Branch (25635:9): [True: 0, False: 380]
|
25636 | p->error_indicator = 1; |
25637 | PyErr_NoMemory(); |
25638 | } |
25639 | if (p->error_indicator) { Branch (25639:9): [True: 0, False: 380]
|
25640 | p->level--; |
25641 | return NULL; |
25642 | } |
25643 | void *_res = NULL; |
25644 | int _mark = p->mark; |
25645 | int _start_mark = p->mark; |
25646 | void **_children = PyMem_Malloc(sizeof(void *)); |
25647 | if (!_children) { Branch (25647:9): [True: 0, False: 380]
|
25648 | p->error_indicator = 1; |
25649 | PyErr_NoMemory(); |
25650 | p->level--; |
25651 | return NULL; |
25652 | } |
25653 | Py_ssize_t _children_capacity = 1; |
25654 | Py_ssize_t _n = 0; |
25655 | { // param_with_default |
25656 | if (p->error_indicator) { Branch (25656:13): [True: 0, False: 380]
|
25657 | p->level--; |
25658 | return NULL; |
25659 | } |
25660 | D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
25661 | NameDefaultPair* param_with_default_var; |
25662 | while ( |
25663 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (25663:13): [True: 40, False: 380]
|
25664 | ) |
25665 | { |
25666 | _res = param_with_default_var; |
25667 | if (_n == _children_capacity) { Branch (25667:17): [True: 21, False: 19]
|
25668 | _children_capacity *= 2; |
25669 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25670 | if (!_new_children) { |
25671 | p->error_indicator = 1; |
25672 | PyErr_NoMemory(); |
25673 | p->level--; |
25674 | return NULL; |
25675 | } |
25676 | _children = _new_children; |
25677 | } |
25678 | _children[_n++] = _res; |
25679 | _mark = p->mark; |
25680 | } |
25681 | p->mark = _mark; |
25682 | D(fprintf(stderr, "%*c%s _loop0_37[%d-%d]: %s failed!\n", p->level, ' ', |
25683 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
25684 | } |
25685 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25686 | if (!_seq) { Branch (25686:9): [True: 0, False: 380]
|
25687 | PyMem_Free(_children); |
25688 | p->error_indicator = 1; |
25689 | PyErr_NoMemory(); |
25690 | p->level--; |
25691 | return NULL; |
25692 | } |
25693 | for (int i = 0; 380 i < _n; i++40 ) asdl_seq_SET_UNTYPED380 (_seq, i, _children[i]); Branch (25693:21): [True: 40, False: 380]
|
25694 | PyMem_Free(_children); |
25695 | _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq); |
25696 | p->level--; |
25697 | return _seq; |
25698 | } |
25699 | |
25700 | // _loop0_38: param_with_default |
25701 | static asdl_seq * |
25702 | _loop0_38_rule(Parser *p) |
25703 | { |
25704 | if (p->level++ == MAXSTACK) { Branch (25704:9): [True: 0, False: 125]
|
25705 | p->error_indicator = 1; |
25706 | PyErr_NoMemory(); |
25707 | } |
25708 | if (p->error_indicator) { Branch (25708:9): [True: 0, False: 125]
|
25709 | p->level--; |
25710 | return NULL; |
25711 | } |
25712 | void *_res = NULL; |
25713 | int _mark = p->mark; |
25714 | int _start_mark = p->mark; |
25715 | void **_children = PyMem_Malloc(sizeof(void *)); |
25716 | if (!_children) { Branch (25716:9): [True: 0, False: 125]
|
25717 | p->error_indicator = 1; |
25718 | PyErr_NoMemory(); |
25719 | p->level--; |
25720 | return NULL; |
25721 | } |
25722 | Py_ssize_t _children_capacity = 1; |
25723 | Py_ssize_t _n = 0; |
25724 | { // param_with_default |
25725 | if (p->error_indicator) { Branch (25725:13): [True: 0, False: 125]
|
25726 | p->level--; |
25727 | return NULL; |
25728 | } |
25729 | D(fprintf(stderr, "%*c> _loop0_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
25730 | NameDefaultPair* param_with_default_var; |
25731 | while ( |
25732 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (25732:13): [True: 72, False: 125]
|
25733 | ) |
25734 | { |
25735 | _res = param_with_default_var; |
25736 | if (_n == _children_capacity) { Branch (25736:17): [True: 26, False: 46]
|
25737 | _children_capacity *= 2; |
25738 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25739 | if (!_new_children) { |
25740 | p->error_indicator = 1; |
25741 | PyErr_NoMemory(); |
25742 | p->level--; |
25743 | return NULL; |
25744 | } |
25745 | _children = _new_children; |
25746 | } |
25747 | _children[_n++] = _res; |
25748 | _mark = p->mark; |
25749 | } |
25750 | p->mark = _mark; |
25751 | D(fprintf(stderr, "%*c%s _loop0_38[%d-%d]: %s failed!\n", p->level, ' ', |
25752 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
25753 | } |
25754 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25755 | if (!_seq) { Branch (25755:9): [True: 0, False: 125]
|
25756 | PyMem_Free(_children); |
25757 | p->error_indicator = 1; |
25758 | PyErr_NoMemory(); |
25759 | p->level--; |
25760 | return NULL; |
25761 | } |
25762 | for (int i = 0; 125 i < _n; i++72 ) asdl_seq_SET_UNTYPED125 (_seq, i, _children[i]); Branch (25762:21): [True: 72, False: 125]
|
25763 | PyMem_Free(_children); |
25764 | _PyPegen_insert_memo(p, _start_mark, _loop0_38_type, _seq); |
25765 | p->level--; |
25766 | return _seq; |
25767 | } |
25768 | |
25769 | // _loop1_39: param_no_default |
25770 | static asdl_seq * |
25771 | _loop1_39_rule(Parser *p) |
25772 | { |
25773 | if (p->level++ == MAXSTACK) { Branch (25773:9): [True: 0, False: 32.8k]
|
25774 | p->error_indicator = 1; |
25775 | PyErr_NoMemory(); |
25776 | } |
25777 | if (p->error_indicator) { Branch (25777:9): [True: 0, False: 32.8k]
|
25778 | p->level--; |
25779 | return NULL; |
25780 | } |
25781 | void *_res = NULL; |
25782 | int _mark = p->mark; |
25783 | int _start_mark = p->mark; |
25784 | void **_children = PyMem_Malloc(sizeof(void *)); |
25785 | if (!_children) { Branch (25785:9): [True: 0, False: 32.8k]
|
25786 | p->error_indicator = 1; |
25787 | PyErr_NoMemory(); |
25788 | p->level--; |
25789 | return NULL; |
25790 | } |
25791 | Py_ssize_t _children_capacity = 1; |
25792 | Py_ssize_t _n = 0; |
25793 | { // param_no_default |
25794 | if (p->error_indicator) { Branch (25794:13): [True: 0, False: 32.8k]
|
25795 | p->level--; |
25796 | return NULL; |
25797 | } |
25798 | D(fprintf(stderr, "%*c> _loop1_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
25799 | arg_ty param_no_default_var; |
25800 | while ( |
25801 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (25801:13): [True: 41.9k, False: 32.8k]
|
25802 | ) |
25803 | { |
25804 | _res = param_no_default_var; |
25805 | if (_n == _children_capacity) { Branch (25805:17): [True: 12.7k, False: 29.1k]
|
25806 | _children_capacity *= 2; |
25807 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25808 | if (!_new_children) { Branch (25808:21): [True: 0, False: 12.7k]
|
25809 | p->error_indicator = 1; |
25810 | PyErr_NoMemory(); |
25811 | p->level--; |
25812 | return NULL; |
25813 | } |
25814 | _children = _new_children; |
25815 | } |
25816 | _children[_n++] = _res; |
25817 | _mark = p->mark; |
25818 | } |
25819 | p->mark = _mark; |
25820 | D(fprintf(stderr, "%*c%s _loop1_39[%d-%d]: %s failed!\n", p->level, ' ', |
25821 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
25822 | } |
25823 | if (_n == 0 || p->error_indicator26.1k ) { Branch (25823:9): [True: 6.74k, False: 26.1k]
Branch (25823:20): [True: 0, False: 26.1k]
|
25824 | PyMem_Free(_children); |
25825 | p->level--; |
25826 | return NULL; |
25827 | } |
25828 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25829 | if (!_seq) { Branch (25829:9): [True: 0, False: 26.1k]
|
25830 | PyMem_Free(_children); |
25831 | p->error_indicator = 1; |
25832 | PyErr_NoMemory(); |
25833 | p->level--; |
25834 | return NULL; |
25835 | } |
25836 | for (int i = 0; 26.1k i < _n; i++41.9k ) asdl_seq_SET_UNTYPED26.1k (_seq, i, _children[i]); Branch (25836:21): [True: 41.9k, False: 26.1k]
|
25837 | PyMem_Free(_children); |
25838 | _PyPegen_insert_memo(p, _start_mark, _loop1_39_type, _seq); |
25839 | p->level--; |
25840 | return _seq; |
25841 | } |
25842 | |
25843 | // _loop0_40: param_with_default |
25844 | static asdl_seq * |
25845 | _loop0_40_rule(Parser *p) |
25846 | { |
25847 | if (p->level++ == MAXSTACK) { Branch (25847:9): [True: 0, False: 26.1k]
|
25848 | p->error_indicator = 1; |
25849 | PyErr_NoMemory(); |
25850 | } |
25851 | if (p->error_indicator) { Branch (25851:9): [True: 0, False: 26.1k]
|
25852 | p->level--; |
25853 | return NULL; |
25854 | } |
25855 | void *_res = NULL; |
25856 | int _mark = p->mark; |
25857 | int _start_mark = p->mark; |
25858 | void **_children = PyMem_Malloc(sizeof(void *)); |
25859 | if (!_children) { Branch (25859:9): [True: 0, False: 26.1k]
|
25860 | p->error_indicator = 1; |
25861 | PyErr_NoMemory(); |
25862 | p->level--; |
25863 | return NULL; |
25864 | } |
25865 | Py_ssize_t _children_capacity = 1; |
25866 | Py_ssize_t _n = 0; |
25867 | { // param_with_default |
25868 | if (p->error_indicator) { Branch (25868:13): [True: 0, False: 26.1k]
|
25869 | p->level--; |
25870 | return NULL; |
25871 | } |
25872 | D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
25873 | NameDefaultPair* param_with_default_var; |
25874 | while ( |
25875 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (25875:13): [True: 4.39k, False: 26.1k]
|
25876 | ) |
25877 | { |
25878 | _res = param_with_default_var; |
25879 | if (_n == _children_capacity) { Branch (25879:17): [True: 1.44k, False: 2.94k]
|
25880 | _children_capacity *= 2; |
25881 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25882 | if (!_new_children) { Branch (25882:21): [True: 0, False: 1.44k]
|
25883 | p->error_indicator = 1; |
25884 | PyErr_NoMemory(); |
25885 | p->level--; |
25886 | return NULL; |
25887 | } |
25888 | _children = _new_children; |
25889 | } |
25890 | _children[_n++] = _res; |
25891 | _mark = p->mark; |
25892 | } |
25893 | p->mark = _mark; |
25894 | D(fprintf(stderr, "%*c%s _loop0_40[%d-%d]: %s failed!\n", p->level, ' ', |
25895 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
25896 | } |
25897 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25898 | if (!_seq) { Branch (25898:9): [True: 0, False: 26.1k]
|
25899 | PyMem_Free(_children); |
25900 | p->error_indicator = 1; |
25901 | PyErr_NoMemory(); |
25902 | p->level--; |
25903 | return NULL; |
25904 | } |
25905 | for (int i = 0; 26.1k i < _n; i++4.39k ) asdl_seq_SET_UNTYPED26.1k (_seq, i, _children[i]); Branch (25905:21): [True: 4.39k, False: 26.1k]
|
25906 | PyMem_Free(_children); |
25907 | _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq); |
25908 | p->level--; |
25909 | return _seq; |
25910 | } |
25911 | |
25912 | // _loop1_41: param_with_default |
25913 | static asdl_seq * |
25914 | _loop1_41_rule(Parser *p) |
25915 | { |
25916 | if (p->level++ == MAXSTACK) { Branch (25916:9): [True: 0, False: 6.74k]
|
25917 | p->error_indicator = 1; |
25918 | PyErr_NoMemory(); |
25919 | } |
25920 | if (p->error_indicator) { Branch (25920:9): [True: 0, False: 6.74k]
|
25921 | p->level--; |
25922 | return NULL; |
25923 | } |
25924 | void *_res = NULL; |
25925 | int _mark = p->mark; |
25926 | int _start_mark = p->mark; |
25927 | void **_children = PyMem_Malloc(sizeof(void *)); |
25928 | if (!_children) { Branch (25928:9): [True: 0, False: 6.74k]
|
25929 | p->error_indicator = 1; |
25930 | PyErr_NoMemory(); |
25931 | p->level--; |
25932 | return NULL; |
25933 | } |
25934 | Py_ssize_t _children_capacity = 1; |
25935 | Py_ssize_t _n = 0; |
25936 | { // param_with_default |
25937 | if (p->error_indicator) { Branch (25937:13): [True: 0, False: 6.74k]
|
25938 | p->level--; |
25939 | return NULL; |
25940 | } |
25941 | D(fprintf(stderr, "%*c> _loop1_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
25942 | NameDefaultPair* param_with_default_var; |
25943 | while ( |
25944 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (25944:13): [True: 640, False: 6.74k]
|
25945 | ) |
25946 | { |
25947 | _res = param_with_default_var; |
25948 | if (_n == _children_capacity) { Branch (25948:17): [True: 247, False: 393]
|
25949 | _children_capacity *= 2; |
25950 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
25951 | if (!_new_children) { Branch (25951:21): [True: 0, False: 247]
|
25952 | p->error_indicator = 1; |
25953 | PyErr_NoMemory(); |
25954 | p->level--; |
25955 | return NULL; |
25956 | } |
25957 | _children = _new_children; |
25958 | } |
25959 | _children[_n++] = _res; |
25960 | _mark = p->mark; |
25961 | } |
25962 | p->mark = _mark; |
25963 | D(fprintf(stderr, "%*c%s _loop1_41[%d-%d]: %s failed!\n", p->level, ' ', |
25964 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
25965 | } |
25966 | if (_n == 0 || p->error_indicator325 ) { Branch (25966:9): [True: 6.42k, False: 325]
Branch (25966:20): [True: 0, False: 325]
|
25967 | PyMem_Free(_children); |
25968 | p->level--; |
25969 | return NULL; |
25970 | } |
25971 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
25972 | if (!_seq) { Branch (25972:9): [True: 0, False: 325]
|
25973 | PyMem_Free(_children); |
25974 | p->error_indicator = 1; |
25975 | PyErr_NoMemory(); |
25976 | p->level--; |
25977 | return NULL; |
25978 | } |
25979 | for (int i = 0; 325 i < _n; i++640 ) asdl_seq_SET_UNTYPED325 (_seq, i, _children[i]); Branch (25979:21): [True: 640, False: 325]
|
25980 | PyMem_Free(_children); |
25981 | _PyPegen_insert_memo(p, _start_mark, _loop1_41_type, _seq); |
25982 | p->level--; |
25983 | return _seq; |
25984 | } |
25985 | |
25986 | // _loop1_42: param_no_default |
25987 | static asdl_seq * |
25988 | _loop1_42_rule(Parser *p) |
25989 | { |
25990 | if (p->level++ == MAXSTACK) { Branch (25990:9): [True: 0, False: 33.9k]
|
25991 | p->error_indicator = 1; |
25992 | PyErr_NoMemory(); |
25993 | } |
25994 | if (p->error_indicator) { Branch (25994:9): [True: 0, False: 33.9k]
|
25995 | p->level--; |
25996 | return NULL; |
25997 | } |
25998 | void *_res = NULL; |
25999 | int _mark = p->mark; |
26000 | int _start_mark = p->mark; |
26001 | void **_children = PyMem_Malloc(sizeof(void *)); |
26002 | if (!_children) { Branch (26002:9): [True: 0, False: 33.9k]
|
26003 | p->error_indicator = 1; |
26004 | PyErr_NoMemory(); |
26005 | p->level--; |
26006 | return NULL; |
26007 | } |
26008 | Py_ssize_t _children_capacity = 1; |
26009 | Py_ssize_t _n = 0; |
26010 | { // param_no_default |
26011 | if (p->error_indicator) { Branch (26011:13): [True: 0, False: 33.9k]
|
26012 | p->level--; |
26013 | return NULL; |
26014 | } |
26015 | D(fprintf(stderr, "%*c> _loop1_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
26016 | arg_ty param_no_default_var; |
26017 | while ( |
26018 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (26018:13): [True: 43.2k, False: 33.9k]
|
26019 | ) |
26020 | { |
26021 | _res = param_no_default_var; |
26022 | if (_n == _children_capacity) { Branch (26022:17): [True: 12.8k, False: 30.3k]
|
26023 | _children_capacity *= 2; |
26024 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26025 | if (!_new_children) { Branch (26025:21): [True: 0, False: 12.8k]
|
26026 | p->error_indicator = 1; |
26027 | PyErr_NoMemory(); |
26028 | p->level--; |
26029 | return NULL; |
26030 | } |
26031 | _children = _new_children; |
26032 | } |
26033 | _children[_n++] = _res; |
26034 | _mark = p->mark; |
26035 | } |
26036 | p->mark = _mark; |
26037 | D(fprintf(stderr, "%*c%s _loop1_42[%d-%d]: %s failed!\n", p->level, ' ', |
26038 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
26039 | } |
26040 | if (_n == 0 || p->error_indicator26.6k ) { Branch (26040:9): [True: 7.24k, False: 26.6k]
Branch (26040:20): [True: 4, False: 26.6k]
|
26041 | PyMem_Free(_children); |
26042 | p->level--; |
26043 | return NULL; |
26044 | } |
26045 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26046 | if (!_seq) { Branch (26046:9): [True: 0, False: 26.6k]
|
26047 | PyMem_Free(_children); |
26048 | p->error_indicator = 1; |
26049 | PyErr_NoMemory(); |
26050 | p->level--; |
26051 | return NULL; |
26052 | } |
26053 | for (int i = 0; 26.6k i < _n; i++43.2k ) asdl_seq_SET_UNTYPED26.6k (_seq, i, _children[i]); Branch (26053:21): [True: 43.2k, False: 26.6k]
|
26054 | PyMem_Free(_children); |
26055 | _PyPegen_insert_memo(p, _start_mark, _loop1_42_type, _seq); |
26056 | p->level--; |
26057 | return _seq; |
26058 | } |
26059 | |
26060 | // _loop1_43: param_no_default |
26061 | static asdl_seq * |
26062 | _loop1_43_rule(Parser *p) |
26063 | { |
26064 | if (p->level++ == MAXSTACK) { Branch (26064:9): [True: 0, False: 33.5k]
|
26065 | p->error_indicator = 1; |
26066 | PyErr_NoMemory(); |
26067 | } |
26068 | if (p->error_indicator) { Branch (26068:9): [True: 0, False: 33.5k]
|
26069 | p->level--; |
26070 | return NULL; |
26071 | } |
26072 | void *_res = NULL; |
26073 | int _mark = p->mark; |
26074 | int _start_mark = p->mark; |
26075 | void **_children = PyMem_Malloc(sizeof(void *)); |
26076 | if (!_children) { Branch (26076:9): [True: 0, False: 33.5k]
|
26077 | p->error_indicator = 1; |
26078 | PyErr_NoMemory(); |
26079 | p->level--; |
26080 | return NULL; |
26081 | } |
26082 | Py_ssize_t _children_capacity = 1; |
26083 | Py_ssize_t _n = 0; |
26084 | { // param_no_default |
26085 | if (p->error_indicator) { Branch (26085:13): [True: 0, False: 33.5k]
|
26086 | p->level--; |
26087 | return NULL; |
26088 | } |
26089 | D(fprintf(stderr, "%*c> _loop1_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
26090 | arg_ty param_no_default_var; |
26091 | while ( |
26092 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (26092:13): [True: 42.7k, False: 33.5k]
|
26093 | ) |
26094 | { |
26095 | _res = param_no_default_var; |
26096 | if (_n == _children_capacity) { Branch (26096:17): [True: 12.7k, False: 29.9k]
|
26097 | _children_capacity *= 2; |
26098 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26099 | if (!_new_children) { Branch (26099:21): [True: 0, False: 12.7k]
|
26100 | p->error_indicator = 1; |
26101 | PyErr_NoMemory(); |
26102 | p->level--; |
26103 | return NULL; |
26104 | } |
26105 | _children = _new_children; |
26106 | } |
26107 | _children[_n++] = _res; |
26108 | _mark = p->mark; |
26109 | } |
26110 | p->mark = _mark; |
26111 | D(fprintf(stderr, "%*c%s _loop1_43[%d-%d]: %s failed!\n", p->level, ' ', |
26112 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
26113 | } |
26114 | if (_n == 0 || p->error_indicator26.3k ) { Branch (26114:9): [True: 7.24k, False: 26.3k]
Branch (26114:20): [True: 0, False: 26.3k]
|
26115 | PyMem_Free(_children); |
26116 | p->level--; |
26117 | return NULL; |
26118 | } |
26119 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26120 | if (!_seq) { Branch (26120:9): [True: 0, False: 26.3k]
|
26121 | PyMem_Free(_children); |
26122 | p->error_indicator = 1; |
26123 | PyErr_NoMemory(); |
26124 | p->level--; |
26125 | return NULL; |
26126 | } |
26127 | for (int i = 0; 26.3k i < _n; i++42.7k ) asdl_seq_SET_UNTYPED26.3k (_seq, i, _children[i]); Branch (26127:21): [True: 42.7k, False: 26.3k]
|
26128 | PyMem_Free(_children); |
26129 | _PyPegen_insert_memo(p, _start_mark, _loop1_43_type, _seq); |
26130 | p->level--; |
26131 | return _seq; |
26132 | } |
26133 | |
26134 | // _loop0_44: param_no_default |
26135 | static asdl_seq * |
26136 | _loop0_44_rule(Parser *p) |
26137 | { |
26138 | if (p->level++ == MAXSTACK) { Branch (26138:9): [True: 0, False: 33.7k]
|
26139 | p->error_indicator = 1; |
26140 | PyErr_NoMemory(); |
26141 | } |
26142 | if (p->error_indicator) { Branch (26142:9): [True: 0, False: 33.7k]
|
26143 | p->level--; |
26144 | return NULL; |
26145 | } |
26146 | void *_res = NULL; |
26147 | int _mark = p->mark; |
26148 | int _start_mark = p->mark; |
26149 | void **_children = PyMem_Malloc(sizeof(void *)); |
26150 | if (!_children) { Branch (26150:9): [True: 0, False: 33.7k]
|
26151 | p->error_indicator = 1; |
26152 | PyErr_NoMemory(); |
26153 | p->level--; |
26154 | return NULL; |
26155 | } |
26156 | Py_ssize_t _children_capacity = 1; |
26157 | Py_ssize_t _n = 0; |
26158 | { // param_no_default |
26159 | if (p->error_indicator) { Branch (26159:13): [True: 0, False: 33.7k]
|
26160 | p->level--; |
26161 | return NULL; |
26162 | } |
26163 | D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
26164 | arg_ty param_no_default_var; |
26165 | while ( |
26166 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (26166:13): [True: 42.0k, False: 33.7k]
|
26167 | ) |
26168 | { |
26169 | _res = param_no_default_var; |
26170 | if (_n == _children_capacity) { Branch (26170:17): [True: 12.7k, False: 29.3k]
|
26171 | _children_capacity *= 2; |
26172 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26173 | if (!_new_children) { Branch (26173:21): [True: 0, False: 12.7k]
|
26174 | p->error_indicator = 1; |
26175 | PyErr_NoMemory(); |
26176 | p->level--; |
26177 | return NULL; |
26178 | } |
26179 | _children = _new_children; |
26180 | } |
26181 | _children[_n++] = _res; |
26182 | _mark = p->mark; |
26183 | } |
26184 | p->mark = _mark; |
26185 | D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ', |
26186 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
26187 | } |
26188 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26189 | if (!_seq) { Branch (26189:9): [True: 0, False: 33.7k]
|
26190 | PyMem_Free(_children); |
26191 | p->error_indicator = 1; |
26192 | PyErr_NoMemory(); |
26193 | p->level--; |
26194 | return NULL; |
26195 | } |
26196 | for (int i = 0; 33.7k i < _n; i++42.0k ) asdl_seq_SET_UNTYPED33.7k (_seq, i, _children[i]); Branch (26196:21): [True: 42.0k, False: 33.7k]
|
26197 | PyMem_Free(_children); |
26198 | _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq); |
26199 | p->level--; |
26200 | return _seq; |
26201 | } |
26202 | |
26203 | // _loop1_45: param_with_default |
26204 | static asdl_seq * |
26205 | _loop1_45_rule(Parser *p) |
26206 | { |
26207 | if (p->level++ == MAXSTACK) { Branch (26207:9): [True: 0, False: 33.7k]
|
26208 | p->error_indicator = 1; |
26209 | PyErr_NoMemory(); |
26210 | } |
26211 | if (p->error_indicator) { Branch (26211:9): [True: 0, False: 33.7k]
|
26212 | p->level--; |
26213 | return NULL; |
26214 | } |
26215 | void *_res = NULL; |
26216 | int _mark = p->mark; |
26217 | int _start_mark = p->mark; |
26218 | void **_children = PyMem_Malloc(sizeof(void *)); |
26219 | if (!_children) { Branch (26219:9): [True: 0, False: 33.7k]
|
26220 | p->error_indicator = 1; |
26221 | PyErr_NoMemory(); |
26222 | p->level--; |
26223 | return NULL; |
26224 | } |
26225 | Py_ssize_t _children_capacity = 1; |
26226 | Py_ssize_t _n = 0; |
26227 | { // param_with_default |
26228 | if (p->error_indicator) { Branch (26228:13): [True: 0, False: 33.7k]
|
26229 | p->level--; |
26230 | return NULL; |
26231 | } |
26232 | D(fprintf(stderr, "%*c> _loop1_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
26233 | NameDefaultPair* param_with_default_var; |
26234 | while ( |
26235 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (26235:13): [True: 5.18k, False: 33.7k]
|
26236 | ) |
26237 | { |
26238 | _res = param_with_default_var; |
26239 | if (_n == _children_capacity) { Branch (26239:17): [True: 1.70k, False: 3.48k]
|
26240 | _children_capacity *= 2; |
26241 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26242 | if (!_new_children) { Branch (26242:21): [True: 0, False: 1.70k]
|
26243 | p->error_indicator = 1; |
26244 | PyErr_NoMemory(); |
26245 | p->level--; |
26246 | return NULL; |
26247 | } |
26248 | _children = _new_children; |
26249 | } |
26250 | _children[_n++] = _res; |
26251 | _mark = p->mark; |
26252 | } |
26253 | p->mark = _mark; |
26254 | D(fprintf(stderr, "%*c%s _loop1_45[%d-%d]: %s failed!\n", p->level, ' ', |
26255 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
26256 | } |
26257 | if (_n == 0 || p->error_indicator3.00k ) { Branch (26257:9): [True: 30.7k, False: 3.00k]
Branch (26257:20): [True: 1, False: 3.00k]
|
26258 | PyMem_Free(_children); |
26259 | p->level--; |
26260 | return NULL; |
26261 | } |
26262 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26263 | if (!_seq) { Branch (26263:9): [True: 0, False: 3.00k]
|
26264 | PyMem_Free(_children); |
26265 | p->error_indicator = 1; |
26266 | PyErr_NoMemory(); |
26267 | p->level--; |
26268 | return NULL; |
26269 | } |
26270 | for (int i = 0; 3.00k i < _n; i++5.18k ) asdl_seq_SET_UNTYPED3.00k (_seq, i, _children[i]); Branch (26270:21): [True: 5.18k, False: 3.00k]
|
26271 | PyMem_Free(_children); |
26272 | _PyPegen_insert_memo(p, _start_mark, _loop1_45_type, _seq); |
26273 | p->level--; |
26274 | return _seq; |
26275 | } |
26276 | |
26277 | // _loop0_46: param_no_default |
26278 | static asdl_seq * |
26279 | _loop0_46_rule(Parser *p) |
26280 | { |
26281 | if (p->level++ == MAXSTACK) { Branch (26281:9): [True: 0, False: 33.6k]
|
26282 | p->error_indicator = 1; |
26283 | PyErr_NoMemory(); |
26284 | } |
26285 | if (p->error_indicator) { Branch (26285:9): [True: 0, False: 33.6k]
|
26286 | p->level--; |
26287 | return NULL; |
26288 | } |
26289 | void *_res = NULL; |
26290 | int _mark = p->mark; |
26291 | int _start_mark = p->mark; |
26292 | void **_children = PyMem_Malloc(sizeof(void *)); |
26293 | if (!_children) { Branch (26293:9): [True: 0, False: 33.6k]
|
26294 | p->error_indicator = 1; |
26295 | PyErr_NoMemory(); |
26296 | p->level--; |
26297 | return NULL; |
26298 | } |
26299 | Py_ssize_t _children_capacity = 1; |
26300 | Py_ssize_t _n = 0; |
26301 | { // param_no_default |
26302 | if (p->error_indicator) { Branch (26302:13): [True: 0, False: 33.6k]
|
26303 | p->level--; |
26304 | return NULL; |
26305 | } |
26306 | D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
26307 | arg_ty param_no_default_var; |
26308 | while ( |
26309 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (26309:13): [True: 42.0k, False: 33.6k]
|
26310 | ) |
26311 | { |
26312 | _res = param_no_default_var; |
26313 | if (_n == _children_capacity) { Branch (26313:17): [True: 12.7k, False: 29.2k]
|
26314 | _children_capacity *= 2; |
26315 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26316 | if (!_new_children) { Branch (26316:21): [True: 0, False: 12.7k]
|
26317 | p->error_indicator = 1; |
26318 | PyErr_NoMemory(); |
26319 | p->level--; |
26320 | return NULL; |
26321 | } |
26322 | _children = _new_children; |
26323 | } |
26324 | _children[_n++] = _res; |
26325 | _mark = p->mark; |
26326 | } |
26327 | p->mark = _mark; |
26328 | D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ', |
26329 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
26330 | } |
26331 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26332 | if (!_seq) { Branch (26332:9): [True: 0, False: 33.6k]
|
26333 | PyMem_Free(_children); |
26334 | p->error_indicator = 1; |
26335 | PyErr_NoMemory(); |
26336 | p->level--; |
26337 | return NULL; |
26338 | } |
26339 | for (int i = 0; 33.6k i < _n; i++42.0k ) asdl_seq_SET_UNTYPED33.6k (_seq, i, _children[i]); Branch (26339:21): [True: 42.0k, False: 33.6k]
|
26340 | PyMem_Free(_children); |
26341 | _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq); |
26342 | p->level--; |
26343 | return _seq; |
26344 | } |
26345 | |
26346 | // _loop1_47: param_with_default |
26347 | static asdl_seq * |
26348 | _loop1_47_rule(Parser *p) |
26349 | { |
26350 | if (p->level++ == MAXSTACK) { Branch (26350:9): [True: 0, False: 33.6k]
|
26351 | p->error_indicator = 1; |
26352 | PyErr_NoMemory(); |
26353 | } |
26354 | if (p->error_indicator) { Branch (26354:9): [True: 0, False: 33.6k]
|
26355 | p->level--; |
26356 | return NULL; |
26357 | } |
26358 | void *_res = NULL; |
26359 | int _mark = p->mark; |
26360 | int _start_mark = p->mark; |
26361 | void **_children = PyMem_Malloc(sizeof(void *)); |
26362 | if (!_children) { Branch (26362:9): [True: 0, False: 33.6k]
|
26363 | p->error_indicator = 1; |
26364 | PyErr_NoMemory(); |
26365 | p->level--; |
26366 | return NULL; |
26367 | } |
26368 | Py_ssize_t _children_capacity = 1; |
26369 | Py_ssize_t _n = 0; |
26370 | { // param_with_default |
26371 | if (p->error_indicator) { Branch (26371:13): [True: 0, False: 33.6k]
|
26372 | p->level--; |
26373 | return NULL; |
26374 | } |
26375 | D(fprintf(stderr, "%*c> _loop1_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
26376 | NameDefaultPair* param_with_default_var; |
26377 | while ( |
26378 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (26378:13): [True: 5.05k, False: 33.6k]
|
26379 | ) |
26380 | { |
26381 | _res = param_with_default_var; |
26382 | if (_n == _children_capacity) { Branch (26382:17): [True: 1.69k, False: 3.36k]
|
26383 | _children_capacity *= 2; |
26384 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26385 | if (!_new_children) { Branch (26385:21): [True: 0, False: 1.69k]
|
26386 | p->error_indicator = 1; |
26387 | PyErr_NoMemory(); |
26388 | p->level--; |
26389 | return NULL; |
26390 | } |
26391 | _children = _new_children; |
26392 | } |
26393 | _children[_n++] = _res; |
26394 | _mark = p->mark; |
26395 | } |
26396 | p->mark = _mark; |
26397 | D(fprintf(stderr, "%*c%s _loop1_47[%d-%d]: %s failed!\n", p->level, ' ', |
26398 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
26399 | } |
26400 | if (_n == 0 || p->error_indicator2.88k ) { Branch (26400:9): [True: 30.7k, False: 2.88k]
Branch (26400:20): [True: 0, False: 2.88k]
|
26401 | PyMem_Free(_children); |
26402 | p->level--; |
26403 | return NULL; |
26404 | } |
26405 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26406 | if (!_seq) { Branch (26406:9): [True: 0, False: 2.88k]
|
26407 | PyMem_Free(_children); |
26408 | p->error_indicator = 1; |
26409 | PyErr_NoMemory(); |
26410 | p->level--; |
26411 | return NULL; |
26412 | } |
26413 | for (int i = 0; 2.88k i < _n; i++5.05k ) asdl_seq_SET_UNTYPED2.88k (_seq, i, _children[i]); Branch (26413:21): [True: 5.05k, False: 2.88k]
|
26414 | PyMem_Free(_children); |
26415 | _PyPegen_insert_memo(p, _start_mark, _loop1_47_type, _seq); |
26416 | p->level--; |
26417 | return _seq; |
26418 | } |
26419 | |
26420 | // _loop0_48: param_maybe_default |
26421 | static asdl_seq * |
26422 | _loop0_48_rule(Parser *p) |
26423 | { |
26424 | if (p->level++ == MAXSTACK) { Branch (26424:9): [True: 0, False: 2.06k]
|
26425 | p->error_indicator = 1; |
26426 | PyErr_NoMemory(); |
26427 | } |
26428 | if (p->error_indicator) { Branch (26428:9): [True: 0, False: 2.06k]
|
26429 | p->level--; |
26430 | return NULL; |
26431 | } |
26432 | void *_res = NULL; |
26433 | int _mark = p->mark; |
26434 | int _start_mark = p->mark; |
26435 | void **_children = PyMem_Malloc(sizeof(void *)); |
26436 | if (!_children) { Branch (26436:9): [True: 0, False: 2.06k]
|
26437 | p->error_indicator = 1; |
26438 | PyErr_NoMemory(); |
26439 | p->level--; |
26440 | return NULL; |
26441 | } |
26442 | Py_ssize_t _children_capacity = 1; |
26443 | Py_ssize_t _n = 0; |
26444 | { // param_maybe_default |
26445 | if (p->error_indicator) { Branch (26445:13): [True: 0, False: 2.06k]
|
26446 | p->level--; |
26447 | return NULL; |
26448 | } |
26449 | D(fprintf(stderr, "%*c> _loop0_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
26450 | NameDefaultPair* param_maybe_default_var; |
26451 | while ( |
26452 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default Branch (26452:13): [True: 186, False: 2.06k]
|
26453 | ) |
26454 | { |
26455 | _res = param_maybe_default_var; |
26456 | if (_n == _children_capacity) { Branch (26456:17): [True: 47, False: 139]
|
26457 | _children_capacity *= 2; |
26458 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26459 | if (!_new_children) { |
26460 | p->error_indicator = 1; |
26461 | PyErr_NoMemory(); |
26462 | p->level--; |
26463 | return NULL; |
26464 | } |
26465 | _children = _new_children; |
26466 | } |
26467 | _children[_n++] = _res; |
26468 | _mark = p->mark; |
26469 | } |
26470 | p->mark = _mark; |
26471 | D(fprintf(stderr, "%*c%s _loop0_48[%d-%d]: %s failed!\n", p->level, ' ', |
26472 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
26473 | } |
26474 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26475 | if (!_seq) { Branch (26475:9): [True: 0, False: 2.06k]
|
26476 | PyMem_Free(_children); |
26477 | p->error_indicator = 1; |
26478 | PyErr_NoMemory(); |
26479 | p->level--; |
26480 | return NULL; |
26481 | } |
26482 | for (int i = 0; 2.06k i < _n; i++186 ) asdl_seq_SET_UNTYPED2.06k (_seq, i, _children[i]); Branch (26482:21): [True: 186, False: 2.06k]
|
26483 | PyMem_Free(_children); |
26484 | _PyPegen_insert_memo(p, _start_mark, _loop0_48_type, _seq); |
26485 | p->level--; |
26486 | return _seq; |
26487 | } |
26488 | |
26489 | // _loop0_49: param_maybe_default |
26490 | static asdl_seq * |
26491 | _loop0_49_rule(Parser *p) |
26492 | { |
26493 | if (p->level++ == MAXSTACK) { Branch (26493:9): [True: 0, False: 20]
|
26494 | p->error_indicator = 1; |
26495 | PyErr_NoMemory(); |
26496 | } |
26497 | if (p->error_indicator) { Branch (26497:9): [True: 0, False: 20]
|
26498 | p->level--; |
26499 | return NULL; |
26500 | } |
26501 | void *_res = NULL; |
26502 | int _mark = p->mark; |
26503 | int _start_mark = p->mark; |
26504 | void **_children = PyMem_Malloc(sizeof(void *)); |
26505 | if (!_children) { Branch (26505:9): [True: 0, False: 20]
|
26506 | p->error_indicator = 1; |
26507 | PyErr_NoMemory(); |
26508 | p->level--; |
26509 | return NULL; |
26510 | } |
26511 | Py_ssize_t _children_capacity = 1; |
26512 | Py_ssize_t _n = 0; |
26513 | { // param_maybe_default |
26514 | if (p->error_indicator) { |
26515 | p->level--; |
26516 | return NULL; |
26517 | } |
26518 | D(fprintf(stderr, "%*c> _loop0_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
26519 | NameDefaultPair* param_maybe_default_var; |
26520 | while ( |
26521 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default |
26522 | ) |
26523 | { |
26524 | _res = param_maybe_default_var; |
26525 | if (_n == _children_capacity) { |
26526 | _children_capacity *= 2; |
26527 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26528 | if (!_new_children) { |
26529 | p->error_indicator = 1; |
26530 | PyErr_NoMemory(); |
26531 | p->level--; |
26532 | return NULL; |
26533 | } |
26534 | _children = _new_children; |
26535 | } |
26536 | _children[_n++] = _res; |
26537 | _mark = p->mark; |
26538 | } |
26539 | p->mark = _mark; |
26540 | D(fprintf(stderr, "%*c%s _loop0_49[%d-%d]: %s failed!\n", p->level, ' ', |
26541 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
26542 | } |
26543 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26544 | if (!_seq) { Branch (26544:9): [True: 0, False: 20]
|
26545 | PyMem_Free(_children); |
26546 | p->error_indicator = 1; |
26547 | PyErr_NoMemory(); |
26548 | p->level--; |
26549 | return NULL; |
26550 | } |
26551 | for (int i = 0; 20 i < _n; i++3 ) asdl_seq_SET_UNTYPED20 (_seq, i, _children[i]); |
26552 | PyMem_Free(_children); |
26553 | _PyPegen_insert_memo(p, _start_mark, _loop0_49_type, _seq); |
26554 | p->level--; |
26555 | return _seq; |
26556 | } |
26557 | |
26558 | // _loop1_50: param_maybe_default |
26559 | static asdl_seq * |
26560 | _loop1_50_rule(Parser *p) |
26561 | { |
26562 | if (p->level++ == MAXSTACK) { Branch (26562:9): [True: 0, False: 1.08k]
|
26563 | p->error_indicator = 1; |
26564 | PyErr_NoMemory(); |
26565 | } |
26566 | if (p->error_indicator) { Branch (26566:9): [True: 0, False: 1.08k]
|
26567 | p->level--; |
26568 | return NULL; |
26569 | } |
26570 | void *_res = NULL; |
26571 | int _mark = p->mark; |
26572 | int _start_mark = p->mark; |
26573 | void **_children = PyMem_Malloc(sizeof(void *)); |
26574 | if (!_children) { Branch (26574:9): [True: 0, False: 1.08k]
|
26575 | p->error_indicator = 1; |
26576 | PyErr_NoMemory(); |
26577 | p->level--; |
26578 | return NULL; |
26579 | } |
26580 | Py_ssize_t _children_capacity = 1; |
26581 | Py_ssize_t _n = 0; |
26582 | { // param_maybe_default |
26583 | if (p->error_indicator) { Branch (26583:13): [True: 0, False: 1.08k]
|
26584 | p->level--; |
26585 | return NULL; |
26586 | } |
26587 | D(fprintf(stderr, "%*c> _loop1_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
26588 | NameDefaultPair* param_maybe_default_var; |
26589 | while ( |
26590 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default Branch (26590:13): [True: 3.67k, False: 1.08k]
|
26591 | ) |
26592 | { |
26593 | _res = param_maybe_default_var; |
26594 | if (_n == _children_capacity) { Branch (26594:17): [True: 1.67k, False: 1.99k]
|
26595 | _children_capacity *= 2; |
26596 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26597 | if (!_new_children) { Branch (26597:21): [True: 0, False: 1.67k]
|
26598 | p->error_indicator = 1; |
26599 | PyErr_NoMemory(); |
26600 | p->level--; |
26601 | return NULL; |
26602 | } |
26603 | _children = _new_children; |
26604 | } |
26605 | _children[_n++] = _res; |
26606 | _mark = p->mark; |
26607 | } |
26608 | p->mark = _mark; |
26609 | D(fprintf(stderr, "%*c%s _loop1_50[%d-%d]: %s failed!\n", p->level, ' ', |
26610 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
26611 | } |
26612 | if (_n == 0 || p->error_indicator1.06k ) { Branch (26612:9): [True: 13, False: 1.06k]
Branch (26612:20): [True: 0, False: 1.06k]
|
26613 | PyMem_Free(_children); |
26614 | p->level--; |
26615 | return NULL; |
26616 | } |
26617 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26618 | if (!_seq) { Branch (26618:9): [True: 0, False: 1.06k]
|
26619 | PyMem_Free(_children); |
26620 | p->error_indicator = 1; |
26621 | PyErr_NoMemory(); |
26622 | p->level--; |
26623 | return NULL; |
26624 | } |
26625 | for (int i = 0; 1.06k i < _n; i++3.67k ) asdl_seq_SET_UNTYPED1.06k (_seq, i, _children[i]); Branch (26625:21): [True: 3.67k, False: 1.06k]
|
26626 | PyMem_Free(_children); |
26627 | _PyPegen_insert_memo(p, _start_mark, _loop1_50_type, _seq); |
26628 | p->level--; |
26629 | return _seq; |
26630 | } |
26631 | |
26632 | // _loop0_52: ',' with_item |
26633 | static asdl_seq * |
26634 | _loop0_52_rule(Parser *p) |
26635 | { |
26636 | if (p->level++ == MAXSTACK) { Branch (26636:9): [True: 0, False: 26]
|
26637 | p->error_indicator = 1; |
26638 | PyErr_NoMemory(); |
26639 | } |
26640 | if (p->error_indicator) { Branch (26640:9): [True: 0, False: 26]
|
26641 | p->level--; |
26642 | return NULL; |
26643 | } |
26644 | void *_res = NULL; |
26645 | int _mark = p->mark; |
26646 | int _start_mark = p->mark; |
26647 | void **_children = PyMem_Malloc(sizeof(void *)); |
26648 | if (!_children) { Branch (26648:9): [True: 0, False: 26]
|
26649 | p->error_indicator = 1; |
26650 | PyErr_NoMemory(); |
26651 | p->level--; |
26652 | return NULL; |
26653 | } |
26654 | Py_ssize_t _children_capacity = 1; |
26655 | Py_ssize_t _n = 0; |
26656 | { // ',' with_item |
26657 | if (p->error_indicator) { |
26658 | p->level--; |
26659 | return NULL; |
26660 | } |
26661 | D(fprintf(stderr, "%*c> _loop0_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); |
26662 | Token * _literal; |
26663 | withitem_ty elem; |
26664 | while ( |
26665 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (26665:13): [True: 29, False: 20]
|
26666 | && |
26667 | (elem = with_item_rule(p))29 // with_item |
26668 | ) |
26669 | { |
26670 | _res = elem; |
26671 | if (_res == NULL && PyErr_Occurred()0 ) { |
26672 | p->error_indicator = 1; |
26673 | PyMem_Free(_children); |
26674 | p->level--; |
26675 | return NULL; |
26676 | } |
26677 | if (_n == _children_capacity) { |
26678 | _children_capacity *= 2; |
26679 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26680 | if (!_new_children) { |
26681 | p->error_indicator = 1; |
26682 | PyErr_NoMemory(); |
26683 | p->level--; |
26684 | return NULL; |
26685 | } |
26686 | _children = _new_children; |
26687 | } |
26688 | _children[_n++] = _res; |
26689 | _mark = p->mark; |
26690 | } |
26691 | p->mark = _mark; |
26692 | D(fprintf(stderr, "%*c%s _loop0_52[%d-%d]: %s failed!\n", p->level, ' ', |
26693 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); |
26694 | } |
26695 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26696 | if (!_seq) { Branch (26696:9): [True: 0, False: 26]
|
26697 | PyMem_Free(_children); |
26698 | p->error_indicator = 1; |
26699 | PyErr_NoMemory(); |
26700 | p->level--; |
26701 | return NULL; |
26702 | } |
26703 | for (int i = 0; 26 i < _n; i++23 ) asdl_seq_SET_UNTYPED26 (_seq, i, _children[i]); Branch (26703:21): [True: 23, False: 26]
|
26704 | PyMem_Free(_children); |
26705 | _PyPegen_insert_memo(p, _start_mark, _loop0_52_type, _seq); |
26706 | p->level--; |
26707 | return _seq; |
26708 | } |
26709 | |
26710 | // _gather_51: with_item _loop0_52 |
26711 | static asdl_seq * |
26712 | _gather_51_rule(Parser *p) |
26713 | { |
26714 | if (p->level++ == MAXSTACK) { Branch (26714:9): [True: 0, False: 27]
|
26715 | p->error_indicator = 1; |
26716 | PyErr_NoMemory(); |
26717 | } |
26718 | if (p->error_indicator) { Branch (26718:9): [True: 0, False: 27]
|
26719 | p->level--; |
26720 | return NULL; |
26721 | } |
26722 | asdl_seq * _res = NULL; |
26723 | int _mark = p->mark; |
26724 | { // with_item _loop0_52 |
26725 | if (p->error_indicator) { |
26726 | p->level--; |
26727 | return NULL; |
26728 | } |
26729 | D(fprintf(stderr, "%*c> _gather_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_52")); |
26730 | withitem_ty elem; |
26731 | asdl_seq * seq; |
26732 | if ( |
26733 | (elem = with_item_rule(p)) // with_item |
26734 | && |
26735 | (seq = _loop0_52_rule(p))26 // _loop0_52 |
26736 | ) |
26737 | { |
26738 | D(fprintf(stderr, "%*c+ _gather_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_52")); |
26739 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
26740 | goto done; |
26741 | } |
26742 | p->mark = _mark; |
26743 | D(fprintf(stderr, "%*c%s _gather_51[%d-%d]: %s failed!\n", p->level, ' ', |
26744 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_52")); |
26745 | } |
26746 | _res = NULL; |
26747 | done: |
26748 | p->level--; |
26749 | return _res; |
26750 | } |
26751 | |
26752 | // _loop0_54: ',' with_item |
26753 | static asdl_seq * |
26754 | _loop0_54_rule(Parser *p) |
26755 | { |
26756 | if (p->level++ == MAXSTACK) { Branch (26756:9): [True: 0, False: 1.87k]
|
26757 | p->error_indicator = 1; |
26758 | PyErr_NoMemory(); |
26759 | } |
26760 | if (p->error_indicator) { Branch (26760:9): [True: 0, False: 1.87k]
|
26761 | p->level--; |
26762 | return NULL; |
26763 | } |
26764 | void *_res = NULL; |
26765 | int _mark = p->mark; |
26766 | int _start_mark = p->mark; |
26767 | void **_children = PyMem_Malloc(sizeof(void *)); |
26768 | if (!_children) { Branch (26768:9): [True: 0, False: 1.87k]
|
26769 | p->error_indicator = 1; |
26770 | PyErr_NoMemory(); |
26771 | p->level--; |
26772 | return NULL; |
26773 | } |
26774 | Py_ssize_t _children_capacity = 1; |
26775 | Py_ssize_t _n = 0; |
26776 | { // ',' with_item |
26777 | if (p->error_indicator) { Branch (26777:13): [True: 0, False: 1.87k]
|
26778 | p->level--; |
26779 | return NULL; |
26780 | } |
26781 | D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); |
26782 | Token * _literal; |
26783 | withitem_ty elem; |
26784 | while ( |
26785 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (26785:13): [True: 78, False: 1.87k]
|
26786 | && |
26787 | (elem = with_item_rule(p))78 // with_item |
26788 | ) |
26789 | { |
26790 | _res = elem; |
26791 | if (_res == NULL && PyErr_Occurred()0 ) { |
26792 | p->error_indicator = 1; |
26793 | PyMem_Free(_children); |
26794 | p->level--; |
26795 | return NULL; |
26796 | } |
26797 | if (_n == _children_capacity) { |
26798 | _children_capacity *= 2; |
26799 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26800 | if (!_new_children) { |
26801 | p->error_indicator = 1; |
26802 | PyErr_NoMemory(); |
26803 | p->level--; |
26804 | return NULL; |
26805 | } |
26806 | _children = _new_children; |
26807 | } |
26808 | _children[_n++] = _res; |
26809 | _mark = p->mark; |
26810 | } |
26811 | p->mark = _mark; |
26812 | D(fprintf(stderr, "%*c%s _loop0_54[%d-%d]: %s failed!\n", p->level, ' ', |
26813 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); |
26814 | } |
26815 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26816 | if (!_seq) { Branch (26816:9): [True: 0, False: 1.87k]
|
26817 | PyMem_Free(_children); |
26818 | p->error_indicator = 1; |
26819 | PyErr_NoMemory(); |
26820 | p->level--; |
26821 | return NULL; |
26822 | } |
26823 | for (int i = 0; 1.87k i < _n; i++77 ) asdl_seq_SET_UNTYPED1.87k (_seq, i, _children[i]); Branch (26823:21): [True: 77, False: 1.87k]
|
26824 | PyMem_Free(_children); |
26825 | _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq); |
26826 | p->level--; |
26827 | return _seq; |
26828 | } |
26829 | |
26830 | // _gather_53: with_item _loop0_54 |
26831 | static asdl_seq * |
26832 | _gather_53_rule(Parser *p) |
26833 | { |
26834 | if (p->level++ == MAXSTACK) { Branch (26834:9): [True: 0, False: 1.89k]
|
26835 | p->error_indicator = 1; |
26836 | PyErr_NoMemory(); |
26837 | } |
26838 | if (p->error_indicator) { Branch (26838:9): [True: 0, False: 1.89k]
|
26839 | p->level--; |
26840 | return NULL; |
26841 | } |
26842 | asdl_seq * _res = NULL; |
26843 | int _mark = p->mark; |
26844 | { // with_item _loop0_54 |
26845 | if (p->error_indicator) { Branch (26845:13): [True: 0, False: 1.89k]
|
26846 | p->level--; |
26847 | return NULL; |
26848 | } |
26849 | D(fprintf(stderr, "%*c> _gather_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_54")); |
26850 | withitem_ty elem; |
26851 | asdl_seq * seq; |
26852 | if ( |
26853 | (elem = with_item_rule(p)) // with_item Branch (26853:13): [True: 1.87k, False: 20]
|
26854 | && |
26855 | (seq = _loop0_54_rule(p))1.87k // _loop0_54 Branch (26855:13): [True: 1.87k, False: 0]
|
26856 | ) |
26857 | { |
26858 | D(fprintf(stderr, "%*c+ _gather_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_54")); |
26859 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
26860 | goto done; |
26861 | } |
26862 | p->mark = _mark; |
26863 | D(fprintf(stderr, "%*c%s _gather_53[%d-%d]: %s failed!\n", p->level, ' ', |
26864 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_54")); |
26865 | } |
26866 | _res = NULL; |
26867 | done: |
26868 | p->level--; |
26869 | return _res; |
26870 | } |
26871 | |
26872 | // _loop0_56: ',' with_item |
26873 | static asdl_seq * |
26874 | _loop0_56_rule(Parser *p) |
26875 | { |
26876 | if (p->level++ == MAXSTACK) { Branch (26876:9): [True: 0, False: 1]
|
26877 | p->error_indicator = 1; |
26878 | PyErr_NoMemory(); |
26879 | } |
26880 | if (p->error_indicator) { Branch (26880:9): [True: 0, False: 1]
|
26881 | p->level--; |
26882 | return NULL; |
26883 | } |
26884 | void *_res = NULL; |
26885 | int _mark = p->mark; |
26886 | int _start_mark = p->mark; |
26887 | void **_children = PyMem_Malloc(sizeof(void *)); |
26888 | if (!_children) { Branch (26888:9): [True: 0, False: 1]
|
26889 | p->error_indicator = 1; |
26890 | PyErr_NoMemory(); |
26891 | p->level--; |
26892 | return NULL; |
26893 | } |
26894 | Py_ssize_t _children_capacity = 1; |
26895 | Py_ssize_t _n = 0; |
26896 | { // ',' with_item |
26897 | if (p->error_indicator) { |
26898 | p->level--; |
26899 | return NULL; |
26900 | } |
26901 | D(fprintf(stderr, "%*c> _loop0_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); |
26902 | Token * _literal; |
26903 | withitem_ty elem; |
26904 | while ( |
26905 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
26906 | && |
26907 | (elem = with_item_rule(p))1 // with_item |
26908 | ) |
26909 | { |
26910 | _res = elem; |
26911 | if (_res == NULL && PyErr_Occurred()0 ) { |
26912 | p->error_indicator = 1; |
26913 | PyMem_Free(_children); |
26914 | p->level--; |
26915 | return NULL; |
26916 | } |
26917 | if (_n == _children_capacity) { |
26918 | _children_capacity *= 2; |
26919 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
26920 | if (!_new_children) { |
26921 | p->error_indicator = 1; |
26922 | PyErr_NoMemory(); |
26923 | p->level--; |
26924 | return NULL; |
26925 | } |
26926 | _children = _new_children; |
26927 | } |
26928 | _children[_n++] = _res; |
26929 | _mark = p->mark; |
26930 | } |
26931 | p->mark = _mark; |
26932 | D(fprintf(stderr, "%*c%s _loop0_56[%d-%d]: %s failed!\n", p->level, ' ', |
26933 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); |
26934 | } |
26935 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
26936 | if (!_seq) { Branch (26936:9): [True: 0, False: 1]
|
26937 | PyMem_Free(_children); |
26938 | p->error_indicator = 1; |
26939 | PyErr_NoMemory(); |
26940 | p->level--; |
26941 | return NULL; |
26942 | } |
26943 | for (int i = 0; 1 i < _n; i++1 ) asdl_seq_SET_UNTYPED1 (_seq, i, _children[i]); |
26944 | PyMem_Free(_children); |
26945 | _PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq); |
26946 | p->level--; |
26947 | return _seq; |
26948 | } |
26949 | |
26950 | // _gather_55: with_item _loop0_56 |
26951 | static asdl_seq * |
26952 | _gather_55_rule(Parser *p) |
26953 | { |
26954 | if (p->level++ == MAXSTACK) { Branch (26954:9): [True: 0, False: 1]
|
26955 | p->error_indicator = 1; |
26956 | PyErr_NoMemory(); |
26957 | } |
26958 | if (p->error_indicator) { Branch (26958:9): [True: 0, False: 1]
|
26959 | p->level--; |
26960 | return NULL; |
26961 | } |
26962 | asdl_seq * _res = NULL; |
26963 | int _mark = p->mark; |
26964 | { // with_item _loop0_56 |
26965 | if (p->error_indicator) { |
26966 | p->level--; |
26967 | return NULL; |
26968 | } |
26969 | D(fprintf(stderr, "%*c> _gather_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_56")); |
26970 | withitem_ty elem; |
26971 | asdl_seq * seq; |
26972 | if ( |
26973 | (elem = with_item_rule(p)) // with_item |
26974 | && |
26975 | (seq = _loop0_56_rule(p)) // _loop0_56 |
26976 | ) |
26977 | { |
26978 | D(fprintf(stderr, "%*c+ _gather_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_56")); |
26979 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
26980 | goto done; |
26981 | } |
26982 | p->mark = _mark; |
26983 | D(fprintf(stderr, "%*c%s _gather_55[%d-%d]: %s failed!\n", p->level, ' ', |
26984 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_56")); |
26985 | } |
26986 | _res = NULL; |
26987 | done: |
26988 | p->level--; |
26989 | return _res; |
26990 | } |
26991 | |
26992 | // _loop0_58: ',' with_item |
26993 | static asdl_seq * |
26994 | _loop0_58_rule(Parser *p) |
26995 | { |
26996 | if (p->level++ == MAXSTACK) { Branch (26996:9): [True: 0, False: 69]
|
26997 | p->error_indicator = 1; |
26998 | PyErr_NoMemory(); |
26999 | } |
27000 | if (p->error_indicator) { Branch (27000:9): [True: 0, False: 69]
|
27001 | p->level--; |
27002 | return NULL; |
27003 | } |
27004 | void *_res = NULL; |
27005 | int _mark = p->mark; |
27006 | int _start_mark = p->mark; |
27007 | void **_children = PyMem_Malloc(sizeof(void *)); |
27008 | if (!_children) { Branch (27008:9): [True: 0, False: 69]
|
27009 | p->error_indicator = 1; |
27010 | PyErr_NoMemory(); |
27011 | p->level--; |
27012 | return NULL; |
27013 | } |
27014 | Py_ssize_t _children_capacity = 1; |
27015 | Py_ssize_t _n = 0; |
27016 | { // ',' with_item |
27017 | if (p->error_indicator) { |
27018 | p->level--; |
27019 | return NULL; |
27020 | } |
27021 | D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); |
27022 | Token * _literal; |
27023 | withitem_ty elem; |
27024 | while ( |
27025 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (27025:13): [True: 10, False: 69]
|
27026 | && |
27027 | (elem = with_item_rule(p))10 // with_item |
27028 | ) |
27029 | { |
27030 | _res = elem; |
27031 | if (_res == NULL && PyErr_Occurred()0 ) { |
27032 | p->error_indicator = 1; |
27033 | PyMem_Free(_children); |
27034 | p->level--; |
27035 | return NULL; |
27036 | } |
27037 | if (_n == _children_capacity) { |
27038 | _children_capacity *= 2; |
27039 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
27040 | if (!_new_children) { |
27041 | p->error_indicator = 1; |
27042 | PyErr_NoMemory(); |
27043 | p->level--; |
27044 | return NULL; |
27045 | } |
27046 | _children = _new_children; |
27047 | } |
27048 | _children[_n++] = _res; |
27049 | _mark = p->mark; |
27050 | } |
27051 | p->mark = _mark; |
27052 | D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ', |
27053 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); |
27054 | } |
27055 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
27056 | if (!_seq) { Branch (27056:9): [True: 0, False: 69]
|
27057 | PyMem_Free(_children); |
27058 | p->error_indicator = 1; |
27059 | PyErr_NoMemory(); |
27060 | p->level--; |
27061 | return NULL; |
27062 | } |
27063 | for (int i = 0; 69 i < _n; i++10 ) asdl_seq_SET_UNTYPED69 (_seq, i, _children[i]); Branch (27063:21): [True: 10, False: 69]
|
27064 | PyMem_Free(_children); |
27065 | _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq); |
27066 | p->level--; |
27067 | return _seq; |
27068 | } |
27069 | |
27070 | // _gather_57: with_item _loop0_58 |
27071 | static asdl_seq * |
27072 | _gather_57_rule(Parser *p) |
27073 | { |
27074 | if (p->level++ == MAXSTACK) { Branch (27074:9): [True: 0, False: 70]
|
27075 | p->error_indicator = 1; |
27076 | PyErr_NoMemory(); |
27077 | } |
27078 | if (p->error_indicator) { Branch (27078:9): [True: 0, False: 70]
|
27079 | p->level--; |
27080 | return NULL; |
27081 | } |
27082 | asdl_seq * _res = NULL; |
27083 | int _mark = p->mark; |
27084 | { // with_item _loop0_58 |
27085 | if (p->error_indicator) { |
27086 | p->level--; |
27087 | return NULL; |
27088 | } |
27089 | D(fprintf(stderr, "%*c> _gather_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_58")); |
27090 | withitem_ty elem; |
27091 | asdl_seq * seq; |
27092 | if ( |
27093 | (elem = with_item_rule(p)) // with_item |
27094 | && |
27095 | (seq = _loop0_58_rule(p))69 // _loop0_58 |
27096 | ) |
27097 | { |
27098 | D(fprintf(stderr, "%*c+ _gather_57[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_58")); |
27099 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
27100 | goto done; |
27101 | } |
27102 | p->mark = _mark; |
27103 | D(fprintf(stderr, "%*c%s _gather_57[%d-%d]: %s failed!\n", p->level, ' ', |
27104 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_58")); |
27105 | } |
27106 | _res = NULL; |
27107 | done: |
27108 | p->level--; |
27109 | return _res; |
27110 | } |
27111 | |
27112 | // _tmp_59: ',' | ')' | ':' |
27113 | static void * |
27114 | _tmp_59_rule(Parser *p) |
27115 | { |
27116 | if (p->level++ == MAXSTACK) { Branch (27116:9): [True: 0, False: 987]
|
27117 | p->error_indicator = 1; |
27118 | PyErr_NoMemory(); |
27119 | } |
27120 | if (p->error_indicator) { Branch (27120:9): [True: 0, False: 987]
|
27121 | p->level--; |
27122 | return NULL; |
27123 | } |
27124 | void * _res = NULL; |
27125 | int _mark = p->mark; |
27126 | { // ',' |
27127 | if (p->error_indicator) { Branch (27127:13): [True: 0, False: 987]
|
27128 | p->level--; |
27129 | return NULL; |
27130 | } |
27131 | D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
27132 | Token * _literal; |
27133 | if ( |
27134 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (27134:13): [True: 80, False: 907]
|
27135 | ) |
27136 | { |
27137 | D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
27138 | _res = _literal; |
27139 | goto done; |
27140 | } |
27141 | p->mark = _mark; |
27142 | D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ', |
27143 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
27144 | } |
27145 | { // ')' |
27146 | if (p->error_indicator) { Branch (27146:13): [True: 0, False: 907]
|
27147 | p->level--; |
27148 | return NULL; |
27149 | } |
27150 | D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); |
27151 | Token * _literal; |
27152 | if ( |
27153 | (_literal = _PyPegen_expect_token(p, 8)) // token=')' Branch (27153:13): [True: 10, False: 897]
|
27154 | ) |
27155 | { |
27156 | D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); |
27157 | _res = _literal; |
27158 | goto done; |
27159 | } |
27160 | p->mark = _mark; |
27161 | D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ', |
27162 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); |
27163 | } |
27164 | { // ':' |
27165 | if (p->error_indicator) { Branch (27165:13): [True: 0, False: 897]
|
27166 | p->level--; |
27167 | return NULL; |
27168 | } |
27169 | D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); |
27170 | Token * _literal; |
27171 | if ( |
27172 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' Branch (27172:13): [True: 887, False: 10]
|
27173 | ) |
27174 | { |
27175 | D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); |
27176 | _res = _literal; |
27177 | goto done; |
27178 | } |
27179 | p->mark = _mark; |
27180 | D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ', |
27181 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); |
27182 | } |
27183 | _res = NULL; |
27184 | done: |
27185 | p->level--; |
27186 | return _res; |
27187 | } |
27188 | |
27189 | // _loop1_60: except_block |
27190 | static asdl_seq * |
27191 | _loop1_60_rule(Parser *p) |
27192 | { |
27193 | if (p->level++ == MAXSTACK) { Branch (27193:9): [True: 0, False: 3.24k]
|
27194 | p->error_indicator = 1; |
27195 | PyErr_NoMemory(); |
27196 | } |
27197 | if (p->error_indicator) { Branch (27197:9): [True: 0, False: 3.24k]
|
27198 | p->level--; |
27199 | return NULL; |
27200 | } |
27201 | void *_res = NULL; |
27202 | int _mark = p->mark; |
27203 | int _start_mark = p->mark; |
27204 | void **_children = PyMem_Malloc(sizeof(void *)); |
27205 | if (!_children) { Branch (27205:9): [True: 0, False: 3.24k]
|
27206 | p->error_indicator = 1; |
27207 | PyErr_NoMemory(); |
27208 | p->level--; |
27209 | return NULL; |
27210 | } |
27211 | Py_ssize_t _children_capacity = 1; |
27212 | Py_ssize_t _n = 0; |
27213 | { // except_block |
27214 | if (p->error_indicator) { Branch (27214:13): [True: 0, False: 3.24k]
|
27215 | p->level--; |
27216 | return NULL; |
27217 | } |
27218 | D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block")); |
27219 | excepthandler_ty except_block_var; |
27220 | while ( |
27221 | (except_block_var = except_block_rule(p)) // except_block Branch (27221:13): [True: 3.32k, False: 3.24k]
|
27222 | ) |
27223 | { |
27224 | _res = except_block_var; |
27225 | if (_n == _children_capacity) { Branch (27225:17): [True: 172, False: 3.15k]
|
27226 | _children_capacity *= 2; |
27227 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
27228 | if (!_new_children) { Branch (27228:21): [True: 0, False: 172]
|
27229 | p->error_indicator = 1; |
27230 | PyErr_NoMemory(); |
27231 | p->level--; |
27232 | return NULL; |
27233 | } |
27234 | _children = _new_children; |
27235 | } |
27236 | _children[_n++] = _res; |
27237 | _mark = p->mark; |
27238 | } |
27239 | p->mark = _mark; |
27240 | D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ', |
27241 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block")); |
27242 | } |
27243 | if (_n == 0 || p->error_indicator3.14k ) { Branch (27243:9): [True: 104, False: 3.14k]
Branch (27243:20): [True: 0, False: 3.14k]
|
27244 | PyMem_Free(_children); |
27245 | p->level--; |
27246 | return NULL; |
27247 | } |
27248 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
27249 | if (!_seq) { Branch (27249:9): [True: 0, False: 3.14k]
|
27250 | PyMem_Free(_children); |
27251 | p->error_indicator = 1; |
27252 | PyErr_NoMemory(); |
27253 | p->level--; |
27254 | return NULL; |
27255 | } |
27256 | for (int i = 0; 3.14k i < _n; i++3.32k ) asdl_seq_SET_UNTYPED3.14k (_seq, i, _children[i]); Branch (27256:21): [True: 3.32k, False: 3.14k]
|
27257 | PyMem_Free(_children); |
27258 | _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq); |
27259 | p->level--; |
27260 | return _seq; |
27261 | } |
27262 | |
27263 | // _loop1_61: except_star_block |
27264 | static asdl_seq * |
27265 | _loop1_61_rule(Parser *p) |
27266 | { |
27267 | if (p->level++ == MAXSTACK) { Branch (27267:9): [True: 0, False: 104]
|
27268 | p->error_indicator = 1; |
27269 | PyErr_NoMemory(); |
27270 | } |
27271 | if (p->error_indicator) { Branch (27271:9): [True: 0, False: 104]
|
27272 | p->level--; |
27273 | return NULL; |
27274 | } |
27275 | void *_res = NULL; |
27276 | int _mark = p->mark; |
27277 | int _start_mark = p->mark; |
27278 | void **_children = PyMem_Malloc(sizeof(void *)); |
27279 | if (!_children) { Branch (27279:9): [True: 0, False: 104]
|
27280 | p->error_indicator = 1; |
27281 | PyErr_NoMemory(); |
27282 | p->level--; |
27283 | return NULL; |
27284 | } |
27285 | Py_ssize_t _children_capacity = 1; |
27286 | Py_ssize_t _n = 0; |
27287 | { // except_star_block |
27288 | if (p->error_indicator) { Branch (27288:13): [True: 0, False: 104]
|
27289 | p->level--; |
27290 | return NULL; |
27291 | } |
27292 | D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block")); |
27293 | excepthandler_ty except_star_block_var; |
27294 | while ( |
27295 | (except_star_block_var = except_star_block_rule(p)) // except_star_block Branch (27295:13): [True: 69, False: 104]
|
27296 | ) |
27297 | { |
27298 | _res = except_star_block_var; |
27299 | if (_n == _children_capacity) { |
27300 | _children_capacity *= 2; |
27301 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
27302 | if (!_new_children) { |
27303 | p->error_indicator = 1; |
27304 | PyErr_NoMemory(); |
27305 | p->level--; |
27306 | return NULL; |
27307 | } |
27308 | _children = _new_children; |
27309 | } |
27310 | _children[_n++] = _res; |
27311 | _mark = p->mark; |
27312 | } |
27313 | p->mark = _mark; |
27314 | D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', |
27315 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block")); |
27316 | } |
27317 | if (_n == 0 || p->error_indicator63 ) { Branch (27317:9): [True: 41, False: 63]
Branch (27317:20): [True: 0, False: 63]
|
27318 | PyMem_Free(_children); |
27319 | p->level--; |
27320 | return NULL; |
27321 | } |
27322 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
27323 | if (!_seq) { Branch (27323:9): [True: 0, False: 63]
|
27324 | PyMem_Free(_children); |
27325 | p->error_indicator = 1; |
27326 | PyErr_NoMemory(); |
27327 | p->level--; |
27328 | return NULL; |
27329 | } |
27330 | for (int i = 0; 63 i < _n; i++69 ) asdl_seq_SET_UNTYPED63 (_seq, i, _children[i]); Branch (27330:21): [True: 69, False: 63]
|
27331 | PyMem_Free(_children); |
27332 | _PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq); |
27333 | p->level--; |
27334 | return _seq; |
27335 | } |
27336 | |
27337 | // _tmp_62: 'as' NAME |
27338 | static void * |
27339 | _tmp_62_rule(Parser *p) |
27340 | { |
27341 | if (p->level++ == MAXSTACK) { Branch (27341:9): [True: 0, False: 3.12k]
|
27342 | p->error_indicator = 1; |
27343 | PyErr_NoMemory(); |
27344 | } |
27345 | if (p->error_indicator) { Branch (27345:9): [True: 0, False: 3.12k]
|
27346 | p->level--; |
27347 | return NULL; |
27348 | } |
27349 | void * _res = NULL; |
27350 | int _mark = p->mark; |
27351 | { // 'as' NAME |
27352 | if (p->error_indicator) { Branch (27352:13): [True: 0, False: 3.12k]
|
27353 | p->level--; |
27354 | return NULL; |
27355 | } |
27356 | D(fprintf(stderr, "%*c> _tmp_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
27357 | Token * _keyword; |
27358 | expr_ty z; |
27359 | if ( |
27360 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' Branch (27360:13): [True: 529, False: 2.59k]
|
27361 | && |
27362 | (z = _PyPegen_name_token(p))529 // NAME Branch (27362:13): [True: 529, False: 0]
|
27363 | ) |
27364 | { |
27365 | D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
27366 | _res = z; |
27367 | if (_res == NULL && PyErr_Occurred()0 ) { |
27368 | p->error_indicator = 1; |
27369 | p->level--; |
27370 | return NULL; |
27371 | } |
27372 | goto done; |
27373 | } |
27374 | p->mark = _mark; |
27375 | D(fprintf(stderr, "%*c%s _tmp_62[%d-%d]: %s failed!\n", p->level, ' ', |
27376 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
27377 | } |
27378 | _res = NULL; |
27379 | done: |
27380 | p->level--; |
27381 | return _res; |
27382 | } |
27383 | |
27384 | // _tmp_63: 'as' NAME |
27385 | static void * |
27386 | _tmp_63_rule(Parser *p) |
27387 | { |
27388 | if (p->level++ == MAXSTACK) { Branch (27388:9): [True: 0, False: 91]
|
27389 | p->error_indicator = 1; |
27390 | PyErr_NoMemory(); |
27391 | } |
27392 | if (p->error_indicator) { Branch (27392:9): [True: 0, False: 91]
|
27393 | p->level--; |
27394 | return NULL; |
27395 | } |
27396 | void * _res = NULL; |
27397 | int _mark = p->mark; |
27398 | { // 'as' NAME |
27399 | if (p->error_indicator) { |
27400 | p->level--; |
27401 | return NULL; |
27402 | } |
27403 | D(fprintf(stderr, "%*c> _tmp_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
27404 | Token * _keyword; |
27405 | expr_ty z; |
27406 | if ( |
27407 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' Branch (27407:13): [True: 31, False: 60]
|
27408 | && |
27409 | (z = _PyPegen_name_token(p))31 // NAME |
27410 | ) |
27411 | { |
27412 | D(fprintf(stderr, "%*c+ _tmp_63[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
27413 | _res = z; |
27414 | if (_res == NULL && PyErr_Occurred()0 ) { |
27415 | p->error_indicator = 1; |
27416 | p->level--; |
27417 | return NULL; |
27418 | } |
27419 | goto done; |
27420 | } |
27421 | p->mark = _mark; |
27422 | D(fprintf(stderr, "%*c%s _tmp_63[%d-%d]: %s failed!\n", p->level, ' ', |
27423 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
27424 | } |
27425 | _res = NULL; |
27426 | done: |
27427 | p->level--; |
27428 | return _res; |
27429 | } |
27430 | |
27431 | // _loop1_64: case_block |
27432 | static asdl_seq * |
27433 | _loop1_64_rule(Parser *p) |
27434 | { |
27435 | if (p->level++ == MAXSTACK) { Branch (27435:9): [True: 0, False: 955]
|
27436 | p->error_indicator = 1; |
27437 | PyErr_NoMemory(); |
27438 | } |
27439 | if (p->error_indicator) { Branch (27439:9): [True: 0, False: 955]
|
27440 | p->level--; |
27441 | return NULL; |
27442 | } |
27443 | void *_res = NULL; |
27444 | int _mark = p->mark; |
27445 | int _start_mark = p->mark; |
27446 | void **_children = PyMem_Malloc(sizeof(void *)); |
27447 | if (!_children) { Branch (27447:9): [True: 0, False: 955]
|
27448 | p->error_indicator = 1; |
27449 | PyErr_NoMemory(); |
27450 | p->level--; |
27451 | return NULL; |
27452 | } |
27453 | Py_ssize_t _children_capacity = 1; |
27454 | Py_ssize_t _n = 0; |
27455 | { // case_block |
27456 | if (p->error_indicator) { Branch (27456:13): [True: 0, False: 955]
|
27457 | p->level--; |
27458 | return NULL; |
27459 | } |
27460 | D(fprintf(stderr, "%*c> _loop1_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "case_block")); |
27461 | match_case_ty case_block_var; |
27462 | while ( |
27463 | (case_block_var = case_block_rule(p)) // case_block Branch (27463:13): [True: 1.28k, False: 955]
|
27464 | ) |
27465 | { |
27466 | _res = case_block_var; |
27467 | if (_n == _children_capacity) { Branch (27467:17): [True: 352, False: 932]
|
27468 | _children_capacity *= 2; |
27469 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
27470 | if (!_new_children) { Branch (27470:21): [True: 0, False: 352]
|
27471 | p->error_indicator = 1; |
27472 | PyErr_NoMemory(); |
27473 | p->level--; |
27474 | return NULL; |
27475 | } |
27476 | _children = _new_children; |
27477 | } |
27478 | _children[_n++] = _res; |
27479 | _mark = p->mark; |
27480 | } |
27481 | p->mark = _mark; |
27482 | D(fprintf(stderr, "%*c%s _loop1_64[%d-%d]: %s failed!\n", p->level, ' ', |
27483 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "case_block")); |
27484 | } |
27485 | if (_n == 0 || p->error_indicator911 ) { Branch (27485:9): [True: 44, False: 911]
Branch (27485:20): [True: 1, False: 910]
|
27486 | PyMem_Free(_children); |
27487 | p->level--; |
27488 | return NULL; |
27489 | } |
27490 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
27491 | if (!_seq) { Branch (27491:9): [True: 0, False: 910]
|
27492 | PyMem_Free(_children); |
27493 | p->error_indicator = 1; |
27494 | PyErr_NoMemory(); |
27495 | p->level--; |
27496 | return NULL; |
27497 | } |
27498 | for (int i = 0; 910 i < _n; i++1.28k ) asdl_seq_SET_UNTYPED910 (_seq, i, _children[i]); Branch (27498:21): [True: 1.28k, False: 910]
|
27499 | PyMem_Free(_children); |
27500 | _PyPegen_insert_memo(p, _start_mark, _loop1_64_type, _seq); |
27501 | p->level--; |
27502 | return _seq; |
27503 | } |
27504 | |
27505 | // _loop0_66: '|' closed_pattern |
27506 | static asdl_seq * |
27507 | _loop0_66_rule(Parser *p) |
27508 | { |
27509 | if (p->level++ == MAXSTACK) { Branch (27509:9): [True: 0, False: 9.57k]
|
27510 | p->error_indicator = 1; |
27511 | PyErr_NoMemory(); |
27512 | } |
27513 | if (p->error_indicator) { Branch (27513:9): [True: 0, False: 9.57k]
|
27514 | p->level--; |
27515 | return NULL; |
27516 | } |
27517 | void *_res = NULL; |
27518 | int _mark = p->mark; |
27519 | int _start_mark = p->mark; |
27520 | void **_children = PyMem_Malloc(sizeof(void *)); |
27521 | if (!_children) { Branch (27521:9): [True: 0, False: 9.57k]
|
27522 | p->error_indicator = 1; |
27523 | PyErr_NoMemory(); |
27524 | p->level--; |
27525 | return NULL; |
27526 | } |
27527 | Py_ssize_t _children_capacity = 1; |
27528 | Py_ssize_t _n = 0; |
27529 | { // '|' closed_pattern |
27530 | if (p->error_indicator) { Branch (27530:13): [True: 0, False: 9.57k]
|
27531 | p->level--; |
27532 | return NULL; |
27533 | } |
27534 | D(fprintf(stderr, "%*c> _loop0_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|' closed_pattern")); |
27535 | Token * _literal; |
27536 | pattern_ty elem; |
27537 | while ( |
27538 | (_literal = _PyPegen_expect_token(p, 18)) // token='|' Branch (27538:13): [True: 935, False: 9.57k]
|
27539 | && |
27540 | (elem = closed_pattern_rule(p))935 // closed_pattern Branch (27540:13): [True: 935, False: 0]
|
27541 | ) |
27542 | { |
27543 | _res = elem; |
27544 | if (_res == NULL && PyErr_Occurred()0 ) { |
27545 | p->error_indicator = 1; |
27546 | PyMem_Free(_children); |
27547 | p->level--; |
27548 | return NULL; |
27549 | } |
27550 | if (_n == _children_capacity) { Branch (27550:17): [True: 382, False: 553]
|
27551 | _children_capacity *= 2; |
27552 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
27553 | if (!_new_children) { Branch (27553:21): [True: 0, False: 382]
|
27554 | p->error_indicator = 1; |
27555 | PyErr_NoMemory(); |
27556 | p->level--; |
27557 | return NULL; |
27558 | } |
27559 | _children = _new_children; |
27560 | } |
27561 | _children[_n++] = _res; |
27562 | _mark = p->mark; |
27563 | } |
27564 | p->mark = _mark; |
27565 | D(fprintf(stderr, "%*c%s _loop0_66[%d-%d]: %s failed!\n", p->level, ' ', |
27566 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|' closed_pattern")); |
27567 | } |
27568 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
27569 | if (!_seq) { Branch (27569:9): [True: 0, False: 9.57k]
|
27570 | PyMem_Free(_children); |
27571 | p->error_indicator = 1; |
27572 | PyErr_NoMemory(); |
27573 | p->level--; |
27574 | return NULL; |
27575 | } |
27576 | for (int i = 0; 9.57k i < _n; i++935 ) asdl_seq_SET_UNTYPED9.57k (_seq, i, _children[i]); Branch (27576:21): [True: 935, False: 9.57k]
|
27577 | PyMem_Free(_children); |
27578 | _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq); |
27579 | p->level--; |
27580 | return _seq; |
27581 | } |
27582 | |
27583 | // _gather_65: closed_pattern _loop0_66 |
27584 | static asdl_seq * |
27585 | _gather_65_rule(Parser *p) |
27586 | { |
27587 | if (p->level++ == MAXSTACK) { Branch (27587:9): [True: 0, False: 10.3k]
|
27588 | p->error_indicator = 1; |
27589 | PyErr_NoMemory(); |
27590 | } |
27591 | if (p->error_indicator) { Branch (27591:9): [True: 0, False: 10.3k]
|
27592 | p->level--; |
27593 | return NULL; |
27594 | } |
27595 | asdl_seq * _res = NULL; |
27596 | int _mark = p->mark; |
27597 | { // closed_pattern _loop0_66 |
27598 | if (p->error_indicator) { Branch (27598:13): [True: 0, False: 10.3k]
|
27599 | p->level--; |
27600 | return NULL; |
27601 | } |
27602 | D(fprintf(stderr, "%*c> _gather_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_66")); |
27603 | pattern_ty elem; |
27604 | asdl_seq * seq; |
27605 | if ( |
27606 | (elem = closed_pattern_rule(p)) // closed_pattern Branch (27606:13): [True: 9.57k, False: 738]
|
27607 | && |
27608 | (seq = _loop0_66_rule(p))9.57k // _loop0_66 Branch (27608:13): [True: 9.57k, False: 0]
|
27609 | ) |
27610 | { |
27611 | D(fprintf(stderr, "%*c+ _gather_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_66")); |
27612 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
27613 | goto done; |
27614 | } |
27615 | p->mark = _mark; |
27616 | D(fprintf(stderr, "%*c%s _gather_65[%d-%d]: %s failed!\n", p->level, ' ', |
27617 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "closed_pattern _loop0_66")); |
27618 | } |
27619 | _res = NULL; |
27620 | done: |
27621 | p->level--; |
27622 | return _res; |
27623 | } |
27624 | |
27625 | // _tmp_67: '+' | '-' |
27626 | static void * |
27627 | _tmp_67_rule(Parser *p) |
27628 | { |
27629 | if (p->level++ == MAXSTACK) { Branch (27629:9): [True: 0, False: 1.02k]
|
27630 | p->error_indicator = 1; |
27631 | PyErr_NoMemory(); |
27632 | } |
27633 | if (p->error_indicator) { Branch (27633:9): [True: 0, False: 1.02k]
|
27634 | p->level--; |
27635 | return NULL; |
27636 | } |
27637 | void * _res = NULL; |
27638 | int _mark = p->mark; |
27639 | { // '+' |
27640 | if (p->error_indicator) { Branch (27640:13): [True: 0, False: 1.02k]
|
27641 | p->level--; |
27642 | return NULL; |
27643 | } |
27644 | D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); |
27645 | Token * _literal; |
27646 | if ( |
27647 | (_literal = _PyPegen_expect_token(p, 14)) // token='+' Branch (27647:13): [True: 18, False: 1.00k]
|
27648 | ) |
27649 | { |
27650 | D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); |
27651 | _res = _literal; |
27652 | goto done; |
27653 | } |
27654 | p->mark = _mark; |
27655 | D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', |
27656 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); |
27657 | } |
27658 | { // '-' |
27659 | if (p->error_indicator) { Branch (27659:13): [True: 0, False: 1.00k]
|
27660 | p->level--; |
27661 | return NULL; |
27662 | } |
27663 | D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); |
27664 | Token * _literal; |
27665 | if ( |
27666 | (_literal = _PyPegen_expect_token(p, 15)) // token='-' Branch (27666:13): [True: 15, False: 987]
|
27667 | ) |
27668 | { |
27669 | D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); |
27670 | _res = _literal; |
27671 | goto done; |
27672 | } |
27673 | p->mark = _mark; |
27674 | D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', |
27675 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); |
27676 | } |
27677 | _res = NULL; |
27678 | done: |
27679 | p->level--; |
27680 | return _res; |
27681 | } |
27682 | |
27683 | // _tmp_68: '+' | '-' |
27684 | static void * |
27685 | _tmp_68_rule(Parser *p) |
27686 | { |
27687 | if (p->level++ == MAXSTACK) { Branch (27687:9): [True: 0, False: 490]
|
27688 | p->error_indicator = 1; |
27689 | PyErr_NoMemory(); |
27690 | } |
27691 | if (p->error_indicator) { Branch (27691:9): [True: 0, False: 490]
|
27692 | p->level--; |
27693 | return NULL; |
27694 | } |
27695 | void * _res = NULL; |
27696 | int _mark = p->mark; |
27697 | { // '+' |
27698 | if (p->error_indicator) { Branch (27698:13): [True: 0, False: 490]
|
27699 | p->level--; |
27700 | return NULL; |
27701 | } |
27702 | D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); |
27703 | Token * _literal; |
27704 | if ( |
27705 | (_literal = _PyPegen_expect_token(p, 14)) // token='+' Branch (27705:13): [True: 3, False: 487]
|
27706 | ) |
27707 | { |
27708 | D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); |
27709 | _res = _literal; |
27710 | goto done; |
27711 | } |
27712 | p->mark = _mark; |
27713 | D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', |
27714 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); |
27715 | } |
27716 | { // '-' |
27717 | if (p->error_indicator) { Branch (27717:13): [True: 0, False: 487]
|
27718 | p->level--; |
27719 | return NULL; |
27720 | } |
27721 | D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); |
27722 | Token * _literal; |
27723 | if ( |
27724 | (_literal = _PyPegen_expect_token(p, 15)) // token='-' Branch (27724:13): [True: 6, False: 481]
|
27725 | ) |
27726 | { |
27727 | D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); |
27728 | _res = _literal; |
27729 | goto done; |
27730 | } |
27731 | p->mark = _mark; |
27732 | D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', |
27733 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); |
27734 | } |
27735 | _res = NULL; |
27736 | done: |
27737 | p->level--; |
27738 | return _res; |
27739 | } |
27740 | |
27741 | // _tmp_69: '.' | '(' | '=' |
27742 | static void * |
27743 | _tmp_69_rule(Parser *p) |
27744 | { |
27745 | if (p->level++ == MAXSTACK) { Branch (27745:9): [True: 0, False: 1.34k]
|
27746 | p->error_indicator = 1; |
27747 | PyErr_NoMemory(); |
27748 | } |
27749 | if (p->error_indicator) { Branch (27749:9): [True: 0, False: 1.34k]
|
27750 | p->level--; |
27751 | return NULL; |
27752 | } |
27753 | void * _res = NULL; |
27754 | int _mark = p->mark; |
27755 | { // '.' |
27756 | if (p->error_indicator) { Branch (27756:13): [True: 0, False: 1.34k]
|
27757 | p->level--; |
27758 | return NULL; |
27759 | } |
27760 | D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); |
27761 | Token * _literal; |
27762 | if ( |
27763 | (_literal = _PyPegen_expect_token(p, 23)) // token='.' Branch (27763:13): [True: 54, False: 1.29k]
|
27764 | ) |
27765 | { |
27766 | D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); |
27767 | _res = _literal; |
27768 | goto done; |
27769 | } |
27770 | p->mark = _mark; |
27771 | D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', |
27772 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); |
27773 | } |
27774 | { // '(' |
27775 | if (p->error_indicator) { Branch (27775:13): [True: 0, False: 1.29k]
|
27776 | p->level--; |
27777 | return NULL; |
27778 | } |
27779 | D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); |
27780 | Token * _literal; |
27781 | if ( |
27782 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (27782:13): [True: 185, False: 1.11k]
|
27783 | ) |
27784 | { |
27785 | D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); |
27786 | _res = _literal; |
27787 | goto done; |
27788 | } |
27789 | p->mark = _mark; |
27790 | D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', |
27791 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); |
27792 | } |
27793 | { // '=' |
27794 | if (p->error_indicator) { Branch (27794:13): [True: 0, False: 1.11k]
|
27795 | p->level--; |
27796 | return NULL; |
27797 | } |
27798 | D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); |
27799 | Token * _literal; |
27800 | if ( |
27801 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' Branch (27801:13): [True: 64, False: 1.04k]
|
27802 | ) |
27803 | { |
27804 | D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); |
27805 | _res = _literal; |
27806 | goto done; |
27807 | } |
27808 | p->mark = _mark; |
27809 | D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', |
27810 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); |
27811 | } |
27812 | _res = NULL; |
27813 | done: |
27814 | p->level--; |
27815 | return _res; |
27816 | } |
27817 | |
27818 | // _tmp_70: '.' | '(' | '=' |
27819 | static void * |
27820 | _tmp_70_rule(Parser *p) |
27821 | { |
27822 | if (p->level++ == MAXSTACK) { Branch (27822:9): [True: 0, False: 54]
|
27823 | p->error_indicator = 1; |
27824 | PyErr_NoMemory(); |
27825 | } |
27826 | if (p->error_indicator) { Branch (27826:9): [True: 0, False: 54]
|
27827 | p->level--; |
27828 | return NULL; |
27829 | } |
27830 | void * _res = NULL; |
27831 | int _mark = p->mark; |
27832 | { // '.' |
27833 | if (p->error_indicator) { |
27834 | p->level--; |
27835 | return NULL; |
27836 | } |
27837 | D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); |
27838 | Token * _literal; |
27839 | if ( |
27840 | (_literal = _PyPegen_expect_token(p, 23)) // token='.' |
27841 | ) |
27842 | { |
27843 | D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); |
27844 | _res = _literal; |
27845 | goto done; |
27846 | } |
27847 | p->mark = _mark; |
27848 | D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', |
27849 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); |
27850 | } |
27851 | { // '(' |
27852 | if (p->error_indicator) { |
27853 | p->level--; |
27854 | return NULL; |
27855 | } |
27856 | D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); |
27857 | Token * _literal; |
27858 | if ( |
27859 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' |
27860 | ) |
27861 | { |
27862 | D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); |
27863 | _res = _literal; |
27864 | goto done; |
27865 | } |
27866 | p->mark = _mark; |
27867 | D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', |
27868 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); |
27869 | } |
27870 | { // '=' |
27871 | if (p->error_indicator) { |
27872 | p->level--; |
27873 | return NULL; |
27874 | } |
27875 | D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); |
27876 | Token * _literal; |
27877 | if ( |
27878 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' |
27879 | ) |
27880 | { |
27881 | D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); |
27882 | _res = _literal; |
27883 | goto done; |
27884 | } |
27885 | p->mark = _mark; |
27886 | D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', |
27887 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); |
27888 | } |
27889 | _res = NULL; |
27890 | done: |
27891 | p->level--; |
27892 | return _res; |
27893 | } |
27894 | |
27895 | // _loop0_72: ',' maybe_star_pattern |
27896 | static asdl_seq * |
27897 | _loop0_72_rule(Parser *p) |
27898 | { |
27899 | if (p->level++ == MAXSTACK) { Branch (27899:9): [True: 0, False: 500]
|
27900 | p->error_indicator = 1; |
27901 | PyErr_NoMemory(); |
27902 | } |
27903 | if (p->error_indicator) { Branch (27903:9): [True: 0, False: 500]
|
27904 | p->level--; |
27905 | return NULL; |
27906 | } |
27907 | void *_res = NULL; |
27908 | int _mark = p->mark; |
27909 | int _start_mark = p->mark; |
27910 | void **_children = PyMem_Malloc(sizeof(void *)); |
27911 | if (!_children) { Branch (27911:9): [True: 0, False: 500]
|
27912 | p->error_indicator = 1; |
27913 | PyErr_NoMemory(); |
27914 | p->level--; |
27915 | return NULL; |
27916 | } |
27917 | Py_ssize_t _children_capacity = 1; |
27918 | Py_ssize_t _n = 0; |
27919 | { // ',' maybe_star_pattern |
27920 | if (p->error_indicator) { Branch (27920:13): [True: 0, False: 500]
|
27921 | p->level--; |
27922 | return NULL; |
27923 | } |
27924 | D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pattern")); |
27925 | Token * _literal; |
27926 | pattern_ty elem; |
27927 | while ( |
27928 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (27928:13): [True: 594, False: 482]
|
27929 | && |
27930 | (elem = maybe_star_pattern_rule(p))594 // maybe_star_pattern Branch (27930:13): [True: 576, False: 18]
|
27931 | ) |
27932 | { |
27933 | _res = elem; |
27934 | if (_res == NULL && PyErr_Occurred()0 ) { |
27935 | p->error_indicator = 1; |
27936 | PyMem_Free(_children); |
27937 | p->level--; |
27938 | return NULL; |
27939 | } |
27940 | if (_n == _children_capacity) { Branch (27940:17): [True: 210, False: 366]
|
27941 | _children_capacity *= 2; |
27942 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
27943 | if (!_new_children) { Branch (27943:21): [True: 0, False: 210]
|
27944 | p->error_indicator = 1; |
27945 | PyErr_NoMemory(); |
27946 | p->level--; |
27947 | return NULL; |
27948 | } |
27949 | _children = _new_children; |
27950 | } |
27951 | _children[_n++] = _res; |
27952 | _mark = p->mark; |
27953 | } |
27954 | p->mark = _mark; |
27955 | D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ', |
27956 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' maybe_star_pattern")); |
27957 | } |
27958 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
27959 | if (!_seq) { Branch (27959:9): [True: 0, False: 500]
|
27960 | PyMem_Free(_children); |
27961 | p->error_indicator = 1; |
27962 | PyErr_NoMemory(); |
27963 | p->level--; |
27964 | return NULL; |
27965 | } |
27966 | for (int i = 0; 500 i < _n; i++576 ) asdl_seq_SET_UNTYPED500 (_seq, i, _children[i]); Branch (27966:21): [True: 576, False: 500]
|
27967 | PyMem_Free(_children); |
27968 | _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq); |
27969 | p->level--; |
27970 | return _seq; |
27971 | } |
27972 | |
27973 | // _gather_71: maybe_star_pattern _loop0_72 |
27974 | static asdl_seq * |
27975 | _gather_71_rule(Parser *p) |
27976 | { |
27977 | if (p->level++ == MAXSTACK) { Branch (27977:9): [True: 0, False: 595]
|
27978 | p->error_indicator = 1; |
27979 | PyErr_NoMemory(); |
27980 | } |
27981 | if (p->error_indicator) { Branch (27981:9): [True: 0, False: 595]
|
27982 | p->level--; |
27983 | return NULL; |
27984 | } |
27985 | asdl_seq * _res = NULL; |
27986 | int _mark = p->mark; |
27987 | { // maybe_star_pattern _loop0_72 |
27988 | if (p->error_indicator) { Branch (27988:13): [True: 0, False: 595]
|
27989 | p->level--; |
27990 | return NULL; |
27991 | } |
27992 | D(fprintf(stderr, "%*c> _gather_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_72")); |
27993 | pattern_ty elem; |
27994 | asdl_seq * seq; |
27995 | if ( |
27996 | (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern Branch (27996:13): [True: 500, False: 95]
|
27997 | && |
27998 | (seq = _loop0_72_rule(p))500 // _loop0_72 Branch (27998:13): [True: 500, False: 0]
|
27999 | ) |
28000 | { |
28001 | D(fprintf(stderr, "%*c+ _gather_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_72")); |
28002 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
28003 | goto done; |
28004 | } |
28005 | p->mark = _mark; |
28006 | D(fprintf(stderr, "%*c%s _gather_71[%d-%d]: %s failed!\n", p->level, ' ', |
28007 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_72")); |
28008 | } |
28009 | _res = NULL; |
28010 | done: |
28011 | p->level--; |
28012 | return _res; |
28013 | } |
28014 | |
28015 | // _loop0_74: ',' key_value_pattern |
28016 | static asdl_seq * |
28017 | _loop0_74_rule(Parser *p) |
28018 | { |
28019 | if (p->level++ == MAXSTACK) { Branch (28019:9): [True: 0, False: 525]
|
28020 | p->error_indicator = 1; |
28021 | PyErr_NoMemory(); |
28022 | } |
28023 | if (p->error_indicator) { Branch (28023:9): [True: 0, False: 525]
|
28024 | p->level--; |
28025 | return NULL; |
28026 | } |
28027 | void *_res = NULL; |
28028 | int _mark = p->mark; |
28029 | int _start_mark = p->mark; |
28030 | void **_children = PyMem_Malloc(sizeof(void *)); |
28031 | if (!_children) { Branch (28031:9): [True: 0, False: 525]
|
28032 | p->error_indicator = 1; |
28033 | PyErr_NoMemory(); |
28034 | p->level--; |
28035 | return NULL; |
28036 | } |
28037 | Py_ssize_t _children_capacity = 1; |
28038 | Py_ssize_t _n = 0; |
28039 | { // ',' key_value_pattern |
28040 | if (p->error_indicator) { Branch (28040:13): [True: 0, False: 525]
|
28041 | p->level--; |
28042 | return NULL; |
28043 | } |
28044 | D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pattern")); |
28045 | Token * _literal; |
28046 | KeyPatternPair* elem; |
28047 | while ( |
28048 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (28048:13): [True: 135, False: 506]
|
28049 | && |
28050 | (elem = key_value_pattern_rule(p))135 // key_value_pattern Branch (28050:13): [True: 116, False: 19]
|
28051 | ) |
28052 | { |
28053 | _res = elem; |
28054 | if (_res == NULL && PyErr_Occurred()0 ) { |
28055 | p->error_indicator = 1; |
28056 | PyMem_Free(_children); |
28057 | p->level--; |
28058 | return NULL; |
28059 | } |
28060 | if (_n == _children_capacity) { Branch (28060:17): [True: 22, False: 94]
|
28061 | _children_capacity *= 2; |
28062 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28063 | if (!_new_children) { |
28064 | p->error_indicator = 1; |
28065 | PyErr_NoMemory(); |
28066 | p->level--; |
28067 | return NULL; |
28068 | } |
28069 | _children = _new_children; |
28070 | } |
28071 | _children[_n++] = _res; |
28072 | _mark = p->mark; |
28073 | } |
28074 | p->mark = _mark; |
28075 | D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ', |
28076 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' key_value_pattern")); |
28077 | } |
28078 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28079 | if (!_seq) { Branch (28079:9): [True: 0, False: 525]
|
28080 | PyMem_Free(_children); |
28081 | p->error_indicator = 1; |
28082 | PyErr_NoMemory(); |
28083 | p->level--; |
28084 | return NULL; |
28085 | } |
28086 | for (int i = 0; 525 i < _n; i++116 ) asdl_seq_SET_UNTYPED525 (_seq, i, _children[i]); Branch (28086:21): [True: 116, False: 525]
|
28087 | PyMem_Free(_children); |
28088 | _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq); |
28089 | p->level--; |
28090 | return _seq; |
28091 | } |
28092 | |
28093 | // _gather_73: key_value_pattern _loop0_74 |
28094 | static asdl_seq * |
28095 | _gather_73_rule(Parser *p) |
28096 | { |
28097 | if (p->level++ == MAXSTACK) { Branch (28097:9): [True: 0, False: 548]
|
28098 | p->error_indicator = 1; |
28099 | PyErr_NoMemory(); |
28100 | } |
28101 | if (p->error_indicator) { Branch (28101:9): [True: 0, False: 548]
|
28102 | p->level--; |
28103 | return NULL; |
28104 | } |
28105 | asdl_seq * _res = NULL; |
28106 | int _mark = p->mark; |
28107 | { // key_value_pattern _loop0_74 |
28108 | if (p->error_indicator) { Branch (28108:13): [True: 0, False: 548]
|
28109 | p->level--; |
28110 | return NULL; |
28111 | } |
28112 | D(fprintf(stderr, "%*c> _gather_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_74")); |
28113 | KeyPatternPair* elem; |
28114 | asdl_seq * seq; |
28115 | if ( |
28116 | (elem = key_value_pattern_rule(p)) // key_value_pattern Branch (28116:13): [True: 525, False: 23]
|
28117 | && |
28118 | (seq = _loop0_74_rule(p))525 // _loop0_74 Branch (28118:13): [True: 525, False: 0]
|
28119 | ) |
28120 | { |
28121 | D(fprintf(stderr, "%*c+ _gather_73[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_74")); |
28122 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
28123 | goto done; |
28124 | } |
28125 | p->mark = _mark; |
28126 | D(fprintf(stderr, "%*c%s _gather_73[%d-%d]: %s failed!\n", p->level, ' ', |
28127 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "key_value_pattern _loop0_74")); |
28128 | } |
28129 | _res = NULL; |
28130 | done: |
28131 | p->level--; |
28132 | return _res; |
28133 | } |
28134 | |
28135 | // _tmp_75: literal_expr | attr |
28136 | static void * |
28137 | _tmp_75_rule(Parser *p) |
28138 | { |
28139 | if (p->level++ == MAXSTACK) { Branch (28139:9): [True: 0, False: 683]
|
28140 | p->error_indicator = 1; |
28141 | PyErr_NoMemory(); |
28142 | } |
28143 | if (p->error_indicator) { Branch (28143:9): [True: 0, False: 683]
|
28144 | p->level--; |
28145 | return NULL; |
28146 | } |
28147 | void * _res = NULL; |
28148 | int _mark = p->mark; |
28149 | { // literal_expr |
28150 | if (p->error_indicator) { Branch (28150:13): [True: 0, False: 683]
|
28151 | p->level--; |
28152 | return NULL; |
28153 | } |
28154 | D(fprintf(stderr, "%*c> _tmp_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr")); |
28155 | expr_ty literal_expr_var; |
28156 | if ( |
28157 | (literal_expr_var = literal_expr_rule(p)) // literal_expr Branch (28157:13): [True: 635, False: 48]
|
28158 | ) |
28159 | { |
28160 | D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_expr")); |
28161 | _res = literal_expr_var; |
28162 | goto done; |
28163 | } |
28164 | p->mark = _mark; |
28165 | D(fprintf(stderr, "%*c%s _tmp_75[%d-%d]: %s failed!\n", p->level, ' ', |
28166 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr")); |
28167 | } |
28168 | { // attr |
28169 | if (p->error_indicator) { |
28170 | p->level--; |
28171 | return NULL; |
28172 | } |
28173 | D(fprintf(stderr, "%*c> _tmp_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr")); |
28174 | expr_ty attr_var; |
28175 | if ( |
28176 | (attr_var = attr_rule(p)) // attr |
28177 | ) |
28178 | { |
28179 | D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr")); |
28180 | _res = attr_var; |
28181 | goto done; |
28182 | } |
28183 | p->mark = _mark; |
28184 | D(fprintf(stderr, "%*c%s _tmp_75[%d-%d]: %s failed!\n", p->level, ' ', |
28185 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); |
28186 | } |
28187 | _res = NULL; |
28188 | done: |
28189 | p->level--; |
28190 | return _res; |
28191 | } |
28192 | |
28193 | // _loop0_77: ',' pattern |
28194 | static asdl_seq * |
28195 | _loop0_77_rule(Parser *p) |
28196 | { |
28197 | if (p->level++ == MAXSTACK) { Branch (28197:9): [True: 0, False: 200]
|
28198 | p->error_indicator = 1; |
28199 | PyErr_NoMemory(); |
28200 | } |
28201 | if (p->error_indicator) { Branch (28201:9): [True: 0, False: 200]
|
28202 | p->level--; |
28203 | return NULL; |
28204 | } |
28205 | void *_res = NULL; |
28206 | int _mark = p->mark; |
28207 | int _start_mark = p->mark; |
28208 | void **_children = PyMem_Malloc(sizeof(void *)); |
28209 | if (!_children) { Branch (28209:9): [True: 0, False: 200]
|
28210 | p->error_indicator = 1; |
28211 | PyErr_NoMemory(); |
28212 | p->level--; |
28213 | return NULL; |
28214 | } |
28215 | Py_ssize_t _children_capacity = 1; |
28216 | Py_ssize_t _n = 0; |
28217 | { // ',' pattern |
28218 | if (p->error_indicator) { Branch (28218:13): [True: 0, False: 200]
|
28219 | p->level--; |
28220 | return NULL; |
28221 | } |
28222 | D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern")); |
28223 | Token * _literal; |
28224 | pattern_ty elem; |
28225 | while ( |
28226 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (28226:13): [True: 158, False: 123]
|
28227 | && |
28228 | (elem = pattern_rule(p))158 // pattern Branch (28228:13): [True: 81, False: 77]
|
28229 | ) |
28230 | { |
28231 | _res = elem; |
28232 | if (_res == NULL && PyErr_Occurred()0 ) { |
28233 | p->error_indicator = 1; |
28234 | PyMem_Free(_children); |
28235 | p->level--; |
28236 | return NULL; |
28237 | } |
28238 | if (_n == _children_capacity) { |
28239 | _children_capacity *= 2; |
28240 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28241 | if (!_new_children) { |
28242 | p->error_indicator = 1; |
28243 | PyErr_NoMemory(); |
28244 | p->level--; |
28245 | return NULL; |
28246 | } |
28247 | _children = _new_children; |
28248 | } |
28249 | _children[_n++] = _res; |
28250 | _mark = p->mark; |
28251 | } |
28252 | p->mark = _mark; |
28253 | D(fprintf(stderr, "%*c%s _loop0_77[%d-%d]: %s failed!\n", p->level, ' ', |
28254 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' pattern")); |
28255 | } |
28256 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28257 | if (!_seq) { Branch (28257:9): [True: 0, False: 200]
|
28258 | PyMem_Free(_children); |
28259 | p->error_indicator = 1; |
28260 | PyErr_NoMemory(); |
28261 | p->level--; |
28262 | return NULL; |
28263 | } |
28264 | for (int i = 0; 200 i < _n; i++81 ) asdl_seq_SET_UNTYPED200 (_seq, i, _children[i]); Branch (28264:21): [True: 81, False: 200]
|
28265 | PyMem_Free(_children); |
28266 | _PyPegen_insert_memo(p, _start_mark, _loop0_77_type, _seq); |
28267 | p->level--; |
28268 | return _seq; |
28269 | } |
28270 | |
28271 | // _gather_76: pattern _loop0_77 |
28272 | static asdl_seq * |
28273 | _gather_76_rule(Parser *p) |
28274 | { |
28275 | if (p->level++ == MAXSTACK) { Branch (28275:9): [True: 0, False: 234]
|
28276 | p->error_indicator = 1; |
28277 | PyErr_NoMemory(); |
28278 | } |
28279 | if (p->error_indicator) { Branch (28279:9): [True: 0, False: 234]
|
28280 | p->level--; |
28281 | return NULL; |
28282 | } |
28283 | asdl_seq * _res = NULL; |
28284 | int _mark = p->mark; |
28285 | { // pattern _loop0_77 |
28286 | if (p->error_indicator) { Branch (28286:13): [True: 0, False: 234]
|
28287 | p->level--; |
28288 | return NULL; |
28289 | } |
28290 | D(fprintf(stderr, "%*c> _gather_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_77")); |
28291 | pattern_ty elem; |
28292 | asdl_seq * seq; |
28293 | if ( |
28294 | (elem = pattern_rule(p)) // pattern Branch (28294:13): [True: 200, False: 34]
|
28295 | && |
28296 | (seq = _loop0_77_rule(p))200 // _loop0_77 Branch (28296:13): [True: 200, False: 0]
|
28297 | ) |
28298 | { |
28299 | D(fprintf(stderr, "%*c+ _gather_76[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern _loop0_77")); |
28300 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
28301 | goto done; |
28302 | } |
28303 | p->mark = _mark; |
28304 | D(fprintf(stderr, "%*c%s _gather_76[%d-%d]: %s failed!\n", p->level, ' ', |
28305 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern _loop0_77")); |
28306 | } |
28307 | _res = NULL; |
28308 | done: |
28309 | p->level--; |
28310 | return _res; |
28311 | } |
28312 | |
28313 | // _loop0_79: ',' keyword_pattern |
28314 | static asdl_seq * |
28315 | _loop0_79_rule(Parser *p) |
28316 | { |
28317 | if (p->level++ == MAXSTACK) { Branch (28317:9): [True: 0, False: 66]
|
28318 | p->error_indicator = 1; |
28319 | PyErr_NoMemory(); |
28320 | } |
28321 | if (p->error_indicator) { Branch (28321:9): [True: 0, False: 66]
|
28322 | p->level--; |
28323 | return NULL; |
28324 | } |
28325 | void *_res = NULL; |
28326 | int _mark = p->mark; |
28327 | int _start_mark = p->mark; |
28328 | void **_children = PyMem_Malloc(sizeof(void *)); |
28329 | if (!_children) { Branch (28329:9): [True: 0, False: 66]
|
28330 | p->error_indicator = 1; |
28331 | PyErr_NoMemory(); |
28332 | p->level--; |
28333 | return NULL; |
28334 | } |
28335 | Py_ssize_t _children_capacity = 1; |
28336 | Py_ssize_t _n = 0; |
28337 | { // ',' keyword_pattern |
28338 | if (p->error_indicator) { |
28339 | p->level--; |
28340 | return NULL; |
28341 | } |
28342 | D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_pattern")); |
28343 | Token * _literal; |
28344 | KeyPatternPair* elem; |
28345 | while ( |
28346 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (28346:13): [True: 53, False: 54]
|
28347 | && |
28348 | (elem = keyword_pattern_rule(p))53 // keyword_pattern Branch (28348:13): [True: 41, False: 12]
|
28349 | ) |
28350 | { |
28351 | _res = elem; |
28352 | if (_res == NULL && PyErr_Occurred()0 ) { |
28353 | p->error_indicator = 1; |
28354 | PyMem_Free(_children); |
28355 | p->level--; |
28356 | return NULL; |
28357 | } |
28358 | if (_n == _children_capacity) { |
28359 | _children_capacity *= 2; |
28360 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28361 | if (!_new_children) { |
28362 | p->error_indicator = 1; |
28363 | PyErr_NoMemory(); |
28364 | p->level--; |
28365 | return NULL; |
28366 | } |
28367 | _children = _new_children; |
28368 | } |
28369 | _children[_n++] = _res; |
28370 | _mark = p->mark; |
28371 | } |
28372 | p->mark = _mark; |
28373 | D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', |
28374 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' keyword_pattern")); |
28375 | } |
28376 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28377 | if (!_seq) { Branch (28377:9): [True: 0, False: 66]
|
28378 | PyMem_Free(_children); |
28379 | p->error_indicator = 1; |
28380 | PyErr_NoMemory(); |
28381 | p->level--; |
28382 | return NULL; |
28383 | } |
28384 | for (int i = 0; 66 i < _n; i++41 ) asdl_seq_SET_UNTYPED66 (_seq, i, _children[i]); Branch (28384:21): [True: 41, False: 66]
|
28385 | PyMem_Free(_children); |
28386 | _PyPegen_insert_memo(p, _start_mark, _loop0_79_type, _seq); |
28387 | p->level--; |
28388 | return _seq; |
28389 | } |
28390 | |
28391 | // _gather_78: keyword_pattern _loop0_79 |
28392 | static asdl_seq * |
28393 | _gather_78_rule(Parser *p) |
28394 | { |
28395 | if (p->level++ == MAXSTACK) { Branch (28395:9): [True: 0, False: 103]
|
28396 | p->error_indicator = 1; |
28397 | PyErr_NoMemory(); |
28398 | } |
28399 | if (p->error_indicator) { Branch (28399:9): [True: 0, False: 103]
|
28400 | p->level--; |
28401 | return NULL; |
28402 | } |
28403 | asdl_seq * _res = NULL; |
28404 | int _mark = p->mark; |
28405 | { // keyword_pattern _loop0_79 |
28406 | if (p->error_indicator) { Branch (28406:13): [True: 0, False: 103]
|
28407 | p->level--; |
28408 | return NULL; |
28409 | } |
28410 | D(fprintf(stderr, "%*c> _gather_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_79")); |
28411 | KeyPatternPair* elem; |
28412 | asdl_seq * seq; |
28413 | if ( |
28414 | (elem = keyword_pattern_rule(p)) // keyword_pattern Branch (28414:13): [True: 66, False: 37]
|
28415 | && |
28416 | (seq = _loop0_79_rule(p))66 // _loop0_79 |
28417 | ) |
28418 | { |
28419 | D(fprintf(stderr, "%*c+ _gather_78[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_79")); |
28420 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
28421 | goto done; |
28422 | } |
28423 | p->mark = _mark; |
28424 | D(fprintf(stderr, "%*c%s _gather_78[%d-%d]: %s failed!\n", p->level, ' ', |
28425 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "keyword_pattern _loop0_79")); |
28426 | } |
28427 | _res = NULL; |
28428 | done: |
28429 | p->level--; |
28430 | return _res; |
28431 | } |
28432 | |
28433 | // _loop1_80: (',' expression) |
28434 | static asdl_seq * |
28435 | _loop1_80_rule(Parser *p) |
28436 | { |
28437 | if (p->level++ == MAXSTACK) { Branch (28437:9): [True: 0, False: 36.6k]
|
28438 | p->error_indicator = 1; |
28439 | PyErr_NoMemory(); |
28440 | } |
28441 | if (p->error_indicator) { Branch (28441:9): [True: 0, False: 36.6k]
|
28442 | p->level--; |
28443 | return NULL; |
28444 | } |
28445 | void *_res = NULL; |
28446 | int _mark = p->mark; |
28447 | int _start_mark = p->mark; |
28448 | void **_children = PyMem_Malloc(sizeof(void *)); |
28449 | if (!_children) { Branch (28449:9): [True: 0, False: 36.6k]
|
28450 | p->error_indicator = 1; |
28451 | PyErr_NoMemory(); |
28452 | p->level--; |
28453 | return NULL; |
28454 | } |
28455 | Py_ssize_t _children_capacity = 1; |
28456 | Py_ssize_t _n = 0; |
28457 | { // (',' expression) |
28458 | if (p->error_indicator) { Branch (28458:13): [True: 0, False: 36.6k]
|
28459 | p->level--; |
28460 | return NULL; |
28461 | } |
28462 | D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)")); |
28463 | void *_tmp_223_var; |
28464 | while ( |
28465 | (_tmp_223_var = _tmp_223_rule(p)) // ',' expression Branch (28465:13): [True: 207, False: 36.6k]
|
28466 | ) |
28467 | { |
28468 | _res = _tmp_223_var; |
28469 | if (_n == _children_capacity) { Branch (28469:17): [True: 1, False: 206]
|
28470 | _children_capacity *= 2; |
28471 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28472 | if (!_new_children) { |
28473 | p->error_indicator = 1; |
28474 | PyErr_NoMemory(); |
28475 | p->level--; |
28476 | return NULL; |
28477 | } |
28478 | _children = _new_children; |
28479 | } |
28480 | _children[_n++] = _res; |
28481 | _mark = p->mark; |
28482 | } |
28483 | p->mark = _mark; |
28484 | D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', |
28485 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)")); |
28486 | } |
28487 | if (_n == 0 || p->error_indicator206 ) { Branch (28487:9): [True: 36.4k, False: 206]
Branch (28487:20): [True: 0, False: 206]
|
28488 | PyMem_Free(_children); |
28489 | p->level--; |
28490 | return NULL; |
28491 | } |
28492 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28493 | if (!_seq) { Branch (28493:9): [True: 0, False: 206]
|
28494 | PyMem_Free(_children); |
28495 | p->error_indicator = 1; |
28496 | PyErr_NoMemory(); |
28497 | p->level--; |
28498 | return NULL; |
28499 | } |
28500 | for (int i = 0; 206 i < _n; i++207 ) asdl_seq_SET_UNTYPED206 (_seq, i, _children[i]); Branch (28500:21): [True: 207, False: 206]
|
28501 | PyMem_Free(_children); |
28502 | _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq); |
28503 | p->level--; |
28504 | return _seq; |
28505 | } |
28506 | |
28507 | // _loop1_81: (',' star_expression) |
28508 | static asdl_seq * |
28509 | _loop1_81_rule(Parser *p) |
28510 | { |
28511 | if (p->level++ == MAXSTACK) { Branch (28511:9): [True: 0, False: 438k]
|
28512 | p->error_indicator = 1; |
28513 | PyErr_NoMemory(); |
28514 | } |
28515 | if (p->error_indicator) { Branch (28515:9): [True: 0, False: 438k]
|
28516 | p->level--; |
28517 | return NULL; |
28518 | } |
28519 | void *_res = NULL; |
28520 | int _mark = p->mark; |
28521 | int _start_mark = p->mark; |
28522 | void **_children = PyMem_Malloc(sizeof(void *)); |
28523 | if (!_children) { Branch (28523:9): [True: 0, False: 438k]
|
28524 | p->error_indicator = 1; |
28525 | PyErr_NoMemory(); |
28526 | p->level--; |
28527 | return NULL; |
28528 | } |
28529 | Py_ssize_t _children_capacity = 1; |
28530 | Py_ssize_t _n = 0; |
28531 | { // (',' star_expression) |
28532 | if (p->error_indicator) { Branch (28532:13): [True: 0, False: 438k]
|
28533 | p->level--; |
28534 | return NULL; |
28535 | } |
28536 | D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); |
28537 | void *_tmp_224_var; |
28538 | while ( |
28539 | (_tmp_224_var = _tmp_224_rule(p)) // ',' star_expression Branch (28539:13): [True: 2.53k, False: 438k]
|
28540 | ) |
28541 | { |
28542 | _res = _tmp_224_var; |
28543 | if (_n == _children_capacity) { Branch (28543:17): [True: 707, False: 1.82k]
|
28544 | _children_capacity *= 2; |
28545 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28546 | if (!_new_children) { Branch (28546:21): [True: 0, False: 707]
|
28547 | p->error_indicator = 1; |
28548 | PyErr_NoMemory(); |
28549 | p->level--; |
28550 | return NULL; |
28551 | } |
28552 | _children = _new_children; |
28553 | } |
28554 | _children[_n++] = _res; |
28555 | _mark = p->mark; |
28556 | } |
28557 | p->mark = _mark; |
28558 | D(fprintf(stderr, "%*c%s _loop1_81[%d-%d]: %s failed!\n", p->level, ' ', |
28559 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)")); |
28560 | } |
28561 | if (_n == 0 || p->error_indicator1.71k ) { Branch (28561:9): [True: 436k, False: 1.71k]
Branch (28561:20): [True: 0, False: 1.71k]
|
28562 | PyMem_Free(_children); |
28563 | p->level--; |
28564 | return NULL; |
28565 | } |
28566 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28567 | if (!_seq) { Branch (28567:9): [True: 0, False: 1.71k]
|
28568 | PyMem_Free(_children); |
28569 | p->error_indicator = 1; |
28570 | PyErr_NoMemory(); |
28571 | p->level--; |
28572 | return NULL; |
28573 | } |
28574 | for (int i = 0; 1.71k i < _n; i++2.53k ) asdl_seq_SET_UNTYPED1.71k (_seq, i, _children[i]); Branch (28574:21): [True: 2.53k, False: 1.71k]
|
28575 | PyMem_Free(_children); |
28576 | _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq); |
28577 | p->level--; |
28578 | return _seq; |
28579 | } |
28580 | |
28581 | // _loop0_83: ',' star_named_expression |
28582 | static asdl_seq * |
28583 | _loop0_83_rule(Parser *p) |
28584 | { |
28585 | if (p->level++ == MAXSTACK) { Branch (28585:9): [True: 0, False: 40.4k]
|
28586 | p->error_indicator = 1; |
28587 | PyErr_NoMemory(); |
28588 | } |
28589 | if (p->error_indicator) { Branch (28589:9): [True: 0, False: 40.4k]
|
28590 | p->level--; |
28591 | return NULL; |
28592 | } |
28593 | void *_res = NULL; |
28594 | int _mark = p->mark; |
28595 | int _start_mark = p->mark; |
28596 | void **_children = PyMem_Malloc(sizeof(void *)); |
28597 | if (!_children) { Branch (28597:9): [True: 0, False: 40.4k]
|
28598 | p->error_indicator = 1; |
28599 | PyErr_NoMemory(); |
28600 | p->level--; |
28601 | return NULL; |
28602 | } |
28603 | Py_ssize_t _children_capacity = 1; |
28604 | Py_ssize_t _n = 0; |
28605 | { // ',' star_named_expression |
28606 | if (p->error_indicator) { Branch (28606:13): [True: 0, False: 40.4k]
|
28607 | p->level--; |
28608 | return NULL; |
28609 | } |
28610 | D(fprintf(stderr, "%*c> _loop0_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression")); |
28611 | Token * _literal; |
28612 | expr_ty elem; |
28613 | while ( |
28614 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (28614:13): [True: 621k, False: 38.5k]
|
28615 | && |
28616 | (elem = star_named_expression_rule(p))621k // star_named_expression Branch (28616:13): [True: 619k, False: 1.82k]
|
28617 | ) |
28618 | { |
28619 | _res = elem; |
28620 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (28620:17): [True: 0, False: 619k]
Branch (28620:33): [True: 0, False: 0]
|
28621 | p->error_indicator = 1; |
28622 | PyMem_Free(_children); |
28623 | p->level--; |
28624 | return NULL; |
28625 | } |
28626 | if (_n == _children_capacity) { Branch (28626:17): [True: 19.4k, False: 600k]
|
28627 | _children_capacity *= 2; |
28628 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28629 | if (!_new_children) { Branch (28629:21): [True: 0, False: 19.4k]
|
28630 | p->error_indicator = 1; |
28631 | PyErr_NoMemory(); |
28632 | p->level--; |
28633 | return NULL; |
28634 | } |
28635 | _children = _new_children; |
28636 | } |
28637 | _children[_n++] = _res; |
28638 | _mark = p->mark; |
28639 | } |
28640 | p->mark = _mark; |
28641 | D(fprintf(stderr, "%*c%s _loop0_83[%d-%d]: %s failed!\n", p->level, ' ', |
28642 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression")); |
28643 | } |
28644 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28645 | if (!_seq) { Branch (28645:9): [True: 0, False: 40.4k]
|
28646 | PyMem_Free(_children); |
28647 | p->error_indicator = 1; |
28648 | PyErr_NoMemory(); |
28649 | p->level--; |
28650 | return NULL; |
28651 | } |
28652 | for (int i = 0; 40.4k i < _n; i++619k ) asdl_seq_SET_UNTYPED40.4k (_seq, i, _children[i]); Branch (28652:21): [True: 619k, False: 40.4k]
|
28653 | PyMem_Free(_children); |
28654 | _PyPegen_insert_memo(p, _start_mark, _loop0_83_type, _seq); |
28655 | p->level--; |
28656 | return _seq; |
28657 | } |
28658 | |
28659 | // _gather_82: star_named_expression _loop0_83 |
28660 | static asdl_seq * |
28661 | _gather_82_rule(Parser *p) |
28662 | { |
28663 | if (p->level++ == MAXSTACK) { Branch (28663:9): [True: 0, False: 97.3k]
|
28664 | p->error_indicator = 1; |
28665 | PyErr_NoMemory(); |
28666 | } |
28667 | if (p->error_indicator) { Branch (28667:9): [True: 0, False: 97.3k]
|
28668 | p->level--; |
28669 | return NULL; |
28670 | } |
28671 | asdl_seq * _res = NULL; |
28672 | int _mark = p->mark; |
28673 | { // star_named_expression _loop0_83 |
28674 | if (p->error_indicator) { Branch (28674:13): [True: 0, False: 97.3k]
|
28675 | p->level--; |
28676 | return NULL; |
28677 | } |
28678 | D(fprintf(stderr, "%*c> _gather_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_83")); |
28679 | expr_ty elem; |
28680 | asdl_seq * seq; |
28681 | if ( |
28682 | (elem = star_named_expression_rule(p)) // star_named_expression Branch (28682:13): [True: 40.4k, False: 56.9k]
|
28683 | && |
28684 | (seq = _loop0_83_rule(p))40.4k // _loop0_83 Branch (28684:13): [True: 40.4k, False: 0]
|
28685 | ) |
28686 | { |
28687 | D(fprintf(stderr, "%*c+ _gather_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_83")); |
28688 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
28689 | goto done; |
28690 | } |
28691 | p->mark = _mark; |
28692 | D(fprintf(stderr, "%*c%s _gather_82[%d-%d]: %s failed!\n", p->level, ' ', |
28693 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_83")); |
28694 | } |
28695 | _res = NULL; |
28696 | done: |
28697 | p->level--; |
28698 | return _res; |
28699 | } |
28700 | |
28701 | // _loop1_84: ('or' conjunction) |
28702 | static asdl_seq * |
28703 | _loop1_84_rule(Parser *p) |
28704 | { |
28705 | if (p->level++ == MAXSTACK) { Branch (28705:9): [True: 0, False: 1.73M]
|
28706 | p->error_indicator = 1; |
28707 | PyErr_NoMemory(); |
28708 | } |
28709 | if (p->error_indicator) { Branch (28709:9): [True: 0, False: 1.73M]
|
28710 | p->level--; |
28711 | return NULL; |
28712 | } |
28713 | void *_res = NULL; |
28714 | int _mark = p->mark; |
28715 | int _start_mark = p->mark; |
28716 | void **_children = PyMem_Malloc(sizeof(void *)); |
28717 | if (!_children) { Branch (28717:9): [True: 0, False: 1.73M]
|
28718 | p->error_indicator = 1; |
28719 | PyErr_NoMemory(); |
28720 | p->level--; |
28721 | return NULL; |
28722 | } |
28723 | Py_ssize_t _children_capacity = 1; |
28724 | Py_ssize_t _n = 0; |
28725 | { // ('or' conjunction) |
28726 | if (p->error_indicator) { Branch (28726:13): [True: 0, False: 1.73M]
|
28727 | p->level--; |
28728 | return NULL; |
28729 | } |
28730 | D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); |
28731 | void *_tmp_225_var; |
28732 | while ( |
28733 | (_tmp_225_var = _tmp_225_rule(p)) // 'or' conjunction Branch (28733:13): [True: 2.87k, False: 1.73M]
|
28734 | ) |
28735 | { |
28736 | _res = _tmp_225_var; |
28737 | if (_n == _children_capacity) { Branch (28737:17): [True: 286, False: 2.59k]
|
28738 | _children_capacity *= 2; |
28739 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28740 | if (!_new_children) { Branch (28740:21): [True: 0, False: 286]
|
28741 | p->error_indicator = 1; |
28742 | PyErr_NoMemory(); |
28743 | p->level--; |
28744 | return NULL; |
28745 | } |
28746 | _children = _new_children; |
28747 | } |
28748 | _children[_n++] = _res; |
28749 | _mark = p->mark; |
28750 | } |
28751 | p->mark = _mark; |
28752 | D(fprintf(stderr, "%*c%s _loop1_84[%d-%d]: %s failed!\n", p->level, ' ', |
28753 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)")); |
28754 | } |
28755 | if (_n == 0 || p->error_indicator2.39k ) { Branch (28755:9): [True: 1.73M, False: 2.39k]
Branch (28755:20): [True: 0, False: 2.39k]
|
28756 | PyMem_Free(_children); |
28757 | p->level--; |
28758 | return NULL; |
28759 | } |
28760 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28761 | if (!_seq) { Branch (28761:9): [True: 0, False: 2.39k]
|
28762 | PyMem_Free(_children); |
28763 | p->error_indicator = 1; |
28764 | PyErr_NoMemory(); |
28765 | p->level--; |
28766 | return NULL; |
28767 | } |
28768 | for (int i = 0; 2.39k i < _n; i++2.87k ) asdl_seq_SET_UNTYPED2.39k (_seq, i, _children[i]); Branch (28768:21): [True: 2.87k, False: 2.39k]
|
28769 | PyMem_Free(_children); |
28770 | _PyPegen_insert_memo(p, _start_mark, _loop1_84_type, _seq); |
28771 | p->level--; |
28772 | return _seq; |
28773 | } |
28774 | |
28775 | // _loop1_85: ('and' inversion) |
28776 | static asdl_seq * |
28777 | _loop1_85_rule(Parser *p) |
28778 | { |
28779 | if (p->level++ == MAXSTACK) { Branch (28779:9): [True: 0, False: 1.74M]
|
28780 | p->error_indicator = 1; |
28781 | PyErr_NoMemory(); |
28782 | } |
28783 | if (p->error_indicator) { Branch (28783:9): [True: 0, False: 1.74M]
|
28784 | p->level--; |
28785 | return NULL; |
28786 | } |
28787 | void *_res = NULL; |
28788 | int _mark = p->mark; |
28789 | int _start_mark = p->mark; |
28790 | void **_children = PyMem_Malloc(sizeof(void *)); |
28791 | if (!_children) { Branch (28791:9): [True: 0, False: 1.74M]
|
28792 | p->error_indicator = 1; |
28793 | PyErr_NoMemory(); |
28794 | p->level--; |
28795 | return NULL; |
28796 | } |
28797 | Py_ssize_t _children_capacity = 1; |
28798 | Py_ssize_t _n = 0; |
28799 | { // ('and' inversion) |
28800 | if (p->error_indicator) { Branch (28800:13): [True: 0, False: 1.74M]
|
28801 | p->level--; |
28802 | return NULL; |
28803 | } |
28804 | D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); |
28805 | void *_tmp_226_var; |
28806 | while ( |
28807 | (_tmp_226_var = _tmp_226_rule(p)) // 'and' inversion Branch (28807:13): [True: 4.74k, False: 1.74M]
|
28808 | ) |
28809 | { |
28810 | _res = _tmp_226_var; |
28811 | if (_n == _children_capacity) { Branch (28811:17): [True: 752, False: 3.98k]
|
28812 | _children_capacity *= 2; |
28813 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28814 | if (!_new_children) { Branch (28814:21): [True: 0, False: 752]
|
28815 | p->error_indicator = 1; |
28816 | PyErr_NoMemory(); |
28817 | p->level--; |
28818 | return NULL; |
28819 | } |
28820 | _children = _new_children; |
28821 | } |
28822 | _children[_n++] = _res; |
28823 | _mark = p->mark; |
28824 | } |
28825 | p->mark = _mark; |
28826 | D(fprintf(stderr, "%*c%s _loop1_85[%d-%d]: %s failed!\n", p->level, ' ', |
28827 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)")); |
28828 | } |
28829 | if (_n == 0 || p->error_indicator3.83k ) { Branch (28829:9): [True: 1.73M, False: 3.83k]
Branch (28829:20): [True: 0, False: 3.83k]
|
28830 | PyMem_Free(_children); |
28831 | p->level--; |
28832 | return NULL; |
28833 | } |
28834 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28835 | if (!_seq) { Branch (28835:9): [True: 0, False: 3.83k]
|
28836 | PyMem_Free(_children); |
28837 | p->error_indicator = 1; |
28838 | PyErr_NoMemory(); |
28839 | p->level--; |
28840 | return NULL; |
28841 | } |
28842 | for (int i = 0; 3.83k i < _n; i++4.74k ) asdl_seq_SET_UNTYPED3.83k (_seq, i, _children[i]); Branch (28842:21): [True: 4.74k, False: 3.83k]
|
28843 | PyMem_Free(_children); |
28844 | _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq); |
28845 | p->level--; |
28846 | return _seq; |
28847 | } |
28848 | |
28849 | // _loop1_86: compare_op_bitwise_or_pair |
28850 | static asdl_seq * |
28851 | _loop1_86_rule(Parser *p) |
28852 | { |
28853 | if (p->level++ == MAXSTACK) { Branch (28853:9): [True: 0, False: 1.74M]
|
28854 | p->error_indicator = 1; |
28855 | PyErr_NoMemory(); |
28856 | } |
28857 | if (p->error_indicator) { Branch (28857:9): [True: 0, False: 1.74M]
|
28858 | p->level--; |
28859 | return NULL; |
28860 | } |
28861 | void *_res = NULL; |
28862 | int _mark = p->mark; |
28863 | int _start_mark = p->mark; |
28864 | void **_children = PyMem_Malloc(sizeof(void *)); |
28865 | if (!_children) { Branch (28865:9): [True: 0, False: 1.74M]
|
28866 | p->error_indicator = 1; |
28867 | PyErr_NoMemory(); |
28868 | p->level--; |
28869 | return NULL; |
28870 | } |
28871 | Py_ssize_t _children_capacity = 1; |
28872 | Py_ssize_t _n = 0; |
28873 | { // compare_op_bitwise_or_pair |
28874 | if (p->error_indicator) { Branch (28874:13): [True: 0, False: 1.74M]
|
28875 | p->level--; |
28876 | return NULL; |
28877 | } |
28878 | D(fprintf(stderr, "%*c> _loop1_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); |
28879 | CmpopExprPair* compare_op_bitwise_or_pair_var; |
28880 | while ( |
28881 | (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair Branch (28881:13): [True: 22.2k, False: 1.74M]
|
28882 | ) |
28883 | { |
28884 | _res = compare_op_bitwise_or_pair_var; |
28885 | if (_n == _children_capacity) { Branch (28885:17): [True: 246, False: 22.0k]
|
28886 | _children_capacity *= 2; |
28887 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
28888 | if (!_new_children) { Branch (28888:21): [True: 0, False: 246]
|
28889 | p->error_indicator = 1; |
28890 | PyErr_NoMemory(); |
28891 | p->level--; |
28892 | return NULL; |
28893 | } |
28894 | _children = _new_children; |
28895 | } |
28896 | _children[_n++] = _res; |
28897 | _mark = p->mark; |
28898 | } |
28899 | p->mark = _mark; |
28900 | D(fprintf(stderr, "%*c%s _loop1_86[%d-%d]: %s failed!\n", p->level, ' ', |
28901 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair")); |
28902 | } |
28903 | if (_n == 0 || p->error_indicator21.9k ) { Branch (28903:9): [True: 1.72M, False: 21.9k]
Branch (28903:20): [True: 0, False: 21.9k]
|
28904 | PyMem_Free(_children); |
28905 | p->level--; |
28906 | return NULL; |
28907 | } |
28908 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
28909 | if (!_seq) { Branch (28909:9): [True: 0, False: 21.9k]
|
28910 | PyMem_Free(_children); |
28911 | p->error_indicator = 1; |
28912 | PyErr_NoMemory(); |
28913 | p->level--; |
28914 | return NULL; |
28915 | } |
28916 | for (int i = 0; 21.9k i < _n; i++22.2k ) asdl_seq_SET_UNTYPED21.9k (_seq, i, _children[i]); Branch (28916:21): [True: 22.2k, False: 21.9k]
|
28917 | PyMem_Free(_children); |
28918 | _PyPegen_insert_memo(p, _start_mark, _loop1_86_type, _seq); |
28919 | p->level--; |
28920 | return _seq; |
28921 | } |
28922 | |
28923 | // _tmp_87: '!=' |
28924 | static void * |
28925 | _tmp_87_rule(Parser *p) |
28926 | { |
28927 | if (p->level++ == MAXSTACK) { Branch (28927:9): [True: 0, False: 1.76M]
|
28928 | p->error_indicator = 1; |
28929 | PyErr_NoMemory(); |
28930 | } |
28931 | if (p->error_indicator) { Branch (28931:9): [True: 0, False: 1.76M]
|
28932 | p->level--; |
28933 | return NULL; |
28934 | } |
28935 | void * _res = NULL; |
28936 | int _mark = p->mark; |
28937 | { // '!=' |
28938 | if (p->error_indicator) { Branch (28938:13): [True: 0, False: 1.76M]
|
28939 | p->level--; |
28940 | return NULL; |
28941 | } |
28942 | D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); |
28943 | Token * tok; |
28944 | if ( |
28945 | (tok = _PyPegen_expect_token(p, 28)) // token='!=' Branch (28945:13): [True: 1.72k, False: 1.76M]
|
28946 | ) |
28947 | { |
28948 | D(fprintf(stderr, "%*c+ _tmp_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); |
28949 | _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok1.72k ; Branch (28949:20): [True: 3, False: 1.72k]
|
28950 | if (_res == NULL && PyErr_Occurred()3 ) { Branch (28950:17): [True: 3, False: 1.72k]
Branch (28950:33): [True: 1, False: 2]
|
28951 | p->error_indicator = 1; |
28952 | p->level--; |
28953 | return NULL; |
28954 | } |
28955 | goto done; |
28956 | } |
28957 | p->mark = _mark; |
28958 | D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ', |
28959 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='")); |
28960 | } |
28961 | _res = NULL; |
28962 | done: |
28963 | p->level--; |
28964 | return _res; |
28965 | } |
28966 | |
28967 | // _loop0_89: ',' (slice | starred_expression) |
28968 | static asdl_seq * |
28969 | _loop0_89_rule(Parser *p) |
28970 | { |
28971 | if (p->level++ == MAXSTACK) { Branch (28971:9): [True: 0, False: 2.73k]
|
28972 | p->error_indicator = 1; |
28973 | PyErr_NoMemory(); |
28974 | } |
28975 | if (p->error_indicator) { Branch (28975:9): [True: 0, False: 2.73k]
|
28976 | p->level--; |
28977 | return NULL; |
28978 | } |
28979 | void *_res = NULL; |
28980 | int _mark = p->mark; |
28981 | int _start_mark = p->mark; |
28982 | void **_children = PyMem_Malloc(sizeof(void *)); |
28983 | if (!_children) { Branch (28983:9): [True: 0, False: 2.73k]
|
28984 | p->error_indicator = 1; |
28985 | PyErr_NoMemory(); |
28986 | p->level--; |
28987 | return NULL; |
28988 | } |
28989 | Py_ssize_t _children_capacity = 1; |
28990 | Py_ssize_t _n = 0; |
28991 | { // ',' (slice | starred_expression) |
28992 | if (p->error_indicator) { Branch (28992:13): [True: 0, False: 2.73k]
|
28993 | p->level--; |
28994 | return NULL; |
28995 | } |
28996 | D(fprintf(stderr, "%*c> _loop0_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | starred_expression)")); |
28997 | Token * _literal; |
28998 | void *elem; |
28999 | while ( |
29000 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (29000:13): [True: 2.91k, False: 2.64k]
|
29001 | && |
29002 | (elem = _tmp_227_rule(p))2.91k // slice | starred_expression Branch (29002:13): [True: 2.81k, False: 96]
|
29003 | ) |
29004 | { |
29005 | _res = elem; |
29006 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (29006:17): [True: 0, False: 2.81k]
Branch (29006:33): [True: 0, False: 0]
|
29007 | p->error_indicator = 1; |
29008 | PyMem_Free(_children); |
29009 | p->level--; |
29010 | return NULL; |
29011 | } |
29012 | if (_n == _children_capacity) { Branch (29012:17): [True: 524, False: 2.29k]
|
29013 | _children_capacity *= 2; |
29014 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29015 | if (!_new_children) { Branch (29015:21): [True: 0, False: 524]
|
29016 | p->error_indicator = 1; |
29017 | PyErr_NoMemory(); |
29018 | p->level--; |
29019 | return NULL; |
29020 | } |
29021 | _children = _new_children; |
29022 | } |
29023 | _children[_n++] = _res; |
29024 | _mark = p->mark; |
29025 | } |
29026 | p->mark = _mark; |
29027 | D(fprintf(stderr, "%*c%s _loop0_89[%d-%d]: %s failed!\n", p->level, ' ', |
29028 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (slice | starred_expression)")); |
29029 | } |
29030 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29031 | if (!_seq) { Branch (29031:9): [True: 0, False: 2.73k]
|
29032 | PyMem_Free(_children); |
29033 | p->error_indicator = 1; |
29034 | PyErr_NoMemory(); |
29035 | p->level--; |
29036 | return NULL; |
29037 | } |
29038 | for (int i = 0; 2.73k i < _n; i++2.81k ) asdl_seq_SET_UNTYPED2.73k (_seq, i, _children[i]); Branch (29038:21): [True: 2.81k, False: 2.73k]
|
29039 | PyMem_Free(_children); |
29040 | _PyPegen_insert_memo(p, _start_mark, _loop0_89_type, _seq); |
29041 | p->level--; |
29042 | return _seq; |
29043 | } |
29044 | |
29045 | // _gather_88: (slice | starred_expression) _loop0_89 |
29046 | static asdl_seq * |
29047 | _gather_88_rule(Parser *p) |
29048 | { |
29049 | if (p->level++ == MAXSTACK) { Branch (29049:9): [True: 0, False: 2.83k]
|
29050 | p->error_indicator = 1; |
29051 | PyErr_NoMemory(); |
29052 | } |
29053 | if (p->error_indicator) { Branch (29053:9): [True: 0, False: 2.83k]
|
29054 | p->level--; |
29055 | return NULL; |
29056 | } |
29057 | asdl_seq * _res = NULL; |
29058 | int _mark = p->mark; |
29059 | { // (slice | starred_expression) _loop0_89 |
29060 | if (p->error_indicator) { Branch (29060:13): [True: 0, False: 2.83k]
|
29061 | p->level--; |
29062 | return NULL; |
29063 | } |
29064 | D(fprintf(stderr, "%*c> _gather_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_89")); |
29065 | void *elem; |
29066 | asdl_seq * seq; |
29067 | if ( |
29068 | (elem = _tmp_227_rule(p)) // slice | starred_expression Branch (29068:13): [True: 2.73k, False: 95]
|
29069 | && |
29070 | (seq = _loop0_89_rule(p))2.73k // _loop0_89 Branch (29070:13): [True: 2.73k, False: 0]
|
29071 | ) |
29072 | { |
29073 | D(fprintf(stderr, "%*c+ _gather_88[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_89")); |
29074 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
29075 | goto done; |
29076 | } |
29077 | p->mark = _mark; |
29078 | D(fprintf(stderr, "%*c%s _gather_88[%d-%d]: %s failed!\n", p->level, ' ', |
29079 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_89")); |
29080 | } |
29081 | _res = NULL; |
29082 | done: |
29083 | p->level--; |
29084 | return _res; |
29085 | } |
29086 | |
29087 | // _tmp_90: ':' expression? |
29088 | static void * |
29089 | _tmp_90_rule(Parser *p) |
29090 | { |
29091 | if (p->level++ == MAXSTACK) { Branch (29091:9): [True: 0, False: 5.36k]
|
29092 | p->error_indicator = 1; |
29093 | PyErr_NoMemory(); |
29094 | } |
29095 | if (p->error_indicator) { Branch (29095:9): [True: 0, False: 5.36k]
|
29096 | p->level--; |
29097 | return NULL; |
29098 | } |
29099 | void * _res = NULL; |
29100 | int _mark = p->mark; |
29101 | { // ':' expression? |
29102 | if (p->error_indicator) { Branch (29102:13): [True: 0, False: 5.36k]
|
29103 | p->level--; |
29104 | return NULL; |
29105 | } |
29106 | D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); |
29107 | Token * _literal; |
29108 | void *d; |
29109 | if ( |
29110 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' Branch (29110:13): [True: 313, False: 5.05k]
|
29111 | && |
29112 | (d = expression_rule(p), !p->error_indicator)313 // expression? Branch (29112:13): [True: 309, False: 4]
|
29113 | ) |
29114 | { |
29115 | D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?")); |
29116 | _res = d; |
29117 | if (_res == NULL && PyErr_Occurred()5 ) { |
29118 | p->error_indicator = 1; |
29119 | p->level--; |
29120 | return NULL; |
29121 | } |
29122 | goto done; |
29123 | } |
29124 | p->mark = _mark; |
29125 | D(fprintf(stderr, "%*c%s _tmp_90[%d-%d]: %s failed!\n", p->level, ' ', |
29126 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?")); |
29127 | } |
29128 | _res = NULL; |
29129 | done: |
29130 | p->level--; |
29131 | return _res; |
29132 | } |
29133 | |
29134 | // _tmp_91: tuple | group | genexp |
29135 | static void * |
29136 | _tmp_91_rule(Parser *p) |
29137 | { |
29138 | if (p->level++ == MAXSTACK) { Branch (29138:9): [True: 0, False: 232k]
|
29139 | p->error_indicator = 1; |
29140 | PyErr_NoMemory(); |
29141 | } |
29142 | if (p->error_indicator) { Branch (29142:9): [True: 0, False: 232k]
|
29143 | p->level--; |
29144 | return NULL; |
29145 | } |
29146 | void * _res = NULL; |
29147 | int _mark = p->mark; |
29148 | { // tuple |
29149 | if (p->error_indicator) { Branch (29149:13): [True: 0, False: 232k]
|
29150 | p->level--; |
29151 | return NULL; |
29152 | } |
29153 | D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); |
29154 | expr_ty tuple_var; |
29155 | if ( |
29156 | (tuple_var = tuple_rule(p)) // tuple Branch (29156:13): [True: 76.0k, False: 156k]
|
29157 | ) |
29158 | { |
29159 | D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); |
29160 | _res = tuple_var; |
29161 | goto done; |
29162 | } |
29163 | p->mark = _mark; |
29164 | D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', |
29165 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); |
29166 | } |
29167 | { // group |
29168 | if (p->error_indicator) { Branch (29168:13): [True: 49, False: 156k]
|
29169 | p->level--; |
29170 | return NULL; |
29171 | } |
29172 | D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group")); |
29173 | expr_ty group_var; |
29174 | if ( |
29175 | (group_var = group_rule(p)) // group Branch (29175:13): [True: 155k, False: 718]
|
29176 | ) |
29177 | { |
29178 | D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group")); |
29179 | _res = group_var; |
29180 | goto done; |
29181 | } |
29182 | p->mark = _mark; |
29183 | D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', |
29184 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group")); |
29185 | } |
29186 | { // genexp |
29187 | if (p->error_indicator) { Branch (29187:13): [True: 10, False: 708]
|
29188 | p->level--; |
29189 | return NULL; |
29190 | } |
29191 | D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); |
29192 | expr_ty genexp_var; |
29193 | if ( |
29194 | (genexp_var = genexp_rule(p)) // genexp Branch (29194:13): [True: 590, False: 118]
|
29195 | ) |
29196 | { |
29197 | D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); |
29198 | _res = genexp_var; |
29199 | goto done; |
29200 | } |
29201 | p->mark = _mark; |
29202 | D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', |
29203 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); |
29204 | } |
29205 | _res = NULL; |
29206 | done: |
29207 | p->level--; |
29208 | return _res; |
29209 | } |
29210 | |
29211 | // _tmp_92: list | listcomp |
29212 | static void * |
29213 | _tmp_92_rule(Parser *p) |
29214 | { |
29215 | if (p->level++ == MAXSTACK) { Branch (29215:9): [True: 0, False: 21.3k]
|
29216 | p->error_indicator = 1; |
29217 | PyErr_NoMemory(); |
29218 | } |
29219 | if (p->error_indicator) { Branch (29219:9): [True: 0, False: 21.3k]
|
29220 | p->level--; |
29221 | return NULL; |
29222 | } |
29223 | void * _res = NULL; |
29224 | int _mark = p->mark; |
29225 | { // list |
29226 | if (p->error_indicator) { Branch (29226:13): [True: 0, False: 21.3k]
|
29227 | p->level--; |
29228 | return NULL; |
29229 | } |
29230 | D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); |
29231 | expr_ty list_var; |
29232 | if ( |
29233 | (list_var = list_rule(p)) // list Branch (29233:13): [True: 18.4k, False: 2.85k]
|
29234 | ) |
29235 | { |
29236 | D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); |
29237 | _res = list_var; |
29238 | goto done; |
29239 | } |
29240 | p->mark = _mark; |
29241 | D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ', |
29242 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); |
29243 | } |
29244 | { // listcomp |
29245 | if (p->error_indicator) { Branch (29245:13): [True: 34, False: 2.81k]
|
29246 | p->level--; |
29247 | return NULL; |
29248 | } |
29249 | D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp")); |
29250 | expr_ty listcomp_var; |
29251 | if ( |
29252 | (listcomp_var = listcomp_rule(p)) // listcomp Branch (29252:13): [True: 2.73k, False: 89]
|
29253 | ) |
29254 | { |
29255 | D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp")); |
29256 | _res = listcomp_var; |
29257 | goto done; |
29258 | } |
29259 | p->mark = _mark; |
29260 | D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ', |
29261 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp")); |
29262 | } |
29263 | _res = NULL; |
29264 | done: |
29265 | p->level--; |
29266 | return _res; |
29267 | } |
29268 | |
29269 | // _tmp_93: dict | set | dictcomp | setcomp |
29270 | static void * |
29271 | _tmp_93_rule(Parser *p) |
29272 | { |
29273 | if (p->level++ == MAXSTACK) { Branch (29273:9): [True: 0, False: 10.4k]
|
29274 | p->error_indicator = 1; |
29275 | PyErr_NoMemory(); |
29276 | } |
29277 | if (p->error_indicator) { Branch (29277:9): [True: 0, False: 10.4k]
|
29278 | p->level--; |
29279 | return NULL; |
29280 | } |
29281 | void * _res = NULL; |
29282 | int _mark = p->mark; |
29283 | { // dict |
29284 | if (p->error_indicator) { Branch (29284:13): [True: 0, False: 10.4k]
|
29285 | p->level--; |
29286 | return NULL; |
29287 | } |
29288 | D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict")); |
29289 | expr_ty dict_var; |
29290 | if ( |
29291 | (dict_var = dict_rule(p)) // dict Branch (29291:13): [True: 8.57k, False: 1.84k]
|
29292 | ) |
29293 | { |
29294 | D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict")); |
29295 | _res = dict_var; |
29296 | goto done; |
29297 | } |
29298 | p->mark = _mark; |
29299 | D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', |
29300 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict")); |
29301 | } |
29302 | { // set |
29303 | if (p->error_indicator) { Branch (29303:13): [True: 32, False: 1.81k]
|
29304 | p->level--; |
29305 | return NULL; |
29306 | } |
29307 | D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set")); |
29308 | expr_ty set_var; |
29309 | if ( |
29310 | (set_var = set_rule(p)) // set Branch (29310:13): [True: 929, False: 882]
|
29311 | ) |
29312 | { |
29313 | D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set")); |
29314 | _res = set_var; |
29315 | goto done; |
29316 | } |
29317 | p->mark = _mark; |
29318 | D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', |
29319 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set")); |
29320 | } |
29321 | { // dictcomp |
29322 | if (p->error_indicator) { Branch (29322:13): [True: 5, False: 877]
|
29323 | p->level--; |
29324 | return NULL; |
29325 | } |
29326 | D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp")); |
29327 | expr_ty dictcomp_var; |
29328 | if ( |
29329 | (dictcomp_var = dictcomp_rule(p)) // dictcomp Branch (29329:13): [True: 365, False: 512]
|
29330 | ) |
29331 | { |
29332 | D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp")); |
29333 | _res = dictcomp_var; |
29334 | goto done; |
29335 | } |
29336 | p->mark = _mark; |
29337 | D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', |
29338 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp")); |
29339 | } |
29340 | { // setcomp |
29341 | if (p->error_indicator) { Branch (29341:13): [True: 1, False: 511]
|
29342 | p->level--; |
29343 | return NULL; |
29344 | } |
29345 | D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp")); |
29346 | expr_ty setcomp_var; |
29347 | if ( |
29348 | (setcomp_var = setcomp_rule(p)) // setcomp Branch (29348:13): [True: 453, False: 58]
|
29349 | ) |
29350 | { |
29351 | D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp")); |
29352 | _res = setcomp_var; |
29353 | goto done; |
29354 | } |
29355 | p->mark = _mark; |
29356 | D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ', |
29357 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp")); |
29358 | } |
29359 | _res = NULL; |
29360 | done: |
29361 | p->level--; |
29362 | return _res; |
29363 | } |
29364 | |
29365 | // _tmp_94: yield_expr | named_expression |
29366 | static void * |
29367 | _tmp_94_rule(Parser *p) |
29368 | { |
29369 | if (p->level++ == MAXSTACK) { Branch (29369:9): [True: 0, False: 156k]
|
29370 | p->error_indicator = 1; |
29371 | PyErr_NoMemory(); |
29372 | } |
29373 | if (p->error_indicator) { Branch (29373:9): [True: 0, False: 156k]
|
29374 | p->level--; |
29375 | return NULL; |
29376 | } |
29377 | void * _res = NULL; |
29378 | int _mark = p->mark; |
29379 | { // yield_expr |
29380 | if (p->error_indicator) { Branch (29380:13): [True: 0, False: 156k]
|
29381 | p->level--; |
29382 | return NULL; |
29383 | } |
29384 | D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
29385 | expr_ty yield_expr_var; |
29386 | if ( |
29387 | (yield_expr_var = yield_expr_rule(p)) // yield_expr Branch (29387:13): [True: 162, False: 155k]
|
29388 | ) |
29389 | { |
29390 | D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
29391 | _res = yield_expr_var; |
29392 | goto done; |
29393 | } |
29394 | p->mark = _mark; |
29395 | D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ', |
29396 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); |
29397 | } |
29398 | { // named_expression |
29399 | if (p->error_indicator) { Branch (29399:13): [True: 0, False: 155k]
|
29400 | p->level--; |
29401 | return NULL; |
29402 | } |
29403 | D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); |
29404 | expr_ty named_expression_var; |
29405 | if ( |
29406 | (named_expression_var = named_expression_rule(p)) // named_expression Branch (29406:13): [True: 155k, False: 60]
|
29407 | ) |
29408 | { |
29409 | D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); |
29410 | _res = named_expression_var; |
29411 | goto done; |
29412 | } |
29413 | p->mark = _mark; |
29414 | D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ', |
29415 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); |
29416 | } |
29417 | _res = NULL; |
29418 | done: |
29419 | p->level--; |
29420 | return _res; |
29421 | } |
29422 | |
29423 | // _loop0_95: lambda_param_no_default |
29424 | static asdl_seq * |
29425 | _loop0_95_rule(Parser *p) |
29426 | { |
29427 | if (p->level++ == MAXSTACK) { Branch (29427:9): [True: 0, False: 67]
|
29428 | p->error_indicator = 1; |
29429 | PyErr_NoMemory(); |
29430 | } |
29431 | if (p->error_indicator) { Branch (29431:9): [True: 0, False: 67]
|
29432 | p->level--; |
29433 | return NULL; |
29434 | } |
29435 | void *_res = NULL; |
29436 | int _mark = p->mark; |
29437 | int _start_mark = p->mark; |
29438 | void **_children = PyMem_Malloc(sizeof(void *)); |
29439 | if (!_children) { Branch (29439:9): [True: 0, False: 67]
|
29440 | p->error_indicator = 1; |
29441 | PyErr_NoMemory(); |
29442 | p->level--; |
29443 | return NULL; |
29444 | } |
29445 | Py_ssize_t _children_capacity = 1; |
29446 | Py_ssize_t _n = 0; |
29447 | { // lambda_param_no_default |
29448 | if (p->error_indicator) { |
29449 | p->level--; |
29450 | return NULL; |
29451 | } |
29452 | D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
29453 | arg_ty lambda_param_no_default_var; |
29454 | while ( |
29455 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (29455:13): [True: 29, False: 67]
|
29456 | ) |
29457 | { |
29458 | _res = lambda_param_no_default_var; |
29459 | if (_n == _children_capacity) { |
29460 | _children_capacity *= 2; |
29461 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29462 | if (!_new_children) { |
29463 | p->error_indicator = 1; |
29464 | PyErr_NoMemory(); |
29465 | p->level--; |
29466 | return NULL; |
29467 | } |
29468 | _children = _new_children; |
29469 | } |
29470 | _children[_n++] = _res; |
29471 | _mark = p->mark; |
29472 | } |
29473 | p->mark = _mark; |
29474 | D(fprintf(stderr, "%*c%s _loop0_95[%d-%d]: %s failed!\n", p->level, ' ', |
29475 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
29476 | } |
29477 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29478 | if (!_seq) { Branch (29478:9): [True: 0, False: 67]
|
29479 | PyMem_Free(_children); |
29480 | p->error_indicator = 1; |
29481 | PyErr_NoMemory(); |
29482 | p->level--; |
29483 | return NULL; |
29484 | } |
29485 | for (int i = 0; 67 i < _n; i++29 ) asdl_seq_SET_UNTYPED67 (_seq, i, _children[i]); Branch (29485:21): [True: 29, False: 67]
|
29486 | PyMem_Free(_children); |
29487 | _PyPegen_insert_memo(p, _start_mark, _loop0_95_type, _seq); |
29488 | p->level--; |
29489 | return _seq; |
29490 | } |
29491 | |
29492 | // _loop0_96: lambda_param_with_default |
29493 | static asdl_seq * |
29494 | _loop0_96_rule(Parser *p) |
29495 | { |
29496 | if (p->level++ == MAXSTACK) { Branch (29496:9): [True: 0, False: 67]
|
29497 | p->error_indicator = 1; |
29498 | PyErr_NoMemory(); |
29499 | } |
29500 | if (p->error_indicator) { Branch (29500:9): [True: 0, False: 67]
|
29501 | p->level--; |
29502 | return NULL; |
29503 | } |
29504 | void *_res = NULL; |
29505 | int _mark = p->mark; |
29506 | int _start_mark = p->mark; |
29507 | void **_children = PyMem_Malloc(sizeof(void *)); |
29508 | if (!_children) { Branch (29508:9): [True: 0, False: 67]
|
29509 | p->error_indicator = 1; |
29510 | PyErr_NoMemory(); |
29511 | p->level--; |
29512 | return NULL; |
29513 | } |
29514 | Py_ssize_t _children_capacity = 1; |
29515 | Py_ssize_t _n = 0; |
29516 | { // lambda_param_with_default |
29517 | if (p->error_indicator) { |
29518 | p->level--; |
29519 | return NULL; |
29520 | } |
29521 | D(fprintf(stderr, "%*c> _loop0_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
29522 | NameDefaultPair* lambda_param_with_default_var; |
29523 | while ( |
29524 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default Branch (29524:13): [True: 37, False: 67]
|
29525 | ) |
29526 | { |
29527 | _res = lambda_param_with_default_var; |
29528 | if (_n == _children_capacity) { |
29529 | _children_capacity *= 2; |
29530 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29531 | if (!_new_children) { |
29532 | p->error_indicator = 1; |
29533 | PyErr_NoMemory(); |
29534 | p->level--; |
29535 | return NULL; |
29536 | } |
29537 | _children = _new_children; |
29538 | } |
29539 | _children[_n++] = _res; |
29540 | _mark = p->mark; |
29541 | } |
29542 | p->mark = _mark; |
29543 | D(fprintf(stderr, "%*c%s _loop0_96[%d-%d]: %s failed!\n", p->level, ' ', |
29544 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
29545 | } |
29546 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29547 | if (!_seq) { Branch (29547:9): [True: 0, False: 67]
|
29548 | PyMem_Free(_children); |
29549 | p->error_indicator = 1; |
29550 | PyErr_NoMemory(); |
29551 | p->level--; |
29552 | return NULL; |
29553 | } |
29554 | for (int i = 0; 67 i < _n; i++37 ) asdl_seq_SET_UNTYPED67 (_seq, i, _children[i]); Branch (29554:21): [True: 37, False: 67]
|
29555 | PyMem_Free(_children); |
29556 | _PyPegen_insert_memo(p, _start_mark, _loop0_96_type, _seq); |
29557 | p->level--; |
29558 | return _seq; |
29559 | } |
29560 | |
29561 | // _loop0_97: lambda_param_with_default |
29562 | static asdl_seq * |
29563 | _loop0_97_rule(Parser *p) |
29564 | { |
29565 | if (p->level++ == MAXSTACK) { Branch (29565:9): [True: 0, False: 58]
|
29566 | p->error_indicator = 1; |
29567 | PyErr_NoMemory(); |
29568 | } |
29569 | if (p->error_indicator) { Branch (29569:9): [True: 0, False: 58]
|
29570 | p->level--; |
29571 | return NULL; |
29572 | } |
29573 | void *_res = NULL; |
29574 | int _mark = p->mark; |
29575 | int _start_mark = p->mark; |
29576 | void **_children = PyMem_Malloc(sizeof(void *)); |
29577 | if (!_children) { Branch (29577:9): [True: 0, False: 58]
|
29578 | p->error_indicator = 1; |
29579 | PyErr_NoMemory(); |
29580 | p->level--; |
29581 | return NULL; |
29582 | } |
29583 | Py_ssize_t _children_capacity = 1; |
29584 | Py_ssize_t _n = 0; |
29585 | { // lambda_param_with_default |
29586 | if (p->error_indicator) { |
29587 | p->level--; |
29588 | return NULL; |
29589 | } |
29590 | D(fprintf(stderr, "%*c> _loop0_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
29591 | NameDefaultPair* lambda_param_with_default_var; |
29592 | while ( |
29593 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default Branch (29593:13): [True: 45, False: 58]
|
29594 | ) |
29595 | { |
29596 | _res = lambda_param_with_default_var; |
29597 | if (_n == _children_capacity) { |
29598 | _children_capacity *= 2; |
29599 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29600 | if (!_new_children) { |
29601 | p->error_indicator = 1; |
29602 | PyErr_NoMemory(); |
29603 | p->level--; |
29604 | return NULL; |
29605 | } |
29606 | _children = _new_children; |
29607 | } |
29608 | _children[_n++] = _res; |
29609 | _mark = p->mark; |
29610 | } |
29611 | p->mark = _mark; |
29612 | D(fprintf(stderr, "%*c%s _loop0_97[%d-%d]: %s failed!\n", p->level, ' ', |
29613 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
29614 | } |
29615 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29616 | if (!_seq) { Branch (29616:9): [True: 0, False: 58]
|
29617 | PyMem_Free(_children); |
29618 | p->error_indicator = 1; |
29619 | PyErr_NoMemory(); |
29620 | p->level--; |
29621 | return NULL; |
29622 | } |
29623 | for (int i = 0; 58 i < _n; i++45 ) asdl_seq_SET_UNTYPED58 (_seq, i, _children[i]); Branch (29623:21): [True: 45, False: 58]
|
29624 | PyMem_Free(_children); |
29625 | _PyPegen_insert_memo(p, _start_mark, _loop0_97_type, _seq); |
29626 | p->level--; |
29627 | return _seq; |
29628 | } |
29629 | |
29630 | // _loop1_98: lambda_param_no_default |
29631 | static asdl_seq * |
29632 | _loop1_98_rule(Parser *p) |
29633 | { |
29634 | if (p->level++ == MAXSTACK) { Branch (29634:9): [True: 0, False: 1.45k]
|
29635 | p->error_indicator = 1; |
29636 | PyErr_NoMemory(); |
29637 | } |
29638 | if (p->error_indicator) { Branch (29638:9): [True: 0, False: 1.45k]
|
29639 | p->level--; |
29640 | return NULL; |
29641 | } |
29642 | void *_res = NULL; |
29643 | int _mark = p->mark; |
29644 | int _start_mark = p->mark; |
29645 | void **_children = PyMem_Malloc(sizeof(void *)); |
29646 | if (!_children) { Branch (29646:9): [True: 0, False: 1.45k]
|
29647 | p->error_indicator = 1; |
29648 | PyErr_NoMemory(); |
29649 | p->level--; |
29650 | return NULL; |
29651 | } |
29652 | Py_ssize_t _children_capacity = 1; |
29653 | Py_ssize_t _n = 0; |
29654 | { // lambda_param_no_default |
29655 | if (p->error_indicator) { Branch (29655:13): [True: 0, False: 1.45k]
|
29656 | p->level--; |
29657 | return NULL; |
29658 | } |
29659 | D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
29660 | arg_ty lambda_param_no_default_var; |
29661 | while ( |
29662 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (29662:13): [True: 8.03k, False: 1.45k]
|
29663 | ) |
29664 | { |
29665 | _res = lambda_param_no_default_var; |
29666 | if (_n == _children_capacity) { Branch (29666:17): [True: 1.28k, False: 6.75k]
|
29667 | _children_capacity *= 2; |
29668 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29669 | if (!_new_children) { Branch (29669:21): [True: 0, False: 1.28k]
|
29670 | p->error_indicator = 1; |
29671 | PyErr_NoMemory(); |
29672 | p->level--; |
29673 | return NULL; |
29674 | } |
29675 | _children = _new_children; |
29676 | } |
29677 | _children[_n++] = _res; |
29678 | _mark = p->mark; |
29679 | } |
29680 | p->mark = _mark; |
29681 | D(fprintf(stderr, "%*c%s _loop1_98[%d-%d]: %s failed!\n", p->level, ' ', |
29682 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
29683 | } |
29684 | if (_n == 0 || p->error_indicator1.04k ) { Branch (29684:9): [True: 408, False: 1.04k]
Branch (29684:20): [True: 0, False: 1.04k]
|
29685 | PyMem_Free(_children); |
29686 | p->level--; |
29687 | return NULL; |
29688 | } |
29689 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29690 | if (!_seq) { Branch (29690:9): [True: 0, False: 1.04k]
|
29691 | PyMem_Free(_children); |
29692 | p->error_indicator = 1; |
29693 | PyErr_NoMemory(); |
29694 | p->level--; |
29695 | return NULL; |
29696 | } |
29697 | for (int i = 0; 1.04k i < _n; i++8.03k ) asdl_seq_SET_UNTYPED1.04k (_seq, i, _children[i]); Branch (29697:21): [True: 8.03k, False: 1.04k]
|
29698 | PyMem_Free(_children); |
29699 | _PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq); |
29700 | p->level--; |
29701 | return _seq; |
29702 | } |
29703 | |
29704 | // _loop0_99: lambda_param_with_default |
29705 | static asdl_seq * |
29706 | _loop0_99_rule(Parser *p) |
29707 | { |
29708 | if (p->level++ == MAXSTACK) { Branch (29708:9): [True: 0, False: 1.04k]
|
29709 | p->error_indicator = 1; |
29710 | PyErr_NoMemory(); |
29711 | } |
29712 | if (p->error_indicator) { Branch (29712:9): [True: 0, False: 1.04k]
|
29713 | p->level--; |
29714 | return NULL; |
29715 | } |
29716 | void *_res = NULL; |
29717 | int _mark = p->mark; |
29718 | int _start_mark = p->mark; |
29719 | void **_children = PyMem_Malloc(sizeof(void *)); |
29720 | if (!_children) { Branch (29720:9): [True: 0, False: 1.04k]
|
29721 | p->error_indicator = 1; |
29722 | PyErr_NoMemory(); |
29723 | p->level--; |
29724 | return NULL; |
29725 | } |
29726 | Py_ssize_t _children_capacity = 1; |
29727 | Py_ssize_t _n = 0; |
29728 | { // lambda_param_with_default |
29729 | if (p->error_indicator) { Branch (29729:13): [True: 0, False: 1.04k]
|
29730 | p->level--; |
29731 | return NULL; |
29732 | } |
29733 | D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
29734 | NameDefaultPair* lambda_param_with_default_var; |
29735 | while ( |
29736 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default Branch (29736:13): [True: 51, False: 1.04k]
|
29737 | ) |
29738 | { |
29739 | _res = lambda_param_with_default_var; |
29740 | if (_n == _children_capacity) { |
29741 | _children_capacity *= 2; |
29742 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29743 | if (!_new_children) { |
29744 | p->error_indicator = 1; |
29745 | PyErr_NoMemory(); |
29746 | p->level--; |
29747 | return NULL; |
29748 | } |
29749 | _children = _new_children; |
29750 | } |
29751 | _children[_n++] = _res; |
29752 | _mark = p->mark; |
29753 | } |
29754 | p->mark = _mark; |
29755 | D(fprintf(stderr, "%*c%s _loop0_99[%d-%d]: %s failed!\n", p->level, ' ', |
29756 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
29757 | } |
29758 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29759 | if (!_seq) { Branch (29759:9): [True: 0, False: 1.04k]
|
29760 | PyMem_Free(_children); |
29761 | p->error_indicator = 1; |
29762 | PyErr_NoMemory(); |
29763 | p->level--; |
29764 | return NULL; |
29765 | } |
29766 | for (int i = 0; 1.04k i < _n; i++51 ) asdl_seq_SET_UNTYPED1.04k (_seq, i, _children[i]); Branch (29766:21): [True: 51, False: 1.04k]
|
29767 | PyMem_Free(_children); |
29768 | _PyPegen_insert_memo(p, _start_mark, _loop0_99_type, _seq); |
29769 | p->level--; |
29770 | return _seq; |
29771 | } |
29772 | |
29773 | // _loop1_100: lambda_param_with_default |
29774 | static asdl_seq * |
29775 | _loop1_100_rule(Parser *p) |
29776 | { |
29777 | if (p->level++ == MAXSTACK) { Branch (29777:9): [True: 0, False: 408]
|
29778 | p->error_indicator = 1; |
29779 | PyErr_NoMemory(); |
29780 | } |
29781 | if (p->error_indicator) { Branch (29781:9): [True: 0, False: 408]
|
29782 | p->level--; |
29783 | return NULL; |
29784 | } |
29785 | void *_res = NULL; |
29786 | int _mark = p->mark; |
29787 | int _start_mark = p->mark; |
29788 | void **_children = PyMem_Malloc(sizeof(void *)); |
29789 | if (!_children) { Branch (29789:9): [True: 0, False: 408]
|
29790 | p->error_indicator = 1; |
29791 | PyErr_NoMemory(); |
29792 | p->level--; |
29793 | return NULL; |
29794 | } |
29795 | Py_ssize_t _children_capacity = 1; |
29796 | Py_ssize_t _n = 0; |
29797 | { // lambda_param_with_default |
29798 | if (p->error_indicator) { Branch (29798:13): [True: 0, False: 408]
|
29799 | p->level--; |
29800 | return NULL; |
29801 | } |
29802 | D(fprintf(stderr, "%*c> _loop1_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
29803 | NameDefaultPair* lambda_param_with_default_var; |
29804 | while ( |
29805 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default Branch (29805:13): [True: 53, False: 408]
|
29806 | ) |
29807 | { |
29808 | _res = lambda_param_with_default_var; |
29809 | if (_n == _children_capacity) { |
29810 | _children_capacity *= 2; |
29811 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29812 | if (!_new_children) { |
29813 | p->error_indicator = 1; |
29814 | PyErr_NoMemory(); |
29815 | p->level--; |
29816 | return NULL; |
29817 | } |
29818 | _children = _new_children; |
29819 | } |
29820 | _children[_n++] = _res; |
29821 | _mark = p->mark; |
29822 | } |
29823 | p->mark = _mark; |
29824 | D(fprintf(stderr, "%*c%s _loop1_100[%d-%d]: %s failed!\n", p->level, ' ', |
29825 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
29826 | } |
29827 | if (_n == 0 || p->error_indicator52 ) { Branch (29827:9): [True: 356, False: 52]
Branch (29827:20): [True: 0, False: 52]
|
29828 | PyMem_Free(_children); |
29829 | p->level--; |
29830 | return NULL; |
29831 | } |
29832 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29833 | if (!_seq) { Branch (29833:9): [True: 0, False: 52]
|
29834 | PyMem_Free(_children); |
29835 | p->error_indicator = 1; |
29836 | PyErr_NoMemory(); |
29837 | p->level--; |
29838 | return NULL; |
29839 | } |
29840 | for (int i = 0; 52 i < _n; i++53 ) asdl_seq_SET_UNTYPED52 (_seq, i, _children[i]); Branch (29840:21): [True: 53, False: 52]
|
29841 | PyMem_Free(_children); |
29842 | _PyPegen_insert_memo(p, _start_mark, _loop1_100_type, _seq); |
29843 | p->level--; |
29844 | return _seq; |
29845 | } |
29846 | |
29847 | // _loop1_101: lambda_param_no_default |
29848 | static asdl_seq * |
29849 | _loop1_101_rule(Parser *p) |
29850 | { |
29851 | if (p->level++ == MAXSTACK) { Branch (29851:9): [True: 0, False: 1.65k]
|
29852 | p->error_indicator = 1; |
29853 | PyErr_NoMemory(); |
29854 | } |
29855 | if (p->error_indicator) { Branch (29855:9): [True: 0, False: 1.65k]
|
29856 | p->level--; |
29857 | return NULL; |
29858 | } |
29859 | void *_res = NULL; |
29860 | int _mark = p->mark; |
29861 | int _start_mark = p->mark; |
29862 | void **_children = PyMem_Malloc(sizeof(void *)); |
29863 | if (!_children) { Branch (29863:9): [True: 0, False: 1.65k]
|
29864 | p->error_indicator = 1; |
29865 | PyErr_NoMemory(); |
29866 | p->level--; |
29867 | return NULL; |
29868 | } |
29869 | Py_ssize_t _children_capacity = 1; |
29870 | Py_ssize_t _n = 0; |
29871 | { // lambda_param_no_default |
29872 | if (p->error_indicator) { Branch (29872:13): [True: 0, False: 1.65k]
|
29873 | p->level--; |
29874 | return NULL; |
29875 | } |
29876 | D(fprintf(stderr, "%*c> _loop1_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
29877 | arg_ty lambda_param_no_default_var; |
29878 | while ( |
29879 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (29879:13): [True: 8.15k, False: 1.65k]
|
29880 | ) |
29881 | { |
29882 | _res = lambda_param_no_default_var; |
29883 | if (_n == _children_capacity) { Branch (29883:17): [True: 1.29k, False: 6.85k]
|
29884 | _children_capacity *= 2; |
29885 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29886 | if (!_new_children) { Branch (29886:21): [True: 0, False: 1.29k]
|
29887 | p->error_indicator = 1; |
29888 | PyErr_NoMemory(); |
29889 | p->level--; |
29890 | return NULL; |
29891 | } |
29892 | _children = _new_children; |
29893 | } |
29894 | _children[_n++] = _res; |
29895 | _mark = p->mark; |
29896 | } |
29897 | p->mark = _mark; |
29898 | D(fprintf(stderr, "%*c%s _loop1_101[%d-%d]: %s failed!\n", p->level, ' ', |
29899 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
29900 | } |
29901 | if (_n == 0 || p->error_indicator1.15k ) { Branch (29901:9): [True: 500, False: 1.15k]
Branch (29901:20): [True: 0, False: 1.15k]
|
29902 | PyMem_Free(_children); |
29903 | p->level--; |
29904 | return NULL; |
29905 | } |
29906 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29907 | if (!_seq) { Branch (29907:9): [True: 0, False: 1.15k]
|
29908 | PyMem_Free(_children); |
29909 | p->error_indicator = 1; |
29910 | PyErr_NoMemory(); |
29911 | p->level--; |
29912 | return NULL; |
29913 | } |
29914 | for (int i = 0; 1.15k i < _n; i++8.15k ) asdl_seq_SET_UNTYPED1.15k (_seq, i, _children[i]); Branch (29914:21): [True: 8.15k, False: 1.15k]
|
29915 | PyMem_Free(_children); |
29916 | _PyPegen_insert_memo(p, _start_mark, _loop1_101_type, _seq); |
29917 | p->level--; |
29918 | return _seq; |
29919 | } |
29920 | |
29921 | // _loop1_102: lambda_param_no_default |
29922 | static asdl_seq * |
29923 | _loop1_102_rule(Parser *p) |
29924 | { |
29925 | if (p->level++ == MAXSTACK) { Branch (29925:9): [True: 0, False: 1.58k]
|
29926 | p->error_indicator = 1; |
29927 | PyErr_NoMemory(); |
29928 | } |
29929 | if (p->error_indicator) { Branch (29929:9): [True: 0, False: 1.58k]
|
29930 | p->level--; |
29931 | return NULL; |
29932 | } |
29933 | void *_res = NULL; |
29934 | int _mark = p->mark; |
29935 | int _start_mark = p->mark; |
29936 | void **_children = PyMem_Malloc(sizeof(void *)); |
29937 | if (!_children) { Branch (29937:9): [True: 0, False: 1.58k]
|
29938 | p->error_indicator = 1; |
29939 | PyErr_NoMemory(); |
29940 | p->level--; |
29941 | return NULL; |
29942 | } |
29943 | Py_ssize_t _children_capacity = 1; |
29944 | Py_ssize_t _n = 0; |
29945 | { // lambda_param_no_default |
29946 | if (p->error_indicator) { Branch (29946:13): [True: 0, False: 1.58k]
|
29947 | p->level--; |
29948 | return NULL; |
29949 | } |
29950 | D(fprintf(stderr, "%*c> _loop1_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
29951 | arg_ty lambda_param_no_default_var; |
29952 | while ( |
29953 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (29953:13): [True: 8.07k, False: 1.58k]
|
29954 | ) |
29955 | { |
29956 | _res = lambda_param_no_default_var; |
29957 | if (_n == _children_capacity) { Branch (29957:17): [True: 1.28k, False: 6.79k]
|
29958 | _children_capacity *= 2; |
29959 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
29960 | if (!_new_children) { Branch (29960:21): [True: 0, False: 1.28k]
|
29961 | p->error_indicator = 1; |
29962 | PyErr_NoMemory(); |
29963 | p->level--; |
29964 | return NULL; |
29965 | } |
29966 | _children = _new_children; |
29967 | } |
29968 | _children[_n++] = _res; |
29969 | _mark = p->mark; |
29970 | } |
29971 | p->mark = _mark; |
29972 | D(fprintf(stderr, "%*c%s _loop1_102[%d-%d]: %s failed!\n", p->level, ' ', |
29973 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
29974 | } |
29975 | if (_n == 0 || p->error_indicator1.08k ) { Branch (29975:9): [True: 500, False: 1.08k]
Branch (29975:20): [True: 0, False: 1.08k]
|
29976 | PyMem_Free(_children); |
29977 | p->level--; |
29978 | return NULL; |
29979 | } |
29980 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
29981 | if (!_seq) { Branch (29981:9): [True: 0, False: 1.08k]
|
29982 | PyMem_Free(_children); |
29983 | p->error_indicator = 1; |
29984 | PyErr_NoMemory(); |
29985 | p->level--; |
29986 | return NULL; |
29987 | } |
29988 | for (int i = 0; 1.08k i < _n; i++8.07k ) asdl_seq_SET_UNTYPED1.08k (_seq, i, _children[i]); Branch (29988:21): [True: 8.07k, False: 1.08k]
|
29989 | PyMem_Free(_children); |
29990 | _PyPegen_insert_memo(p, _start_mark, _loop1_102_type, _seq); |
29991 | p->level--; |
29992 | return _seq; |
29993 | } |
29994 | |
29995 | // _loop0_103: lambda_param_no_default |
29996 | static asdl_seq * |
29997 | _loop0_103_rule(Parser *p) |
29998 | { |
29999 | if (p->level++ == MAXSTACK) { Branch (29999:9): [True: 0, False: 1.62k]
|
30000 | p->error_indicator = 1; |
30001 | PyErr_NoMemory(); |
30002 | } |
30003 | if (p->error_indicator) { Branch (30003:9): [True: 0, False: 1.62k]
|
30004 | p->level--; |
30005 | return NULL; |
30006 | } |
30007 | void *_res = NULL; |
30008 | int _mark = p->mark; |
30009 | int _start_mark = p->mark; |
30010 | void **_children = PyMem_Malloc(sizeof(void *)); |
30011 | if (!_children) { Branch (30011:9): [True: 0, False: 1.62k]
|
30012 | p->error_indicator = 1; |
30013 | PyErr_NoMemory(); |
30014 | p->level--; |
30015 | return NULL; |
30016 | } |
30017 | Py_ssize_t _children_capacity = 1; |
30018 | Py_ssize_t _n = 0; |
30019 | { // lambda_param_no_default |
30020 | if (p->error_indicator) { Branch (30020:13): [True: 0, False: 1.62k]
|
30021 | p->level--; |
30022 | return NULL; |
30023 | } |
30024 | D(fprintf(stderr, "%*c> _loop0_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
30025 | arg_ty lambda_param_no_default_var; |
30026 | while ( |
30027 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (30027:13): [True: 8.06k, False: 1.62k]
|
30028 | ) |
30029 | { |
30030 | _res = lambda_param_no_default_var; |
30031 | if (_n == _children_capacity) { Branch (30031:17): [True: 1.28k, False: 6.78k]
|
30032 | _children_capacity *= 2; |
30033 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30034 | if (!_new_children) { Branch (30034:21): [True: 0, False: 1.28k]
|
30035 | p->error_indicator = 1; |
30036 | PyErr_NoMemory(); |
30037 | p->level--; |
30038 | return NULL; |
30039 | } |
30040 | _children = _new_children; |
30041 | } |
30042 | _children[_n++] = _res; |
30043 | _mark = p->mark; |
30044 | } |
30045 | p->mark = _mark; |
30046 | D(fprintf(stderr, "%*c%s _loop0_103[%d-%d]: %s failed!\n", p->level, ' ', |
30047 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
30048 | } |
30049 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30050 | if (!_seq) { Branch (30050:9): [True: 0, False: 1.62k]
|
30051 | PyMem_Free(_children); |
30052 | p->error_indicator = 1; |
30053 | PyErr_NoMemory(); |
30054 | p->level--; |
30055 | return NULL; |
30056 | } |
30057 | for (int i = 0; 1.62k i < _n; i++8.06k ) asdl_seq_SET_UNTYPED1.62k (_seq, i, _children[i]); Branch (30057:21): [True: 8.06k, False: 1.62k]
|
30058 | PyMem_Free(_children); |
30059 | _PyPegen_insert_memo(p, _start_mark, _loop0_103_type, _seq); |
30060 | p->level--; |
30061 | return _seq; |
30062 | } |
30063 | |
30064 | // _loop1_104: lambda_param_with_default |
30065 | static asdl_seq * |
30066 | _loop1_104_rule(Parser *p) |
30067 | { |
30068 | if (p->level++ == MAXSTACK) { Branch (30068:9): [True: 0, False: 1.62k]
|
30069 | p->error_indicator = 1; |
30070 | PyErr_NoMemory(); |
30071 | } |
30072 | if (p->error_indicator) { Branch (30072:9): [True: 0, False: 1.62k]
|
30073 | p->level--; |
30074 | return NULL; |
30075 | } |
30076 | void *_res = NULL; |
30077 | int _mark = p->mark; |
30078 | int _start_mark = p->mark; |
30079 | void **_children = PyMem_Malloc(sizeof(void *)); |
30080 | if (!_children) { Branch (30080:9): [True: 0, False: 1.62k]
|
30081 | p->error_indicator = 1; |
30082 | PyErr_NoMemory(); |
30083 | p->level--; |
30084 | return NULL; |
30085 | } |
30086 | Py_ssize_t _children_capacity = 1; |
30087 | Py_ssize_t _n = 0; |
30088 | { // lambda_param_with_default |
30089 | if (p->error_indicator) { Branch (30089:13): [True: 0, False: 1.62k]
|
30090 | p->level--; |
30091 | return NULL; |
30092 | } |
30093 | D(fprintf(stderr, "%*c> _loop1_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
30094 | NameDefaultPair* lambda_param_with_default_var; |
30095 | while ( |
30096 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default Branch (30096:13): [True: 213, False: 1.62k]
|
30097 | ) |
30098 | { |
30099 | _res = lambda_param_with_default_var; |
30100 | if (_n == _children_capacity) { Branch (30100:17): [True: 37, False: 176]
|
30101 | _children_capacity *= 2; |
30102 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30103 | if (!_new_children) { |
30104 | p->error_indicator = 1; |
30105 | PyErr_NoMemory(); |
30106 | p->level--; |
30107 | return NULL; |
30108 | } |
30109 | _children = _new_children; |
30110 | } |
30111 | _children[_n++] = _res; |
30112 | _mark = p->mark; |
30113 | } |
30114 | p->mark = _mark; |
30115 | D(fprintf(stderr, "%*c%s _loop1_104[%d-%d]: %s failed!\n", p->level, ' ', |
30116 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
30117 | } |
30118 | if (_n == 0 || p->error_indicator176 ) { Branch (30118:9): [True: 1.44k, False: 176]
Branch (30118:20): [True: 1, False: 175]
|
30119 | PyMem_Free(_children); |
30120 | p->level--; |
30121 | return NULL; |
30122 | } |
30123 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30124 | if (!_seq) { Branch (30124:9): [True: 0, False: 175]
|
30125 | PyMem_Free(_children); |
30126 | p->error_indicator = 1; |
30127 | PyErr_NoMemory(); |
30128 | p->level--; |
30129 | return NULL; |
30130 | } |
30131 | for (int i = 0; 175 i < _n; i++212 ) asdl_seq_SET_UNTYPED175 (_seq, i, _children[i]); Branch (30131:21): [True: 212, False: 175]
|
30132 | PyMem_Free(_children); |
30133 | _PyPegen_insert_memo(p, _start_mark, _loop1_104_type, _seq); |
30134 | p->level--; |
30135 | return _seq; |
30136 | } |
30137 | |
30138 | // _loop0_105: lambda_param_no_default |
30139 | static asdl_seq * |
30140 | _loop0_105_rule(Parser *p) |
30141 | { |
30142 | if (p->level++ == MAXSTACK) { Branch (30142:9): [True: 0, False: 1.56k]
|
30143 | p->error_indicator = 1; |
30144 | PyErr_NoMemory(); |
30145 | } |
30146 | if (p->error_indicator) { Branch (30146:9): [True: 0, False: 1.56k]
|
30147 | p->level--; |
30148 | return NULL; |
30149 | } |
30150 | void *_res = NULL; |
30151 | int _mark = p->mark; |
30152 | int _start_mark = p->mark; |
30153 | void **_children = PyMem_Malloc(sizeof(void *)); |
30154 | if (!_children) { Branch (30154:9): [True: 0, False: 1.56k]
|
30155 | p->error_indicator = 1; |
30156 | PyErr_NoMemory(); |
30157 | p->level--; |
30158 | return NULL; |
30159 | } |
30160 | Py_ssize_t _children_capacity = 1; |
30161 | Py_ssize_t _n = 0; |
30162 | { // lambda_param_no_default |
30163 | if (p->error_indicator) { Branch (30163:13): [True: 0, False: 1.56k]
|
30164 | p->level--; |
30165 | return NULL; |
30166 | } |
30167 | D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
30168 | arg_ty lambda_param_no_default_var; |
30169 | while ( |
30170 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (30170:13): [True: 8.06k, False: 1.56k]
|
30171 | ) |
30172 | { |
30173 | _res = lambda_param_no_default_var; |
30174 | if (_n == _children_capacity) { Branch (30174:17): [True: 1.28k, False: 6.78k]
|
30175 | _children_capacity *= 2; |
30176 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30177 | if (!_new_children) { Branch (30177:21): [True: 0, False: 1.28k]
|
30178 | p->error_indicator = 1; |
30179 | PyErr_NoMemory(); |
30180 | p->level--; |
30181 | return NULL; |
30182 | } |
30183 | _children = _new_children; |
30184 | } |
30185 | _children[_n++] = _res; |
30186 | _mark = p->mark; |
30187 | } |
30188 | p->mark = _mark; |
30189 | D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ', |
30190 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
30191 | } |
30192 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30193 | if (!_seq) { Branch (30193:9): [True: 0, False: 1.56k]
|
30194 | PyMem_Free(_children); |
30195 | p->error_indicator = 1; |
30196 | PyErr_NoMemory(); |
30197 | p->level--; |
30198 | return NULL; |
30199 | } |
30200 | for (int i = 0; 1.56k i < _n; i++8.06k ) asdl_seq_SET_UNTYPED1.56k (_seq, i, _children[i]); Branch (30200:21): [True: 8.06k, False: 1.56k]
|
30201 | PyMem_Free(_children); |
30202 | _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq); |
30203 | p->level--; |
30204 | return _seq; |
30205 | } |
30206 | |
30207 | // _loop1_106: lambda_param_with_default |
30208 | static asdl_seq * |
30209 | _loop1_106_rule(Parser *p) |
30210 | { |
30211 | if (p->level++ == MAXSTACK) { Branch (30211:9): [True: 0, False: 1.56k]
|
30212 | p->error_indicator = 1; |
30213 | PyErr_NoMemory(); |
30214 | } |
30215 | if (p->error_indicator) { Branch (30215:9): [True: 0, False: 1.56k]
|
30216 | p->level--; |
30217 | return NULL; |
30218 | } |
30219 | void *_res = NULL; |
30220 | int _mark = p->mark; |
30221 | int _start_mark = p->mark; |
30222 | void **_children = PyMem_Malloc(sizeof(void *)); |
30223 | if (!_children) { Branch (30223:9): [True: 0, False: 1.56k]
|
30224 | p->error_indicator = 1; |
30225 | PyErr_NoMemory(); |
30226 | p->level--; |
30227 | return NULL; |
30228 | } |
30229 | Py_ssize_t _children_capacity = 1; |
30230 | Py_ssize_t _n = 0; |
30231 | { // lambda_param_with_default |
30232 | if (p->error_indicator) { Branch (30232:13): [True: 0, False: 1.56k]
|
30233 | p->level--; |
30234 | return NULL; |
30235 | } |
30236 | D(fprintf(stderr, "%*c> _loop1_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
30237 | NameDefaultPair* lambda_param_with_default_var; |
30238 | while ( |
30239 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default Branch (30239:13): [True: 121, False: 1.56k]
|
30240 | ) |
30241 | { |
30242 | _res = lambda_param_with_default_var; |
30243 | if (_n == _children_capacity) { Branch (30243:17): [True: 1, False: 120]
|
30244 | _children_capacity *= 2; |
30245 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30246 | if (!_new_children) { |
30247 | p->error_indicator = 1; |
30248 | PyErr_NoMemory(); |
30249 | p->level--; |
30250 | return NULL; |
30251 | } |
30252 | _children = _new_children; |
30253 | } |
30254 | _children[_n++] = _res; |
30255 | _mark = p->mark; |
30256 | } |
30257 | p->mark = _mark; |
30258 | D(fprintf(stderr, "%*c%s _loop1_106[%d-%d]: %s failed!\n", p->level, ' ', |
30259 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
30260 | } |
30261 | if (_n == 0 || p->error_indicator120 ) { Branch (30261:9): [True: 1.44k, False: 120]
Branch (30261:20): [True: 0, False: 120]
|
30262 | PyMem_Free(_children); |
30263 | p->level--; |
30264 | return NULL; |
30265 | } |
30266 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30267 | if (!_seq) { Branch (30267:9): [True: 0, False: 120]
|
30268 | PyMem_Free(_children); |
30269 | p->error_indicator = 1; |
30270 | PyErr_NoMemory(); |
30271 | p->level--; |
30272 | return NULL; |
30273 | } |
30274 | for (int i = 0; 120 i < _n; i++121 ) asdl_seq_SET_UNTYPED120 (_seq, i, _children[i]); Branch (30274:21): [True: 121, False: 120]
|
30275 | PyMem_Free(_children); |
30276 | _PyPegen_insert_memo(p, _start_mark, _loop1_106_type, _seq); |
30277 | p->level--; |
30278 | return _seq; |
30279 | } |
30280 | |
30281 | // _loop0_107: lambda_param_maybe_default |
30282 | static asdl_seq * |
30283 | _loop0_107_rule(Parser *p) |
30284 | { |
30285 | if (p->level++ == MAXSTACK) { Branch (30285:9): [True: 0, False: 74]
|
30286 | p->error_indicator = 1; |
30287 | PyErr_NoMemory(); |
30288 | } |
30289 | if (p->error_indicator) { Branch (30289:9): [True: 0, False: 74]
|
30290 | p->level--; |
30291 | return NULL; |
30292 | } |
30293 | void *_res = NULL; |
30294 | int _mark = p->mark; |
30295 | int _start_mark = p->mark; |
30296 | void **_children = PyMem_Malloc(sizeof(void *)); |
30297 | if (!_children) { Branch (30297:9): [True: 0, False: 74]
|
30298 | p->error_indicator = 1; |
30299 | PyErr_NoMemory(); |
30300 | p->level--; |
30301 | return NULL; |
30302 | } |
30303 | Py_ssize_t _children_capacity = 1; |
30304 | Py_ssize_t _n = 0; |
30305 | { // lambda_param_maybe_default |
30306 | if (p->error_indicator) { |
30307 | p->level--; |
30308 | return NULL; |
30309 | } |
30310 | D(fprintf(stderr, "%*c> _loop0_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
30311 | NameDefaultPair* lambda_param_maybe_default_var; |
30312 | while ( |
30313 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default Branch (30313:13): [True: 68, False: 74]
|
30314 | ) |
30315 | { |
30316 | _res = lambda_param_maybe_default_var; |
30317 | if (_n == _children_capacity) { Branch (30317:17): [True: 21, False: 47]
|
30318 | _children_capacity *= 2; |
30319 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30320 | if (!_new_children) { |
30321 | p->error_indicator = 1; |
30322 | PyErr_NoMemory(); |
30323 | p->level--; |
30324 | return NULL; |
30325 | } |
30326 | _children = _new_children; |
30327 | } |
30328 | _children[_n++] = _res; |
30329 | _mark = p->mark; |
30330 | } |
30331 | p->mark = _mark; |
30332 | D(fprintf(stderr, "%*c%s _loop0_107[%d-%d]: %s failed!\n", p->level, ' ', |
30333 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
30334 | } |
30335 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30336 | if (!_seq) { Branch (30336:9): [True: 0, False: 74]
|
30337 | PyMem_Free(_children); |
30338 | p->error_indicator = 1; |
30339 | PyErr_NoMemory(); |
30340 | p->level--; |
30341 | return NULL; |
30342 | } |
30343 | for (int i = 0; 74 i < _n; i++68 ) asdl_seq_SET_UNTYPED74 (_seq, i, _children[i]); Branch (30343:21): [True: 68, False: 74]
|
30344 | PyMem_Free(_children); |
30345 | _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq); |
30346 | p->level--; |
30347 | return _seq; |
30348 | } |
30349 | |
30350 | // _loop1_108: lambda_param_maybe_default |
30351 | static asdl_seq * |
30352 | _loop1_108_rule(Parser *p) |
30353 | { |
30354 | if (p->level++ == MAXSTACK) { Branch (30354:9): [True: 0, False: 92]
|
30355 | p->error_indicator = 1; |
30356 | PyErr_NoMemory(); |
30357 | } |
30358 | if (p->error_indicator) { Branch (30358:9): [True: 0, False: 92]
|
30359 | p->level--; |
30360 | return NULL; |
30361 | } |
30362 | void *_res = NULL; |
30363 | int _mark = p->mark; |
30364 | int _start_mark = p->mark; |
30365 | void **_children = PyMem_Malloc(sizeof(void *)); |
30366 | if (!_children) { Branch (30366:9): [True: 0, False: 92]
|
30367 | p->error_indicator = 1; |
30368 | PyErr_NoMemory(); |
30369 | p->level--; |
30370 | return NULL; |
30371 | } |
30372 | Py_ssize_t _children_capacity = 1; |
30373 | Py_ssize_t _n = 0; |
30374 | { // lambda_param_maybe_default |
30375 | if (p->error_indicator) { |
30376 | p->level--; |
30377 | return NULL; |
30378 | } |
30379 | D(fprintf(stderr, "%*c> _loop1_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
30380 | NameDefaultPair* lambda_param_maybe_default_var; |
30381 | while ( |
30382 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default Branch (30382:13): [True: 127, False: 92]
|
30383 | ) |
30384 | { |
30385 | _res = lambda_param_maybe_default_var; |
30386 | if (_n == _children_capacity) { Branch (30386:17): [True: 36, False: 91]
|
30387 | _children_capacity *= 2; |
30388 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30389 | if (!_new_children) { |
30390 | p->error_indicator = 1; |
30391 | PyErr_NoMemory(); |
30392 | p->level--; |
30393 | return NULL; |
30394 | } |
30395 | _children = _new_children; |
30396 | } |
30397 | _children[_n++] = _res; |
30398 | _mark = p->mark; |
30399 | } |
30400 | p->mark = _mark; |
30401 | D(fprintf(stderr, "%*c%s _loop1_108[%d-%d]: %s failed!\n", p->level, ' ', |
30402 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
30403 | } |
30404 | if (_n == 0 || p->error_indicator91 ) { Branch (30404:9): [True: 1, False: 91]
Branch (30404:20): [True: 0, False: 91]
|
30405 | PyMem_Free(_children); |
30406 | p->level--; |
30407 | return NULL; |
30408 | } |
30409 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30410 | if (!_seq) { Branch (30410:9): [True: 0, False: 91]
|
30411 | PyMem_Free(_children); |
30412 | p->error_indicator = 1; |
30413 | PyErr_NoMemory(); |
30414 | p->level--; |
30415 | return NULL; |
30416 | } |
30417 | for (int i = 0; 91 i < _n; i++127 ) asdl_seq_SET_UNTYPED91 (_seq, i, _children[i]); Branch (30417:21): [True: 127, False: 91]
|
30418 | PyMem_Free(_children); |
30419 | _PyPegen_insert_memo(p, _start_mark, _loop1_108_type, _seq); |
30420 | p->level--; |
30421 | return _seq; |
30422 | } |
30423 | |
30424 | // _loop1_109: STRING |
30425 | static asdl_seq * |
30426 | _loop1_109_rule(Parser *p) |
30427 | { |
30428 | if (p->level++ == MAXSTACK) { Branch (30428:9): [True: 0, False: 183k]
|
30429 | p->error_indicator = 1; |
30430 | PyErr_NoMemory(); |
30431 | } |
30432 | if (p->error_indicator) { Branch (30432:9): [True: 0, False: 183k]
|
30433 | p->level--; |
30434 | return NULL; |
30435 | } |
30436 | void *_res = NULL; |
30437 | int _mark = p->mark; |
30438 | int _start_mark = p->mark; |
30439 | void **_children = PyMem_Malloc(sizeof(void *)); |
30440 | if (!_children) { Branch (30440:9): [True: 0, False: 183k]
|
30441 | p->error_indicator = 1; |
30442 | PyErr_NoMemory(); |
30443 | p->level--; |
30444 | return NULL; |
30445 | } |
30446 | Py_ssize_t _children_capacity = 1; |
30447 | Py_ssize_t _n = 0; |
30448 | { // STRING |
30449 | if (p->error_indicator) { Branch (30449:13): [True: 0, False: 183k]
|
30450 | p->level--; |
30451 | return NULL; |
30452 | } |
30453 | D(fprintf(stderr, "%*c> _loop1_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING")); |
30454 | expr_ty string_var; |
30455 | while ( |
30456 | (string_var = _PyPegen_string_token(p)) // STRING Branch (30456:13): [True: 205k, False: 183k]
|
30457 | ) |
30458 | { |
30459 | _res = string_var; |
30460 | if (_n == _children_capacity) { Branch (30460:17): [True: 4.18k, False: 201k]
|
30461 | _children_capacity *= 2; |
30462 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30463 | if (!_new_children) { Branch (30463:21): [True: 0, False: 4.18k]
|
30464 | p->error_indicator = 1; |
30465 | PyErr_NoMemory(); |
30466 | p->level--; |
30467 | return NULL; |
30468 | } |
30469 | _children = _new_children; |
30470 | } |
30471 | _children[_n++] = _res; |
30472 | _mark = p->mark; |
30473 | } |
30474 | p->mark = _mark; |
30475 | D(fprintf(stderr, "%*c%s _loop1_109[%d-%d]: %s failed!\n", p->level, ' ', |
30476 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING")); |
30477 | } |
30478 | if (_n == 0 || p->error_indicator181k ) { Branch (30478:9): [True: 2.57k, False: 181k]
Branch (30478:20): [True: 2, False: 181k]
|
30479 | PyMem_Free(_children); |
30480 | p->level--; |
30481 | return NULL; |
30482 | } |
30483 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30484 | if (!_seq) { Branch (30484:9): [True: 0, False: 181k]
|
30485 | PyMem_Free(_children); |
30486 | p->error_indicator = 1; |
30487 | PyErr_NoMemory(); |
30488 | p->level--; |
30489 | return NULL; |
30490 | } |
30491 | for (int i = 0; 181k i < _n; i++205k ) asdl_seq_SET_UNTYPED181k (_seq, i, _children[i]); Branch (30491:21): [True: 205k, False: 181k]
|
30492 | PyMem_Free(_children); |
30493 | _PyPegen_insert_memo(p, _start_mark, _loop1_109_type, _seq); |
30494 | p->level--; |
30495 | return _seq; |
30496 | } |
30497 | |
30498 | // _tmp_110: star_named_expression ',' star_named_expressions? |
30499 | static void * |
30500 | _tmp_110_rule(Parser *p) |
30501 | { |
30502 | if (p->level++ == MAXSTACK) { Branch (30502:9): [True: 0, False: 232k]
|
30503 | p->error_indicator = 1; |
30504 | PyErr_NoMemory(); |
30505 | } |
30506 | if (p->error_indicator) { Branch (30506:9): [True: 0, False: 232k]
|
30507 | p->level--; |
30508 | return NULL; |
30509 | } |
30510 | void * _res = NULL; |
30511 | int _mark = p->mark; |
30512 | { // star_named_expression ',' star_named_expressions? |
30513 | if (p->error_indicator) { Branch (30513:13): [True: 0, False: 232k]
|
30514 | p->level--; |
30515 | return NULL; |
30516 | } |
30517 | D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); |
30518 | Token * _literal; |
30519 | expr_ty y; |
30520 | void *z; |
30521 | if ( |
30522 | (y = star_named_expression_rule(p)) // star_named_expression Branch (30522:13): [True: 230k, False: 2.13k]
|
30523 | && |
30524 | (_literal = _PyPegen_expect_token(p, 12))230k // token=',' Branch (30524:13): [True: 74.1k, False: 155k]
|
30525 | && |
30526 | (z = star_named_expressions_rule(p), !p->error_indicator)74.1k // star_named_expressions? Branch (30526:13): [True: 74.1k, False: 17]
|
30527 | ) |
30528 | { |
30529 | D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); |
30530 | _res = _PyPegen_seq_insert_in_front ( p , y , z ); |
30531 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (30531:17): [True: 0, False: 74.1k]
Branch (30531:33): [True: 0, False: 0]
|
30532 | p->error_indicator = 1; |
30533 | p->level--; |
30534 | return NULL; |
30535 | } |
30536 | goto done; |
30537 | } |
30538 | p->mark = _mark; |
30539 | D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', |
30540 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); |
30541 | } |
30542 | _res = NULL; |
30543 | done: |
30544 | p->level--; |
30545 | return _res; |
30546 | } |
30547 | |
30548 | // _loop0_112: ',' double_starred_kvpair |
30549 | static asdl_seq * |
30550 | _loop0_112_rule(Parser *p) |
30551 | { |
30552 | if (p->level++ == MAXSTACK) { Branch (30552:9): [True: 0, False: 5.70k]
|
30553 | p->error_indicator = 1; |
30554 | PyErr_NoMemory(); |
30555 | } |
30556 | if (p->error_indicator) { Branch (30556:9): [True: 0, False: 5.70k]
|
30557 | p->level--; |
30558 | return NULL; |
30559 | } |
30560 | void *_res = NULL; |
30561 | int _mark = p->mark; |
30562 | int _start_mark = p->mark; |
30563 | void **_children = PyMem_Malloc(sizeof(void *)); |
30564 | if (!_children) { Branch (30564:9): [True: 0, False: 5.70k]
|
30565 | p->error_indicator = 1; |
30566 | PyErr_NoMemory(); |
30567 | p->level--; |
30568 | return NULL; |
30569 | } |
30570 | Py_ssize_t _children_capacity = 1; |
30571 | Py_ssize_t _n = 0; |
30572 | { // ',' double_starred_kvpair |
30573 | if (p->error_indicator) { Branch (30573:13): [True: 0, False: 5.70k]
|
30574 | p->level--; |
30575 | return NULL; |
30576 | } |
30577 | D(fprintf(stderr, "%*c> _loop0_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); |
30578 | Token * _literal; |
30579 | KeyValuePair* elem; |
30580 | while ( |
30581 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (30581:13): [True: 161k, False: 5.09k]
|
30582 | && |
30583 | (elem = double_starred_kvpair_rule(p))161k // double_starred_kvpair Branch (30583:13): [True: 160k, False: 607]
|
30584 | ) |
30585 | { |
30586 | _res = elem; |
30587 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (30587:17): [True: 0, False: 160k]
Branch (30587:33): [True: 0, False: 0]
|
30588 | p->error_indicator = 1; |
30589 | PyMem_Free(_children); |
30590 | p->level--; |
30591 | return NULL; |
30592 | } |
30593 | if (_n == _children_capacity) { Branch (30593:17): [True: 2.81k, False: 158k]
|
30594 | _children_capacity *= 2; |
30595 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30596 | if (!_new_children) { Branch (30596:21): [True: 0, False: 2.81k]
|
30597 | p->error_indicator = 1; |
30598 | PyErr_NoMemory(); |
30599 | p->level--; |
30600 | return NULL; |
30601 | } |
30602 | _children = _new_children; |
30603 | } |
30604 | _children[_n++] = _res; |
30605 | _mark = p->mark; |
30606 | } |
30607 | p->mark = _mark; |
30608 | D(fprintf(stderr, "%*c%s _loop0_112[%d-%d]: %s failed!\n", p->level, ' ', |
30609 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); |
30610 | } |
30611 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30612 | if (!_seq) { Branch (30612:9): [True: 0, False: 5.70k]
|
30613 | PyMem_Free(_children); |
30614 | p->error_indicator = 1; |
30615 | PyErr_NoMemory(); |
30616 | p->level--; |
30617 | return NULL; |
30618 | } |
30619 | for (int i = 0; 5.70k i < _n; i++160k ) asdl_seq_SET_UNTYPED5.70k (_seq, i, _children[i]); Branch (30619:21): [True: 160k, False: 5.70k]
|
30620 | PyMem_Free(_children); |
30621 | _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq); |
30622 | p->level--; |
30623 | return _seq; |
30624 | } |
30625 | |
30626 | // _gather_111: double_starred_kvpair _loop0_112 |
30627 | static asdl_seq * |
30628 | _gather_111_rule(Parser *p) |
30629 | { |
30630 | if (p->level++ == MAXSTACK) { Branch (30630:9): [True: 0, False: 10.4k]
|
30631 | p->error_indicator = 1; |
30632 | PyErr_NoMemory(); |
30633 | } |
30634 | if (p->error_indicator) { Branch (30634:9): [True: 0, False: 10.4k]
|
30635 | p->level--; |
30636 | return NULL; |
30637 | } |
30638 | asdl_seq * _res = NULL; |
30639 | int _mark = p->mark; |
30640 | { // double_starred_kvpair _loop0_112 |
30641 | if (p->error_indicator) { Branch (30641:13): [True: 0, False: 10.4k]
|
30642 | p->level--; |
30643 | return NULL; |
30644 | } |
30645 | D(fprintf(stderr, "%*c> _gather_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_112")); |
30646 | KeyValuePair* elem; |
30647 | asdl_seq * seq; |
30648 | if ( |
30649 | (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair Branch (30649:13): [True: 5.70k, False: 4.70k]
|
30650 | && |
30651 | (seq = _loop0_112_rule(p))5.70k // _loop0_112 Branch (30651:13): [True: 5.70k, False: 0]
|
30652 | ) |
30653 | { |
30654 | D(fprintf(stderr, "%*c+ _gather_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_112")); |
30655 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
30656 | goto done; |
30657 | } |
30658 | p->mark = _mark; |
30659 | D(fprintf(stderr, "%*c%s _gather_111[%d-%d]: %s failed!\n", p->level, ' ', |
30660 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_112")); |
30661 | } |
30662 | _res = NULL; |
30663 | done: |
30664 | p->level--; |
30665 | return _res; |
30666 | } |
30667 | |
30668 | // _loop1_113: for_if_clause |
30669 | static asdl_seq * |
30670 | _loop1_113_rule(Parser *p) |
30671 | { |
30672 | if (p->level++ == MAXSTACK) { Branch (30672:9): [True: 0, False: 144k]
|
30673 | p->error_indicator = 1; |
30674 | PyErr_NoMemory(); |
30675 | } |
30676 | if (p->error_indicator) { Branch (30676:9): [True: 0, False: 144k]
|
30677 | p->level--; |
30678 | return NULL; |
30679 | } |
30680 | void *_res = NULL; |
30681 | int _mark = p->mark; |
30682 | int _start_mark = p->mark; |
30683 | void **_children = PyMem_Malloc(sizeof(void *)); |
30684 | if (!_children) { Branch (30684:9): [True: 0, False: 144k]
|
30685 | p->error_indicator = 1; |
30686 | PyErr_NoMemory(); |
30687 | p->level--; |
30688 | return NULL; |
30689 | } |
30690 | Py_ssize_t _children_capacity = 1; |
30691 | Py_ssize_t _n = 0; |
30692 | { // for_if_clause |
30693 | if (p->error_indicator) { Branch (30693:13): [True: 0, False: 144k]
|
30694 | p->level--; |
30695 | return NULL; |
30696 | } |
30697 | D(fprintf(stderr, "%*c> _loop1_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); |
30698 | comprehension_ty for_if_clause_var; |
30699 | while ( |
30700 | (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause Branch (30700:13): [True: 5.39k, False: 144k]
|
30701 | ) |
30702 | { |
30703 | _res = for_if_clause_var; |
30704 | if (_n == _children_capacity) { Branch (30704:17): [True: 390, False: 5.00k]
|
30705 | _children_capacity *= 2; |
30706 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30707 | if (!_new_children) { Branch (30707:21): [True: 0, False: 390]
|
30708 | p->error_indicator = 1; |
30709 | PyErr_NoMemory(); |
30710 | p->level--; |
30711 | return NULL; |
30712 | } |
30713 | _children = _new_children; |
30714 | } |
30715 | _children[_n++] = _res; |
30716 | _mark = p->mark; |
30717 | } |
30718 | p->mark = _mark; |
30719 | D(fprintf(stderr, "%*c%s _loop1_113[%d-%d]: %s failed!\n", p->level, ' ', |
30720 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); |
30721 | } |
30722 | if (_n == 0 || p->error_indicator5.00k ) { Branch (30722:9): [True: 139k, False: 5.00k]
Branch (30722:20): [True: 0, False: 5.00k]
|
30723 | PyMem_Free(_children); |
30724 | p->level--; |
30725 | return NULL; |
30726 | } |
30727 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30728 | if (!_seq) { Branch (30728:9): [True: 0, False: 5.00k]
|
30729 | PyMem_Free(_children); |
30730 | p->error_indicator = 1; |
30731 | PyErr_NoMemory(); |
30732 | p->level--; |
30733 | return NULL; |
30734 | } |
30735 | for (int i = 0; 5.00k i < _n; i++5.39k ) asdl_seq_SET_UNTYPED5.00k (_seq, i, _children[i]); Branch (30735:21): [True: 5.39k, False: 5.00k]
|
30736 | PyMem_Free(_children); |
30737 | _PyPegen_insert_memo(p, _start_mark, _loop1_113_type, _seq); |
30738 | p->level--; |
30739 | return _seq; |
30740 | } |
30741 | |
30742 | // _loop0_114: ('if' disjunction) |
30743 | static asdl_seq * |
30744 | _loop0_114_rule(Parser *p) |
30745 | { |
30746 | if (p->level++ == MAXSTACK) { Branch (30746:9): [True: 0, False: 218]
|
30747 | p->error_indicator = 1; |
30748 | PyErr_NoMemory(); |
30749 | } |
30750 | if (p->error_indicator) { Branch (30750:9): [True: 0, False: 218]
|
30751 | p->level--; |
30752 | return NULL; |
30753 | } |
30754 | void *_res = NULL; |
30755 | int _mark = p->mark; |
30756 | int _start_mark = p->mark; |
30757 | void **_children = PyMem_Malloc(sizeof(void *)); |
30758 | if (!_children) { Branch (30758:9): [True: 0, False: 218]
|
30759 | p->error_indicator = 1; |
30760 | PyErr_NoMemory(); |
30761 | p->level--; |
30762 | return NULL; |
30763 | } |
30764 | Py_ssize_t _children_capacity = 1; |
30765 | Py_ssize_t _n = 0; |
30766 | { // ('if' disjunction) |
30767 | if (p->error_indicator) { Branch (30767:13): [True: 0, False: 218]
|
30768 | p->level--; |
30769 | return NULL; |
30770 | } |
30771 | D(fprintf(stderr, "%*c> _loop0_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); |
30772 | void *_tmp_228_var; |
30773 | while ( |
30774 | (_tmp_228_var = _tmp_228_rule(p)) // 'if' disjunction Branch (30774:13): [True: 0, False: 218]
|
30775 | ) |
30776 | { |
30777 | _res = _tmp_228_var; |
30778 | if (_n == _children_capacity) { |
30779 | _children_capacity *= 2; |
30780 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30781 | if (!_new_children) { |
30782 | p->error_indicator = 1; |
30783 | PyErr_NoMemory(); |
30784 | p->level--; |
30785 | return NULL; |
30786 | } |
30787 | _children = _new_children; |
30788 | } |
30789 | _children[_n++] = _res; |
30790 | _mark = p->mark; |
30791 | } |
30792 | p->mark = _mark; |
30793 | D(fprintf(stderr, "%*c%s _loop0_114[%d-%d]: %s failed!\n", p->level, ' ', |
30794 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); |
30795 | } |
30796 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30797 | if (!_seq) { Branch (30797:9): [True: 0, False: 218]
|
30798 | PyMem_Free(_children); |
30799 | p->error_indicator = 1; |
30800 | PyErr_NoMemory(); |
30801 | p->level--; |
30802 | return NULL; |
30803 | } |
30804 | for (int i = 0; i < _n; i++0 ) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); Branch (30804:21): [True: 0, False: 218]
|
30805 | PyMem_Free(_children); |
30806 | _PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq); |
30807 | p->level--; |
30808 | return _seq; |
30809 | } |
30810 | |
30811 | // _loop0_115: ('if' disjunction) |
30812 | static asdl_seq * |
30813 | _loop0_115_rule(Parser *p) |
30814 | { |
30815 | if (p->level++ == MAXSTACK) { Branch (30815:9): [True: 0, False: 5.18k]
|
30816 | p->error_indicator = 1; |
30817 | PyErr_NoMemory(); |
30818 | } |
30819 | if (p->error_indicator) { Branch (30819:9): [True: 0, False: 5.18k]
|
30820 | p->level--; |
30821 | return NULL; |
30822 | } |
30823 | void *_res = NULL; |
30824 | int _mark = p->mark; |
30825 | int _start_mark = p->mark; |
30826 | void **_children = PyMem_Malloc(sizeof(void *)); |
30827 | if (!_children) { Branch (30827:9): [True: 0, False: 5.18k]
|
30828 | p->error_indicator = 1; |
30829 | PyErr_NoMemory(); |
30830 | p->level--; |
30831 | return NULL; |
30832 | } |
30833 | Py_ssize_t _children_capacity = 1; |
30834 | Py_ssize_t _n = 0; |
30835 | { // ('if' disjunction) |
30836 | if (p->error_indicator) { Branch (30836:13): [True: 0, False: 5.18k]
|
30837 | p->level--; |
30838 | return NULL; |
30839 | } |
30840 | D(fprintf(stderr, "%*c> _loop0_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); |
30841 | void *_tmp_229_var; |
30842 | while ( |
30843 | (_tmp_229_var = _tmp_229_rule(p)) // 'if' disjunction Branch (30843:13): [True: 1.16k, False: 5.18k]
|
30844 | ) |
30845 | { |
30846 | _res = _tmp_229_var; |
30847 | if (_n == _children_capacity) { Branch (30847:17): [True: 10, False: 1.15k]
|
30848 | _children_capacity *= 2; |
30849 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30850 | if (!_new_children) { |
30851 | p->error_indicator = 1; |
30852 | PyErr_NoMemory(); |
30853 | p->level--; |
30854 | return NULL; |
30855 | } |
30856 | _children = _new_children; |
30857 | } |
30858 | _children[_n++] = _res; |
30859 | _mark = p->mark; |
30860 | } |
30861 | p->mark = _mark; |
30862 | D(fprintf(stderr, "%*c%s _loop0_115[%d-%d]: %s failed!\n", p->level, ' ', |
30863 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); |
30864 | } |
30865 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
30866 | if (!_seq) { Branch (30866:9): [True: 0, False: 5.18k]
|
30867 | PyMem_Free(_children); |
30868 | p->error_indicator = 1; |
30869 | PyErr_NoMemory(); |
30870 | p->level--; |
30871 | return NULL; |
30872 | } |
30873 | for (int i = 0; 5.18k i < _n; i++1.16k ) asdl_seq_SET_UNTYPED5.18k (_seq, i, _children[i]); Branch (30873:21): [True: 1.16k, False: 5.18k]
|
30874 | PyMem_Free(_children); |
30875 | _PyPegen_insert_memo(p, _start_mark, _loop0_115_type, _seq); |
30876 | p->level--; |
30877 | return _seq; |
30878 | } |
30879 | |
30880 | // _tmp_116: assignment_expression | expression !':=' |
30881 | static void * |
30882 | _tmp_116_rule(Parser *p) |
30883 | { |
30884 | if (p->level++ == MAXSTACK) { Branch (30884:9): [True: 0, False: 782k]
|
30885 | p->error_indicator = 1; |
30886 | PyErr_NoMemory(); |
30887 | } |
30888 | if (p->error_indicator) { Branch (30888:9): [True: 0, False: 782k]
|
30889 | p->level--; |
30890 | return NULL; |
30891 | } |
30892 | void * _res = NULL; |
30893 | int _mark = p->mark; |
30894 | { // assignment_expression |
30895 | if (p->error_indicator) { Branch (30895:13): [True: 0, False: 782k]
|
30896 | p->level--; |
30897 | return NULL; |
30898 | } |
30899 | D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); |
30900 | expr_ty assignment_expression_var; |
30901 | if ( |
30902 | (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression Branch (30902:13): [True: 7, False: 782k]
|
30903 | ) |
30904 | { |
30905 | D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); |
30906 | _res = assignment_expression_var; |
30907 | goto done; |
30908 | } |
30909 | p->mark = _mark; |
30910 | D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', |
30911 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); |
30912 | } |
30913 | { // expression !':=' |
30914 | if (p->error_indicator) { Branch (30914:13): [True: 17, False: 782k]
|
30915 | p->level--; |
30916 | return NULL; |
30917 | } |
30918 | D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); |
30919 | expr_ty expression_var; |
30920 | if ( |
30921 | (expression_var = expression_rule(p)) // expression Branch (30921:13): [True: 141k, False: 640k]
|
30922 | && |
30923 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)141k // token=':=' Branch (30923:13): [True: 141k, False: 6]
|
30924 | ) |
30925 | { |
30926 | D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); |
30927 | _res = expression_var; |
30928 | goto done; |
30929 | } |
30930 | p->mark = _mark; |
30931 | D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', |
30932 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); |
30933 | } |
30934 | _res = NULL; |
30935 | done: |
30936 | p->level--; |
30937 | return _res; |
30938 | } |
30939 | |
30940 | // _loop0_118: ',' (starred_expression | (assignment_expression | expression !':=') !'=') |
30941 | static asdl_seq * |
30942 | _loop0_118_rule(Parser *p) |
30943 | { |
30944 | if (p->level++ == MAXSTACK) { Branch (30944:9): [True: 0, False: 90.7k]
|
30945 | p->error_indicator = 1; |
30946 | PyErr_NoMemory(); |
30947 | } |
30948 | if (p->error_indicator) { Branch (30948:9): [True: 0, False: 90.7k]
|
30949 | p->level--; |
30950 | return NULL; |
30951 | } |
30952 | void *_res = NULL; |
30953 | int _mark = p->mark; |
30954 | int _start_mark = p->mark; |
30955 | void **_children = PyMem_Malloc(sizeof(void *)); |
30956 | if (!_children) { Branch (30956:9): [True: 0, False: 90.7k]
|
30957 | p->error_indicator = 1; |
30958 | PyErr_NoMemory(); |
30959 | p->level--; |
30960 | return NULL; |
30961 | } |
30962 | Py_ssize_t _children_capacity = 1; |
30963 | Py_ssize_t _n = 0; |
30964 | { // ',' (starred_expression | (assignment_expression | expression !':=') !'=') |
30965 | if (p->error_indicator) { Branch (30965:13): [True: 0, False: 90.7k]
|
30966 | p->level--; |
30967 | return NULL; |
30968 | } |
30969 | D(fprintf(stderr, "%*c> _loop0_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); |
30970 | Token * _literal; |
30971 | void *elem; |
30972 | while ( |
30973 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (30973:13): [True: 50.7k, False: 86.5k]
|
30974 | && |
30975 | (elem = _tmp_230_rule(p))50.7k // starred_expression | (assignment_expression | expression !':=') !'=' Branch (30975:13): [True: 46.5k, False: 4.16k]
|
30976 | ) |
30977 | { |
30978 | _res = elem; |
30979 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (30979:17): [True: 0, False: 46.5k]
Branch (30979:33): [True: 0, False: 0]
|
30980 | p->error_indicator = 1; |
30981 | PyMem_Free(_children); |
30982 | p->level--; |
30983 | return NULL; |
30984 | } |
30985 | if (_n == _children_capacity) { Branch (30985:17): [True: 8.93k, False: 37.6k]
|
30986 | _children_capacity *= 2; |
30987 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
30988 | if (!_new_children) { Branch (30988:21): [True: 0, False: 8.93k]
|
30989 | p->error_indicator = 1; |
30990 | PyErr_NoMemory(); |
30991 | p->level--; |
30992 | return NULL; |
30993 | } |
30994 | _children = _new_children; |
30995 | } |
30996 | _children[_n++] = _res; |
30997 | _mark = p->mark; |
30998 | } |
30999 | p->mark = _mark; |
31000 | D(fprintf(stderr, "%*c%s _loop0_118[%d-%d]: %s failed!\n", p->level, ' ', |
31001 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); |
31002 | } |
31003 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31004 | if (!_seq) { Branch (31004:9): [True: 0, False: 90.7k]
|
31005 | PyMem_Free(_children); |
31006 | p->error_indicator = 1; |
31007 | PyErr_NoMemory(); |
31008 | p->level--; |
31009 | return NULL; |
31010 | } |
31011 | for (int i = 0; 90.7k i < _n; i++46.5k ) asdl_seq_SET_UNTYPED90.7k (_seq, i, _children[i]); Branch (31011:21): [True: 46.5k, False: 90.7k]
|
31012 | PyMem_Free(_children); |
31013 | _PyPegen_insert_memo(p, _start_mark, _loop0_118_type, _seq); |
31014 | p->level--; |
31015 | return _seq; |
31016 | } |
31017 | |
31018 | // _gather_117: |
31019 | // | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118 |
31020 | static asdl_seq * |
31021 | _gather_117_rule(Parser *p) |
31022 | { |
31023 | if (p->level++ == MAXSTACK) { Branch (31023:9): [True: 0, False: 416k]
|
31024 | p->error_indicator = 1; |
31025 | PyErr_NoMemory(); |
31026 | } |
31027 | if (p->error_indicator) { Branch (31027:9): [True: 0, False: 416k]
|
31028 | p->level--; |
31029 | return NULL; |
31030 | } |
31031 | asdl_seq * _res = NULL; |
31032 | int _mark = p->mark; |
31033 | { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118 |
31034 | if (p->error_indicator) { Branch (31034:13): [True: 0, False: 416k]
|
31035 | p->level--; |
31036 | return NULL; |
31037 | } |
31038 | D(fprintf(stderr, "%*c> _gather_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118")); |
31039 | void *elem; |
31040 | asdl_seq * seq; |
31041 | if ( |
31042 | (elem = _tmp_230_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' Branch (31042:13): [True: 90.7k, False: 325k]
|
31043 | && |
31044 | (seq = _loop0_118_rule(p))90.7k // _loop0_118 Branch (31044:13): [True: 90.7k, False: 0]
|
31045 | ) |
31046 | { |
31047 | D(fprintf(stderr, "%*c+ _gather_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118")); |
31048 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
31049 | goto done; |
31050 | } |
31051 | p->mark = _mark; |
31052 | D(fprintf(stderr, "%*c%s _gather_117[%d-%d]: %s failed!\n", p->level, ' ', |
31053 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118")); |
31054 | } |
31055 | _res = NULL; |
31056 | done: |
31057 | p->level--; |
31058 | return _res; |
31059 | } |
31060 | |
31061 | // _tmp_119: ',' kwargs |
31062 | static void * |
31063 | _tmp_119_rule(Parser *p) |
31064 | { |
31065 | if (p->level++ == MAXSTACK) { Branch (31065:9): [True: 0, False: 90.7k]
|
31066 | p->error_indicator = 1; |
31067 | PyErr_NoMemory(); |
31068 | } |
31069 | if (p->error_indicator) { Branch (31069:9): [True: 14, False: 90.7k]
|
31070 | p->level--; |
31071 | return NULL; |
31072 | } |
31073 | void * _res = NULL; |
31074 | int _mark = p->mark; |
31075 | { // ',' kwargs |
31076 | if (p->error_indicator) { Branch (31076:13): [True: 0, False: 90.7k]
|
31077 | p->level--; |
31078 | return NULL; |
31079 | } |
31080 | D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); |
31081 | Token * _literal; |
31082 | asdl_seq* k; |
31083 | if ( |
31084 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31084:13): [True: 4.15k, False: 86.5k]
|
31085 | && |
31086 | (k = kwargs_rule(p))4.15k // kwargs Branch (31086:13): [True: 3.95k, False: 197]
|
31087 | ) |
31088 | { |
31089 | D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); |
31090 | _res = k; |
31091 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (31091:17): [True: 0, False: 3.95k]
Branch (31091:33): [True: 0, False: 0]
|
31092 | p->error_indicator = 1; |
31093 | p->level--; |
31094 | return NULL; |
31095 | } |
31096 | goto done; |
31097 | } |
31098 | p->mark = _mark; |
31099 | D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', |
31100 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); |
31101 | } |
31102 | _res = NULL; |
31103 | done: |
31104 | p->level--; |
31105 | return _res; |
31106 | } |
31107 | |
31108 | // _loop0_121: ',' kwarg_or_starred |
31109 | static asdl_seq * |
31110 | _loop0_121_rule(Parser *p) |
31111 | { |
31112 | if (p->level++ == MAXSTACK) { Branch (31112:9): [True: 0, False: 5.31k]
|
31113 | p->error_indicator = 1; |
31114 | PyErr_NoMemory(); |
31115 | } |
31116 | if (p->error_indicator) { Branch (31116:9): [True: 0, False: 5.31k]
|
31117 | p->level--; |
31118 | return NULL; |
31119 | } |
31120 | void *_res = NULL; |
31121 | int _mark = p->mark; |
31122 | int _start_mark = p->mark; |
31123 | void **_children = PyMem_Malloc(sizeof(void *)); |
31124 | if (!_children) { Branch (31124:9): [True: 0, False: 5.31k]
|
31125 | p->error_indicator = 1; |
31126 | PyErr_NoMemory(); |
31127 | p->level--; |
31128 | return NULL; |
31129 | } |
31130 | Py_ssize_t _children_capacity = 1; |
31131 | Py_ssize_t _n = 0; |
31132 | { // ',' kwarg_or_starred |
31133 | if (p->error_indicator) { Branch (31133:13): [True: 0, False: 5.31k]
|
31134 | p->level--; |
31135 | return NULL; |
31136 | } |
31137 | D(fprintf(stderr, "%*c> _loop0_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); |
31138 | Token * _literal; |
31139 | KeywordOrStarred* elem; |
31140 | while ( |
31141 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31141:13): [True: 4.21k, False: 5.01k]
|
31142 | && |
31143 | (elem = kwarg_or_starred_rule(p))4.21k // kwarg_or_starred Branch (31143:13): [True: 3.91k, False: 304]
|
31144 | ) |
31145 | { |
31146 | _res = elem; |
31147 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (31147:17): [True: 0, False: 3.91k]
Branch (31147:33): [True: 0, False: 0]
|
31148 | p->error_indicator = 1; |
31149 | PyMem_Free(_children); |
31150 | p->level--; |
31151 | return NULL; |
31152 | } |
31153 | if (_n == _children_capacity) { Branch (31153:17): [True: 1.38k, False: 2.52k]
|
31154 | _children_capacity *= 2; |
31155 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31156 | if (!_new_children) { Branch (31156:21): [True: 0, False: 1.38k]
|
31157 | p->error_indicator = 1; |
31158 | PyErr_NoMemory(); |
31159 | p->level--; |
31160 | return NULL; |
31161 | } |
31162 | _children = _new_children; |
31163 | } |
31164 | _children[_n++] = _res; |
31165 | _mark = p->mark; |
31166 | } |
31167 | p->mark = _mark; |
31168 | D(fprintf(stderr, "%*c%s _loop0_121[%d-%d]: %s failed!\n", p->level, ' ', |
31169 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); |
31170 | } |
31171 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31172 | if (!_seq) { Branch (31172:9): [True: 0, False: 5.31k]
|
31173 | PyMem_Free(_children); |
31174 | p->error_indicator = 1; |
31175 | PyErr_NoMemory(); |
31176 | p->level--; |
31177 | return NULL; |
31178 | } |
31179 | for (int i = 0; 5.31k i < _n; i++3.91k ) asdl_seq_SET_UNTYPED5.31k (_seq, i, _children[i]); Branch (31179:21): [True: 3.91k, False: 5.31k]
|
31180 | PyMem_Free(_children); |
31181 | _PyPegen_insert_memo(p, _start_mark, _loop0_121_type, _seq); |
31182 | p->level--; |
31183 | return _seq; |
31184 | } |
31185 | |
31186 | // _gather_120: kwarg_or_starred _loop0_121 |
31187 | static asdl_seq * |
31188 | _gather_120_rule(Parser *p) |
31189 | { |
31190 | if (p->level++ == MAXSTACK) { Branch (31190:9): [True: 0, False: 329k]
|
31191 | p->error_indicator = 1; |
31192 | PyErr_NoMemory(); |
31193 | } |
31194 | if (p->error_indicator) { Branch (31194:9): [True: 0, False: 329k]
|
31195 | p->level--; |
31196 | return NULL; |
31197 | } |
31198 | asdl_seq * _res = NULL; |
31199 | int _mark = p->mark; |
31200 | { // kwarg_or_starred _loop0_121 |
31201 | if (p->error_indicator) { Branch (31201:13): [True: 0, False: 329k]
|
31202 | p->level--; |
31203 | return NULL; |
31204 | } |
31205 | D(fprintf(stderr, "%*c> _gather_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_121")); |
31206 | KeywordOrStarred* elem; |
31207 | asdl_seq * seq; |
31208 | if ( |
31209 | (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred Branch (31209:13): [True: 5.31k, False: 324k]
|
31210 | && |
31211 | (seq = _loop0_121_rule(p))5.31k // _loop0_121 Branch (31211:13): [True: 5.31k, False: 0]
|
31212 | ) |
31213 | { |
31214 | D(fprintf(stderr, "%*c+ _gather_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_121")); |
31215 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
31216 | goto done; |
31217 | } |
31218 | p->mark = _mark; |
31219 | D(fprintf(stderr, "%*c%s _gather_120[%d-%d]: %s failed!\n", p->level, ' ', |
31220 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_121")); |
31221 | } |
31222 | _res = NULL; |
31223 | done: |
31224 | p->level--; |
31225 | return _res; |
31226 | } |
31227 | |
31228 | // _loop0_123: ',' kwarg_or_double_starred |
31229 | static asdl_seq * |
31230 | _loop0_123_rule(Parser *p) |
31231 | { |
31232 | if (p->level++ == MAXSTACK) { Branch (31232:9): [True: 0, False: 153]
|
31233 | p->error_indicator = 1; |
31234 | PyErr_NoMemory(); |
31235 | } |
31236 | if (p->error_indicator) { Branch (31236:9): [True: 0, False: 153]
|
31237 | p->level--; |
31238 | return NULL; |
31239 | } |
31240 | void *_res = NULL; |
31241 | int _mark = p->mark; |
31242 | int _start_mark = p->mark; |
31243 | void **_children = PyMem_Malloc(sizeof(void *)); |
31244 | if (!_children) { Branch (31244:9): [True: 0, False: 153]
|
31245 | p->error_indicator = 1; |
31246 | PyErr_NoMemory(); |
31247 | p->level--; |
31248 | return NULL; |
31249 | } |
31250 | Py_ssize_t _children_capacity = 1; |
31251 | Py_ssize_t _n = 0; |
31252 | { // ',' kwarg_or_double_starred |
31253 | if (p->error_indicator) { Branch (31253:13): [True: 0, False: 153]
|
31254 | p->level--; |
31255 | return NULL; |
31256 | } |
31257 | D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); |
31258 | Token * _literal; |
31259 | KeywordOrStarred* elem; |
31260 | while ( |
31261 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31261:13): [True: 16, False: 153]
|
31262 | && |
31263 | (elem = kwarg_or_double_starred_rule(p))16 // kwarg_or_double_starred |
31264 | ) |
31265 | { |
31266 | _res = elem; |
31267 | if (_res == NULL && PyErr_Occurred()0 ) { |
31268 | p->error_indicator = 1; |
31269 | PyMem_Free(_children); |
31270 | p->level--; |
31271 | return NULL; |
31272 | } |
31273 | if (_n == _children_capacity) { |
31274 | _children_capacity *= 2; |
31275 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31276 | if (!_new_children) { |
31277 | p->error_indicator = 1; |
31278 | PyErr_NoMemory(); |
31279 | p->level--; |
31280 | return NULL; |
31281 | } |
31282 | _children = _new_children; |
31283 | } |
31284 | _children[_n++] = _res; |
31285 | _mark = p->mark; |
31286 | } |
31287 | p->mark = _mark; |
31288 | D(fprintf(stderr, "%*c%s _loop0_123[%d-%d]: %s failed!\n", p->level, ' ', |
31289 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); |
31290 | } |
31291 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31292 | if (!_seq) { Branch (31292:9): [True: 0, False: 153]
|
31293 | PyMem_Free(_children); |
31294 | p->error_indicator = 1; |
31295 | PyErr_NoMemory(); |
31296 | p->level--; |
31297 | return NULL; |
31298 | } |
31299 | for (int i = 0; 153 i < _n; i++16 ) asdl_seq_SET_UNTYPED153 (_seq, i, _children[i]); Branch (31299:21): [True: 16, False: 153]
|
31300 | PyMem_Free(_children); |
31301 | _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq); |
31302 | p->level--; |
31303 | return _seq; |
31304 | } |
31305 | |
31306 | // _gather_122: kwarg_or_double_starred _loop0_123 |
31307 | static asdl_seq * |
31308 | _gather_122_rule(Parser *p) |
31309 | { |
31310 | if (p->level++ == MAXSTACK) { Branch (31310:9): [True: 0, False: 304]
|
31311 | p->error_indicator = 1; |
31312 | PyErr_NoMemory(); |
31313 | } |
31314 | if (p->error_indicator) { Branch (31314:9): [True: 0, False: 304]
|
31315 | p->level--; |
31316 | return NULL; |
31317 | } |
31318 | asdl_seq * _res = NULL; |
31319 | int _mark = p->mark; |
31320 | { // kwarg_or_double_starred _loop0_123 |
31321 | if (p->error_indicator) { Branch (31321:13): [True: 0, False: 304]
|
31322 | p->level--; |
31323 | return NULL; |
31324 | } |
31325 | D(fprintf(stderr, "%*c> _gather_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_123")); |
31326 | KeywordOrStarred* elem; |
31327 | asdl_seq * seq; |
31328 | if ( |
31329 | (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred Branch (31329:13): [True: 153, False: 151]
|
31330 | && |
31331 | (seq = _loop0_123_rule(p))153 // _loop0_123 Branch (31331:13): [True: 153, False: 0]
|
31332 | ) |
31333 | { |
31334 | D(fprintf(stderr, "%*c+ _gather_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_123")); |
31335 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
31336 | goto done; |
31337 | } |
31338 | p->mark = _mark; |
31339 | D(fprintf(stderr, "%*c%s _gather_122[%d-%d]: %s failed!\n", p->level, ' ', |
31340 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_123")); |
31341 | } |
31342 | _res = NULL; |
31343 | done: |
31344 | p->level--; |
31345 | return _res; |
31346 | } |
31347 | |
31348 | // _loop0_125: ',' kwarg_or_starred |
31349 | static asdl_seq * |
31350 | _loop0_125_rule(Parser *p) |
31351 | { |
31352 | if (p->level++ == MAXSTACK) { Branch (31352:9): [True: 0, False: 5.16k]
|
31353 | p->error_indicator = 1; |
31354 | PyErr_NoMemory(); |
31355 | } |
31356 | if (p->error_indicator) { Branch (31356:9): [True: 0, False: 5.16k]
|
31357 | p->level--; |
31358 | return NULL; |
31359 | } |
31360 | void *_res = NULL; |
31361 | int _mark = p->mark; |
31362 | int _start_mark = p->mark; |
31363 | void **_children = PyMem_Malloc(sizeof(void *)); |
31364 | if (!_children) { Branch (31364:9): [True: 0, False: 5.16k]
|
31365 | p->error_indicator = 1; |
31366 | PyErr_NoMemory(); |
31367 | p->level--; |
31368 | return NULL; |
31369 | } |
31370 | Py_ssize_t _children_capacity = 1; |
31371 | Py_ssize_t _n = 0; |
31372 | { // ',' kwarg_or_starred |
31373 | if (p->error_indicator) { Branch (31373:13): [True: 0, False: 5.16k]
|
31374 | p->level--; |
31375 | return NULL; |
31376 | } |
31377 | D(fprintf(stderr, "%*c> _loop0_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); |
31378 | Token * _literal; |
31379 | KeywordOrStarred* elem; |
31380 | while ( |
31381 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31381:13): [True: 3.92k, False: 5.01k]
|
31382 | && |
31383 | (elem = kwarg_or_starred_rule(p))3.92k // kwarg_or_starred Branch (31383:13): [True: 3.77k, False: 151]
|
31384 | ) |
31385 | { |
31386 | _res = elem; |
31387 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (31387:17): [True: 0, False: 3.77k]
Branch (31387:33): [True: 0, False: 0]
|
31388 | p->error_indicator = 1; |
31389 | PyMem_Free(_children); |
31390 | p->level--; |
31391 | return NULL; |
31392 | } |
31393 | if (_n == _children_capacity) { Branch (31393:17): [True: 1.33k, False: 2.44k]
|
31394 | _children_capacity *= 2; |
31395 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31396 | if (!_new_children) { Branch (31396:21): [True: 0, False: 1.33k]
|
31397 | p->error_indicator = 1; |
31398 | PyErr_NoMemory(); |
31399 | p->level--; |
31400 | return NULL; |
31401 | } |
31402 | _children = _new_children; |
31403 | } |
31404 | _children[_n++] = _res; |
31405 | _mark = p->mark; |
31406 | } |
31407 | p->mark = _mark; |
31408 | D(fprintf(stderr, "%*c%s _loop0_125[%d-%d]: %s failed!\n", p->level, ' ', |
31409 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); |
31410 | } |
31411 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31412 | if (!_seq) { Branch (31412:9): [True: 0, False: 5.16k]
|
31413 | PyMem_Free(_children); |
31414 | p->error_indicator = 1; |
31415 | PyErr_NoMemory(); |
31416 | p->level--; |
31417 | return NULL; |
31418 | } |
31419 | for (int i = 0; 5.16k i < _n; i++3.77k ) asdl_seq_SET_UNTYPED5.16k (_seq, i, _children[i]); Branch (31419:21): [True: 3.77k, False: 5.16k]
|
31420 | PyMem_Free(_children); |
31421 | _PyPegen_insert_memo(p, _start_mark, _loop0_125_type, _seq); |
31422 | p->level--; |
31423 | return _seq; |
31424 | } |
31425 | |
31426 | // _gather_124: kwarg_or_starred _loop0_125 |
31427 | static asdl_seq * |
31428 | _gather_124_rule(Parser *p) |
31429 | { |
31430 | if (p->level++ == MAXSTACK) { Branch (31430:9): [True: 0, False: 329k]
|
31431 | p->error_indicator = 1; |
31432 | PyErr_NoMemory(); |
31433 | } |
31434 | if (p->error_indicator) { Branch (31434:9): [True: 0, False: 329k]
|
31435 | p->level--; |
31436 | return NULL; |
31437 | } |
31438 | asdl_seq * _res = NULL; |
31439 | int _mark = p->mark; |
31440 | { // kwarg_or_starred _loop0_125 |
31441 | if (p->error_indicator) { Branch (31441:13): [True: 0, False: 329k]
|
31442 | p->level--; |
31443 | return NULL; |
31444 | } |
31445 | D(fprintf(stderr, "%*c> _gather_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_125")); |
31446 | KeywordOrStarred* elem; |
31447 | asdl_seq * seq; |
31448 | if ( |
31449 | (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred Branch (31449:13): [True: 5.16k, False: 324k]
|
31450 | && |
31451 | (seq = _loop0_125_rule(p))5.16k // _loop0_125 Branch (31451:13): [True: 5.16k, False: 0]
|
31452 | ) |
31453 | { |
31454 | D(fprintf(stderr, "%*c+ _gather_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_125")); |
31455 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
31456 | goto done; |
31457 | } |
31458 | p->mark = _mark; |
31459 | D(fprintf(stderr, "%*c%s _gather_124[%d-%d]: %s failed!\n", p->level, ' ', |
31460 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_125")); |
31461 | } |
31462 | _res = NULL; |
31463 | done: |
31464 | p->level--; |
31465 | return _res; |
31466 | } |
31467 | |
31468 | // _loop0_127: ',' kwarg_or_double_starred |
31469 | static asdl_seq * |
31470 | _loop0_127_rule(Parser *p) |
31471 | { |
31472 | if (p->level++ == MAXSTACK) { Branch (31472:9): [True: 0, False: 680]
|
31473 | p->error_indicator = 1; |
31474 | PyErr_NoMemory(); |
31475 | } |
31476 | if (p->error_indicator) { Branch (31476:9): [True: 0, False: 680]
|
31477 | p->level--; |
31478 | return NULL; |
31479 | } |
31480 | void *_res = NULL; |
31481 | int _mark = p->mark; |
31482 | int _start_mark = p->mark; |
31483 | void **_children = PyMem_Malloc(sizeof(void *)); |
31484 | if (!_children) { Branch (31484:9): [True: 0, False: 680]
|
31485 | p->error_indicator = 1; |
31486 | PyErr_NoMemory(); |
31487 | p->level--; |
31488 | return NULL; |
31489 | } |
31490 | Py_ssize_t _children_capacity = 1; |
31491 | Py_ssize_t _n = 0; |
31492 | { // ',' kwarg_or_double_starred |
31493 | if (p->error_indicator) { Branch (31493:13): [True: 0, False: 680]
|
31494 | p->level--; |
31495 | return NULL; |
31496 | } |
31497 | D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); |
31498 | Token * _literal; |
31499 | KeywordOrStarred* elem; |
31500 | while ( |
31501 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31501:13): [True: 41, False: 670]
|
31502 | && |
31503 | (elem = kwarg_or_double_starred_rule(p))41 // kwarg_or_double_starred Branch (31503:13): [True: 31, False: 10]
|
31504 | ) |
31505 | { |
31506 | _res = elem; |
31507 | if (_res == NULL && PyErr_Occurred()0 ) { |
31508 | p->error_indicator = 1; |
31509 | PyMem_Free(_children); |
31510 | p->level--; |
31511 | return NULL; |
31512 | } |
31513 | if (_n == _children_capacity) { Branch (31513:17): [True: 10, False: 21]
|
31514 | _children_capacity *= 2; |
31515 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31516 | if (!_new_children) { |
31517 | p->error_indicator = 1; |
31518 | PyErr_NoMemory(); |
31519 | p->level--; |
31520 | return NULL; |
31521 | } |
31522 | _children = _new_children; |
31523 | } |
31524 | _children[_n++] = _res; |
31525 | _mark = p->mark; |
31526 | } |
31527 | p->mark = _mark; |
31528 | D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ', |
31529 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); |
31530 | } |
31531 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31532 | if (!_seq) { Branch (31532:9): [True: 0, False: 680]
|
31533 | PyMem_Free(_children); |
31534 | p->error_indicator = 1; |
31535 | PyErr_NoMemory(); |
31536 | p->level--; |
31537 | return NULL; |
31538 | } |
31539 | for (int i = 0; 680 i < _n; i++31 ) asdl_seq_SET_UNTYPED680 (_seq, i, _children[i]); Branch (31539:21): [True: 31, False: 680]
|
31540 | PyMem_Free(_children); |
31541 | _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq); |
31542 | p->level--; |
31543 | return _seq; |
31544 | } |
31545 | |
31546 | // _gather_126: kwarg_or_double_starred _loop0_127 |
31547 | static asdl_seq * |
31548 | _gather_126_rule(Parser *p) |
31549 | { |
31550 | if (p->level++ == MAXSTACK) { Branch (31550:9): [True: 0, False: 324k]
|
31551 | p->error_indicator = 1; |
31552 | PyErr_NoMemory(); |
31553 | } |
31554 | if (p->error_indicator) { Branch (31554:9): [True: 0, False: 324k]
|
31555 | p->level--; |
31556 | return NULL; |
31557 | } |
31558 | asdl_seq * _res = NULL; |
31559 | int _mark = p->mark; |
31560 | { // kwarg_or_double_starred _loop0_127 |
31561 | if (p->error_indicator) { Branch (31561:13): [True: 0, False: 324k]
|
31562 | p->level--; |
31563 | return NULL; |
31564 | } |
31565 | D(fprintf(stderr, "%*c> _gather_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_127")); |
31566 | KeywordOrStarred* elem; |
31567 | asdl_seq * seq; |
31568 | if ( |
31569 | (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred Branch (31569:13): [True: 680, False: 323k]
|
31570 | && |
31571 | (seq = _loop0_127_rule(p))680 // _loop0_127 Branch (31571:13): [True: 680, False: 0]
|
31572 | ) |
31573 | { |
31574 | D(fprintf(stderr, "%*c+ _gather_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_127")); |
31575 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
31576 | goto done; |
31577 | } |
31578 | p->mark = _mark; |
31579 | D(fprintf(stderr, "%*c%s _gather_126[%d-%d]: %s failed!\n", p->level, ' ', |
31580 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_127")); |
31581 | } |
31582 | _res = NULL; |
31583 | done: |
31584 | p->level--; |
31585 | return _res; |
31586 | } |
31587 | |
31588 | // _loop0_128: (',' star_target) |
31589 | static asdl_seq * |
31590 | _loop0_128_rule(Parser *p) |
31591 | { |
31592 | if (p->level++ == MAXSTACK) { Branch (31592:9): [True: 0, False: 4.39k]
|
31593 | p->error_indicator = 1; |
31594 | PyErr_NoMemory(); |
31595 | } |
31596 | if (p->error_indicator) { Branch (31596:9): [True: 0, False: 4.39k]
|
31597 | p->level--; |
31598 | return NULL; |
31599 | } |
31600 | void *_res = NULL; |
31601 | int _mark = p->mark; |
31602 | int _start_mark = p->mark; |
31603 | void **_children = PyMem_Malloc(sizeof(void *)); |
31604 | if (!_children) { Branch (31604:9): [True: 0, False: 4.39k]
|
31605 | p->error_indicator = 1; |
31606 | PyErr_NoMemory(); |
31607 | p->level--; |
31608 | return NULL; |
31609 | } |
31610 | Py_ssize_t _children_capacity = 1; |
31611 | Py_ssize_t _n = 0; |
31612 | { // (',' star_target) |
31613 | if (p->error_indicator) { Branch (31613:13): [True: 0, False: 4.39k]
|
31614 | p->level--; |
31615 | return NULL; |
31616 | } |
31617 | D(fprintf(stderr, "%*c> _loop0_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); |
31618 | void *_tmp_231_var; |
31619 | while ( |
31620 | (_tmp_231_var = _tmp_231_rule(p)) // ',' star_target Branch (31620:13): [True: 9.67k, False: 4.39k]
|
31621 | ) |
31622 | { |
31623 | _res = _tmp_231_var; |
31624 | if (_n == _children_capacity) { Branch (31624:17): [True: 1.44k, False: 8.23k]
|
31625 | _children_capacity *= 2; |
31626 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31627 | if (!_new_children) { Branch (31627:21): [True: 0, False: 1.44k]
|
31628 | p->error_indicator = 1; |
31629 | PyErr_NoMemory(); |
31630 | p->level--; |
31631 | return NULL; |
31632 | } |
31633 | _children = _new_children; |
31634 | } |
31635 | _children[_n++] = _res; |
31636 | _mark = p->mark; |
31637 | } |
31638 | p->mark = _mark; |
31639 | D(fprintf(stderr, "%*c%s _loop0_128[%d-%d]: %s failed!\n", p->level, ' ', |
31640 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); |
31641 | } |
31642 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31643 | if (!_seq) { Branch (31643:9): [True: 0, False: 4.39k]
|
31644 | PyMem_Free(_children); |
31645 | p->error_indicator = 1; |
31646 | PyErr_NoMemory(); |
31647 | p->level--; |
31648 | return NULL; |
31649 | } |
31650 | for (int i = 0; 4.39k i < _n; i++9.67k ) asdl_seq_SET_UNTYPED4.39k (_seq, i, _children[i]); Branch (31650:21): [True: 9.67k, False: 4.39k]
|
31651 | PyMem_Free(_children); |
31652 | _PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq); |
31653 | p->level--; |
31654 | return _seq; |
31655 | } |
31656 | |
31657 | // _loop0_130: ',' star_target |
31658 | static asdl_seq * |
31659 | _loop0_130_rule(Parser *p) |
31660 | { |
31661 | if (p->level++ == MAXSTACK) { Branch (31661:9): [True: 0, False: 1.16k]
|
31662 | p->error_indicator = 1; |
31663 | PyErr_NoMemory(); |
31664 | } |
31665 | if (p->error_indicator) { Branch (31665:9): [True: 0, False: 1.16k]
|
31666 | p->level--; |
31667 | return NULL; |
31668 | } |
31669 | void *_res = NULL; |
31670 | int _mark = p->mark; |
31671 | int _start_mark = p->mark; |
31672 | void **_children = PyMem_Malloc(sizeof(void *)); |
31673 | if (!_children) { Branch (31673:9): [True: 0, False: 1.16k]
|
31674 | p->error_indicator = 1; |
31675 | PyErr_NoMemory(); |
31676 | p->level--; |
31677 | return NULL; |
31678 | } |
31679 | Py_ssize_t _children_capacity = 1; |
31680 | Py_ssize_t _n = 0; |
31681 | { // ',' star_target |
31682 | if (p->error_indicator) { Branch (31682:13): [True: 0, False: 1.16k]
|
31683 | p->level--; |
31684 | return NULL; |
31685 | } |
31686 | D(fprintf(stderr, "%*c> _loop0_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); |
31687 | Token * _literal; |
31688 | expr_ty elem; |
31689 | while ( |
31690 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31690:13): [True: 500, False: 1.15k]
|
31691 | && |
31692 | (elem = star_target_rule(p))500 // star_target Branch (31692:13): [True: 482, False: 18]
|
31693 | ) |
31694 | { |
31695 | _res = elem; |
31696 | if (_res == NULL && PyErr_Occurred()0 ) { |
31697 | p->error_indicator = 1; |
31698 | PyMem_Free(_children); |
31699 | p->level--; |
31700 | return NULL; |
31701 | } |
31702 | if (_n == _children_capacity) { Branch (31702:17): [True: 161, False: 321]
|
31703 | _children_capacity *= 2; |
31704 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31705 | if (!_new_children) { Branch (31705:21): [True: 0, False: 161]
|
31706 | p->error_indicator = 1; |
31707 | PyErr_NoMemory(); |
31708 | p->level--; |
31709 | return NULL; |
31710 | } |
31711 | _children = _new_children; |
31712 | } |
31713 | _children[_n++] = _res; |
31714 | _mark = p->mark; |
31715 | } |
31716 | p->mark = _mark; |
31717 | D(fprintf(stderr, "%*c%s _loop0_130[%d-%d]: %s failed!\n", p->level, ' ', |
31718 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); |
31719 | } |
31720 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31721 | if (!_seq) { Branch (31721:9): [True: 0, False: 1.16k]
|
31722 | PyMem_Free(_children); |
31723 | p->error_indicator = 1; |
31724 | PyErr_NoMemory(); |
31725 | p->level--; |
31726 | return NULL; |
31727 | } |
31728 | for (int i = 0; 1.16k i < _n; i++482 ) asdl_seq_SET_UNTYPED1.16k (_seq, i, _children[i]); Branch (31728:21): [True: 482, False: 1.16k]
|
31729 | PyMem_Free(_children); |
31730 | _PyPegen_insert_memo(p, _start_mark, _loop0_130_type, _seq); |
31731 | p->level--; |
31732 | return _seq; |
31733 | } |
31734 | |
31735 | // _gather_129: star_target _loop0_130 |
31736 | static asdl_seq * |
31737 | _gather_129_rule(Parser *p) |
31738 | { |
31739 | if (p->level++ == MAXSTACK) { Branch (31739:9): [True: 0, False: 3.49k]
|
31740 | p->error_indicator = 1; |
31741 | PyErr_NoMemory(); |
31742 | } |
31743 | if (p->error_indicator) { Branch (31743:9): [True: 0, False: 3.49k]
|
31744 | p->level--; |
31745 | return NULL; |
31746 | } |
31747 | asdl_seq * _res = NULL; |
31748 | int _mark = p->mark; |
31749 | { // star_target _loop0_130 |
31750 | if (p->error_indicator) { Branch (31750:13): [True: 0, False: 3.49k]
|
31751 | p->level--; |
31752 | return NULL; |
31753 | } |
31754 | D(fprintf(stderr, "%*c> _gather_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_130")); |
31755 | expr_ty elem; |
31756 | asdl_seq * seq; |
31757 | if ( |
31758 | (elem = star_target_rule(p)) // star_target Branch (31758:13): [True: 1.16k, False: 2.32k]
|
31759 | && |
31760 | (seq = _loop0_130_rule(p))1.16k // _loop0_130 Branch (31760:13): [True: 1.16k, False: 0]
|
31761 | ) |
31762 | { |
31763 | D(fprintf(stderr, "%*c+ _gather_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_130")); |
31764 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
31765 | goto done; |
31766 | } |
31767 | p->mark = _mark; |
31768 | D(fprintf(stderr, "%*c%s _gather_129[%d-%d]: %s failed!\n", p->level, ' ', |
31769 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_130")); |
31770 | } |
31771 | _res = NULL; |
31772 | done: |
31773 | p->level--; |
31774 | return _res; |
31775 | } |
31776 | |
31777 | // _loop1_131: (',' star_target) |
31778 | static asdl_seq * |
31779 | _loop1_131_rule(Parser *p) |
31780 | { |
31781 | if (p->level++ == MAXSTACK) { Branch (31781:9): [True: 0, False: 1.26k]
|
31782 | p->error_indicator = 1; |
31783 | PyErr_NoMemory(); |
31784 | } |
31785 | if (p->error_indicator) { Branch (31785:9): [True: 0, False: 1.26k]
|
31786 | p->level--; |
31787 | return NULL; |
31788 | } |
31789 | void *_res = NULL; |
31790 | int _mark = p->mark; |
31791 | int _start_mark = p->mark; |
31792 | void **_children = PyMem_Malloc(sizeof(void *)); |
31793 | if (!_children) { Branch (31793:9): [True: 0, False: 1.26k]
|
31794 | p->error_indicator = 1; |
31795 | PyErr_NoMemory(); |
31796 | p->level--; |
31797 | return NULL; |
31798 | } |
31799 | Py_ssize_t _children_capacity = 1; |
31800 | Py_ssize_t _n = 0; |
31801 | { // (',' star_target) |
31802 | if (p->error_indicator) { Branch (31802:13): [True: 0, False: 1.26k]
|
31803 | p->level--; |
31804 | return NULL; |
31805 | } |
31806 | D(fprintf(stderr, "%*c> _loop1_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); |
31807 | void *_tmp_232_var; |
31808 | while ( |
31809 | (_tmp_232_var = _tmp_232_rule(p)) // ',' star_target Branch (31809:13): [True: 1.76k, False: 1.26k]
|
31810 | ) |
31811 | { |
31812 | _res = _tmp_232_var; |
31813 | if (_n == _children_capacity) { Branch (31813:17): [True: 309, False: 1.45k]
|
31814 | _children_capacity *= 2; |
31815 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31816 | if (!_new_children) { Branch (31816:21): [True: 0, False: 309]
|
31817 | p->error_indicator = 1; |
31818 | PyErr_NoMemory(); |
31819 | p->level--; |
31820 | return NULL; |
31821 | } |
31822 | _children = _new_children; |
31823 | } |
31824 | _children[_n++] = _res; |
31825 | _mark = p->mark; |
31826 | } |
31827 | p->mark = _mark; |
31828 | D(fprintf(stderr, "%*c%s _loop1_131[%d-%d]: %s failed!\n", p->level, ' ', |
31829 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); |
31830 | } |
31831 | if (_n == 0 || p->error_indicator623 ) { Branch (31831:9): [True: 645, False: 623]
Branch (31831:20): [True: 0, False: 623]
|
31832 | PyMem_Free(_children); |
31833 | p->level--; |
31834 | return NULL; |
31835 | } |
31836 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31837 | if (!_seq) { Branch (31837:9): [True: 0, False: 623]
|
31838 | PyMem_Free(_children); |
31839 | p->error_indicator = 1; |
31840 | PyErr_NoMemory(); |
31841 | p->level--; |
31842 | return NULL; |
31843 | } |
31844 | for (int i = 0; 623 i < _n; i++1.76k ) asdl_seq_SET_UNTYPED623 (_seq, i, _children[i]); Branch (31844:21): [True: 1.76k, False: 623]
|
31845 | PyMem_Free(_children); |
31846 | _PyPegen_insert_memo(p, _start_mark, _loop1_131_type, _seq); |
31847 | p->level--; |
31848 | return _seq; |
31849 | } |
31850 | |
31851 | // _tmp_132: !'*' star_target |
31852 | static void * |
31853 | _tmp_132_rule(Parser *p) |
31854 | { |
31855 | if (p->level++ == MAXSTACK) { Branch (31855:9): [True: 0, False: 150]
|
31856 | p->error_indicator = 1; |
31857 | PyErr_NoMemory(); |
31858 | } |
31859 | if (p->error_indicator) { Branch (31859:9): [True: 0, False: 150]
|
31860 | p->level--; |
31861 | return NULL; |
31862 | } |
31863 | void * _res = NULL; |
31864 | int _mark = p->mark; |
31865 | { // !'*' star_target |
31866 | if (p->error_indicator) { Branch (31866:13): [True: 0, False: 150]
|
31867 | p->level--; |
31868 | return NULL; |
31869 | } |
31870 | D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); |
31871 | expr_ty star_target_var; |
31872 | if ( |
31873 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*' Branch (31873:13): [True: 150, False: 0]
|
31874 | && |
31875 | (star_target_var = star_target_rule(p)) // star_target Branch (31875:13): [True: 139, False: 11]
|
31876 | ) |
31877 | { |
31878 | D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); |
31879 | _res = star_target_var; |
31880 | goto done; |
31881 | } |
31882 | p->mark = _mark; |
31883 | D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', |
31884 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); |
31885 | } |
31886 | _res = NULL; |
31887 | done: |
31888 | p->level--; |
31889 | return _res; |
31890 | } |
31891 | |
31892 | // _loop0_134: ',' del_target |
31893 | static asdl_seq * |
31894 | _loop0_134_rule(Parser *p) |
31895 | { |
31896 | if (p->level++ == MAXSTACK) { Branch (31896:9): [True: 0, False: 829]
|
31897 | p->error_indicator = 1; |
31898 | PyErr_NoMemory(); |
31899 | } |
31900 | if (p->error_indicator) { Branch (31900:9): [True: 0, False: 829]
|
31901 | p->level--; |
31902 | return NULL; |
31903 | } |
31904 | void *_res = NULL; |
31905 | int _mark = p->mark; |
31906 | int _start_mark = p->mark; |
31907 | void **_children = PyMem_Malloc(sizeof(void *)); |
31908 | if (!_children) { Branch (31908:9): [True: 0, False: 829]
|
31909 | p->error_indicator = 1; |
31910 | PyErr_NoMemory(); |
31911 | p->level--; |
31912 | return NULL; |
31913 | } |
31914 | Py_ssize_t _children_capacity = 1; |
31915 | Py_ssize_t _n = 0; |
31916 | { // ',' del_target |
31917 | if (p->error_indicator) { Branch (31917:13): [True: 0, False: 829]
|
31918 | p->level--; |
31919 | return NULL; |
31920 | } |
31921 | D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); |
31922 | Token * _literal; |
31923 | expr_ty elem; |
31924 | while ( |
31925 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (31925:13): [True: 223, False: 817]
|
31926 | && |
31927 | (elem = del_target_rule(p))223 // del_target Branch (31927:13): [True: 211, False: 12]
|
31928 | ) |
31929 | { |
31930 | _res = elem; |
31931 | if (_res == NULL && PyErr_Occurred()0 ) { |
31932 | p->error_indicator = 1; |
31933 | PyMem_Free(_children); |
31934 | p->level--; |
31935 | return NULL; |
31936 | } |
31937 | if (_n == _children_capacity) { Branch (31937:17): [True: 67, False: 144]
|
31938 | _children_capacity *= 2; |
31939 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
31940 | if (!_new_children) { |
31941 | p->error_indicator = 1; |
31942 | PyErr_NoMemory(); |
31943 | p->level--; |
31944 | return NULL; |
31945 | } |
31946 | _children = _new_children; |
31947 | } |
31948 | _children[_n++] = _res; |
31949 | _mark = p->mark; |
31950 | } |
31951 | p->mark = _mark; |
31952 | D(fprintf(stderr, "%*c%s _loop0_134[%d-%d]: %s failed!\n", p->level, ' ', |
31953 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target")); |
31954 | } |
31955 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
31956 | if (!_seq) { Branch (31956:9): [True: 0, False: 829]
|
31957 | PyMem_Free(_children); |
31958 | p->error_indicator = 1; |
31959 | PyErr_NoMemory(); |
31960 | p->level--; |
31961 | return NULL; |
31962 | } |
31963 | for (int i = 0; 829 i < _n; i++211 ) asdl_seq_SET_UNTYPED829 (_seq, i, _children[i]); Branch (31963:21): [True: 211, False: 829]
|
31964 | PyMem_Free(_children); |
31965 | _PyPegen_insert_memo(p, _start_mark, _loop0_134_type, _seq); |
31966 | p->level--; |
31967 | return _seq; |
31968 | } |
31969 | |
31970 | // _gather_133: del_target _loop0_134 |
31971 | static asdl_seq * |
31972 | _gather_133_rule(Parser *p) |
31973 | { |
31974 | if (p->level++ == MAXSTACK) { Branch (31974:9): [True: 0, False: 894]
|
31975 | p->error_indicator = 1; |
31976 | PyErr_NoMemory(); |
31977 | } |
31978 | if (p->error_indicator) { Branch (31978:9): [True: 0, False: 894]
|
31979 | p->level--; |
31980 | return NULL; |
31981 | } |
31982 | asdl_seq * _res = NULL; |
31983 | int _mark = p->mark; |
31984 | { // del_target _loop0_134 |
31985 | if (p->error_indicator) { Branch (31985:13): [True: 0, False: 894]
|
31986 | p->level--; |
31987 | return NULL; |
31988 | } |
31989 | D(fprintf(stderr, "%*c> _gather_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_134")); |
31990 | expr_ty elem; |
31991 | asdl_seq * seq; |
31992 | if ( |
31993 | (elem = del_target_rule(p)) // del_target Branch (31993:13): [True: 829, False: 65]
|
31994 | && |
31995 | (seq = _loop0_134_rule(p))829 // _loop0_134 Branch (31995:13): [True: 829, False: 0]
|
31996 | ) |
31997 | { |
31998 | D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_134")); |
31999 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
32000 | goto done; |
32001 | } |
32002 | p->mark = _mark; |
32003 | D(fprintf(stderr, "%*c%s _gather_133[%d-%d]: %s failed!\n", p->level, ' ', |
32004 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_134")); |
32005 | } |
32006 | _res = NULL; |
32007 | done: |
32008 | p->level--; |
32009 | return _res; |
32010 | } |
32011 | |
32012 | // _loop0_136: ',' expression |
32013 | static asdl_seq * |
32014 | _loop0_136_rule(Parser *p) |
32015 | { |
32016 | if (p->level++ == MAXSTACK) { Branch (32016:9): [True: 0, False: 10]
|
32017 | p->error_indicator = 1; |
32018 | PyErr_NoMemory(); |
32019 | } |
32020 | if (p->error_indicator) { Branch (32020:9): [True: 0, False: 10]
|
32021 | p->level--; |
32022 | return NULL; |
32023 | } |
32024 | void *_res = NULL; |
32025 | int _mark = p->mark; |
32026 | int _start_mark = p->mark; |
32027 | void **_children = PyMem_Malloc(sizeof(void *)); |
32028 | if (!_children) { Branch (32028:9): [True: 0, False: 10]
|
32029 | p->error_indicator = 1; |
32030 | PyErr_NoMemory(); |
32031 | p->level--; |
32032 | return NULL; |
32033 | } |
32034 | Py_ssize_t _children_capacity = 1; |
32035 | Py_ssize_t _n = 0; |
32036 | { // ',' expression |
32037 | if (p->error_indicator) { |
32038 | p->level--; |
32039 | return NULL; |
32040 | } |
32041 | D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); |
32042 | Token * _literal; |
32043 | expr_ty elem; |
32044 | while ( |
32045 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
32046 | && |
32047 | (elem = expression_rule(p))9 // expression |
32048 | ) |
32049 | { |
32050 | _res = elem; |
32051 | if (_res == NULL && PyErr_Occurred()0 ) { |
32052 | p->error_indicator = 1; |
32053 | PyMem_Free(_children); |
32054 | p->level--; |
32055 | return NULL; |
32056 | } |
32057 | if (_n == _children_capacity) { |
32058 | _children_capacity *= 2; |
32059 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
32060 | if (!_new_children) { |
32061 | p->error_indicator = 1; |
32062 | PyErr_NoMemory(); |
32063 | p->level--; |
32064 | return NULL; |
32065 | } |
32066 | _children = _new_children; |
32067 | } |
32068 | _children[_n++] = _res; |
32069 | _mark = p->mark; |
32070 | } |
32071 | p->mark = _mark; |
32072 | D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ', |
32073 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); |
32074 | } |
32075 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
32076 | if (!_seq) { Branch (32076:9): [True: 0, False: 10]
|
32077 | PyMem_Free(_children); |
32078 | p->error_indicator = 1; |
32079 | PyErr_NoMemory(); |
32080 | p->level--; |
32081 | return NULL; |
32082 | } |
32083 | for (int i = 0; 10 i < _n; i++4 ) asdl_seq_SET_UNTYPED10 (_seq, i, _children[i]); |
32084 | PyMem_Free(_children); |
32085 | _PyPegen_insert_memo(p, _start_mark, _loop0_136_type, _seq); |
32086 | p->level--; |
32087 | return _seq; |
32088 | } |
32089 | |
32090 | // _gather_135: expression _loop0_136 |
32091 | static asdl_seq * |
32092 | _gather_135_rule(Parser *p) |
32093 | { |
32094 | if (p->level++ == MAXSTACK) { Branch (32094:9): [True: 0, False: 18]
|
32095 | p->error_indicator = 1; |
32096 | PyErr_NoMemory(); |
32097 | } |
32098 | if (p->error_indicator) { Branch (32098:9): [True: 0, False: 18]
|
32099 | p->level--; |
32100 | return NULL; |
32101 | } |
32102 | asdl_seq * _res = NULL; |
32103 | int _mark = p->mark; |
32104 | { // expression _loop0_136 |
32105 | if (p->error_indicator) { |
32106 | p->level--; |
32107 | return NULL; |
32108 | } |
32109 | D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_136")); |
32110 | expr_ty elem; |
32111 | asdl_seq * seq; |
32112 | if ( |
32113 | (elem = expression_rule(p)) // expression |
32114 | && |
32115 | (seq = _loop0_136_rule(p))10 // _loop0_136 |
32116 | ) |
32117 | { |
32118 | D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_136")); |
32119 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
32120 | goto done; |
32121 | } |
32122 | p->mark = _mark; |
32123 | D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ', |
32124 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_136")); |
32125 | } |
32126 | _res = NULL; |
32127 | done: |
32128 | p->level--; |
32129 | return _res; |
32130 | } |
32131 | |
32132 | // _loop0_138: ',' expression |
32133 | static asdl_seq * |
32134 | _loop0_138_rule(Parser *p) |
32135 | { |
32136 | if (p->level++ == MAXSTACK) { Branch (32136:9): [True: 0, False: 9]
|
32137 | p->error_indicator = 1; |
32138 | PyErr_NoMemory(); |
32139 | } |
32140 | if (p->error_indicator) { Branch (32140:9): [True: 0, False: 9]
|
32141 | p->level--; |
32142 | return NULL; |
32143 | } |
32144 | void *_res = NULL; |
32145 | int _mark = p->mark; |
32146 | int _start_mark = p->mark; |
32147 | void **_children = PyMem_Malloc(sizeof(void *)); |
32148 | if (!_children) { Branch (32148:9): [True: 0, False: 9]
|
32149 | p->error_indicator = 1; |
32150 | PyErr_NoMemory(); |
32151 | p->level--; |
32152 | return NULL; |
32153 | } |
32154 | Py_ssize_t _children_capacity = 1; |
32155 | Py_ssize_t _n = 0; |
32156 | { // ',' expression |
32157 | if (p->error_indicator) { |
32158 | p->level--; |
32159 | return NULL; |
32160 | } |
32161 | D(fprintf(stderr, "%*c> _loop0_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); |
32162 | Token * _literal; |
32163 | expr_ty elem; |
32164 | while ( |
32165 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
32166 | && |
32167 | (elem = expression_rule(p))8 // expression |
32168 | ) |
32169 | { |
32170 | _res = elem; |
32171 | if (_res == NULL && PyErr_Occurred()0 ) { |
32172 | p->error_indicator = 1; |
32173 | PyMem_Free(_children); |
32174 | p->level--; |
32175 | return NULL; |
32176 | } |
32177 | if (_n == _children_capacity) { |
32178 | _children_capacity *= 2; |
32179 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
32180 | if (!_new_children) { |
32181 | p->error_indicator = 1; |
32182 | PyErr_NoMemory(); |
32183 | p->level--; |
32184 | return NULL; |
32185 | } |
32186 | _children = _new_children; |
32187 | } |
32188 | _children[_n++] = _res; |
32189 | _mark = p->mark; |
32190 | } |
32191 | p->mark = _mark; |
32192 | D(fprintf(stderr, "%*c%s _loop0_138[%d-%d]: %s failed!\n", p->level, ' ', |
32193 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); |
32194 | } |
32195 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
32196 | if (!_seq) { Branch (32196:9): [True: 0, False: 9]
|
32197 | PyMem_Free(_children); |
32198 | p->error_indicator = 1; |
32199 | PyErr_NoMemory(); |
32200 | p->level--; |
32201 | return NULL; |
32202 | } |
32203 | for (int i = 0; 9 i < _n; i++4 ) asdl_seq_SET_UNTYPED9 (_seq, i, _children[i]); |
32204 | PyMem_Free(_children); |
32205 | _PyPegen_insert_memo(p, _start_mark, _loop0_138_type, _seq); |
32206 | p->level--; |
32207 | return _seq; |
32208 | } |
32209 | |
32210 | // _gather_137: expression _loop0_138 |
32211 | static asdl_seq * |
32212 | _gather_137_rule(Parser *p) |
32213 | { |
32214 | if (p->level++ == MAXSTACK) { Branch (32214:9): [True: 0, False: 17]
|
32215 | p->error_indicator = 1; |
32216 | PyErr_NoMemory(); |
32217 | } |
32218 | if (p->error_indicator) { Branch (32218:9): [True: 0, False: 17]
|
32219 | p->level--; |
32220 | return NULL; |
32221 | } |
32222 | asdl_seq * _res = NULL; |
32223 | int _mark = p->mark; |
32224 | { // expression _loop0_138 |
32225 | if (p->error_indicator) { |
32226 | p->level--; |
32227 | return NULL; |
32228 | } |
32229 | D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_138")); |
32230 | expr_ty elem; |
32231 | asdl_seq * seq; |
32232 | if ( |
32233 | (elem = expression_rule(p)) // expression |
32234 | && |
32235 | (seq = _loop0_138_rule(p))9 // _loop0_138 |
32236 | ) |
32237 | { |
32238 | D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_138")); |
32239 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
32240 | goto done; |
32241 | } |
32242 | p->mark = _mark; |
32243 | D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', |
32244 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_138")); |
32245 | } |
32246 | _res = NULL; |
32247 | done: |
32248 | p->level--; |
32249 | return _res; |
32250 | } |
32251 | |
32252 | // _loop0_140: ',' expression |
32253 | static asdl_seq * |
32254 | _loop0_140_rule(Parser *p) |
32255 | { |
32256 | if (p->level++ == MAXSTACK) { Branch (32256:9): [True: 0, False: 7]
|
32257 | p->error_indicator = 1; |
32258 | PyErr_NoMemory(); |
32259 | } |
32260 | if (p->error_indicator) { Branch (32260:9): [True: 0, False: 7]
|
32261 | p->level--; |
32262 | return NULL; |
32263 | } |
32264 | void *_res = NULL; |
32265 | int _mark = p->mark; |
32266 | int _start_mark = p->mark; |
32267 | void **_children = PyMem_Malloc(sizeof(void *)); |
32268 | if (!_children) { Branch (32268:9): [True: 0, False: 7]
|
32269 | p->error_indicator = 1; |
32270 | PyErr_NoMemory(); |
32271 | p->level--; |
32272 | return NULL; |
32273 | } |
32274 | Py_ssize_t _children_capacity = 1; |
32275 | Py_ssize_t _n = 0; |
32276 | { // ',' expression |
32277 | if (p->error_indicator) { |
32278 | p->level--; |
32279 | return NULL; |
32280 | } |
32281 | D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); |
32282 | Token * _literal; |
32283 | expr_ty elem; |
32284 | while ( |
32285 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
32286 | && |
32287 | (elem = expression_rule(p))6 // expression |
32288 | ) |
32289 | { |
32290 | _res = elem; |
32291 | if (_res == NULL && PyErr_Occurred()0 ) { |
32292 | p->error_indicator = 1; |
32293 | PyMem_Free(_children); |
32294 | p->level--; |
32295 | return NULL; |
32296 | } |
32297 | if (_n == _children_capacity) { |
32298 | _children_capacity *= 2; |
32299 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
32300 | if (!_new_children) { |
32301 | p->error_indicator = 1; |
32302 | PyErr_NoMemory(); |
32303 | p->level--; |
32304 | return NULL; |
32305 | } |
32306 | _children = _new_children; |
32307 | } |
32308 | _children[_n++] = _res; |
32309 | _mark = p->mark; |
32310 | } |
32311 | p->mark = _mark; |
32312 | D(fprintf(stderr, "%*c%s _loop0_140[%d-%d]: %s failed!\n", p->level, ' ', |
32313 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); |
32314 | } |
32315 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
32316 | if (!_seq) { Branch (32316:9): [True: 0, False: 7]
|
32317 | PyMem_Free(_children); |
32318 | p->error_indicator = 1; |
32319 | PyErr_NoMemory(); |
32320 | p->level--; |
32321 | return NULL; |
32322 | } |
32323 | for (int i = 0; 7 i < _n; i++4 ) asdl_seq_SET_UNTYPED7 (_seq, i, _children[i]); |
32324 | PyMem_Free(_children); |
32325 | _PyPegen_insert_memo(p, _start_mark, _loop0_140_type, _seq); |
32326 | p->level--; |
32327 | return _seq; |
32328 | } |
32329 | |
32330 | // _gather_139: expression _loop0_140 |
32331 | static asdl_seq * |
32332 | _gather_139_rule(Parser *p) |
32333 | { |
32334 | if (p->level++ == MAXSTACK) { Branch (32334:9): [True: 0, False: 15]
|
32335 | p->error_indicator = 1; |
32336 | PyErr_NoMemory(); |
32337 | } |
32338 | if (p->error_indicator) { Branch (32338:9): [True: 0, False: 15]
|
32339 | p->level--; |
32340 | return NULL; |
32341 | } |
32342 | asdl_seq * _res = NULL; |
32343 | int _mark = p->mark; |
32344 | { // expression _loop0_140 |
32345 | if (p->error_indicator) { |
32346 | p->level--; |
32347 | return NULL; |
32348 | } |
32349 | D(fprintf(stderr, "%*c> _gather_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_140")); |
32350 | expr_ty elem; |
32351 | asdl_seq * seq; |
32352 | if ( |
32353 | (elem = expression_rule(p)) // expression |
32354 | && |
32355 | (seq = _loop0_140_rule(p))7 // _loop0_140 |
32356 | ) |
32357 | { |
32358 | D(fprintf(stderr, "%*c+ _gather_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_140")); |
32359 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
32360 | goto done; |
32361 | } |
32362 | p->mark = _mark; |
32363 | D(fprintf(stderr, "%*c%s _gather_139[%d-%d]: %s failed!\n", p->level, ' ', |
32364 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_140")); |
32365 | } |
32366 | _res = NULL; |
32367 | done: |
32368 | p->level--; |
32369 | return _res; |
32370 | } |
32371 | |
32372 | // _loop0_142: ',' expression |
32373 | static asdl_seq * |
32374 | _loop0_142_rule(Parser *p) |
32375 | { |
32376 | if (p->level++ == MAXSTACK) { Branch (32376:9): [True: 0, False: 5]
|
32377 | p->error_indicator = 1; |
32378 | PyErr_NoMemory(); |
32379 | } |
32380 | if (p->error_indicator) { Branch (32380:9): [True: 0, False: 5]
|
32381 | p->level--; |
32382 | return NULL; |
32383 | } |
32384 | void *_res = NULL; |
32385 | int _mark = p->mark; |
32386 | int _start_mark = p->mark; |
32387 | void **_children = PyMem_Malloc(sizeof(void *)); |
32388 | if (!_children) { Branch (32388:9): [True: 0, False: 5]
|
32389 | p->error_indicator = 1; |
32390 | PyErr_NoMemory(); |
32391 | p->level--; |
32392 | return NULL; |
32393 | } |
32394 | Py_ssize_t _children_capacity = 1; |
32395 | Py_ssize_t _n = 0; |
32396 | { // ',' expression |
32397 | if (p->error_indicator) { |
32398 | p->level--; |
32399 | return NULL; |
32400 | } |
32401 | D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); |
32402 | Token * _literal; |
32403 | expr_ty elem; |
32404 | while ( |
32405 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
32406 | && |
32407 | (elem = expression_rule(p))4 // expression |
32408 | ) |
32409 | { |
32410 | _res = elem; |
32411 | if (_res == NULL && PyErr_Occurred()0 ) { |
32412 | p->error_indicator = 1; |
32413 | PyMem_Free(_children); |
32414 | p->level--; |
32415 | return NULL; |
32416 | } |
32417 | if (_n == _children_capacity) { |
32418 | _children_capacity *= 2; |
32419 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
32420 | if (!_new_children) { |
32421 | p->error_indicator = 1; |
32422 | PyErr_NoMemory(); |
32423 | p->level--; |
32424 | return NULL; |
32425 | } |
32426 | _children = _new_children; |
32427 | } |
32428 | _children[_n++] = _res; |
32429 | _mark = p->mark; |
32430 | } |
32431 | p->mark = _mark; |
32432 | D(fprintf(stderr, "%*c%s _loop0_142[%d-%d]: %s failed!\n", p->level, ' ', |
32433 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); |
32434 | } |
32435 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
32436 | if (!_seq) { Branch (32436:9): [True: 0, False: 5]
|
32437 | PyMem_Free(_children); |
32438 | p->error_indicator = 1; |
32439 | PyErr_NoMemory(); |
32440 | p->level--; |
32441 | return NULL; |
32442 | } |
32443 | for (int i = 0; 5 i < _n; i++4 ) asdl_seq_SET_UNTYPED5 (_seq, i, _children[i]); |
32444 | PyMem_Free(_children); |
32445 | _PyPegen_insert_memo(p, _start_mark, _loop0_142_type, _seq); |
32446 | p->level--; |
32447 | return _seq; |
32448 | } |
32449 | |
32450 | // _gather_141: expression _loop0_142 |
32451 | static asdl_seq * |
32452 | _gather_141_rule(Parser *p) |
32453 | { |
32454 | if (p->level++ == MAXSTACK) { Branch (32454:9): [True: 0, False: 8]
|
32455 | p->error_indicator = 1; |
32456 | PyErr_NoMemory(); |
32457 | } |
32458 | if (p->error_indicator) { Branch (32458:9): [True: 0, False: 8]
|
32459 | p->level--; |
32460 | return NULL; |
32461 | } |
32462 | asdl_seq * _res = NULL; |
32463 | int _mark = p->mark; |
32464 | { // expression _loop0_142 |
32465 | if (p->error_indicator) { |
32466 | p->level--; |
32467 | return NULL; |
32468 | } |
32469 | D(fprintf(stderr, "%*c> _gather_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_142")); |
32470 | expr_ty elem; |
32471 | asdl_seq * seq; |
32472 | if ( |
32473 | (elem = expression_rule(p)) // expression |
32474 | && |
32475 | (seq = _loop0_142_rule(p))5 // _loop0_142 |
32476 | ) |
32477 | { |
32478 | D(fprintf(stderr, "%*c+ _gather_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_142")); |
32479 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
32480 | goto done; |
32481 | } |
32482 | p->mark = _mark; |
32483 | D(fprintf(stderr, "%*c%s _gather_141[%d-%d]: %s failed!\n", p->level, ' ', |
32484 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_142")); |
32485 | } |
32486 | _res = NULL; |
32487 | done: |
32488 | p->level--; |
32489 | return _res; |
32490 | } |
32491 | |
32492 | // _tmp_143: NEWLINE INDENT |
32493 | static void * |
32494 | _tmp_143_rule(Parser *p) |
32495 | { |
32496 | if (p->level++ == MAXSTACK) { Branch (32496:9): [True: 0, False: 27]
|
32497 | p->error_indicator = 1; |
32498 | PyErr_NoMemory(); |
32499 | } |
32500 | if (p->error_indicator) { Branch (32500:9): [True: 0, False: 27]
|
32501 | p->level--; |
32502 | return NULL; |
32503 | } |
32504 | void * _res = NULL; |
32505 | int _mark = p->mark; |
32506 | { // NEWLINE INDENT |
32507 | if (p->error_indicator) { |
32508 | p->level--; |
32509 | return NULL; |
32510 | } |
32511 | D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); |
32512 | Token * indent_var; |
32513 | Token * newline_var; |
32514 | if ( |
32515 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' |
32516 | && |
32517 | (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' |
32518 | ) |
32519 | { |
32520 | D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); |
32521 | _res = _PyPegen_dummy_name(p, newline_var, indent_var); |
32522 | goto done; |
32523 | } |
32524 | p->mark = _mark; |
32525 | D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', |
32526 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); |
32527 | } |
32528 | _res = NULL; |
32529 | done: |
32530 | p->level--; |
32531 | return _res; |
32532 | } |
32533 | |
32534 | // _tmp_144: args | expression for_if_clauses |
32535 | static void * |
32536 | _tmp_144_rule(Parser *p) |
32537 | { |
32538 | if (p->level++ == MAXSTACK) { Branch (32538:9): [True: 0, False: 11]
|
32539 | p->error_indicator = 1; |
32540 | PyErr_NoMemory(); |
32541 | } |
32542 | if (p->error_indicator) { Branch (32542:9): [True: 0, False: 11]
|
32543 | p->level--; |
32544 | return NULL; |
32545 | } |
32546 | void * _res = NULL; |
32547 | int _mark = p->mark; |
32548 | { // args |
32549 | if (p->error_indicator) { |
32550 | p->level--; |
32551 | return NULL; |
32552 | } |
32553 | D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); |
32554 | expr_ty args_var; |
32555 | if ( |
32556 | (args_var = args_rule(p)) // args |
32557 | ) |
32558 | { |
32559 | D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); |
32560 | _res = args_var; |
32561 | goto done; |
32562 | } |
32563 | p->mark = _mark; |
32564 | D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', |
32565 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); |
32566 | } |
32567 | { // expression for_if_clauses |
32568 | if (p->error_indicator) { |
32569 | p->level--; |
32570 | return NULL; |
32571 | } |
32572 | D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); |
32573 | expr_ty expression_var; |
32574 | asdl_comprehension_seq* for_if_clauses_var; |
32575 | if ( |
32576 | (expression_var = expression_rule(p)) // expression |
32577 | && |
32578 | (for_if_clauses_var = for_if_clauses_rule(p))0 // for_if_clauses |
32579 | ) |
32580 | { |
32581 | D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); |
32582 | _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var); |
32583 | goto done; |
32584 | } |
32585 | p->mark = _mark; |
32586 | D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', |
32587 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses")); |
32588 | } |
32589 | _res = NULL; |
32590 | done: |
32591 | p->level--; |
32592 | return _res; |
32593 | } |
32594 | |
32595 | // _tmp_145: 'True' | 'False' | 'None' |
32596 | static void * |
32597 | _tmp_145_rule(Parser *p) |
32598 | { |
32599 | if (p->level++ == MAXSTACK) { Branch (32599:9): [True: 0, False: 1.13k]
|
32600 | p->error_indicator = 1; |
32601 | PyErr_NoMemory(); |
32602 | } |
32603 | if (p->error_indicator) { Branch (32603:9): [True: 0, False: 1.13k]
|
32604 | p->level--; |
32605 | return NULL; |
32606 | } |
32607 | void * _res = NULL; |
32608 | int _mark = p->mark; |
32609 | { // 'True' |
32610 | if (p->error_indicator) { Branch (32610:13): [True: 0, False: 1.13k]
|
32611 | p->level--; |
32612 | return NULL; |
32613 | } |
32614 | D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); |
32615 | Token * _keyword; |
32616 | if ( |
32617 | (_keyword = _PyPegen_expect_token(p, 600)) // token='True' Branch (32617:13): [True: 1, False: 1.12k]
|
32618 | ) |
32619 | { |
32620 | D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); |
32621 | _res = _keyword; |
32622 | goto done; |
32623 | } |
32624 | p->mark = _mark; |
32625 | D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', |
32626 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); |
32627 | } |
32628 | { // 'False' |
32629 | if (p->error_indicator) { Branch (32629:13): [True: 0, False: 1.12k]
|
32630 | p->level--; |
32631 | return NULL; |
32632 | } |
32633 | D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); |
32634 | Token * _keyword; |
32635 | if ( |
32636 | (_keyword = _PyPegen_expect_token(p, 602)) // token='False' Branch (32636:13): [True: 1, False: 1.12k]
|
32637 | ) |
32638 | { |
32639 | D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); |
32640 | _res = _keyword; |
32641 | goto done; |
32642 | } |
32643 | p->mark = _mark; |
32644 | D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', |
32645 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); |
32646 | } |
32647 | { // 'None' |
32648 | if (p->error_indicator) { Branch (32648:13): [True: 0, False: 1.12k]
|
32649 | p->level--; |
32650 | return NULL; |
32651 | } |
32652 | D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); |
32653 | Token * _keyword; |
32654 | if ( |
32655 | (_keyword = _PyPegen_expect_token(p, 601)) // token='None' Branch (32655:13): [True: 2, False: 1.12k]
|
32656 | ) |
32657 | { |
32658 | D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); |
32659 | _res = _keyword; |
32660 | goto done; |
32661 | } |
32662 | p->mark = _mark; |
32663 | D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', |
32664 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); |
32665 | } |
32666 | _res = NULL; |
32667 | done: |
32668 | p->level--; |
32669 | return _res; |
32670 | } |
32671 | |
32672 | // _tmp_146: NAME '=' |
32673 | static void * |
32674 | _tmp_146_rule(Parser *p) |
32675 | { |
32676 | if (p->level++ == MAXSTACK) { Branch (32676:9): [True: 0, False: 1.12k]
|
32677 | p->error_indicator = 1; |
32678 | PyErr_NoMemory(); |
32679 | } |
32680 | if (p->error_indicator) { Branch (32680:9): [True: 0, False: 1.12k]
|
32681 | p->level--; |
32682 | return NULL; |
32683 | } |
32684 | void * _res = NULL; |
32685 | int _mark = p->mark; |
32686 | { // NAME '=' |
32687 | if (p->error_indicator) { Branch (32687:13): [True: 0, False: 1.12k]
|
32688 | p->level--; |
32689 | return NULL; |
32690 | } |
32691 | D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); |
32692 | Token * _literal; |
32693 | expr_ty name_var; |
32694 | if ( |
32695 | (name_var = _PyPegen_name_token(p)) // NAME Branch (32695:13): [True: 276, False: 849]
|
32696 | && |
32697 | (_literal = _PyPegen_expect_token(p, 22))276 // token='=' Branch (32697:13): [True: 167, False: 109]
|
32698 | ) |
32699 | { |
32700 | D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); |
32701 | _res = _PyPegen_dummy_name(p, name_var, _literal); |
32702 | goto done; |
32703 | } |
32704 | p->mark = _mark; |
32705 | D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', |
32706 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='")); |
32707 | } |
32708 | _res = NULL; |
32709 | done: |
32710 | p->level--; |
32711 | return _res; |
32712 | } |
32713 | |
32714 | // _tmp_147: NAME STRING | SOFT_KEYWORD |
32715 | static void * |
32716 | _tmp_147_rule(Parser *p) |
32717 | { |
32718 | if (p->level++ == MAXSTACK) { Branch (32718:9): [True: 0, False: 2.68k]
|
32719 | p->error_indicator = 1; |
32720 | PyErr_NoMemory(); |
32721 | } |
32722 | if (p->error_indicator) { Branch (32722:9): [True: 0, False: 2.68k]
|
32723 | p->level--; |
32724 | return NULL; |
32725 | } |
32726 | void * _res = NULL; |
32727 | int _mark = p->mark; |
32728 | { // NAME STRING |
32729 | if (p->error_indicator) { Branch (32729:13): [True: 0, False: 2.68k]
|
32730 | p->level--; |
32731 | return NULL; |
32732 | } |
32733 | D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); |
32734 | expr_ty name_var; |
32735 | expr_ty string_var; |
32736 | if ( |
32737 | (name_var = _PyPegen_name_token(p)) // NAME Branch (32737:13): [True: 701, False: 1.98k]
|
32738 | && |
32739 | (string_var = _PyPegen_string_token(p))701 // STRING Branch (32739:13): [True: 63, False: 638]
|
32740 | ) |
32741 | { |
32742 | D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); |
32743 | _res = _PyPegen_dummy_name(p, name_var, string_var); |
32744 | goto done; |
32745 | } |
32746 | p->mark = _mark; |
32747 | D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', |
32748 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME STRING")); |
32749 | } |
32750 | { // SOFT_KEYWORD |
32751 | if (p->error_indicator) { Branch (32751:13): [True: 0, False: 2.61k]
|
32752 | p->level--; |
32753 | return NULL; |
32754 | } |
32755 | D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); |
32756 | expr_ty soft_keyword_var; |
32757 | if ( |
32758 | (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD Branch (32758:13): [True: 31, False: 2.58k]
|
32759 | ) |
32760 | { |
32761 | D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); |
32762 | _res = soft_keyword_var; |
32763 | goto done; |
32764 | } |
32765 | p->mark = _mark; |
32766 | D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', |
32767 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "SOFT_KEYWORD")); |
32768 | } |
32769 | _res = NULL; |
32770 | done: |
32771 | p->level--; |
32772 | return _res; |
32773 | } |
32774 | |
32775 | // _tmp_148: 'else' | ':' |
32776 | static void * |
32777 | _tmp_148_rule(Parser *p) |
32778 | { |
32779 | if (p->level++ == MAXSTACK) { Branch (32779:9): [True: 0, False: 7]
|
32780 | p->error_indicator = 1; |
32781 | PyErr_NoMemory(); |
32782 | } |
32783 | if (p->error_indicator) { Branch (32783:9): [True: 0, False: 7]
|
32784 | p->level--; |
32785 | return NULL; |
32786 | } |
32787 | void * _res = NULL; |
32788 | int _mark = p->mark; |
32789 | { // 'else' |
32790 | if (p->error_indicator) { |
32791 | p->level--; |
32792 | return NULL; |
32793 | } |
32794 | D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); |
32795 | Token * _keyword; |
32796 | if ( |
32797 | (_keyword = _PyPegen_expect_token(p, 637)) // token='else' |
32798 | ) |
32799 | { |
32800 | D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); |
32801 | _res = _keyword; |
32802 | goto done; |
32803 | } |
32804 | p->mark = _mark; |
32805 | D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', |
32806 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'")); |
32807 | } |
32808 | { // ':' |
32809 | if (p->error_indicator) { |
32810 | p->level--; |
32811 | return NULL; |
32812 | } |
32813 | D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); |
32814 | Token * _literal; |
32815 | if ( |
32816 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
32817 | ) |
32818 | { |
32819 | D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); |
32820 | _res = _literal; |
32821 | goto done; |
32822 | } |
32823 | p->mark = _mark; |
32824 | D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', |
32825 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); |
32826 | } |
32827 | _res = NULL; |
32828 | done: |
32829 | p->level--; |
32830 | return _res; |
32831 | } |
32832 | |
32833 | // _tmp_149: '=' | ':=' |
32834 | static void * |
32835 | _tmp_149_rule(Parser *p) |
32836 | { |
32837 | if (p->level++ == MAXSTACK) { Branch (32837:9): [True: 0, False: 11]
|
32838 | p->error_indicator = 1; |
32839 | PyErr_NoMemory(); |
32840 | } |
32841 | if (p->error_indicator) { Branch (32841:9): [True: 0, False: 11]
|
32842 | p->level--; |
32843 | return NULL; |
32844 | } |
32845 | void * _res = NULL; |
32846 | int _mark = p->mark; |
32847 | { // '=' |
32848 | if (p->error_indicator) { |
32849 | p->level--; |
32850 | return NULL; |
32851 | } |
32852 | D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); |
32853 | Token * _literal; |
32854 | if ( |
32855 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' |
32856 | ) |
32857 | { |
32858 | D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); |
32859 | _res = _literal; |
32860 | goto done; |
32861 | } |
32862 | p->mark = _mark; |
32863 | D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', |
32864 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); |
32865 | } |
32866 | { // ':=' |
32867 | if (p->error_indicator) { |
32868 | p->level--; |
32869 | return NULL; |
32870 | } |
32871 | D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); |
32872 | Token * _literal; |
32873 | if ( |
32874 | (_literal = _PyPegen_expect_token(p, 53)) // token=':=' |
32875 | ) |
32876 | { |
32877 | D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); |
32878 | _res = _literal; |
32879 | goto done; |
32880 | } |
32881 | p->mark = _mark; |
32882 | D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', |
32883 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); |
32884 | } |
32885 | _res = NULL; |
32886 | done: |
32887 | p->level--; |
32888 | return _res; |
32889 | } |
32890 | |
32891 | // _tmp_150: list | tuple | genexp | 'True' | 'None' | 'False' |
32892 | static void * |
32893 | _tmp_150_rule(Parser *p) |
32894 | { |
32895 | if (p->level++ == MAXSTACK) { Branch (32895:9): [True: 0, False: 1.22k]
|
32896 | p->error_indicator = 1; |
32897 | PyErr_NoMemory(); |
32898 | } |
32899 | if (p->error_indicator) { Branch (32899:9): [True: 0, False: 1.22k]
|
32900 | p->level--; |
32901 | return NULL; |
32902 | } |
32903 | void * _res = NULL; |
32904 | int _mark = p->mark; |
32905 | { // list |
32906 | if (p->error_indicator) { Branch (32906:13): [True: 0, False: 1.22k]
|
32907 | p->level--; |
32908 | return NULL; |
32909 | } |
32910 | D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); |
32911 | expr_ty list_var; |
32912 | if ( |
32913 | (list_var = list_rule(p)) // list Branch (32913:13): [True: 5, False: 1.21k]
|
32914 | ) |
32915 | { |
32916 | D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); |
32917 | _res = list_var; |
32918 | goto done; |
32919 | } |
32920 | p->mark = _mark; |
32921 | D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', |
32922 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); |
32923 | } |
32924 | { // tuple |
32925 | if (p->error_indicator) { Branch (32925:13): [True: 0, False: 1.21k]
|
32926 | p->level--; |
32927 | return NULL; |
32928 | } |
32929 | D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); |
32930 | expr_ty tuple_var; |
32931 | if ( |
32932 | (tuple_var = tuple_rule(p)) // tuple Branch (32932:13): [True: 17, False: 1.20k]
|
32933 | ) |
32934 | { |
32935 | D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); |
32936 | _res = tuple_var; |
32937 | goto done; |
32938 | } |
32939 | p->mark = _mark; |
32940 | D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', |
32941 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); |
32942 | } |
32943 | { // genexp |
32944 | if (p->error_indicator) { Branch (32944:13): [True: 0, False: 1.20k]
|
32945 | p->level--; |
32946 | return NULL; |
32947 | } |
32948 | D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); |
32949 | expr_ty genexp_var; |
32950 | if ( |
32951 | (genexp_var = genexp_rule(p)) // genexp Branch (32951:13): [True: 4, False: 1.19k]
|
32952 | ) |
32953 | { |
32954 | D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); |
32955 | _res = genexp_var; |
32956 | goto done; |
32957 | } |
32958 | p->mark = _mark; |
32959 | D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', |
32960 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); |
32961 | } |
32962 | { // 'True' |
32963 | if (p->error_indicator) { Branch (32963:13): [True: 0, False: 1.19k]
|
32964 | p->level--; |
32965 | return NULL; |
32966 | } |
32967 | D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); |
32968 | Token * _keyword; |
32969 | if ( |
32970 | (_keyword = _PyPegen_expect_token(p, 600)) // token='True' Branch (32970:13): [True: 25, False: 1.17k]
|
32971 | ) |
32972 | { |
32973 | D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); |
32974 | _res = _keyword; |
32975 | goto done; |
32976 | } |
32977 | p->mark = _mark; |
32978 | D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', |
32979 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); |
32980 | } |
32981 | { // 'None' |
32982 | if (p->error_indicator) { Branch (32982:13): [True: 0, False: 1.17k]
|
32983 | p->level--; |
32984 | return NULL; |
32985 | } |
32986 | D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); |
32987 | Token * _keyword; |
32988 | if ( |
32989 | (_keyword = _PyPegen_expect_token(p, 601)) // token='None' Branch (32989:13): [True: 12, False: 1.16k]
|
32990 | ) |
32991 | { |
32992 | D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); |
32993 | _res = _keyword; |
32994 | goto done; |
32995 | } |
32996 | p->mark = _mark; |
32997 | D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', |
32998 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); |
32999 | } |
33000 | { // 'False' |
33001 | if (p->error_indicator) { Branch (33001:13): [True: 0, False: 1.16k]
|
33002 | p->level--; |
33003 | return NULL; |
33004 | } |
33005 | D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); |
33006 | Token * _keyword; |
33007 | if ( |
33008 | (_keyword = _PyPegen_expect_token(p, 602)) // token='False' Branch (33008:13): [True: 1, False: 1.15k]
|
33009 | ) |
33010 | { |
33011 | D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); |
33012 | _res = _keyword; |
33013 | goto done; |
33014 | } |
33015 | p->mark = _mark; |
33016 | D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', |
33017 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); |
33018 | } |
33019 | _res = NULL; |
33020 | done: |
33021 | p->level--; |
33022 | return _res; |
33023 | } |
33024 | |
33025 | // _tmp_151: '=' | ':=' |
33026 | static void * |
33027 | _tmp_151_rule(Parser *p) |
33028 | { |
33029 | if (p->level++ == MAXSTACK) { Branch (33029:9): [True: 0, False: 31]
|
33030 | p->error_indicator = 1; |
33031 | PyErr_NoMemory(); |
33032 | } |
33033 | if (p->error_indicator) { Branch (33033:9): [True: 0, False: 31]
|
33034 | p->level--; |
33035 | return NULL; |
33036 | } |
33037 | void * _res = NULL; |
33038 | int _mark = p->mark; |
33039 | { // '=' |
33040 | if (p->error_indicator) { |
33041 | p->level--; |
33042 | return NULL; |
33043 | } |
33044 | D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); |
33045 | Token * _literal; |
33046 | if ( |
33047 | (_literal = _PyPegen_expect_token(p, 22)) // token='=' |
33048 | ) |
33049 | { |
33050 | D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); |
33051 | _res = _literal; |
33052 | goto done; |
33053 | } |
33054 | p->mark = _mark; |
33055 | D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', |
33056 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); |
33057 | } |
33058 | { // ':=' |
33059 | if (p->error_indicator) { |
33060 | p->level--; |
33061 | return NULL; |
33062 | } |
33063 | D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); |
33064 | Token * _literal; |
33065 | if ( |
33066 | (_literal = _PyPegen_expect_token(p, 53)) // token=':=' |
33067 | ) |
33068 | { |
33069 | D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); |
33070 | _res = _literal; |
33071 | goto done; |
33072 | } |
33073 | p->mark = _mark; |
33074 | D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', |
33075 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); |
33076 | } |
33077 | _res = NULL; |
33078 | done: |
33079 | p->level--; |
33080 | return _res; |
33081 | } |
33082 | |
33083 | // _loop0_152: star_named_expressions |
33084 | static asdl_seq * |
33085 | _loop0_152_rule(Parser *p) |
33086 | { |
33087 | if (p->level++ == MAXSTACK) { Branch (33087:9): [True: 0, False: 5]
|
33088 | p->error_indicator = 1; |
33089 | PyErr_NoMemory(); |
33090 | } |
33091 | if (p->error_indicator) { Branch (33091:9): [True: 0, False: 5]
|
33092 | p->level--; |
33093 | return NULL; |
33094 | } |
33095 | void *_res = NULL; |
33096 | int _mark = p->mark; |
33097 | int _start_mark = p->mark; |
33098 | void **_children = PyMem_Malloc(sizeof(void *)); |
33099 | if (!_children) { Branch (33099:9): [True: 0, False: 5]
|
33100 | p->error_indicator = 1; |
33101 | PyErr_NoMemory(); |
33102 | p->level--; |
33103 | return NULL; |
33104 | } |
33105 | Py_ssize_t _children_capacity = 1; |
33106 | Py_ssize_t _n = 0; |
33107 | { // star_named_expressions |
33108 | if (p->error_indicator) { |
33109 | p->level--; |
33110 | return NULL; |
33111 | } |
33112 | D(fprintf(stderr, "%*c> _loop0_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); |
33113 | asdl_expr_seq* star_named_expressions_var; |
33114 | while ( |
33115 | (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions |
33116 | ) |
33117 | { |
33118 | _res = star_named_expressions_var; |
33119 | if (_n == _children_capacity) { |
33120 | _children_capacity *= 2; |
33121 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33122 | if (!_new_children) { |
33123 | p->error_indicator = 1; |
33124 | PyErr_NoMemory(); |
33125 | p->level--; |
33126 | return NULL; |
33127 | } |
33128 | _children = _new_children; |
33129 | } |
33130 | _children[_n++] = _res; |
33131 | _mark = p->mark; |
33132 | } |
33133 | p->mark = _mark; |
33134 | D(fprintf(stderr, "%*c%s _loop0_152[%d-%d]: %s failed!\n", p->level, ' ', |
33135 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions")); |
33136 | } |
33137 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33138 | if (!_seq) { Branch (33138:9): [True: 0, False: 5]
|
33139 | PyMem_Free(_children); |
33140 | p->error_indicator = 1; |
33141 | PyErr_NoMemory(); |
33142 | p->level--; |
33143 | return NULL; |
33144 | } |
33145 | for (int i = 0; 5 i < _n; i++3 ) asdl_seq_SET_UNTYPED5 (_seq, i, _children[i]); |
33146 | PyMem_Free(_children); |
33147 | _PyPegen_insert_memo(p, _start_mark, _loop0_152_type, _seq); |
33148 | p->level--; |
33149 | return _seq; |
33150 | } |
33151 | |
33152 | // _loop0_153: (star_targets '=') |
33153 | static asdl_seq * |
33154 | _loop0_153_rule(Parser *p) |
33155 | { |
33156 | if (p->level++ == MAXSTACK) { Branch (33156:9): [True: 0, False: 785]
|
33157 | p->error_indicator = 1; |
33158 | PyErr_NoMemory(); |
33159 | } |
33160 | if (p->error_indicator) { Branch (33160:9): [True: 0, False: 785]
|
33161 | p->level--; |
33162 | return NULL; |
33163 | } |
33164 | void *_res = NULL; |
33165 | int _mark = p->mark; |
33166 | int _start_mark = p->mark; |
33167 | void **_children = PyMem_Malloc(sizeof(void *)); |
33168 | if (!_children) { Branch (33168:9): [True: 0, False: 785]
|
33169 | p->error_indicator = 1; |
33170 | PyErr_NoMemory(); |
33171 | p->level--; |
33172 | return NULL; |
33173 | } |
33174 | Py_ssize_t _children_capacity = 1; |
33175 | Py_ssize_t _n = 0; |
33176 | { // (star_targets '=') |
33177 | if (p->error_indicator) { Branch (33177:13): [True: 0, False: 785]
|
33178 | p->level--; |
33179 | return NULL; |
33180 | } |
33181 | D(fprintf(stderr, "%*c> _loop0_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); |
33182 | void *_tmp_233_var; |
33183 | while ( |
33184 | (_tmp_233_var = _tmp_233_rule(p)) // star_targets '=' Branch (33184:13): [True: 7, False: 785]
|
33185 | ) |
33186 | { |
33187 | _res = _tmp_233_var; |
33188 | if (_n == _children_capacity) { |
33189 | _children_capacity *= 2; |
33190 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33191 | if (!_new_children) { |
33192 | p->error_indicator = 1; |
33193 | PyErr_NoMemory(); |
33194 | p->level--; |
33195 | return NULL; |
33196 | } |
33197 | _children = _new_children; |
33198 | } |
33199 | _children[_n++] = _res; |
33200 | _mark = p->mark; |
33201 | } |
33202 | p->mark = _mark; |
33203 | D(fprintf(stderr, "%*c%s _loop0_153[%d-%d]: %s failed!\n", p->level, ' ', |
33204 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); |
33205 | } |
33206 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33207 | if (!_seq) { Branch (33207:9): [True: 0, False: 785]
|
33208 | PyMem_Free(_children); |
33209 | p->error_indicator = 1; |
33210 | PyErr_NoMemory(); |
33211 | p->level--; |
33212 | return NULL; |
33213 | } |
33214 | for (int i = 0; 785 i < _n; i++7 ) asdl_seq_SET_UNTYPED785 (_seq, i, _children[i]); Branch (33214:21): [True: 7, False: 785]
|
33215 | PyMem_Free(_children); |
33216 | _PyPegen_insert_memo(p, _start_mark, _loop0_153_type, _seq); |
33217 | p->level--; |
33218 | return _seq; |
33219 | } |
33220 | |
33221 | // _loop0_154: (star_targets '=') |
33222 | static asdl_seq * |
33223 | _loop0_154_rule(Parser *p) |
33224 | { |
33225 | if (p->level++ == MAXSTACK) { Branch (33225:9): [True: 0, False: 763]
|
33226 | p->error_indicator = 1; |
33227 | PyErr_NoMemory(); |
33228 | } |
33229 | if (p->error_indicator) { Branch (33229:9): [True: 0, False: 763]
|
33230 | p->level--; |
33231 | return NULL; |
33232 | } |
33233 | void *_res = NULL; |
33234 | int _mark = p->mark; |
33235 | int _start_mark = p->mark; |
33236 | void **_children = PyMem_Malloc(sizeof(void *)); |
33237 | if (!_children) { Branch (33237:9): [True: 0, False: 763]
|
33238 | p->error_indicator = 1; |
33239 | PyErr_NoMemory(); |
33240 | p->level--; |
33241 | return NULL; |
33242 | } |
33243 | Py_ssize_t _children_capacity = 1; |
33244 | Py_ssize_t _n = 0; |
33245 | { // (star_targets '=') |
33246 | if (p->error_indicator) { Branch (33246:13): [True: 0, False: 763]
|
33247 | p->level--; |
33248 | return NULL; |
33249 | } |
33250 | D(fprintf(stderr, "%*c> _loop0_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); |
33251 | void *_tmp_234_var; |
33252 | while ( |
33253 | (_tmp_234_var = _tmp_234_rule(p)) // star_targets '=' Branch (33253:13): [True: 5, False: 763]
|
33254 | ) |
33255 | { |
33256 | _res = _tmp_234_var; |
33257 | if (_n == _children_capacity) { |
33258 | _children_capacity *= 2; |
33259 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33260 | if (!_new_children) { |
33261 | p->error_indicator = 1; |
33262 | PyErr_NoMemory(); |
33263 | p->level--; |
33264 | return NULL; |
33265 | } |
33266 | _children = _new_children; |
33267 | } |
33268 | _children[_n++] = _res; |
33269 | _mark = p->mark; |
33270 | } |
33271 | p->mark = _mark; |
33272 | D(fprintf(stderr, "%*c%s _loop0_154[%d-%d]: %s failed!\n", p->level, ' ', |
33273 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); |
33274 | } |
33275 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33276 | if (!_seq) { Branch (33276:9): [True: 0, False: 763]
|
33277 | PyMem_Free(_children); |
33278 | p->error_indicator = 1; |
33279 | PyErr_NoMemory(); |
33280 | p->level--; |
33281 | return NULL; |
33282 | } |
33283 | for (int i = 0; 763 i < _n; i++5 ) asdl_seq_SET_UNTYPED763 (_seq, i, _children[i]); Branch (33283:21): [True: 5, False: 763]
|
33284 | PyMem_Free(_children); |
33285 | _PyPegen_insert_memo(p, _start_mark, _loop0_154_type, _seq); |
33286 | p->level--; |
33287 | return _seq; |
33288 | } |
33289 | |
33290 | // _tmp_155: yield_expr | star_expressions |
33291 | static void * |
33292 | _tmp_155_rule(Parser *p) |
33293 | { |
33294 | if (p->level++ == MAXSTACK) { Branch (33294:9): [True: 0, False: 14]
|
33295 | p->error_indicator = 1; |
33296 | PyErr_NoMemory(); |
33297 | } |
33298 | if (p->error_indicator) { Branch (33298:9): [True: 0, False: 14]
|
33299 | p->level--; |
33300 | return NULL; |
33301 | } |
33302 | void * _res = NULL; |
33303 | int _mark = p->mark; |
33304 | { // yield_expr |
33305 | if (p->error_indicator) { |
33306 | p->level--; |
33307 | return NULL; |
33308 | } |
33309 | D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
33310 | expr_ty yield_expr_var; |
33311 | if ( |
33312 | (yield_expr_var = yield_expr_rule(p)) // yield_expr |
33313 | ) |
33314 | { |
33315 | D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); |
33316 | _res = yield_expr_var; |
33317 | goto done; |
33318 | } |
33319 | p->mark = _mark; |
33320 | D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', |
33321 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); |
33322 | } |
33323 | { // star_expressions |
33324 | if (p->error_indicator) { |
33325 | p->level--; |
33326 | return NULL; |
33327 | } |
33328 | D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
33329 | expr_ty star_expressions_var; |
33330 | if ( |
33331 | (star_expressions_var = star_expressions_rule(p)) // star_expressions |
33332 | ) |
33333 | { |
33334 | D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); |
33335 | _res = star_expressions_var; |
33336 | goto done; |
33337 | } |
33338 | p->mark = _mark; |
33339 | D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', |
33340 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); |
33341 | } |
33342 | _res = NULL; |
33343 | done: |
33344 | p->level--; |
33345 | return _res; |
33346 | } |
33347 | |
33348 | // _tmp_156: '[' | '(' | '{' |
33349 | static void * |
33350 | _tmp_156_rule(Parser *p) |
33351 | { |
33352 | if (p->level++ == MAXSTACK) { Branch (33352:9): [True: 0, False: 2.86k]
|
33353 | p->error_indicator = 1; |
33354 | PyErr_NoMemory(); |
33355 | } |
33356 | if (p->error_indicator) { Branch (33356:9): [True: 0, False: 2.86k]
|
33357 | p->level--; |
33358 | return NULL; |
33359 | } |
33360 | void * _res = NULL; |
33361 | int _mark = p->mark; |
33362 | { // '[' |
33363 | if (p->error_indicator) { Branch (33363:13): [True: 0, False: 2.86k]
|
33364 | p->level--; |
33365 | return NULL; |
33366 | } |
33367 | D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); |
33368 | Token * _literal; |
33369 | if ( |
33370 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (33370:13): [True: 71, False: 2.79k]
|
33371 | ) |
33372 | { |
33373 | D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); |
33374 | _res = _literal; |
33375 | goto done; |
33376 | } |
33377 | p->mark = _mark; |
33378 | D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', |
33379 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); |
33380 | } |
33381 | { // '(' |
33382 | if (p->error_indicator) { Branch (33382:13): [True: 0, False: 2.79k]
|
33383 | p->level--; |
33384 | return NULL; |
33385 | } |
33386 | D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); |
33387 | Token * _literal; |
33388 | if ( |
33389 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' Branch (33389:13): [True: 268, False: 2.52k]
|
33390 | ) |
33391 | { |
33392 | D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); |
33393 | _res = _literal; |
33394 | goto done; |
33395 | } |
33396 | p->mark = _mark; |
33397 | D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', |
33398 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); |
33399 | } |
33400 | { // '{' |
33401 | if (p->error_indicator) { Branch (33401:13): [True: 0, False: 2.52k]
|
33402 | p->level--; |
33403 | return NULL; |
33404 | } |
33405 | D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); |
33406 | Token * _literal; |
33407 | if ( |
33408 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (33408:13): [True: 79, False: 2.44k]
|
33409 | ) |
33410 | { |
33411 | D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); |
33412 | _res = _literal; |
33413 | goto done; |
33414 | } |
33415 | p->mark = _mark; |
33416 | D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', |
33417 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); |
33418 | } |
33419 | _res = NULL; |
33420 | done: |
33421 | p->level--; |
33422 | return _res; |
33423 | } |
33424 | |
33425 | // _tmp_157: '[' | '{' |
33426 | static void * |
33427 | _tmp_157_rule(Parser *p) |
33428 | { |
33429 | if (p->level++ == MAXSTACK) { Branch (33429:9): [True: 0, False: 2.86k]
|
33430 | p->error_indicator = 1; |
33431 | PyErr_NoMemory(); |
33432 | } |
33433 | if (p->error_indicator) { Branch (33433:9): [True: 0, False: 2.86k]
|
33434 | p->level--; |
33435 | return NULL; |
33436 | } |
33437 | void * _res = NULL; |
33438 | int _mark = p->mark; |
33439 | { // '[' |
33440 | if (p->error_indicator) { Branch (33440:13): [True: 0, False: 2.86k]
|
33441 | p->level--; |
33442 | return NULL; |
33443 | } |
33444 | D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); |
33445 | Token * _literal; |
33446 | if ( |
33447 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (33447:13): [True: 66, False: 2.79k]
|
33448 | ) |
33449 | { |
33450 | D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); |
33451 | _res = _literal; |
33452 | goto done; |
33453 | } |
33454 | p->mark = _mark; |
33455 | D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', |
33456 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); |
33457 | } |
33458 | { // '{' |
33459 | if (p->error_indicator) { Branch (33459:13): [True: 0, False: 2.79k]
|
33460 | p->level--; |
33461 | return NULL; |
33462 | } |
33463 | D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); |
33464 | Token * _literal; |
33465 | if ( |
33466 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (33466:13): [True: 79, False: 2.71k]
|
33467 | ) |
33468 | { |
33469 | D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); |
33470 | _res = _literal; |
33471 | goto done; |
33472 | } |
33473 | p->mark = _mark; |
33474 | D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', |
33475 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); |
33476 | } |
33477 | _res = NULL; |
33478 | done: |
33479 | p->level--; |
33480 | return _res; |
33481 | } |
33482 | |
33483 | // _tmp_158: '[' | '{' |
33484 | static void * |
33485 | _tmp_158_rule(Parser *p) |
33486 | { |
33487 | if (p->level++ == MAXSTACK) { Branch (33487:9): [True: 0, False: 2.85k]
|
33488 | p->error_indicator = 1; |
33489 | PyErr_NoMemory(); |
33490 | } |
33491 | if (p->error_indicator) { Branch (33491:9): [True: 0, False: 2.85k]
|
33492 | p->level--; |
33493 | return NULL; |
33494 | } |
33495 | void * _res = NULL; |
33496 | int _mark = p->mark; |
33497 | { // '[' |
33498 | if (p->error_indicator) { Branch (33498:13): [True: 0, False: 2.85k]
|
33499 | p->level--; |
33500 | return NULL; |
33501 | } |
33502 | D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); |
33503 | Token * _literal; |
33504 | if ( |
33505 | (_literal = _PyPegen_expect_token(p, 9)) // token='[' Branch (33505:13): [True: 63, False: 2.79k]
|
33506 | ) |
33507 | { |
33508 | D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); |
33509 | _res = _literal; |
33510 | goto done; |
33511 | } |
33512 | p->mark = _mark; |
33513 | D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', |
33514 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); |
33515 | } |
33516 | { // '{' |
33517 | if (p->error_indicator) { Branch (33517:13): [True: 0, False: 2.79k]
|
33518 | p->level--; |
33519 | return NULL; |
33520 | } |
33521 | D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); |
33522 | Token * _literal; |
33523 | if ( |
33524 | (_literal = _PyPegen_expect_token(p, 25)) // token='{' Branch (33524:13): [True: 78, False: 2.71k]
|
33525 | ) |
33526 | { |
33527 | D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); |
33528 | _res = _literal; |
33529 | goto done; |
33530 | } |
33531 | p->mark = _mark; |
33532 | D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', |
33533 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); |
33534 | } |
33535 | _res = NULL; |
33536 | done: |
33537 | p->level--; |
33538 | return _res; |
33539 | } |
33540 | |
33541 | // _loop0_159: param_no_default |
33542 | static asdl_seq * |
33543 | _loop0_159_rule(Parser *p) |
33544 | { |
33545 | if (p->level++ == MAXSTACK) { Branch (33545:9): [True: 0, False: 300]
|
33546 | p->error_indicator = 1; |
33547 | PyErr_NoMemory(); |
33548 | } |
33549 | if (p->error_indicator) { Branch (33549:9): [True: 0, False: 300]
|
33550 | p->level--; |
33551 | return NULL; |
33552 | } |
33553 | void *_res = NULL; |
33554 | int _mark = p->mark; |
33555 | int _start_mark = p->mark; |
33556 | void **_children = PyMem_Malloc(sizeof(void *)); |
33557 | if (!_children) { Branch (33557:9): [True: 0, False: 300]
|
33558 | p->error_indicator = 1; |
33559 | PyErr_NoMemory(); |
33560 | p->level--; |
33561 | return NULL; |
33562 | } |
33563 | Py_ssize_t _children_capacity = 1; |
33564 | Py_ssize_t _n = 0; |
33565 | { // param_no_default |
33566 | if (p->error_indicator) { Branch (33566:13): [True: 0, False: 300]
|
33567 | p->level--; |
33568 | return NULL; |
33569 | } |
33570 | D(fprintf(stderr, "%*c> _loop0_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
33571 | arg_ty param_no_default_var; |
33572 | while ( |
33573 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (33573:13): [True: 65, False: 300]
|
33574 | ) |
33575 | { |
33576 | _res = param_no_default_var; |
33577 | if (_n == _children_capacity) { |
33578 | _children_capacity *= 2; |
33579 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33580 | if (!_new_children) { |
33581 | p->error_indicator = 1; |
33582 | PyErr_NoMemory(); |
33583 | p->level--; |
33584 | return NULL; |
33585 | } |
33586 | _children = _new_children; |
33587 | } |
33588 | _children[_n++] = _res; |
33589 | _mark = p->mark; |
33590 | } |
33591 | p->mark = _mark; |
33592 | D(fprintf(stderr, "%*c%s _loop0_159[%d-%d]: %s failed!\n", p->level, ' ', |
33593 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
33594 | } |
33595 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33596 | if (!_seq) { Branch (33596:9): [True: 0, False: 300]
|
33597 | PyMem_Free(_children); |
33598 | p->error_indicator = 1; |
33599 | PyErr_NoMemory(); |
33600 | p->level--; |
33601 | return NULL; |
33602 | } |
33603 | for (int i = 0; 300 i < _n; i++65 ) asdl_seq_SET_UNTYPED300 (_seq, i, _children[i]); Branch (33603:21): [True: 65, False: 300]
|
33604 | PyMem_Free(_children); |
33605 | _PyPegen_insert_memo(p, _start_mark, _loop0_159_type, _seq); |
33606 | p->level--; |
33607 | return _seq; |
33608 | } |
33609 | |
33610 | // _loop0_160: param_no_default |
33611 | static asdl_seq * |
33612 | _loop0_160_rule(Parser *p) |
33613 | { |
33614 | if (p->level++ == MAXSTACK) { Branch (33614:9): [True: 0, False: 282]
|
33615 | p->error_indicator = 1; |
33616 | PyErr_NoMemory(); |
33617 | } |
33618 | if (p->error_indicator) { Branch (33618:9): [True: 0, False: 282]
|
33619 | p->level--; |
33620 | return NULL; |
33621 | } |
33622 | void *_res = NULL; |
33623 | int _mark = p->mark; |
33624 | int _start_mark = p->mark; |
33625 | void **_children = PyMem_Malloc(sizeof(void *)); |
33626 | if (!_children) { Branch (33626:9): [True: 0, False: 282]
|
33627 | p->error_indicator = 1; |
33628 | PyErr_NoMemory(); |
33629 | p->level--; |
33630 | return NULL; |
33631 | } |
33632 | Py_ssize_t _children_capacity = 1; |
33633 | Py_ssize_t _n = 0; |
33634 | { // param_no_default |
33635 | if (p->error_indicator) { Branch (33635:13): [True: 0, False: 282]
|
33636 | p->level--; |
33637 | return NULL; |
33638 | } |
33639 | D(fprintf(stderr, "%*c> _loop0_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
33640 | arg_ty param_no_default_var; |
33641 | while ( |
33642 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (33642:13): [True: 60, False: 282]
|
33643 | ) |
33644 | { |
33645 | _res = param_no_default_var; |
33646 | if (_n == _children_capacity) { |
33647 | _children_capacity *= 2; |
33648 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33649 | if (!_new_children) { |
33650 | p->error_indicator = 1; |
33651 | PyErr_NoMemory(); |
33652 | p->level--; |
33653 | return NULL; |
33654 | } |
33655 | _children = _new_children; |
33656 | } |
33657 | _children[_n++] = _res; |
33658 | _mark = p->mark; |
33659 | } |
33660 | p->mark = _mark; |
33661 | D(fprintf(stderr, "%*c%s _loop0_160[%d-%d]: %s failed!\n", p->level, ' ', |
33662 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
33663 | } |
33664 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33665 | if (!_seq) { Branch (33665:9): [True: 0, False: 282]
|
33666 | PyMem_Free(_children); |
33667 | p->error_indicator = 1; |
33668 | PyErr_NoMemory(); |
33669 | p->level--; |
33670 | return NULL; |
33671 | } |
33672 | for (int i = 0; 282 i < _n; i++60 ) asdl_seq_SET_UNTYPED282 (_seq, i, _children[i]); Branch (33672:21): [True: 60, False: 282]
|
33673 | PyMem_Free(_children); |
33674 | _PyPegen_insert_memo(p, _start_mark, _loop0_160_type, _seq); |
33675 | p->level--; |
33676 | return _seq; |
33677 | } |
33678 | |
33679 | // _loop1_161: param_no_default |
33680 | static asdl_seq * |
33681 | _loop1_161_rule(Parser *p) |
33682 | { |
33683 | if (p->level++ == MAXSTACK) { Branch (33683:9): [True: 0, False: 4]
|
33684 | p->error_indicator = 1; |
33685 | PyErr_NoMemory(); |
33686 | } |
33687 | if (p->error_indicator) { Branch (33687:9): [True: 0, False: 4]
|
33688 | p->level--; |
33689 | return NULL; |
33690 | } |
33691 | void *_res = NULL; |
33692 | int _mark = p->mark; |
33693 | int _start_mark = p->mark; |
33694 | void **_children = PyMem_Malloc(sizeof(void *)); |
33695 | if (!_children) { Branch (33695:9): [True: 0, False: 4]
|
33696 | p->error_indicator = 1; |
33697 | PyErr_NoMemory(); |
33698 | p->level--; |
33699 | return NULL; |
33700 | } |
33701 | Py_ssize_t _children_capacity = 1; |
33702 | Py_ssize_t _n = 0; |
33703 | { // param_no_default |
33704 | if (p->error_indicator) { |
33705 | p->level--; |
33706 | return NULL; |
33707 | } |
33708 | D(fprintf(stderr, "%*c> _loop1_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
33709 | arg_ty param_no_default_var; |
33710 | while ( |
33711 | (param_no_default_var = param_no_default_rule(p)) // param_no_default |
33712 | ) |
33713 | { |
33714 | _res = param_no_default_var; |
33715 | if (_n == _children_capacity) { |
33716 | _children_capacity *= 2; |
33717 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33718 | if (!_new_children) { |
33719 | p->error_indicator = 1; |
33720 | PyErr_NoMemory(); |
33721 | p->level--; |
33722 | return NULL; |
33723 | } |
33724 | _children = _new_children; |
33725 | } |
33726 | _children[_n++] = _res; |
33727 | _mark = p->mark; |
33728 | } |
33729 | p->mark = _mark; |
33730 | D(fprintf(stderr, "%*c%s _loop1_161[%d-%d]: %s failed!\n", p->level, ' ', |
33731 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
33732 | } |
33733 | if (_n == 0 || p->error_indicator) { Branch (33733:9): [True: 0, False: 4]
Branch (33733:20): [True: 0, False: 4]
|
33734 | PyMem_Free(_children); |
33735 | p->level--; |
33736 | return NULL; |
33737 | } |
33738 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33739 | if (!_seq) { Branch (33739:9): [True: 0, False: 4]
|
33740 | PyMem_Free(_children); |
33741 | p->error_indicator = 1; |
33742 | PyErr_NoMemory(); |
33743 | p->level--; |
33744 | return NULL; |
33745 | } |
33746 | for (int i = 0; 4 i < _n; i++12 ) asdl_seq_SET_UNTYPED4 (_seq, i, _children[i]); |
33747 | PyMem_Free(_children); |
33748 | _PyPegen_insert_memo(p, _start_mark, _loop1_161_type, _seq); |
33749 | p->level--; |
33750 | return _seq; |
33751 | } |
33752 | |
33753 | // _tmp_162: slash_no_default | slash_with_default |
33754 | static void * |
33755 | _tmp_162_rule(Parser *p) |
33756 | { |
33757 | if (p->level++ == MAXSTACK) { Branch (33757:9): [True: 0, False: 273]
|
33758 | p->error_indicator = 1; |
33759 | PyErr_NoMemory(); |
33760 | } |
33761 | if (p->error_indicator) { Branch (33761:9): [True: 0, False: 273]
|
33762 | p->level--; |
33763 | return NULL; |
33764 | } |
33765 | void * _res = NULL; |
33766 | int _mark = p->mark; |
33767 | { // slash_no_default |
33768 | if (p->error_indicator) { Branch (33768:13): [True: 0, False: 273]
|
33769 | p->level--; |
33770 | return NULL; |
33771 | } |
33772 | D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); |
33773 | asdl_arg_seq* slash_no_default_var; |
33774 | if ( |
33775 | (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default Branch (33775:13): [True: 12, False: 261]
|
33776 | ) |
33777 | { |
33778 | D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); |
33779 | _res = slash_no_default_var; |
33780 | goto done; |
33781 | } |
33782 | p->mark = _mark; |
33783 | D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', |
33784 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); |
33785 | } |
33786 | { // slash_with_default |
33787 | if (p->error_indicator) { Branch (33787:13): [True: 0, False: 261]
|
33788 | p->level--; |
33789 | return NULL; |
33790 | } |
33791 | D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); |
33792 | SlashWithDefault* slash_with_default_var; |
33793 | if ( |
33794 | (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default Branch (33794:13): [True: 2, False: 259]
|
33795 | ) |
33796 | { |
33797 | D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); |
33798 | _res = slash_with_default_var; |
33799 | goto done; |
33800 | } |
33801 | p->mark = _mark; |
33802 | D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', |
33803 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); |
33804 | } |
33805 | _res = NULL; |
33806 | done: |
33807 | p->level--; |
33808 | return _res; |
33809 | } |
33810 | |
33811 | // _loop0_163: param_maybe_default |
33812 | static asdl_seq * |
33813 | _loop0_163_rule(Parser *p) |
33814 | { |
33815 | if (p->level++ == MAXSTACK) { Branch (33815:9): [True: 0, False: 14]
|
33816 | p->error_indicator = 1; |
33817 | PyErr_NoMemory(); |
33818 | } |
33819 | if (p->error_indicator) { Branch (33819:9): [True: 0, False: 14]
|
33820 | p->level--; |
33821 | return NULL; |
33822 | } |
33823 | void *_res = NULL; |
33824 | int _mark = p->mark; |
33825 | int _start_mark = p->mark; |
33826 | void **_children = PyMem_Malloc(sizeof(void *)); |
33827 | if (!_children) { Branch (33827:9): [True: 0, False: 14]
|
33828 | p->error_indicator = 1; |
33829 | PyErr_NoMemory(); |
33830 | p->level--; |
33831 | return NULL; |
33832 | } |
33833 | Py_ssize_t _children_capacity = 1; |
33834 | Py_ssize_t _n = 0; |
33835 | { // param_maybe_default |
33836 | if (p->error_indicator) { |
33837 | p->level--; |
33838 | return NULL; |
33839 | } |
33840 | D(fprintf(stderr, "%*c> _loop0_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
33841 | NameDefaultPair* param_maybe_default_var; |
33842 | while ( |
33843 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default Branch (33843:13): [True: 11, False: 14]
|
33844 | ) |
33845 | { |
33846 | _res = param_maybe_default_var; |
33847 | if (_n == _children_capacity) { |
33848 | _children_capacity *= 2; |
33849 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33850 | if (!_new_children) { |
33851 | p->error_indicator = 1; |
33852 | PyErr_NoMemory(); |
33853 | p->level--; |
33854 | return NULL; |
33855 | } |
33856 | _children = _new_children; |
33857 | } |
33858 | _children[_n++] = _res; |
33859 | _mark = p->mark; |
33860 | } |
33861 | p->mark = _mark; |
33862 | D(fprintf(stderr, "%*c%s _loop0_163[%d-%d]: %s failed!\n", p->level, ' ', |
33863 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
33864 | } |
33865 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33866 | if (!_seq) { Branch (33866:9): [True: 0, False: 14]
|
33867 | PyMem_Free(_children); |
33868 | p->error_indicator = 1; |
33869 | PyErr_NoMemory(); |
33870 | p->level--; |
33871 | return NULL; |
33872 | } |
33873 | for (int i = 0; 14 i < _n; i++11 ) asdl_seq_SET_UNTYPED14 (_seq, i, _children[i]); Branch (33873:21): [True: 11, False: 14]
|
33874 | PyMem_Free(_children); |
33875 | _PyPegen_insert_memo(p, _start_mark, _loop0_163_type, _seq); |
33876 | p->level--; |
33877 | return _seq; |
33878 | } |
33879 | |
33880 | // _tmp_164: slash_no_default | slash_with_default |
33881 | static void * |
33882 | _tmp_164_rule(Parser *p) |
33883 | { |
33884 | if (p->level++ == MAXSTACK) { Branch (33884:9): [True: 0, False: 263]
|
33885 | p->error_indicator = 1; |
33886 | PyErr_NoMemory(); |
33887 | } |
33888 | if (p->error_indicator) { Branch (33888:9): [True: 0, False: 263]
|
33889 | p->level--; |
33890 | return NULL; |
33891 | } |
33892 | void * _res = NULL; |
33893 | int _mark = p->mark; |
33894 | { // slash_no_default |
33895 | if (p->error_indicator) { Branch (33895:13): [True: 0, False: 263]
|
33896 | p->level--; |
33897 | return NULL; |
33898 | } |
33899 | D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); |
33900 | asdl_arg_seq* slash_no_default_var; |
33901 | if ( |
33902 | (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default Branch (33902:13): [True: 3, False: 260]
|
33903 | ) |
33904 | { |
33905 | D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); |
33906 | _res = slash_no_default_var; |
33907 | goto done; |
33908 | } |
33909 | p->mark = _mark; |
33910 | D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', |
33911 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); |
33912 | } |
33913 | { // slash_with_default |
33914 | if (p->error_indicator) { Branch (33914:13): [True: 0, False: 260]
|
33915 | p->level--; |
33916 | return NULL; |
33917 | } |
33918 | D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); |
33919 | SlashWithDefault* slash_with_default_var; |
33920 | if ( |
33921 | (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default Branch (33921:13): [True: 1, False: 259]
|
33922 | ) |
33923 | { |
33924 | D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); |
33925 | _res = slash_with_default_var; |
33926 | goto done; |
33927 | } |
33928 | p->mark = _mark; |
33929 | D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', |
33930 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); |
33931 | } |
33932 | _res = NULL; |
33933 | done: |
33934 | p->level--; |
33935 | return _res; |
33936 | } |
33937 | |
33938 | // _loop0_165: param_maybe_default |
33939 | static asdl_seq * |
33940 | _loop0_165_rule(Parser *p) |
33941 | { |
33942 | if (p->level++ == MAXSTACK) { Branch (33942:9): [True: 0, False: 263]
|
33943 | p->error_indicator = 1; |
33944 | PyErr_NoMemory(); |
33945 | } |
33946 | if (p->error_indicator) { Branch (33946:9): [True: 0, False: 263]
|
33947 | p->level--; |
33948 | return NULL; |
33949 | } |
33950 | void *_res = NULL; |
33951 | int _mark = p->mark; |
33952 | int _start_mark = p->mark; |
33953 | void **_children = PyMem_Malloc(sizeof(void *)); |
33954 | if (!_children) { Branch (33954:9): [True: 0, False: 263]
|
33955 | p->error_indicator = 1; |
33956 | PyErr_NoMemory(); |
33957 | p->level--; |
33958 | return NULL; |
33959 | } |
33960 | Py_ssize_t _children_capacity = 1; |
33961 | Py_ssize_t _n = 0; |
33962 | { // param_maybe_default |
33963 | if (p->error_indicator) { Branch (33963:13): [True: 0, False: 263]
|
33964 | p->level--; |
33965 | return NULL; |
33966 | } |
33967 | D(fprintf(stderr, "%*c> _loop0_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
33968 | NameDefaultPair* param_maybe_default_var; |
33969 | while ( |
33970 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default Branch (33970:13): [True: 49, False: 263]
|
33971 | ) |
33972 | { |
33973 | _res = param_maybe_default_var; |
33974 | if (_n == _children_capacity) { |
33975 | _children_capacity *= 2; |
33976 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
33977 | if (!_new_children) { |
33978 | p->error_indicator = 1; |
33979 | PyErr_NoMemory(); |
33980 | p->level--; |
33981 | return NULL; |
33982 | } |
33983 | _children = _new_children; |
33984 | } |
33985 | _children[_n++] = _res; |
33986 | _mark = p->mark; |
33987 | } |
33988 | p->mark = _mark; |
33989 | D(fprintf(stderr, "%*c%s _loop0_165[%d-%d]: %s failed!\n", p->level, ' ', |
33990 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
33991 | } |
33992 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
33993 | if (!_seq) { Branch (33993:9): [True: 0, False: 263]
|
33994 | PyMem_Free(_children); |
33995 | p->error_indicator = 1; |
33996 | PyErr_NoMemory(); |
33997 | p->level--; |
33998 | return NULL; |
33999 | } |
34000 | for (int i = 0; 263 i < _n; i++49 ) asdl_seq_SET_UNTYPED263 (_seq, i, _children[i]); Branch (34000:21): [True: 49, False: 263]
|
34001 | PyMem_Free(_children); |
34002 | _PyPegen_insert_memo(p, _start_mark, _loop0_165_type, _seq); |
34003 | p->level--; |
34004 | return _seq; |
34005 | } |
34006 | |
34007 | // _tmp_166: ',' | param_no_default |
34008 | static void * |
34009 | _tmp_166_rule(Parser *p) |
34010 | { |
34011 | if (p->level++ == MAXSTACK) { Branch (34011:9): [True: 0, False: 41]
|
34012 | p->error_indicator = 1; |
34013 | PyErr_NoMemory(); |
34014 | } |
34015 | if (p->error_indicator) { Branch (34015:9): [True: 0, False: 41]
|
34016 | p->level--; |
34017 | return NULL; |
34018 | } |
34019 | void * _res = NULL; |
34020 | int _mark = p->mark; |
34021 | { // ',' |
34022 | if (p->error_indicator) { |
34023 | p->level--; |
34024 | return NULL; |
34025 | } |
34026 | D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
34027 | Token * _literal; |
34028 | if ( |
34029 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (34029:13): [True: 15, False: 26]
|
34030 | ) |
34031 | { |
34032 | D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
34033 | _res = _literal; |
34034 | goto done; |
34035 | } |
34036 | p->mark = _mark; |
34037 | D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', |
34038 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
34039 | } |
34040 | { // param_no_default |
34041 | if (p->error_indicator) { |
34042 | p->level--; |
34043 | return NULL; |
34044 | } |
34045 | D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
34046 | arg_ty param_no_default_var; |
34047 | if ( |
34048 | (param_no_default_var = param_no_default_rule(p)) // param_no_default |
34049 | ) |
34050 | { |
34051 | D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
34052 | _res = param_no_default_var; |
34053 | goto done; |
34054 | } |
34055 | p->mark = _mark; |
34056 | D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', |
34057 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
34058 | } |
34059 | _res = NULL; |
34060 | done: |
34061 | p->level--; |
34062 | return _res; |
34063 | } |
34064 | |
34065 | // _loop0_167: param_maybe_default |
34066 | static asdl_seq * |
34067 | _loop0_167_rule(Parser *p) |
34068 | { |
34069 | if (p->level++ == MAXSTACK) { Branch (34069:9): [True: 0, False: 33]
|
34070 | p->error_indicator = 1; |
34071 | PyErr_NoMemory(); |
34072 | } |
34073 | if (p->error_indicator) { Branch (34073:9): [True: 0, False: 33]
|
34074 | p->level--; |
34075 | return NULL; |
34076 | } |
34077 | void *_res = NULL; |
34078 | int _mark = p->mark; |
34079 | int _start_mark = p->mark; |
34080 | void **_children = PyMem_Malloc(sizeof(void *)); |
34081 | if (!_children) { Branch (34081:9): [True: 0, False: 33]
|
34082 | p->error_indicator = 1; |
34083 | PyErr_NoMemory(); |
34084 | p->level--; |
34085 | return NULL; |
34086 | } |
34087 | Py_ssize_t _children_capacity = 1; |
34088 | Py_ssize_t _n = 0; |
34089 | { // param_maybe_default |
34090 | if (p->error_indicator) { |
34091 | p->level--; |
34092 | return NULL; |
34093 | } |
34094 | D(fprintf(stderr, "%*c> _loop0_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
34095 | NameDefaultPair* param_maybe_default_var; |
34096 | while ( |
34097 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default Branch (34097:13): [True: 16, False: 33]
|
34098 | ) |
34099 | { |
34100 | _res = param_maybe_default_var; |
34101 | if (_n == _children_capacity) { |
34102 | _children_capacity *= 2; |
34103 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34104 | if (!_new_children) { |
34105 | p->error_indicator = 1; |
34106 | PyErr_NoMemory(); |
34107 | p->level--; |
34108 | return NULL; |
34109 | } |
34110 | _children = _new_children; |
34111 | } |
34112 | _children[_n++] = _res; |
34113 | _mark = p->mark; |
34114 | } |
34115 | p->mark = _mark; |
34116 | D(fprintf(stderr, "%*c%s _loop0_167[%d-%d]: %s failed!\n", p->level, ' ', |
34117 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
34118 | } |
34119 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34120 | if (!_seq) { Branch (34120:9): [True: 0, False: 33]
|
34121 | PyMem_Free(_children); |
34122 | p->error_indicator = 1; |
34123 | PyErr_NoMemory(); |
34124 | p->level--; |
34125 | return NULL; |
34126 | } |
34127 | for (int i = 0; 33 i < _n; i++16 ) asdl_seq_SET_UNTYPED33 (_seq, i, _children[i]); Branch (34127:21): [True: 16, False: 33]
|
34128 | PyMem_Free(_children); |
34129 | _PyPegen_insert_memo(p, _start_mark, _loop0_167_type, _seq); |
34130 | p->level--; |
34131 | return _seq; |
34132 | } |
34133 | |
34134 | // _loop1_168: param_maybe_default |
34135 | static asdl_seq * |
34136 | _loop1_168_rule(Parser *p) |
34137 | { |
34138 | if (p->level++ == MAXSTACK) { Branch (34138:9): [True: 0, False: 251]
|
34139 | p->error_indicator = 1; |
34140 | PyErr_NoMemory(); |
34141 | } |
34142 | if (p->error_indicator) { Branch (34142:9): [True: 0, False: 251]
|
34143 | p->level--; |
34144 | return NULL; |
34145 | } |
34146 | void *_res = NULL; |
34147 | int _mark = p->mark; |
34148 | int _start_mark = p->mark; |
34149 | void **_children = PyMem_Malloc(sizeof(void *)); |
34150 | if (!_children) { Branch (34150:9): [True: 0, False: 251]
|
34151 | p->error_indicator = 1; |
34152 | PyErr_NoMemory(); |
34153 | p->level--; |
34154 | return NULL; |
34155 | } |
34156 | Py_ssize_t _children_capacity = 1; |
34157 | Py_ssize_t _n = 0; |
34158 | { // param_maybe_default |
34159 | if (p->error_indicator) { Branch (34159:13): [True: 0, False: 251]
|
34160 | p->level--; |
34161 | return NULL; |
34162 | } |
34163 | D(fprintf(stderr, "%*c> _loop1_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
34164 | NameDefaultPair* param_maybe_default_var; |
34165 | while ( |
34166 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default Branch (34166:13): [True: 48, False: 251]
|
34167 | ) |
34168 | { |
34169 | _res = param_maybe_default_var; |
34170 | if (_n == _children_capacity) { |
34171 | _children_capacity *= 2; |
34172 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34173 | if (!_new_children) { |
34174 | p->error_indicator = 1; |
34175 | PyErr_NoMemory(); |
34176 | p->level--; |
34177 | return NULL; |
34178 | } |
34179 | _children = _new_children; |
34180 | } |
34181 | _children[_n++] = _res; |
34182 | _mark = p->mark; |
34183 | } |
34184 | p->mark = _mark; |
34185 | D(fprintf(stderr, "%*c%s _loop1_168[%d-%d]: %s failed!\n", p->level, ' ', |
34186 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
34187 | } |
34188 | if (_n == 0 || p->error_indicator42 ) { Branch (34188:9): [True: 209, False: 42]
Branch (34188:20): [True: 0, False: 42]
|
34189 | PyMem_Free(_children); |
34190 | p->level--; |
34191 | return NULL; |
34192 | } |
34193 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34194 | if (!_seq) { Branch (34194:9): [True: 0, False: 42]
|
34195 | PyMem_Free(_children); |
34196 | p->error_indicator = 1; |
34197 | PyErr_NoMemory(); |
34198 | p->level--; |
34199 | return NULL; |
34200 | } |
34201 | for (int i = 0; 42 i < _n; i++48 ) asdl_seq_SET_UNTYPED42 (_seq, i, _children[i]); Branch (34201:21): [True: 48, False: 42]
|
34202 | PyMem_Free(_children); |
34203 | _PyPegen_insert_memo(p, _start_mark, _loop1_168_type, _seq); |
34204 | p->level--; |
34205 | return _seq; |
34206 | } |
34207 | |
34208 | // _tmp_169: ')' | ',' |
34209 | static void * |
34210 | _tmp_169_rule(Parser *p) |
34211 | { |
34212 | if (p->level++ == MAXSTACK) { Branch (34212:9): [True: 0, False: 245]
|
34213 | p->error_indicator = 1; |
34214 | PyErr_NoMemory(); |
34215 | } |
34216 | if (p->error_indicator) { Branch (34216:9): [True: 0, False: 245]
|
34217 | p->level--; |
34218 | return NULL; |
34219 | } |
34220 | void * _res = NULL; |
34221 | int _mark = p->mark; |
34222 | { // ')' |
34223 | if (p->error_indicator) { Branch (34223:13): [True: 0, False: 245]
|
34224 | p->level--; |
34225 | return NULL; |
34226 | } |
34227 | D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); |
34228 | Token * _literal; |
34229 | if ( |
34230 | (_literal = _PyPegen_expect_token(p, 8)) // token=')' Branch (34230:13): [True: 0, False: 245]
|
34231 | ) |
34232 | { |
34233 | D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); |
34234 | _res = _literal; |
34235 | goto done; |
34236 | } |
34237 | p->mark = _mark; |
34238 | D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', |
34239 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); |
34240 | } |
34241 | { // ',' |
34242 | if (p->error_indicator) { Branch (34242:13): [True: 0, False: 245]
|
34243 | p->level--; |
34244 | return NULL; |
34245 | } |
34246 | D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
34247 | Token * _literal; |
34248 | if ( |
34249 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (34249:13): [True: 5, False: 240]
|
34250 | ) |
34251 | { |
34252 | D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
34253 | _res = _literal; |
34254 | goto done; |
34255 | } |
34256 | p->mark = _mark; |
34257 | D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', |
34258 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
34259 | } |
34260 | _res = NULL; |
34261 | done: |
34262 | p->level--; |
34263 | return _res; |
34264 | } |
34265 | |
34266 | // _tmp_170: ')' | ',' (')' | '**') |
34267 | static void * |
34268 | _tmp_170_rule(Parser *p) |
34269 | { |
34270 | if (p->level++ == MAXSTACK) { Branch (34270:9): [True: 0, False: 29]
|
34271 | p->error_indicator = 1; |
34272 | PyErr_NoMemory(); |
34273 | } |
34274 | if (p->error_indicator) { Branch (34274:9): [True: 0, False: 29]
|
34275 | p->level--; |
34276 | return NULL; |
34277 | } |
34278 | void * _res = NULL; |
34279 | int _mark = p->mark; |
34280 | { // ')' |
34281 | if (p->error_indicator) { |
34282 | p->level--; |
34283 | return NULL; |
34284 | } |
34285 | D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); |
34286 | Token * _literal; |
34287 | if ( |
34288 | (_literal = _PyPegen_expect_token(p, 8)) // token=')' |
34289 | ) |
34290 | { |
34291 | D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); |
34292 | _res = _literal; |
34293 | goto done; |
34294 | } |
34295 | p->mark = _mark; |
34296 | D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', |
34297 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); |
34298 | } |
34299 | { // ',' (')' | '**') |
34300 | if (p->error_indicator) { |
34301 | p->level--; |
34302 | return NULL; |
34303 | } |
34304 | D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); |
34305 | Token * _literal; |
34306 | void *_tmp_235_var; |
34307 | if ( |
34308 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
34309 | && |
34310 | (_tmp_235_var = _tmp_235_rule(p))9 // ')' | '**' |
34311 | ) |
34312 | { |
34313 | D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); |
34314 | _res = _PyPegen_dummy_name(p, _literal, _tmp_235_var); |
34315 | goto done; |
34316 | } |
34317 | p->mark = _mark; |
34318 | D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', |
34319 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); |
34320 | } |
34321 | _res = NULL; |
34322 | done: |
34323 | p->level--; |
34324 | return _res; |
34325 | } |
34326 | |
34327 | // _tmp_171: param_no_default | ',' |
34328 | static void * |
34329 | _tmp_171_rule(Parser *p) |
34330 | { |
34331 | if (p->level++ == MAXSTACK) { Branch (34331:9): [True: 0, False: 23]
|
34332 | p->error_indicator = 1; |
34333 | PyErr_NoMemory(); |
34334 | } |
34335 | if (p->error_indicator) { Branch (34335:9): [True: 0, False: 23]
|
34336 | p->level--; |
34337 | return NULL; |
34338 | } |
34339 | void * _res = NULL; |
34340 | int _mark = p->mark; |
34341 | { // param_no_default |
34342 | if (p->error_indicator) { |
34343 | p->level--; |
34344 | return NULL; |
34345 | } |
34346 | D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
34347 | arg_ty param_no_default_var; |
34348 | if ( |
34349 | (param_no_default_var = param_no_default_rule(p)) // param_no_default Branch (34349:13): [True: 12, False: 11]
|
34350 | ) |
34351 | { |
34352 | D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
34353 | _res = param_no_default_var; |
34354 | goto done; |
34355 | } |
34356 | p->mark = _mark; |
34357 | D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', |
34358 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
34359 | } |
34360 | { // ',' |
34361 | if (p->error_indicator) { |
34362 | p->level--; |
34363 | return NULL; |
34364 | } |
34365 | D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
34366 | Token * _literal; |
34367 | if ( |
34368 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
34369 | ) |
34370 | { |
34371 | D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
34372 | _res = _literal; |
34373 | goto done; |
34374 | } |
34375 | p->mark = _mark; |
34376 | D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', |
34377 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
34378 | } |
34379 | _res = NULL; |
34380 | done: |
34381 | p->level--; |
34382 | return _res; |
34383 | } |
34384 | |
34385 | // _loop0_172: param_maybe_default |
34386 | static asdl_seq * |
34387 | _loop0_172_rule(Parser *p) |
34388 | { |
34389 | if (p->level++ == MAXSTACK) { Branch (34389:9): [True: 0, False: 19]
|
34390 | p->error_indicator = 1; |
34391 | PyErr_NoMemory(); |
34392 | } |
34393 | if (p->error_indicator) { Branch (34393:9): [True: 0, False: 19]
|
34394 | p->level--; |
34395 | return NULL; |
34396 | } |
34397 | void *_res = NULL; |
34398 | int _mark = p->mark; |
34399 | int _start_mark = p->mark; |
34400 | void **_children = PyMem_Malloc(sizeof(void *)); |
34401 | if (!_children) { Branch (34401:9): [True: 0, False: 19]
|
34402 | p->error_indicator = 1; |
34403 | PyErr_NoMemory(); |
34404 | p->level--; |
34405 | return NULL; |
34406 | } |
34407 | Py_ssize_t _children_capacity = 1; |
34408 | Py_ssize_t _n = 0; |
34409 | { // param_maybe_default |
34410 | if (p->error_indicator) { |
34411 | p->level--; |
34412 | return NULL; |
34413 | } |
34414 | D(fprintf(stderr, "%*c> _loop0_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); |
34415 | NameDefaultPair* param_maybe_default_var; |
34416 | while ( |
34417 | (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default |
34418 | ) |
34419 | { |
34420 | _res = param_maybe_default_var; |
34421 | if (_n == _children_capacity) { |
34422 | _children_capacity *= 2; |
34423 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34424 | if (!_new_children) { |
34425 | p->error_indicator = 1; |
34426 | PyErr_NoMemory(); |
34427 | p->level--; |
34428 | return NULL; |
34429 | } |
34430 | _children = _new_children; |
34431 | } |
34432 | _children[_n++] = _res; |
34433 | _mark = p->mark; |
34434 | } |
34435 | p->mark = _mark; |
34436 | D(fprintf(stderr, "%*c%s _loop0_172[%d-%d]: %s failed!\n", p->level, ' ', |
34437 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); |
34438 | } |
34439 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34440 | if (!_seq) { Branch (34440:9): [True: 0, False: 19]
|
34441 | PyMem_Free(_children); |
34442 | p->error_indicator = 1; |
34443 | PyErr_NoMemory(); |
34444 | p->level--; |
34445 | return NULL; |
34446 | } |
34447 | for (int i = 0; 19 i < _n; i++8 ) asdl_seq_SET_UNTYPED19 (_seq, i, _children[i]); |
34448 | PyMem_Free(_children); |
34449 | _PyPegen_insert_memo(p, _start_mark, _loop0_172_type, _seq); |
34450 | p->level--; |
34451 | return _seq; |
34452 | } |
34453 | |
34454 | // _tmp_173: param_no_default | ',' |
34455 | static void * |
34456 | _tmp_173_rule(Parser *p) |
34457 | { |
34458 | if (p->level++ == MAXSTACK) { Branch (34458:9): [True: 0, False: 4]
|
34459 | p->error_indicator = 1; |
34460 | PyErr_NoMemory(); |
34461 | } |
34462 | if (p->error_indicator) { Branch (34462:9): [True: 0, False: 4]
|
34463 | p->level--; |
34464 | return NULL; |
34465 | } |
34466 | void * _res = NULL; |
34467 | int _mark = p->mark; |
34468 | { // param_no_default |
34469 | if (p->error_indicator) { |
34470 | p->level--; |
34471 | return NULL; |
34472 | } |
34473 | D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
34474 | arg_ty param_no_default_var; |
34475 | if ( |
34476 | (param_no_default_var = param_no_default_rule(p)) // param_no_default |
34477 | ) |
34478 | { |
34479 | D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); |
34480 | _res = param_no_default_var; |
34481 | goto done; |
34482 | } |
34483 | p->mark = _mark; |
34484 | D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', |
34485 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); |
34486 | } |
34487 | { // ',' |
34488 | if (p->error_indicator) { |
34489 | p->level--; |
34490 | return NULL; |
34491 | } |
34492 | D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
34493 | Token * _literal; |
34494 | if ( |
34495 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
34496 | ) |
34497 | { |
34498 | D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
34499 | _res = _literal; |
34500 | goto done; |
34501 | } |
34502 | p->mark = _mark; |
34503 | D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', |
34504 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
34505 | } |
34506 | _res = NULL; |
34507 | done: |
34508 | p->level--; |
34509 | return _res; |
34510 | } |
34511 | |
34512 | // _tmp_174: '*' | '**' | '/' |
34513 | static void * |
34514 | _tmp_174_rule(Parser *p) |
34515 | { |
34516 | if (p->level++ == MAXSTACK) { Branch (34516:9): [True: 0, False: 5]
|
34517 | p->error_indicator = 1; |
34518 | PyErr_NoMemory(); |
34519 | } |
34520 | if (p->error_indicator) { Branch (34520:9): [True: 0, False: 5]
|
34521 | p->level--; |
34522 | return NULL; |
34523 | } |
34524 | void * _res = NULL; |
34525 | int _mark = p->mark; |
34526 | { // '*' |
34527 | if (p->error_indicator) { |
34528 | p->level--; |
34529 | return NULL; |
34530 | } |
34531 | D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); |
34532 | Token * _literal; |
34533 | if ( |
34534 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' |
34535 | ) |
34536 | { |
34537 | D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); |
34538 | _res = _literal; |
34539 | goto done; |
34540 | } |
34541 | p->mark = _mark; |
34542 | D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', |
34543 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); |
34544 | } |
34545 | { // '**' |
34546 | if (p->error_indicator) { |
34547 | p->level--; |
34548 | return NULL; |
34549 | } |
34550 | D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); |
34551 | Token * _literal; |
34552 | if ( |
34553 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
34554 | ) |
34555 | { |
34556 | D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); |
34557 | _res = _literal; |
34558 | goto done; |
34559 | } |
34560 | p->mark = _mark; |
34561 | D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', |
34562 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); |
34563 | } |
34564 | { // '/' |
34565 | if (p->error_indicator) { |
34566 | p->level--; |
34567 | return NULL; |
34568 | } |
34569 | D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); |
34570 | Token * _literal; |
34571 | if ( |
34572 | (_literal = _PyPegen_expect_token(p, 17)) // token='/' |
34573 | ) |
34574 | { |
34575 | D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); |
34576 | _res = _literal; |
34577 | goto done; |
34578 | } |
34579 | p->mark = _mark; |
34580 | D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', |
34581 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); |
34582 | } |
34583 | _res = NULL; |
34584 | done: |
34585 | p->level--; |
34586 | return _res; |
34587 | } |
34588 | |
34589 | // _loop1_175: param_with_default |
34590 | static asdl_seq * |
34591 | _loop1_175_rule(Parser *p) |
34592 | { |
34593 | if (p->level++ == MAXSTACK) { Branch (34593:9): [True: 0, False: 286]
|
34594 | p->error_indicator = 1; |
34595 | PyErr_NoMemory(); |
34596 | } |
34597 | if (p->error_indicator) { Branch (34597:9): [True: 0, False: 286]
|
34598 | p->level--; |
34599 | return NULL; |
34600 | } |
34601 | void *_res = NULL; |
34602 | int _mark = p->mark; |
34603 | int _start_mark = p->mark; |
34604 | void **_children = PyMem_Malloc(sizeof(void *)); |
34605 | if (!_children) { Branch (34605:9): [True: 0, False: 286]
|
34606 | p->error_indicator = 1; |
34607 | PyErr_NoMemory(); |
34608 | p->level--; |
34609 | return NULL; |
34610 | } |
34611 | Py_ssize_t _children_capacity = 1; |
34612 | Py_ssize_t _n = 0; |
34613 | { // param_with_default |
34614 | if (p->error_indicator) { Branch (34614:13): [True: 0, False: 286]
|
34615 | p->level--; |
34616 | return NULL; |
34617 | } |
34618 | D(fprintf(stderr, "%*c> _loop1_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); |
34619 | NameDefaultPair* param_with_default_var; |
34620 | while ( |
34621 | (param_with_default_var = param_with_default_rule(p)) // param_with_default Branch (34621:13): [True: 8, False: 286]
|
34622 | ) |
34623 | { |
34624 | _res = param_with_default_var; |
34625 | if (_n == _children_capacity) { |
34626 | _children_capacity *= 2; |
34627 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34628 | if (!_new_children) { |
34629 | p->error_indicator = 1; |
34630 | PyErr_NoMemory(); |
34631 | p->level--; |
34632 | return NULL; |
34633 | } |
34634 | _children = _new_children; |
34635 | } |
34636 | _children[_n++] = _res; |
34637 | _mark = p->mark; |
34638 | } |
34639 | p->mark = _mark; |
34640 | D(fprintf(stderr, "%*c%s _loop1_175[%d-%d]: %s failed!\n", p->level, ' ', |
34641 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); |
34642 | } |
34643 | if (_n == 0 || p->error_indicator8 ) { Branch (34643:9): [True: 278, False: 8]
Branch (34643:20): [True: 0, False: 8]
|
34644 | PyMem_Free(_children); |
34645 | p->level--; |
34646 | return NULL; |
34647 | } |
34648 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34649 | if (!_seq) { Branch (34649:9): [True: 0, False: 8]
|
34650 | PyMem_Free(_children); |
34651 | p->error_indicator = 1; |
34652 | PyErr_NoMemory(); |
34653 | p->level--; |
34654 | return NULL; |
34655 | } |
34656 | for (int i = 0; 8 i < _n; i++8 ) asdl_seq_SET_UNTYPED8 (_seq, i, _children[i]); |
34657 | PyMem_Free(_children); |
34658 | _PyPegen_insert_memo(p, _start_mark, _loop1_175_type, _seq); |
34659 | p->level--; |
34660 | return _seq; |
34661 | } |
34662 | |
34663 | // _loop0_176: lambda_param_no_default |
34664 | static asdl_seq * |
34665 | _loop0_176_rule(Parser *p) |
34666 | { |
34667 | if (p->level++ == MAXSTACK) { Branch (34667:9): [True: 0, False: 52]
|
34668 | p->error_indicator = 1; |
34669 | PyErr_NoMemory(); |
34670 | } |
34671 | if (p->error_indicator) { Branch (34671:9): [True: 0, False: 52]
|
34672 | p->level--; |
34673 | return NULL; |
34674 | } |
34675 | void *_res = NULL; |
34676 | int _mark = p->mark; |
34677 | int _start_mark = p->mark; |
34678 | void **_children = PyMem_Malloc(sizeof(void *)); |
34679 | if (!_children) { Branch (34679:9): [True: 0, False: 52]
|
34680 | p->error_indicator = 1; |
34681 | PyErr_NoMemory(); |
34682 | p->level--; |
34683 | return NULL; |
34684 | } |
34685 | Py_ssize_t _children_capacity = 1; |
34686 | Py_ssize_t _n = 0; |
34687 | { // lambda_param_no_default |
34688 | if (p->error_indicator) { |
34689 | p->level--; |
34690 | return NULL; |
34691 | } |
34692 | D(fprintf(stderr, "%*c> _loop0_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
34693 | arg_ty lambda_param_no_default_var; |
34694 | while ( |
34695 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (34695:13): [True: 28, False: 52]
|
34696 | ) |
34697 | { |
34698 | _res = lambda_param_no_default_var; |
34699 | if (_n == _children_capacity) { |
34700 | _children_capacity *= 2; |
34701 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34702 | if (!_new_children) { |
34703 | p->error_indicator = 1; |
34704 | PyErr_NoMemory(); |
34705 | p->level--; |
34706 | return NULL; |
34707 | } |
34708 | _children = _new_children; |
34709 | } |
34710 | _children[_n++] = _res; |
34711 | _mark = p->mark; |
34712 | } |
34713 | p->mark = _mark; |
34714 | D(fprintf(stderr, "%*c%s _loop0_176[%d-%d]: %s failed!\n", p->level, ' ', |
34715 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
34716 | } |
34717 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34718 | if (!_seq) { Branch (34718:9): [True: 0, False: 52]
|
34719 | PyMem_Free(_children); |
34720 | p->error_indicator = 1; |
34721 | PyErr_NoMemory(); |
34722 | p->level--; |
34723 | return NULL; |
34724 | } |
34725 | for (int i = 0; 52 i < _n; i++28 ) asdl_seq_SET_UNTYPED52 (_seq, i, _children[i]); Branch (34725:21): [True: 28, False: 52]
|
34726 | PyMem_Free(_children); |
34727 | _PyPegen_insert_memo(p, _start_mark, _loop0_176_type, _seq); |
34728 | p->level--; |
34729 | return _seq; |
34730 | } |
34731 | |
34732 | // _loop0_177: lambda_param_no_default |
34733 | static asdl_seq * |
34734 | _loop0_177_rule(Parser *p) |
34735 | { |
34736 | if (p->level++ == MAXSTACK) { Branch (34736:9): [True: 0, False: 47]
|
34737 | p->error_indicator = 1; |
34738 | PyErr_NoMemory(); |
34739 | } |
34740 | if (p->error_indicator) { Branch (34740:9): [True: 0, False: 47]
|
34741 | p->level--; |
34742 | return NULL; |
34743 | } |
34744 | void *_res = NULL; |
34745 | int _mark = p->mark; |
34746 | int _start_mark = p->mark; |
34747 | void **_children = PyMem_Malloc(sizeof(void *)); |
34748 | if (!_children) { Branch (34748:9): [True: 0, False: 47]
|
34749 | p->error_indicator = 1; |
34750 | PyErr_NoMemory(); |
34751 | p->level--; |
34752 | return NULL; |
34753 | } |
34754 | Py_ssize_t _children_capacity = 1; |
34755 | Py_ssize_t _n = 0; |
34756 | { // lambda_param_no_default |
34757 | if (p->error_indicator) { |
34758 | p->level--; |
34759 | return NULL; |
34760 | } |
34761 | D(fprintf(stderr, "%*c> _loop0_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
34762 | arg_ty lambda_param_no_default_var; |
34763 | while ( |
34764 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default Branch (34764:13): [True: 26, False: 47]
|
34765 | ) |
34766 | { |
34767 | _res = lambda_param_no_default_var; |
34768 | if (_n == _children_capacity) { |
34769 | _children_capacity *= 2; |
34770 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34771 | if (!_new_children) { |
34772 | p->error_indicator = 1; |
34773 | PyErr_NoMemory(); |
34774 | p->level--; |
34775 | return NULL; |
34776 | } |
34777 | _children = _new_children; |
34778 | } |
34779 | _children[_n++] = _res; |
34780 | _mark = p->mark; |
34781 | } |
34782 | p->mark = _mark; |
34783 | D(fprintf(stderr, "%*c%s _loop0_177[%d-%d]: %s failed!\n", p->level, ' ', |
34784 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
34785 | } |
34786 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34787 | if (!_seq) { Branch (34787:9): [True: 0, False: 47]
|
34788 | PyMem_Free(_children); |
34789 | p->error_indicator = 1; |
34790 | PyErr_NoMemory(); |
34791 | p->level--; |
34792 | return NULL; |
34793 | } |
34794 | for (int i = 0; 47 i < _n; i++26 ) asdl_seq_SET_UNTYPED47 (_seq, i, _children[i]); Branch (34794:21): [True: 26, False: 47]
|
34795 | PyMem_Free(_children); |
34796 | _PyPegen_insert_memo(p, _start_mark, _loop0_177_type, _seq); |
34797 | p->level--; |
34798 | return _seq; |
34799 | } |
34800 | |
34801 | // _loop0_179: ',' lambda_param |
34802 | static asdl_seq * |
34803 | _loop0_179_rule(Parser *p) |
34804 | { |
34805 | if (p->level++ == MAXSTACK) { Branch (34805:9): [True: 0, False: 4]
|
34806 | p->error_indicator = 1; |
34807 | PyErr_NoMemory(); |
34808 | } |
34809 | if (p->error_indicator) { Branch (34809:9): [True: 0, False: 4]
|
34810 | p->level--; |
34811 | return NULL; |
34812 | } |
34813 | void *_res = NULL; |
34814 | int _mark = p->mark; |
34815 | int _start_mark = p->mark; |
34816 | void **_children = PyMem_Malloc(sizeof(void *)); |
34817 | if (!_children) { Branch (34817:9): [True: 0, False: 4]
|
34818 | p->error_indicator = 1; |
34819 | PyErr_NoMemory(); |
34820 | p->level--; |
34821 | return NULL; |
34822 | } |
34823 | Py_ssize_t _children_capacity = 1; |
34824 | Py_ssize_t _n = 0; |
34825 | { // ',' lambda_param |
34826 | if (p->error_indicator) { |
34827 | p->level--; |
34828 | return NULL; |
34829 | } |
34830 | D(fprintf(stderr, "%*c> _loop0_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); |
34831 | Token * _literal; |
34832 | arg_ty elem; |
34833 | while ( |
34834 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
34835 | && |
34836 | (elem = lambda_param_rule(p))8 // lambda_param |
34837 | ) |
34838 | { |
34839 | _res = elem; |
34840 | if (_res == NULL && PyErr_Occurred()0 ) { |
34841 | p->error_indicator = 1; |
34842 | PyMem_Free(_children); |
34843 | p->level--; |
34844 | return NULL; |
34845 | } |
34846 | if (_n == _children_capacity) { |
34847 | _children_capacity *= 2; |
34848 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
34849 | if (!_new_children) { |
34850 | p->error_indicator = 1; |
34851 | PyErr_NoMemory(); |
34852 | p->level--; |
34853 | return NULL; |
34854 | } |
34855 | _children = _new_children; |
34856 | } |
34857 | _children[_n++] = _res; |
34858 | _mark = p->mark; |
34859 | } |
34860 | p->mark = _mark; |
34861 | D(fprintf(stderr, "%*c%s _loop0_179[%d-%d]: %s failed!\n", p->level, ' ', |
34862 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' lambda_param")); |
34863 | } |
34864 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
34865 | if (!_seq) { Branch (34865:9): [True: 0, False: 4]
|
34866 | PyMem_Free(_children); |
34867 | p->error_indicator = 1; |
34868 | PyErr_NoMemory(); |
34869 | p->level--; |
34870 | return NULL; |
34871 | } |
34872 | for (int i = 0; 4 i < _n; i++8 ) asdl_seq_SET_UNTYPED4 (_seq, i, _children[i]); |
34873 | PyMem_Free(_children); |
34874 | _PyPegen_insert_memo(p, _start_mark, _loop0_179_type, _seq); |
34875 | p->level--; |
34876 | return _seq; |
34877 | } |
34878 | |
34879 | // _gather_178: lambda_param _loop0_179 |
34880 | static asdl_seq * |
34881 | _gather_178_rule(Parser *p) |
34882 | { |
34883 | if (p->level++ == MAXSTACK) { Branch (34883:9): [True: 0, False: 5]
|
34884 | p->error_indicator = 1; |
34885 | PyErr_NoMemory(); |
34886 | } |
34887 | if (p->error_indicator) { Branch (34887:9): [True: 0, False: 5]
|
34888 | p->level--; |
34889 | return NULL; |
34890 | } |
34891 | asdl_seq * _res = NULL; |
34892 | int _mark = p->mark; |
34893 | { // lambda_param _loop0_179 |
34894 | if (p->error_indicator) { |
34895 | p->level--; |
34896 | return NULL; |
34897 | } |
34898 | D(fprintf(stderr, "%*c> _gather_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_179")); |
34899 | arg_ty elem; |
34900 | asdl_seq * seq; |
34901 | if ( |
34902 | (elem = lambda_param_rule(p)) // lambda_param |
34903 | && |
34904 | (seq = _loop0_179_rule(p))4 // _loop0_179 |
34905 | ) |
34906 | { |
34907 | D(fprintf(stderr, "%*c+ _gather_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_179")); |
34908 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
34909 | goto done; |
34910 | } |
34911 | p->mark = _mark; |
34912 | D(fprintf(stderr, "%*c%s _gather_178[%d-%d]: %s failed!\n", p->level, ' ', |
34913 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_179")); |
34914 | } |
34915 | _res = NULL; |
34916 | done: |
34917 | p->level--; |
34918 | return _res; |
34919 | } |
34920 | |
34921 | // _tmp_180: lambda_slash_no_default | lambda_slash_with_default |
34922 | static void * |
34923 | _tmp_180_rule(Parser *p) |
34924 | { |
34925 | if (p->level++ == MAXSTACK) { Branch (34925:9): [True: 0, False: 40]
|
34926 | p->error_indicator = 1; |
34927 | PyErr_NoMemory(); |
34928 | } |
34929 | if (p->error_indicator) { Branch (34929:9): [True: 0, False: 40]
|
34930 | p->level--; |
34931 | return NULL; |
34932 | } |
34933 | void * _res = NULL; |
34934 | int _mark = p->mark; |
34935 | { // lambda_slash_no_default |
34936 | if (p->error_indicator) { |
34937 | p->level--; |
34938 | return NULL; |
34939 | } |
34940 | D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); |
34941 | asdl_arg_seq* lambda_slash_no_default_var; |
34942 | if ( |
34943 | (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default |
34944 | ) |
34945 | { |
34946 | D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); |
34947 | _res = lambda_slash_no_default_var; |
34948 | goto done; |
34949 | } |
34950 | p->mark = _mark; |
34951 | D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', |
34952 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default")); |
34953 | } |
34954 | { // lambda_slash_with_default |
34955 | if (p->error_indicator) { |
34956 | p->level--; |
34957 | return NULL; |
34958 | } |
34959 | D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); |
34960 | SlashWithDefault* lambda_slash_with_default_var; |
34961 | if ( |
34962 | (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default |
34963 | ) |
34964 | { |
34965 | D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); |
34966 | _res = lambda_slash_with_default_var; |
34967 | goto done; |
34968 | } |
34969 | p->mark = _mark; |
34970 | D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', |
34971 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); |
34972 | } |
34973 | _res = NULL; |
34974 | done: |
34975 | p->level--; |
34976 | return _res; |
34977 | } |
34978 | |
34979 | // _loop0_181: lambda_param_maybe_default |
34980 | static asdl_seq * |
34981 | _loop0_181_rule(Parser *p) |
34982 | { |
34983 | if (p->level++ == MAXSTACK) { Branch (34983:9): [True: 0, False: 10]
|
34984 | p->error_indicator = 1; |
34985 | PyErr_NoMemory(); |
34986 | } |
34987 | if (p->error_indicator) { Branch (34987:9): [True: 0, False: 10]
|
34988 | p->level--; |
34989 | return NULL; |
34990 | } |
34991 | void *_res = NULL; |
34992 | int _mark = p->mark; |
34993 | int _start_mark = p->mark; |
34994 | void **_children = PyMem_Malloc(sizeof(void *)); |
34995 | if (!_children) { Branch (34995:9): [True: 0, False: 10]
|
34996 | p->error_indicator = 1; |
34997 | PyErr_NoMemory(); |
34998 | p->level--; |
34999 | return NULL; |
35000 | } |
35001 | Py_ssize_t _children_capacity = 1; |
35002 | Py_ssize_t _n = 0; |
35003 | { // lambda_param_maybe_default |
35004 | if (p->error_indicator) { |
35005 | p->level--; |
35006 | return NULL; |
35007 | } |
35008 | D(fprintf(stderr, "%*c> _loop0_181[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
35009 | NameDefaultPair* lambda_param_maybe_default_var; |
35010 | while ( |
35011 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default |
35012 | ) |
35013 | { |
35014 | _res = lambda_param_maybe_default_var; |
35015 | if (_n == _children_capacity) { |
35016 | _children_capacity *= 2; |
35017 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35018 | if (!_new_children) { |
35019 | p->error_indicator = 1; |
35020 | PyErr_NoMemory(); |
35021 | p->level--; |
35022 | return NULL; |
35023 | } |
35024 | _children = _new_children; |
35025 | } |
35026 | _children[_n++] = _res; |
35027 | _mark = p->mark; |
35028 | } |
35029 | p->mark = _mark; |
35030 | D(fprintf(stderr, "%*c%s _loop0_181[%d-%d]: %s failed!\n", p->level, ' ', |
35031 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
35032 | } |
35033 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35034 | if (!_seq) { Branch (35034:9): [True: 0, False: 10]
|
35035 | PyMem_Free(_children); |
35036 | p->error_indicator = 1; |
35037 | PyErr_NoMemory(); |
35038 | p->level--; |
35039 | return NULL; |
35040 | } |
35041 | for (int i = 0; 10 i < _n; i++7 ) asdl_seq_SET_UNTYPED10 (_seq, i, _children[i]); |
35042 | PyMem_Free(_children); |
35043 | _PyPegen_insert_memo(p, _start_mark, _loop0_181_type, _seq); |
35044 | p->level--; |
35045 | return _seq; |
35046 | } |
35047 | |
35048 | // _tmp_182: lambda_slash_no_default | lambda_slash_with_default |
35049 | static void * |
35050 | _tmp_182_rule(Parser *p) |
35051 | { |
35052 | if (p->level++ == MAXSTACK) { Branch (35052:9): [True: 0, False: 33]
|
35053 | p->error_indicator = 1; |
35054 | PyErr_NoMemory(); |
35055 | } |
35056 | if (p->error_indicator) { Branch (35056:9): [True: 0, False: 33]
|
35057 | p->level--; |
35058 | return NULL; |
35059 | } |
35060 | void * _res = NULL; |
35061 | int _mark = p->mark; |
35062 | { // lambda_slash_no_default |
35063 | if (p->error_indicator) { |
35064 | p->level--; |
35065 | return NULL; |
35066 | } |
35067 | D(fprintf(stderr, "%*c> _tmp_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); |
35068 | asdl_arg_seq* lambda_slash_no_default_var; |
35069 | if ( |
35070 | (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default |
35071 | ) |
35072 | { |
35073 | D(fprintf(stderr, "%*c+ _tmp_182[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); |
35074 | _res = lambda_slash_no_default_var; |
35075 | goto done; |
35076 | } |
35077 | p->mark = _mark; |
35078 | D(fprintf(stderr, "%*c%s _tmp_182[%d-%d]: %s failed!\n", p->level, ' ', |
35079 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default")); |
35080 | } |
35081 | { // lambda_slash_with_default |
35082 | if (p->error_indicator) { |
35083 | p->level--; |
35084 | return NULL; |
35085 | } |
35086 | D(fprintf(stderr, "%*c> _tmp_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); |
35087 | SlashWithDefault* lambda_slash_with_default_var; |
35088 | if ( |
35089 | (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default |
35090 | ) |
35091 | { |
35092 | D(fprintf(stderr, "%*c+ _tmp_182[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); |
35093 | _res = lambda_slash_with_default_var; |
35094 | goto done; |
35095 | } |
35096 | p->mark = _mark; |
35097 | D(fprintf(stderr, "%*c%s _tmp_182[%d-%d]: %s failed!\n", p->level, ' ', |
35098 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); |
35099 | } |
35100 | _res = NULL; |
35101 | done: |
35102 | p->level--; |
35103 | return _res; |
35104 | } |
35105 | |
35106 | // _loop0_183: lambda_param_maybe_default |
35107 | static asdl_seq * |
35108 | _loop0_183_rule(Parser *p) |
35109 | { |
35110 | if (p->level++ == MAXSTACK) { Branch (35110:9): [True: 0, False: 33]
|
35111 | p->error_indicator = 1; |
35112 | PyErr_NoMemory(); |
35113 | } |
35114 | if (p->error_indicator) { Branch (35114:9): [True: 0, False: 33]
|
35115 | p->level--; |
35116 | return NULL; |
35117 | } |
35118 | void *_res = NULL; |
35119 | int _mark = p->mark; |
35120 | int _start_mark = p->mark; |
35121 | void **_children = PyMem_Malloc(sizeof(void *)); |
35122 | if (!_children) { Branch (35122:9): [True: 0, False: 33]
|
35123 | p->error_indicator = 1; |
35124 | PyErr_NoMemory(); |
35125 | p->level--; |
35126 | return NULL; |
35127 | } |
35128 | Py_ssize_t _children_capacity = 1; |
35129 | Py_ssize_t _n = 0; |
35130 | { // lambda_param_maybe_default |
35131 | if (p->error_indicator) { |
35132 | p->level--; |
35133 | return NULL; |
35134 | } |
35135 | D(fprintf(stderr, "%*c> _loop0_183[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
35136 | NameDefaultPair* lambda_param_maybe_default_var; |
35137 | while ( |
35138 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default Branch (35138:13): [True: 18, False: 33]
|
35139 | ) |
35140 | { |
35141 | _res = lambda_param_maybe_default_var; |
35142 | if (_n == _children_capacity) { |
35143 | _children_capacity *= 2; |
35144 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35145 | if (!_new_children) { |
35146 | p->error_indicator = 1; |
35147 | PyErr_NoMemory(); |
35148 | p->level--; |
35149 | return NULL; |
35150 | } |
35151 | _children = _new_children; |
35152 | } |
35153 | _children[_n++] = _res; |
35154 | _mark = p->mark; |
35155 | } |
35156 | p->mark = _mark; |
35157 | D(fprintf(stderr, "%*c%s _loop0_183[%d-%d]: %s failed!\n", p->level, ' ', |
35158 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
35159 | } |
35160 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35161 | if (!_seq) { Branch (35161:9): [True: 0, False: 33]
|
35162 | PyMem_Free(_children); |
35163 | p->error_indicator = 1; |
35164 | PyErr_NoMemory(); |
35165 | p->level--; |
35166 | return NULL; |
35167 | } |
35168 | for (int i = 0; 33 i < _n; i++18 ) asdl_seq_SET_UNTYPED33 (_seq, i, _children[i]); Branch (35168:21): [True: 18, False: 33]
|
35169 | PyMem_Free(_children); |
35170 | _PyPegen_insert_memo(p, _start_mark, _loop0_183_type, _seq); |
35171 | p->level--; |
35172 | return _seq; |
35173 | } |
35174 | |
35175 | // _tmp_184: ',' | lambda_param_no_default |
35176 | static void * |
35177 | _tmp_184_rule(Parser *p) |
35178 | { |
35179 | if (p->level++ == MAXSTACK) { Branch (35179:9): [True: 0, False: 17]
|
35180 | p->error_indicator = 1; |
35181 | PyErr_NoMemory(); |
35182 | } |
35183 | if (p->error_indicator) { Branch (35183:9): [True: 0, False: 17]
|
35184 | p->level--; |
35185 | return NULL; |
35186 | } |
35187 | void * _res = NULL; |
35188 | int _mark = p->mark; |
35189 | { // ',' |
35190 | if (p->error_indicator) { |
35191 | p->level--; |
35192 | return NULL; |
35193 | } |
35194 | D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
35195 | Token * _literal; |
35196 | if ( |
35197 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
35198 | ) |
35199 | { |
35200 | D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
35201 | _res = _literal; |
35202 | goto done; |
35203 | } |
35204 | p->mark = _mark; |
35205 | D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ', |
35206 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
35207 | } |
35208 | { // lambda_param_no_default |
35209 | if (p->error_indicator) { |
35210 | p->level--; |
35211 | return NULL; |
35212 | } |
35213 | D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
35214 | arg_ty lambda_param_no_default_var; |
35215 | if ( |
35216 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default |
35217 | ) |
35218 | { |
35219 | D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
35220 | _res = lambda_param_no_default_var; |
35221 | goto done; |
35222 | } |
35223 | p->mark = _mark; |
35224 | D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ', |
35225 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
35226 | } |
35227 | _res = NULL; |
35228 | done: |
35229 | p->level--; |
35230 | return _res; |
35231 | } |
35232 | |
35233 | // _loop0_185: lambda_param_maybe_default |
35234 | static asdl_seq * |
35235 | _loop0_185_rule(Parser *p) |
35236 | { |
35237 | if (p->level++ == MAXSTACK) { Branch (35237:9): [True: 0, False: 15]
|
35238 | p->error_indicator = 1; |
35239 | PyErr_NoMemory(); |
35240 | } |
35241 | if (p->error_indicator) { Branch (35241:9): [True: 0, False: 15]
|
35242 | p->level--; |
35243 | return NULL; |
35244 | } |
35245 | void *_res = NULL; |
35246 | int _mark = p->mark; |
35247 | int _start_mark = p->mark; |
35248 | void **_children = PyMem_Malloc(sizeof(void *)); |
35249 | if (!_children) { Branch (35249:9): [True: 0, False: 15]
|
35250 | p->error_indicator = 1; |
35251 | PyErr_NoMemory(); |
35252 | p->level--; |
35253 | return NULL; |
35254 | } |
35255 | Py_ssize_t _children_capacity = 1; |
35256 | Py_ssize_t _n = 0; |
35257 | { // lambda_param_maybe_default |
35258 | if (p->error_indicator) { |
35259 | p->level--; |
35260 | return NULL; |
35261 | } |
35262 | D(fprintf(stderr, "%*c> _loop0_185[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
35263 | NameDefaultPair* lambda_param_maybe_default_var; |
35264 | while ( |
35265 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default Branch (35265:13): [True: 12, False: 15]
|
35266 | ) |
35267 | { |
35268 | _res = lambda_param_maybe_default_var; |
35269 | if (_n == _children_capacity) { |
35270 | _children_capacity *= 2; |
35271 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35272 | if (!_new_children) { |
35273 | p->error_indicator = 1; |
35274 | PyErr_NoMemory(); |
35275 | p->level--; |
35276 | return NULL; |
35277 | } |
35278 | _children = _new_children; |
35279 | } |
35280 | _children[_n++] = _res; |
35281 | _mark = p->mark; |
35282 | } |
35283 | p->mark = _mark; |
35284 | D(fprintf(stderr, "%*c%s _loop0_185[%d-%d]: %s failed!\n", p->level, ' ', |
35285 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
35286 | } |
35287 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35288 | if (!_seq) { Branch (35288:9): [True: 0, False: 15]
|
35289 | PyMem_Free(_children); |
35290 | p->error_indicator = 1; |
35291 | PyErr_NoMemory(); |
35292 | p->level--; |
35293 | return NULL; |
35294 | } |
35295 | for (int i = 0; 15 i < _n; i++12 ) asdl_seq_SET_UNTYPED15 (_seq, i, _children[i]); Branch (35295:21): [True: 12, False: 15]
|
35296 | PyMem_Free(_children); |
35297 | _PyPegen_insert_memo(p, _start_mark, _loop0_185_type, _seq); |
35298 | p->level--; |
35299 | return _seq; |
35300 | } |
35301 | |
35302 | // _loop1_186: lambda_param_maybe_default |
35303 | static asdl_seq * |
35304 | _loop1_186_rule(Parser *p) |
35305 | { |
35306 | if (p->level++ == MAXSTACK) { Branch (35306:9): [True: 0, False: 26]
|
35307 | p->error_indicator = 1; |
35308 | PyErr_NoMemory(); |
35309 | } |
35310 | if (p->error_indicator) { Branch (35310:9): [True: 0, False: 26]
|
35311 | p->level--; |
35312 | return NULL; |
35313 | } |
35314 | void *_res = NULL; |
35315 | int _mark = p->mark; |
35316 | int _start_mark = p->mark; |
35317 | void **_children = PyMem_Malloc(sizeof(void *)); |
35318 | if (!_children) { Branch (35318:9): [True: 0, False: 26]
|
35319 | p->error_indicator = 1; |
35320 | PyErr_NoMemory(); |
35321 | p->level--; |
35322 | return NULL; |
35323 | } |
35324 | Py_ssize_t _children_capacity = 1; |
35325 | Py_ssize_t _n = 0; |
35326 | { // lambda_param_maybe_default |
35327 | if (p->error_indicator) { |
35328 | p->level--; |
35329 | return NULL; |
35330 | } |
35331 | D(fprintf(stderr, "%*c> _loop1_186[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
35332 | NameDefaultPair* lambda_param_maybe_default_var; |
35333 | while ( |
35334 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default Branch (35334:13): [True: 18, False: 26]
|
35335 | ) |
35336 | { |
35337 | _res = lambda_param_maybe_default_var; |
35338 | if (_n == _children_capacity) { |
35339 | _children_capacity *= 2; |
35340 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35341 | if (!_new_children) { |
35342 | p->error_indicator = 1; |
35343 | PyErr_NoMemory(); |
35344 | p->level--; |
35345 | return NULL; |
35346 | } |
35347 | _children = _new_children; |
35348 | } |
35349 | _children[_n++] = _res; |
35350 | _mark = p->mark; |
35351 | } |
35352 | p->mark = _mark; |
35353 | D(fprintf(stderr, "%*c%s _loop1_186[%d-%d]: %s failed!\n", p->level, ' ', |
35354 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
35355 | } |
35356 | if (_n == 0 || p->error_indicator16 ) { Branch (35356:9): [True: 10, False: 16]
Branch (35356:20): [True: 0, False: 16]
|
35357 | PyMem_Free(_children); |
35358 | p->level--; |
35359 | return NULL; |
35360 | } |
35361 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35362 | if (!_seq) { Branch (35362:9): [True: 0, False: 16]
|
35363 | PyMem_Free(_children); |
35364 | p->error_indicator = 1; |
35365 | PyErr_NoMemory(); |
35366 | p->level--; |
35367 | return NULL; |
35368 | } |
35369 | for (int i = 0; 16 i < _n; i++18 ) asdl_seq_SET_UNTYPED16 (_seq, i, _children[i]); Branch (35369:21): [True: 18, False: 16]
|
35370 | PyMem_Free(_children); |
35371 | _PyPegen_insert_memo(p, _start_mark, _loop1_186_type, _seq); |
35372 | p->level--; |
35373 | return _seq; |
35374 | } |
35375 | |
35376 | // _loop1_187: lambda_param_with_default |
35377 | static asdl_seq * |
35378 | _loop1_187_rule(Parser *p) |
35379 | { |
35380 | if (p->level++ == MAXSTACK) { Branch (35380:9): [True: 0, False: 47]
|
35381 | p->error_indicator = 1; |
35382 | PyErr_NoMemory(); |
35383 | } |
35384 | if (p->error_indicator) { Branch (35384:9): [True: 0, False: 47]
|
35385 | p->level--; |
35386 | return NULL; |
35387 | } |
35388 | void *_res = NULL; |
35389 | int _mark = p->mark; |
35390 | int _start_mark = p->mark; |
35391 | void **_children = PyMem_Malloc(sizeof(void *)); |
35392 | if (!_children) { Branch (35392:9): [True: 0, False: 47]
|
35393 | p->error_indicator = 1; |
35394 | PyErr_NoMemory(); |
35395 | p->level--; |
35396 | return NULL; |
35397 | } |
35398 | Py_ssize_t _children_capacity = 1; |
35399 | Py_ssize_t _n = 0; |
35400 | { // lambda_param_with_default |
35401 | if (p->error_indicator) { |
35402 | p->level--; |
35403 | return NULL; |
35404 | } |
35405 | D(fprintf(stderr, "%*c> _loop1_187[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); |
35406 | NameDefaultPair* lambda_param_with_default_var; |
35407 | while ( |
35408 | (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default |
35409 | ) |
35410 | { |
35411 | _res = lambda_param_with_default_var; |
35412 | if (_n == _children_capacity) { |
35413 | _children_capacity *= 2; |
35414 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35415 | if (!_new_children) { |
35416 | p->error_indicator = 1; |
35417 | PyErr_NoMemory(); |
35418 | p->level--; |
35419 | return NULL; |
35420 | } |
35421 | _children = _new_children; |
35422 | } |
35423 | _children[_n++] = _res; |
35424 | _mark = p->mark; |
35425 | } |
35426 | p->mark = _mark; |
35427 | D(fprintf(stderr, "%*c%s _loop1_187[%d-%d]: %s failed!\n", p->level, ' ', |
35428 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); |
35429 | } |
35430 | if (_n == 0 || p->error_indicator4 ) { Branch (35430:9): [True: 43, False: 4]
Branch (35430:20): [True: 0, False: 4]
|
35431 | PyMem_Free(_children); |
35432 | p->level--; |
35433 | return NULL; |
35434 | } |
35435 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35436 | if (!_seq) { Branch (35436:9): [True: 0, False: 4]
|
35437 | PyMem_Free(_children); |
35438 | p->error_indicator = 1; |
35439 | PyErr_NoMemory(); |
35440 | p->level--; |
35441 | return NULL; |
35442 | } |
35443 | for (int i = 0; 4 i < _n; i++4 ) asdl_seq_SET_UNTYPED4 (_seq, i, _children[i]); |
35444 | PyMem_Free(_children); |
35445 | _PyPegen_insert_memo(p, _start_mark, _loop1_187_type, _seq); |
35446 | p->level--; |
35447 | return _seq; |
35448 | } |
35449 | |
35450 | // _tmp_188: ':' | ',' (':' | '**') |
35451 | static void * |
35452 | _tmp_188_rule(Parser *p) |
35453 | { |
35454 | if (p->level++ == MAXSTACK) { Branch (35454:9): [True: 0, False: 10]
|
35455 | p->error_indicator = 1; |
35456 | PyErr_NoMemory(); |
35457 | } |
35458 | if (p->error_indicator) { Branch (35458:9): [True: 0, False: 10]
|
35459 | p->level--; |
35460 | return NULL; |
35461 | } |
35462 | void * _res = NULL; |
35463 | int _mark = p->mark; |
35464 | { // ':' |
35465 | if (p->error_indicator) { |
35466 | p->level--; |
35467 | return NULL; |
35468 | } |
35469 | D(fprintf(stderr, "%*c> _tmp_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); |
35470 | Token * _literal; |
35471 | if ( |
35472 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
35473 | ) |
35474 | { |
35475 | D(fprintf(stderr, "%*c+ _tmp_188[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); |
35476 | _res = _literal; |
35477 | goto done; |
35478 | } |
35479 | p->mark = _mark; |
35480 | D(fprintf(stderr, "%*c%s _tmp_188[%d-%d]: %s failed!\n", p->level, ' ', |
35481 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); |
35482 | } |
35483 | { // ',' (':' | '**') |
35484 | if (p->error_indicator) { |
35485 | p->level--; |
35486 | return NULL; |
35487 | } |
35488 | D(fprintf(stderr, "%*c> _tmp_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); |
35489 | Token * _literal; |
35490 | void *_tmp_236_var; |
35491 | if ( |
35492 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
35493 | && |
35494 | (_tmp_236_var = _tmp_236_rule(p))0 // ':' | '**' |
35495 | ) |
35496 | { |
35497 | D(fprintf(stderr, "%*c+ _tmp_188[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); |
35498 | _res = _PyPegen_dummy_name(p, _literal, _tmp_236_var); |
35499 | goto done; |
35500 | } |
35501 | p->mark = _mark; |
35502 | D(fprintf(stderr, "%*c%s _tmp_188[%d-%d]: %s failed!\n", p->level, ' ', |
35503 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); |
35504 | } |
35505 | _res = NULL; |
35506 | done: |
35507 | p->level--; |
35508 | return _res; |
35509 | } |
35510 | |
35511 | // _tmp_189: lambda_param_no_default | ',' |
35512 | static void * |
35513 | _tmp_189_rule(Parser *p) |
35514 | { |
35515 | if (p->level++ == MAXSTACK) { Branch (35515:9): [True: 0, False: 8]
|
35516 | p->error_indicator = 1; |
35517 | PyErr_NoMemory(); |
35518 | } |
35519 | if (p->error_indicator) { Branch (35519:9): [True: 0, False: 8]
|
35520 | p->level--; |
35521 | return NULL; |
35522 | } |
35523 | void * _res = NULL; |
35524 | int _mark = p->mark; |
35525 | { // lambda_param_no_default |
35526 | if (p->error_indicator) { |
35527 | p->level--; |
35528 | return NULL; |
35529 | } |
35530 | D(fprintf(stderr, "%*c> _tmp_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
35531 | arg_ty lambda_param_no_default_var; |
35532 | if ( |
35533 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default |
35534 | ) |
35535 | { |
35536 | D(fprintf(stderr, "%*c+ _tmp_189[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
35537 | _res = lambda_param_no_default_var; |
35538 | goto done; |
35539 | } |
35540 | p->mark = _mark; |
35541 | D(fprintf(stderr, "%*c%s _tmp_189[%d-%d]: %s failed!\n", p->level, ' ', |
35542 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
35543 | } |
35544 | { // ',' |
35545 | if (p->error_indicator) { |
35546 | p->level--; |
35547 | return NULL; |
35548 | } |
35549 | D(fprintf(stderr, "%*c> _tmp_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
35550 | Token * _literal; |
35551 | if ( |
35552 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
35553 | ) |
35554 | { |
35555 | D(fprintf(stderr, "%*c+ _tmp_189[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
35556 | _res = _literal; |
35557 | goto done; |
35558 | } |
35559 | p->mark = _mark; |
35560 | D(fprintf(stderr, "%*c%s _tmp_189[%d-%d]: %s failed!\n", p->level, ' ', |
35561 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
35562 | } |
35563 | _res = NULL; |
35564 | done: |
35565 | p->level--; |
35566 | return _res; |
35567 | } |
35568 | |
35569 | // _loop0_190: lambda_param_maybe_default |
35570 | static asdl_seq * |
35571 | _loop0_190_rule(Parser *p) |
35572 | { |
35573 | if (p->level++ == MAXSTACK) { Branch (35573:9): [True: 0, False: 8]
|
35574 | p->error_indicator = 1; |
35575 | PyErr_NoMemory(); |
35576 | } |
35577 | if (p->error_indicator) { Branch (35577:9): [True: 0, False: 8]
|
35578 | p->level--; |
35579 | return NULL; |
35580 | } |
35581 | void *_res = NULL; |
35582 | int _mark = p->mark; |
35583 | int _start_mark = p->mark; |
35584 | void **_children = PyMem_Malloc(sizeof(void *)); |
35585 | if (!_children) { Branch (35585:9): [True: 0, False: 8]
|
35586 | p->error_indicator = 1; |
35587 | PyErr_NoMemory(); |
35588 | p->level--; |
35589 | return NULL; |
35590 | } |
35591 | Py_ssize_t _children_capacity = 1; |
35592 | Py_ssize_t _n = 0; |
35593 | { // lambda_param_maybe_default |
35594 | if (p->error_indicator) { |
35595 | p->level--; |
35596 | return NULL; |
35597 | } |
35598 | D(fprintf(stderr, "%*c> _loop0_190[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); |
35599 | NameDefaultPair* lambda_param_maybe_default_var; |
35600 | while ( |
35601 | (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default |
35602 | ) |
35603 | { |
35604 | _res = lambda_param_maybe_default_var; |
35605 | if (_n == _children_capacity) { |
35606 | _children_capacity *= 2; |
35607 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35608 | if (!_new_children) { |
35609 | p->error_indicator = 1; |
35610 | PyErr_NoMemory(); |
35611 | p->level--; |
35612 | return NULL; |
35613 | } |
35614 | _children = _new_children; |
35615 | } |
35616 | _children[_n++] = _res; |
35617 | _mark = p->mark; |
35618 | } |
35619 | p->mark = _mark; |
35620 | D(fprintf(stderr, "%*c%s _loop0_190[%d-%d]: %s failed!\n", p->level, ' ', |
35621 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); |
35622 | } |
35623 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35624 | if (!_seq) { Branch (35624:9): [True: 0, False: 8]
|
35625 | PyMem_Free(_children); |
35626 | p->error_indicator = 1; |
35627 | PyErr_NoMemory(); |
35628 | p->level--; |
35629 | return NULL; |
35630 | } |
35631 | for (int i = 0; 8 i < _n; i++7 ) asdl_seq_SET_UNTYPED8 (_seq, i, _children[i]); |
35632 | PyMem_Free(_children); |
35633 | _PyPegen_insert_memo(p, _start_mark, _loop0_190_type, _seq); |
35634 | p->level--; |
35635 | return _seq; |
35636 | } |
35637 | |
35638 | // _tmp_191: lambda_param_no_default | ',' |
35639 | static void * |
35640 | _tmp_191_rule(Parser *p) |
35641 | { |
35642 | if (p->level++ == MAXSTACK) { Branch (35642:9): [True: 0, False: 4]
|
35643 | p->error_indicator = 1; |
35644 | PyErr_NoMemory(); |
35645 | } |
35646 | if (p->error_indicator) { Branch (35646:9): [True: 0, False: 4]
|
35647 | p->level--; |
35648 | return NULL; |
35649 | } |
35650 | void * _res = NULL; |
35651 | int _mark = p->mark; |
35652 | { // lambda_param_no_default |
35653 | if (p->error_indicator) { |
35654 | p->level--; |
35655 | return NULL; |
35656 | } |
35657 | D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
35658 | arg_ty lambda_param_no_default_var; |
35659 | if ( |
35660 | (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default |
35661 | ) |
35662 | { |
35663 | D(fprintf(stderr, "%*c+ _tmp_191[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); |
35664 | _res = lambda_param_no_default_var; |
35665 | goto done; |
35666 | } |
35667 | p->mark = _mark; |
35668 | D(fprintf(stderr, "%*c%s _tmp_191[%d-%d]: %s failed!\n", p->level, ' ', |
35669 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); |
35670 | } |
35671 | { // ',' |
35672 | if (p->error_indicator) { |
35673 | p->level--; |
35674 | return NULL; |
35675 | } |
35676 | D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
35677 | Token * _literal; |
35678 | if ( |
35679 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
35680 | ) |
35681 | { |
35682 | D(fprintf(stderr, "%*c+ _tmp_191[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
35683 | _res = _literal; |
35684 | goto done; |
35685 | } |
35686 | p->mark = _mark; |
35687 | D(fprintf(stderr, "%*c%s _tmp_191[%d-%d]: %s failed!\n", p->level, ' ', |
35688 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
35689 | } |
35690 | _res = NULL; |
35691 | done: |
35692 | p->level--; |
35693 | return _res; |
35694 | } |
35695 | |
35696 | // _tmp_192: '*' | '**' | '/' |
35697 | static void * |
35698 | _tmp_192_rule(Parser *p) |
35699 | { |
35700 | if (p->level++ == MAXSTACK) { Branch (35700:9): [True: 0, False: 4]
|
35701 | p->error_indicator = 1; |
35702 | PyErr_NoMemory(); |
35703 | } |
35704 | if (p->error_indicator) { Branch (35704:9): [True: 0, False: 4]
|
35705 | p->level--; |
35706 | return NULL; |
35707 | } |
35708 | void * _res = NULL; |
35709 | int _mark = p->mark; |
35710 | { // '*' |
35711 | if (p->error_indicator) { |
35712 | p->level--; |
35713 | return NULL; |
35714 | } |
35715 | D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); |
35716 | Token * _literal; |
35717 | if ( |
35718 | (_literal = _PyPegen_expect_token(p, 16)) // token='*' |
35719 | ) |
35720 | { |
35721 | D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); |
35722 | _res = _literal; |
35723 | goto done; |
35724 | } |
35725 | p->mark = _mark; |
35726 | D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ', |
35727 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); |
35728 | } |
35729 | { // '**' |
35730 | if (p->error_indicator) { |
35731 | p->level--; |
35732 | return NULL; |
35733 | } |
35734 | D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); |
35735 | Token * _literal; |
35736 | if ( |
35737 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
35738 | ) |
35739 | { |
35740 | D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); |
35741 | _res = _literal; |
35742 | goto done; |
35743 | } |
35744 | p->mark = _mark; |
35745 | D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ', |
35746 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); |
35747 | } |
35748 | { // '/' |
35749 | if (p->error_indicator) { |
35750 | p->level--; |
35751 | return NULL; |
35752 | } |
35753 | D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); |
35754 | Token * _literal; |
35755 | if ( |
35756 | (_literal = _PyPegen_expect_token(p, 17)) // token='/' |
35757 | ) |
35758 | { |
35759 | D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); |
35760 | _res = _literal; |
35761 | goto done; |
35762 | } |
35763 | p->mark = _mark; |
35764 | D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ', |
35765 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); |
35766 | } |
35767 | _res = NULL; |
35768 | done: |
35769 | p->level--; |
35770 | return _res; |
35771 | } |
35772 | |
35773 | // _tmp_193: ',' | ')' | ':' |
35774 | static void * |
35775 | _tmp_193_rule(Parser *p) |
35776 | { |
35777 | if (p->level++ == MAXSTACK) { Branch (35777:9): [True: 0, False: 14]
|
35778 | p->error_indicator = 1; |
35779 | PyErr_NoMemory(); |
35780 | } |
35781 | if (p->error_indicator) { Branch (35781:9): [True: 0, False: 14]
|
35782 | p->level--; |
35783 | return NULL; |
35784 | } |
35785 | void * _res = NULL; |
35786 | int _mark = p->mark; |
35787 | { // ',' |
35788 | if (p->error_indicator) { |
35789 | p->level--; |
35790 | return NULL; |
35791 | } |
35792 | D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
35793 | Token * _literal; |
35794 | if ( |
35795 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
35796 | ) |
35797 | { |
35798 | D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
35799 | _res = _literal; |
35800 | goto done; |
35801 | } |
35802 | p->mark = _mark; |
35803 | D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ', |
35804 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
35805 | } |
35806 | { // ')' |
35807 | if (p->error_indicator) { |
35808 | p->level--; |
35809 | return NULL; |
35810 | } |
35811 | D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); |
35812 | Token * _literal; |
35813 | if ( |
35814 | (_literal = _PyPegen_expect_token(p, 8)) // token=')' |
35815 | ) |
35816 | { |
35817 | D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); |
35818 | _res = _literal; |
35819 | goto done; |
35820 | } |
35821 | p->mark = _mark; |
35822 | D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ', |
35823 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); |
35824 | } |
35825 | { // ':' |
35826 | if (p->error_indicator) { |
35827 | p->level--; |
35828 | return NULL; |
35829 | } |
35830 | D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); |
35831 | Token * _literal; |
35832 | if ( |
35833 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
35834 | ) |
35835 | { |
35836 | D(fprintf(stderr, "%*c+ _tmp_193[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); |
35837 | _res = _literal; |
35838 | goto done; |
35839 | } |
35840 | p->mark = _mark; |
35841 | D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ', |
35842 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); |
35843 | } |
35844 | _res = NULL; |
35845 | done: |
35846 | p->level--; |
35847 | return _res; |
35848 | } |
35849 | |
35850 | // _loop0_195: ',' (expression ['as' star_target]) |
35851 | static asdl_seq * |
35852 | _loop0_195_rule(Parser *p) |
35853 | { |
35854 | if (p->level++ == MAXSTACK) { Branch (35854:9): [True: 0, False: 7]
|
35855 | p->error_indicator = 1; |
35856 | PyErr_NoMemory(); |
35857 | } |
35858 | if (p->error_indicator) { Branch (35858:9): [True: 0, False: 7]
|
35859 | p->level--; |
35860 | return NULL; |
35861 | } |
35862 | void *_res = NULL; |
35863 | int _mark = p->mark; |
35864 | int _start_mark = p->mark; |
35865 | void **_children = PyMem_Malloc(sizeof(void *)); |
35866 | if (!_children) { Branch (35866:9): [True: 0, False: 7]
|
35867 | p->error_indicator = 1; |
35868 | PyErr_NoMemory(); |
35869 | p->level--; |
35870 | return NULL; |
35871 | } |
35872 | Py_ssize_t _children_capacity = 1; |
35873 | Py_ssize_t _n = 0; |
35874 | { // ',' (expression ['as' star_target]) |
35875 | if (p->error_indicator) { |
35876 | p->level--; |
35877 | return NULL; |
35878 | } |
35879 | D(fprintf(stderr, "%*c> _loop0_195[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); |
35880 | Token * _literal; |
35881 | void *elem; |
35882 | while ( |
35883 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
35884 | && |
35885 | (elem = _tmp_237_rule(p))3 // expression ['as' star_target] |
35886 | ) |
35887 | { |
35888 | _res = elem; |
35889 | if (_res == NULL && PyErr_Occurred()0 ) { |
35890 | p->error_indicator = 1; |
35891 | PyMem_Free(_children); |
35892 | p->level--; |
35893 | return NULL; |
35894 | } |
35895 | if (_n == _children_capacity) { |
35896 | _children_capacity *= 2; |
35897 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
35898 | if (!_new_children) { |
35899 | p->error_indicator = 1; |
35900 | PyErr_NoMemory(); |
35901 | p->level--; |
35902 | return NULL; |
35903 | } |
35904 | _children = _new_children; |
35905 | } |
35906 | _children[_n++] = _res; |
35907 | _mark = p->mark; |
35908 | } |
35909 | p->mark = _mark; |
35910 | D(fprintf(stderr, "%*c%s _loop0_195[%d-%d]: %s failed!\n", p->level, ' ', |
35911 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])")); |
35912 | } |
35913 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
35914 | if (!_seq) { Branch (35914:9): [True: 0, False: 7]
|
35915 | PyMem_Free(_children); |
35916 | p->error_indicator = 1; |
35917 | PyErr_NoMemory(); |
35918 | p->level--; |
35919 | return NULL; |
35920 | } |
35921 | for (int i = 0; 7 i < _n; i++3 ) asdl_seq_SET_UNTYPED7 (_seq, i, _children[i]); |
35922 | PyMem_Free(_children); |
35923 | _PyPegen_insert_memo(p, _start_mark, _loop0_195_type, _seq); |
35924 | p->level--; |
35925 | return _seq; |
35926 | } |
35927 | |
35928 | // _gather_194: (expression ['as' star_target]) _loop0_195 |
35929 | static asdl_seq * |
35930 | _gather_194_rule(Parser *p) |
35931 | { |
35932 | if (p->level++ == MAXSTACK) { Branch (35932:9): [True: 0, False: 11]
|
35933 | p->error_indicator = 1; |
35934 | PyErr_NoMemory(); |
35935 | } |
35936 | if (p->error_indicator) { Branch (35936:9): [True: 0, False: 11]
|
35937 | p->level--; |
35938 | return NULL; |
35939 | } |
35940 | asdl_seq * _res = NULL; |
35941 | int _mark = p->mark; |
35942 | { // (expression ['as' star_target]) _loop0_195 |
35943 | if (p->error_indicator) { |
35944 | p->level--; |
35945 | return NULL; |
35946 | } |
35947 | D(fprintf(stderr, "%*c> _gather_194[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_195")); |
35948 | void *elem; |
35949 | asdl_seq * seq; |
35950 | if ( |
35951 | (elem = _tmp_237_rule(p)) // expression ['as' star_target] |
35952 | && |
35953 | (seq = _loop0_195_rule(p))7 // _loop0_195 |
35954 | ) |
35955 | { |
35956 | D(fprintf(stderr, "%*c+ _gather_194[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_195")); |
35957 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
35958 | goto done; |
35959 | } |
35960 | p->mark = _mark; |
35961 | D(fprintf(stderr, "%*c%s _gather_194[%d-%d]: %s failed!\n", p->level, ' ', |
35962 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_195")); |
35963 | } |
35964 | _res = NULL; |
35965 | done: |
35966 | p->level--; |
35967 | return _res; |
35968 | } |
35969 | |
35970 | // _loop0_197: ',' (expressions ['as' star_target]) |
35971 | static asdl_seq * |
35972 | _loop0_197_rule(Parser *p) |
35973 | { |
35974 | if (p->level++ == MAXSTACK) { Branch (35974:9): [True: 0, False: 3]
|
35975 | p->error_indicator = 1; |
35976 | PyErr_NoMemory(); |
35977 | } |
35978 | if (p->error_indicator) { Branch (35978:9): [True: 0, False: 3]
|
35979 | p->level--; |
35980 | return NULL; |
35981 | } |
35982 | void *_res = NULL; |
35983 | int _mark = p->mark; |
35984 | int _start_mark = p->mark; |
35985 | void **_children = PyMem_Malloc(sizeof(void *)); |
35986 | if (!_children) { Branch (35986:9): [True: 0, False: 3]
|
35987 | p->error_indicator = 1; |
35988 | PyErr_NoMemory(); |
35989 | p->level--; |
35990 | return NULL; |
35991 | } |
35992 | Py_ssize_t _children_capacity = 1; |
35993 | Py_ssize_t _n = 0; |
35994 | { // ',' (expressions ['as' star_target]) |
35995 | if (p->error_indicator) { |
35996 | p->level--; |
35997 | return NULL; |
35998 | } |
35999 | D(fprintf(stderr, "%*c> _loop0_197[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); |
36000 | Token * _literal; |
36001 | void *elem; |
36002 | while ( |
36003 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
36004 | && |
36005 | (elem = _tmp_238_rule(p))1 // expressions ['as' star_target] |
36006 | ) |
36007 | { |
36008 | _res = elem; |
36009 | if (_res == NULL && PyErr_Occurred()0 ) { |
36010 | p->error_indicator = 1; |
36011 | PyMem_Free(_children); |
36012 | p->level--; |
36013 | return NULL; |
36014 | } |
36015 | if (_n == _children_capacity) { |
36016 | _children_capacity *= 2; |
36017 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
36018 | if (!_new_children) { |
36019 | p->error_indicator = 1; |
36020 | PyErr_NoMemory(); |
36021 | p->level--; |
36022 | return NULL; |
36023 | } |
36024 | _children = _new_children; |
36025 | } |
36026 | _children[_n++] = _res; |
36027 | _mark = p->mark; |
36028 | } |
36029 | p->mark = _mark; |
36030 | D(fprintf(stderr, "%*c%s _loop0_197[%d-%d]: %s failed!\n", p->level, ' ', |
36031 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])")); |
36032 | } |
36033 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
36034 | if (!_seq) { Branch (36034:9): [True: 0, False: 3]
|
36035 | PyMem_Free(_children); |
36036 | p->error_indicator = 1; |
36037 | PyErr_NoMemory(); |
36038 | p->level--; |
36039 | return NULL; |
36040 | } |
36041 | for (int i = 0; 3 i < _n; i++1 ) asdl_seq_SET_UNTYPED3 (_seq, i, _children[i]); |
36042 | PyMem_Free(_children); |
36043 | _PyPegen_insert_memo(p, _start_mark, _loop0_197_type, _seq); |
36044 | p->level--; |
36045 | return _seq; |
36046 | } |
36047 | |
36048 | // _gather_196: (expressions ['as' star_target]) _loop0_197 |
36049 | static asdl_seq * |
36050 | _gather_196_rule(Parser *p) |
36051 | { |
36052 | if (p->level++ == MAXSTACK) { Branch (36052:9): [True: 0, False: 3]
|
36053 | p->error_indicator = 1; |
36054 | PyErr_NoMemory(); |
36055 | } |
36056 | if (p->error_indicator) { Branch (36056:9): [True: 0, False: 3]
|
36057 | p->level--; |
36058 | return NULL; |
36059 | } |
36060 | asdl_seq * _res = NULL; |
36061 | int _mark = p->mark; |
36062 | { // (expressions ['as' star_target]) _loop0_197 |
36063 | if (p->error_indicator) { |
36064 | p->level--; |
36065 | return NULL; |
36066 | } |
36067 | D(fprintf(stderr, "%*c> _gather_196[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_197")); |
36068 | void *elem; |
36069 | asdl_seq * seq; |
36070 | if ( |
36071 | (elem = _tmp_238_rule(p)) // expressions ['as' star_target] |
36072 | && |
36073 | (seq = _loop0_197_rule(p)) // _loop0_197 |
36074 | ) |
36075 | { |
36076 | D(fprintf(stderr, "%*c+ _gather_196[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_197")); |
36077 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
36078 | goto done; |
36079 | } |
36080 | p->mark = _mark; |
36081 | D(fprintf(stderr, "%*c%s _gather_196[%d-%d]: %s failed!\n", p->level, ' ', |
36082 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_197")); |
36083 | } |
36084 | _res = NULL; |
36085 | done: |
36086 | p->level--; |
36087 | return _res; |
36088 | } |
36089 | |
36090 | // _loop0_199: ',' (expression ['as' star_target]) |
36091 | static asdl_seq * |
36092 | _loop0_199_rule(Parser *p) |
36093 | { |
36094 | if (p->level++ == MAXSTACK) { Branch (36094:9): [True: 0, False: 22]
|
36095 | p->error_indicator = 1; |
36096 | PyErr_NoMemory(); |
36097 | } |
36098 | if (p->error_indicator) { Branch (36098:9): [True: 0, False: 22]
|
36099 | p->level--; |
36100 | return NULL; |
36101 | } |
36102 | void *_res = NULL; |
36103 | int _mark = p->mark; |
36104 | int _start_mark = p->mark; |
36105 | void **_children = PyMem_Malloc(sizeof(void *)); |
36106 | if (!_children) { Branch (36106:9): [True: 0, False: 22]
|
36107 | p->error_indicator = 1; |
36108 | PyErr_NoMemory(); |
36109 | p->level--; |
36110 | return NULL; |
36111 | } |
36112 | Py_ssize_t _children_capacity = 1; |
36113 | Py_ssize_t _n = 0; |
36114 | { // ',' (expression ['as' star_target]) |
36115 | if (p->error_indicator) { |
36116 | p->level--; |
36117 | return NULL; |
36118 | } |
36119 | D(fprintf(stderr, "%*c> _loop0_199[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); |
36120 | Token * _literal; |
36121 | void *elem; |
36122 | while ( |
36123 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
36124 | && |
36125 | (elem = _tmp_239_rule(p))6 // expression ['as' star_target] |
36126 | ) |
36127 | { |
36128 | _res = elem; |
36129 | if (_res == NULL && PyErr_Occurred()0 ) { |
36130 | p->error_indicator = 1; |
36131 | PyMem_Free(_children); |
36132 | p->level--; |
36133 | return NULL; |
36134 | } |
36135 | if (_n == _children_capacity) { |
36136 | _children_capacity *= 2; |
36137 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
36138 | if (!_new_children) { |
36139 | p->error_indicator = 1; |
36140 | PyErr_NoMemory(); |
36141 | p->level--; |
36142 | return NULL; |
36143 | } |
36144 | _children = _new_children; |
36145 | } |
36146 | _children[_n++] = _res; |
36147 | _mark = p->mark; |
36148 | } |
36149 | p->mark = _mark; |
36150 | D(fprintf(stderr, "%*c%s _loop0_199[%d-%d]: %s failed!\n", p->level, ' ', |
36151 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])")); |
36152 | } |
36153 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
36154 | if (!_seq) { Branch (36154:9): [True: 0, False: 22]
|
36155 | PyMem_Free(_children); |
36156 | p->error_indicator = 1; |
36157 | PyErr_NoMemory(); |
36158 | p->level--; |
36159 | return NULL; |
36160 | } |
36161 | for (int i = 0; 22 i < _n; i++6 ) asdl_seq_SET_UNTYPED22 (_seq, i, _children[i]); |
36162 | PyMem_Free(_children); |
36163 | _PyPegen_insert_memo(p, _start_mark, _loop0_199_type, _seq); |
36164 | p->level--; |
36165 | return _seq; |
36166 | } |
36167 | |
36168 | // _gather_198: (expression ['as' star_target]) _loop0_199 |
36169 | static asdl_seq * |
36170 | _gather_198_rule(Parser *p) |
36171 | { |
36172 | if (p->level++ == MAXSTACK) { Branch (36172:9): [True: 0, False: 29]
|
36173 | p->error_indicator = 1; |
36174 | PyErr_NoMemory(); |
36175 | } |
36176 | if (p->error_indicator) { Branch (36176:9): [True: 0, False: 29]
|
36177 | p->level--; |
36178 | return NULL; |
36179 | } |
36180 | asdl_seq * _res = NULL; |
36181 | int _mark = p->mark; |
36182 | { // (expression ['as' star_target]) _loop0_199 |
36183 | if (p->error_indicator) { |
36184 | p->level--; |
36185 | return NULL; |
36186 | } |
36187 | D(fprintf(stderr, "%*c> _gather_198[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_199")); |
36188 | void *elem; |
36189 | asdl_seq * seq; |
36190 | if ( |
36191 | (elem = _tmp_239_rule(p)) // expression ['as' star_target] |
36192 | && |
36193 | (seq = _loop0_199_rule(p))22 // _loop0_199 |
36194 | ) |
36195 | { |
36196 | D(fprintf(stderr, "%*c+ _gather_198[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_199")); |
36197 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
36198 | goto done; |
36199 | } |
36200 | p->mark = _mark; |
36201 | D(fprintf(stderr, "%*c%s _gather_198[%d-%d]: %s failed!\n", p->level, ' ', |
36202 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_199")); |
36203 | } |
36204 | _res = NULL; |
36205 | done: |
36206 | p->level--; |
36207 | return _res; |
36208 | } |
36209 | |
36210 | // _loop0_201: ',' (expressions ['as' star_target]) |
36211 | static asdl_seq * |
36212 | _loop0_201_rule(Parser *p) |
36213 | { |
36214 | if (p->level++ == MAXSTACK) { Branch (36214:9): [True: 0, False: 6]
|
36215 | p->error_indicator = 1; |
36216 | PyErr_NoMemory(); |
36217 | } |
36218 | if (p->error_indicator) { Branch (36218:9): [True: 0, False: 6]
|
36219 | p->level--; |
36220 | return NULL; |
36221 | } |
36222 | void *_res = NULL; |
36223 | int _mark = p->mark; |
36224 | int _start_mark = p->mark; |
36225 | void **_children = PyMem_Malloc(sizeof(void *)); |
36226 | if (!_children) { Branch (36226:9): [True: 0, False: 6]
|
36227 | p->error_indicator = 1; |
36228 | PyErr_NoMemory(); |
36229 | p->level--; |
36230 | return NULL; |
36231 | } |
36232 | Py_ssize_t _children_capacity = 1; |
36233 | Py_ssize_t _n = 0; |
36234 | { // ',' (expressions ['as' star_target]) |
36235 | if (p->error_indicator) { |
36236 | p->level--; |
36237 | return NULL; |
36238 | } |
36239 | D(fprintf(stderr, "%*c> _loop0_201[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); |
36240 | Token * _literal; |
36241 | void *elem; |
36242 | while ( |
36243 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
36244 | && |
36245 | (elem = _tmp_240_rule(p))3 // expressions ['as' star_target] |
36246 | ) |
36247 | { |
36248 | _res = elem; |
36249 | if (_res == NULL && PyErr_Occurred()0 ) { |
36250 | p->error_indicator = 1; |
36251 | PyMem_Free(_children); |
36252 | p->level--; |
36253 | return NULL; |
36254 | } |
36255 | if (_n == _children_capacity) { |
36256 | _children_capacity *= 2; |
36257 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
36258 | if (!_new_children) { |
36259 | p->error_indicator = 1; |
36260 | PyErr_NoMemory(); |
36261 | p->level--; |
36262 | return NULL; |
36263 | } |
36264 | _children = _new_children; |
36265 | } |
36266 | _children[_n++] = _res; |
36267 | _mark = p->mark; |
36268 | } |
36269 | p->mark = _mark; |
36270 | D(fprintf(stderr, "%*c%s _loop0_201[%d-%d]: %s failed!\n", p->level, ' ', |
36271 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])")); |
36272 | } |
36273 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
36274 | if (!_seq) { Branch (36274:9): [True: 0, False: 6]
|
36275 | PyMem_Free(_children); |
36276 | p->error_indicator = 1; |
36277 | PyErr_NoMemory(); |
36278 | p->level--; |
36279 | return NULL; |
36280 | } |
36281 | for (int i = 0; 6 i < _n; i++3 ) asdl_seq_SET_UNTYPED6 (_seq, i, _children[i]); |
36282 | PyMem_Free(_children); |
36283 | _PyPegen_insert_memo(p, _start_mark, _loop0_201_type, _seq); |
36284 | p->level--; |
36285 | return _seq; |
36286 | } |
36287 | |
36288 | // _gather_200: (expressions ['as' star_target]) _loop0_201 |
36289 | static asdl_seq * |
36290 | _gather_200_rule(Parser *p) |
36291 | { |
36292 | if (p->level++ == MAXSTACK) { Branch (36292:9): [True: 0, False: 6]
|
36293 | p->error_indicator = 1; |
36294 | PyErr_NoMemory(); |
36295 | } |
36296 | if (p->error_indicator) { Branch (36296:9): [True: 0, False: 6]
|
36297 | p->level--; |
36298 | return NULL; |
36299 | } |
36300 | asdl_seq * _res = NULL; |
36301 | int _mark = p->mark; |
36302 | { // (expressions ['as' star_target]) _loop0_201 |
36303 | if (p->error_indicator) { |
36304 | p->level--; |
36305 | return NULL; |
36306 | } |
36307 | D(fprintf(stderr, "%*c> _gather_200[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_201")); |
36308 | void *elem; |
36309 | asdl_seq * seq; |
36310 | if ( |
36311 | (elem = _tmp_240_rule(p)) // expressions ['as' star_target] |
36312 | && |
36313 | (seq = _loop0_201_rule(p)) // _loop0_201 |
36314 | ) |
36315 | { |
36316 | D(fprintf(stderr, "%*c+ _gather_200[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_201")); |
36317 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
36318 | goto done; |
36319 | } |
36320 | p->mark = _mark; |
36321 | D(fprintf(stderr, "%*c%s _gather_200[%d-%d]: %s failed!\n", p->level, ' ', |
36322 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_201")); |
36323 | } |
36324 | _res = NULL; |
36325 | done: |
36326 | p->level--; |
36327 | return _res; |
36328 | } |
36329 | |
36330 | // _tmp_202: 'except' | 'finally' |
36331 | static void * |
36332 | _tmp_202_rule(Parser *p) |
36333 | { |
36334 | if (p->level++ == MAXSTACK) { Branch (36334:9): [True: 0, False: 41]
|
36335 | p->error_indicator = 1; |
36336 | PyErr_NoMemory(); |
36337 | } |
36338 | if (p->error_indicator) { Branch (36338:9): [True: 0, False: 41]
|
36339 | p->level--; |
36340 | return NULL; |
36341 | } |
36342 | void * _res = NULL; |
36343 | int _mark = p->mark; |
36344 | { // 'except' |
36345 | if (p->error_indicator) { |
36346 | p->level--; |
36347 | return NULL; |
36348 | } |
36349 | D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); |
36350 | Token * _keyword; |
36351 | if ( |
36352 | (_keyword = _PyPegen_expect_token(p, 629)) // token='except' Branch (36352:13): [True: 31, False: 10]
|
36353 | ) |
36354 | { |
36355 | D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); |
36356 | _res = _keyword; |
36357 | goto done; |
36358 | } |
36359 | p->mark = _mark; |
36360 | D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ', |
36361 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); |
36362 | } |
36363 | { // 'finally' |
36364 | if (p->error_indicator) { |
36365 | p->level--; |
36366 | return NULL; |
36367 | } |
36368 | D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); |
36369 | Token * _keyword; |
36370 | if ( |
36371 | (_keyword = _PyPegen_expect_token(p, 625)) // token='finally' |
36372 | ) |
36373 | { |
36374 | D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); |
36375 | _res = _keyword; |
36376 | goto done; |
36377 | } |
36378 | p->mark = _mark; |
36379 | D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ', |
36380 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); |
36381 | } |
36382 | _res = NULL; |
36383 | done: |
36384 | p->level--; |
36385 | return _res; |
36386 | } |
36387 | |
36388 | // _loop0_203: block |
36389 | static asdl_seq * |
36390 | _loop0_203_rule(Parser *p) |
36391 | { |
36392 | if (p->level++ == MAXSTACK) { Branch (36392:9): [True: 0, False: 49]
|
36393 | p->error_indicator = 1; |
36394 | PyErr_NoMemory(); |
36395 | } |
36396 | if (p->error_indicator) { Branch (36396:9): [True: 0, False: 49]
|
36397 | p->level--; |
36398 | return NULL; |
36399 | } |
36400 | void *_res = NULL; |
36401 | int _mark = p->mark; |
36402 | int _start_mark = p->mark; |
36403 | void **_children = PyMem_Malloc(sizeof(void *)); |
36404 | if (!_children) { Branch (36404:9): [True: 0, False: 49]
|
36405 | p->error_indicator = 1; |
36406 | PyErr_NoMemory(); |
36407 | p->level--; |
36408 | return NULL; |
36409 | } |
36410 | Py_ssize_t _children_capacity = 1; |
36411 | Py_ssize_t _n = 0; |
36412 | { // block |
36413 | if (p->error_indicator) { |
36414 | p->level--; |
36415 | return NULL; |
36416 | } |
36417 | D(fprintf(stderr, "%*c> _loop0_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); |
36418 | asdl_stmt_seq* block_var; |
36419 | while ( |
36420 | (block_var = block_rule(p)) // block Branch (36420:13): [True: 40, False: 49]
|
36421 | ) |
36422 | { |
36423 | _res = block_var; |
36424 | if (_n == _children_capacity) { |
36425 | _children_capacity *= 2; |
36426 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
36427 | if (!_new_children) { |
36428 | p->error_indicator = 1; |
36429 | PyErr_NoMemory(); |
36430 | p->level--; |
36431 | return NULL; |
36432 | } |
36433 | _children = _new_children; |
36434 | } |
36435 | _children[_n++] = _res; |
36436 | _mark = p->mark; |
36437 | } |
36438 | p->mark = _mark; |
36439 | D(fprintf(stderr, "%*c%s _loop0_203[%d-%d]: %s failed!\n", p->level, ' ', |
36440 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block")); |
36441 | } |
36442 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
36443 | if (!_seq) { Branch (36443:9): [True: 0, False: 49]
|
36444 | PyMem_Free(_children); |
36445 | p->error_indicator = 1; |
36446 | PyErr_NoMemory(); |
36447 | p->level--; |
36448 | return NULL; |
36449 | } |
36450 | for (int i = 0; 49 i < _n; i++40 ) asdl_seq_SET_UNTYPED49 (_seq, i, _children[i]); Branch (36450:21): [True: 40, False: 49]
|
36451 | PyMem_Free(_children); |
36452 | _PyPegen_insert_memo(p, _start_mark, _loop0_203_type, _seq); |
36453 | p->level--; |
36454 | return _seq; |
36455 | } |
36456 | |
36457 | // _tmp_204: (except_block+ except_star_block) | (except_star_block+ except_block) |
36458 | static void * |
36459 | _tmp_204_rule(Parser *p) |
36460 | { |
36461 | if (p->level++ == MAXSTACK) { Branch (36461:9): [True: 0, False: 49]
|
36462 | p->error_indicator = 1; |
36463 | PyErr_NoMemory(); |
36464 | } |
36465 | if (p->error_indicator) { Branch (36465:9): [True: 0, False: 49]
|
36466 | p->level--; |
36467 | return NULL; |
36468 | } |
36469 | void * _res = NULL; |
36470 | int _mark = p->mark; |
36471 | { // (except_block+ except_star_block) |
36472 | if (p->error_indicator) { |
36473 | p->level--; |
36474 | return NULL; |
36475 | } |
36476 | D(fprintf(stderr, "%*c> _tmp_204[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(except_block+ except_star_block)")); |
36477 | void *_tmp_241_var; |
36478 | if ( |
36479 | (_tmp_241_var = _tmp_241_rule(p)) // except_block+ except_star_block |
36480 | ) |
36481 | { |
36482 | D(fprintf(stderr, "%*c+ _tmp_204[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(except_block+ except_star_block)")); |
36483 | _res = _tmp_241_var; |
36484 | goto done; |
36485 | } |
36486 | p->mark = _mark; |
36487 | D(fprintf(stderr, "%*c%s _tmp_204[%d-%d]: %s failed!\n", p->level, ' ', |
36488 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(except_block+ except_star_block)")); |
36489 | } |
36490 | { // (except_star_block+ except_block) |
36491 | if (p->error_indicator) { Branch (36491:13): [True: 14, False: 30]
|
36492 | p->level--; |
36493 | return NULL; |
36494 | } |
36495 | D(fprintf(stderr, "%*c> _tmp_204[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(except_star_block+ except_block)")); |
36496 | void *_tmp_242_var; |
36497 | if ( |
36498 | (_tmp_242_var = _tmp_242_rule(p)) // except_star_block+ except_block |
36499 | ) |
36500 | { |
36501 | D(fprintf(stderr, "%*c+ _tmp_204[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(except_star_block+ except_block)")); |
36502 | _res = _tmp_242_var; |
36503 | goto done; |
36504 | } |
36505 | p->mark = _mark; |
36506 | D(fprintf(stderr, "%*c%s _tmp_204[%d-%d]: %s failed!\n", p->level, ' ', |
36507 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(except_star_block+ except_block)")); |
36508 | } |
36509 | _res = NULL; |
36510 | done: |
36511 | p->level--; |
36512 | return _res; |
36513 | } |
36514 | |
36515 | // _loop0_205: block |
36516 | static asdl_seq * |
36517 | _loop0_205_rule(Parser *p) |
36518 | { |
36519 | if (p->level++ == MAXSTACK) { Branch (36519:9): [True: 0, False: 11]
|
36520 | p->error_indicator = 1; |
36521 | PyErr_NoMemory(); |
36522 | } |
36523 | if (p->error_indicator) { Branch (36523:9): [True: 0, False: 11]
|
36524 | p->level--; |
36525 | return NULL; |
36526 | } |
36527 | void *_res = NULL; |
36528 | int _mark = p->mark; |
36529 | int _start_mark = p->mark; |
36530 | void **_children = PyMem_Malloc(sizeof(void *)); |
36531 | if (!_children) { Branch (36531:9): [True: 0, False: 11]
|
36532 | p->error_indicator = 1; |
36533 | PyErr_NoMemory(); |
36534 | p->level--; |
36535 | return NULL; |
36536 | } |
36537 | Py_ssize_t _children_capacity = 1; |
36538 | Py_ssize_t _n = 0; |
36539 | { // block |
36540 | if (p->error_indicator) { |
36541 | p->level--; |
36542 | return NULL; |
36543 | } |
36544 | D(fprintf(stderr, "%*c> _loop0_205[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); |
36545 | asdl_stmt_seq* block_var; |
36546 | while ( |
36547 | (block_var = block_rule(p)) // block |
36548 | ) |
36549 | { |
36550 | _res = block_var; |
36551 | if (_n == _children_capacity) { |
36552 | _children_capacity *= 2; |
36553 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
36554 | if (!_new_children) { |
36555 | p->error_indicator = 1; |
36556 | PyErr_NoMemory(); |
36557 | p->level--; |
36558 | return NULL; |
36559 | } |
36560 | _children = _new_children; |
36561 | } |
36562 | _children[_n++] = _res; |
36563 | _mark = p->mark; |
36564 | } |
36565 | p->mark = _mark; |
36566 | D(fprintf(stderr, "%*c%s _loop0_205[%d-%d]: %s failed!\n", p->level, ' ', |
36567 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block")); |
36568 | } |
36569 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
36570 | if (!_seq) { Branch (36570:9): [True: 0, False: 11]
|
36571 | PyMem_Free(_children); |
36572 | p->error_indicator = 1; |
36573 | PyErr_NoMemory(); |
36574 | p->level--; |
36575 | return NULL; |
36576 | } |
36577 | for (int i = 0; i < _n; i++0 ) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); |
36578 | PyMem_Free(_children); |
36579 | _PyPegen_insert_memo(p, _start_mark, _loop0_205_type, _seq); |
36580 | p->level--; |
36581 | return _seq; |
36582 | } |
36583 | |
36584 | // _tmp_206: 'as' NAME |
36585 | static void * |
36586 | _tmp_206_rule(Parser *p) |
36587 | { |
36588 | if (p->level++ == MAXSTACK) { Branch (36588:9): [True: 0, False: 8]
|
36589 | p->error_indicator = 1; |
36590 | PyErr_NoMemory(); |
36591 | } |
36592 | if (p->error_indicator) { Branch (36592:9): [True: 0, False: 8]
|
36593 | p->level--; |
36594 | return NULL; |
36595 | } |
36596 | void * _res = NULL; |
36597 | int _mark = p->mark; |
36598 | { // 'as' NAME |
36599 | if (p->error_indicator) { |
36600 | p->level--; |
36601 | return NULL; |
36602 | } |
36603 | D(fprintf(stderr, "%*c> _tmp_206[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36604 | Token * _keyword; |
36605 | expr_ty name_var; |
36606 | if ( |
36607 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
36608 | && |
36609 | (name_var = _PyPegen_name_token(p))4 // NAME |
36610 | ) |
36611 | { |
36612 | D(fprintf(stderr, "%*c+ _tmp_206[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36613 | _res = _PyPegen_dummy_name(p, _keyword, name_var); |
36614 | goto done; |
36615 | } |
36616 | p->mark = _mark; |
36617 | D(fprintf(stderr, "%*c%s _tmp_206[%d-%d]: %s failed!\n", p->level, ' ', |
36618 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
36619 | } |
36620 | _res = NULL; |
36621 | done: |
36622 | p->level--; |
36623 | return _res; |
36624 | } |
36625 | |
36626 | // _tmp_207: 'as' NAME |
36627 | static void * |
36628 | _tmp_207_rule(Parser *p) |
36629 | { |
36630 | if (p->level++ == MAXSTACK) { Branch (36630:9): [True: 0, False: 29]
|
36631 | p->error_indicator = 1; |
36632 | PyErr_NoMemory(); |
36633 | } |
36634 | if (p->error_indicator) { Branch (36634:9): [True: 0, False: 29]
|
36635 | p->level--; |
36636 | return NULL; |
36637 | } |
36638 | void * _res = NULL; |
36639 | int _mark = p->mark; |
36640 | { // 'as' NAME |
36641 | if (p->error_indicator) { |
36642 | p->level--; |
36643 | return NULL; |
36644 | } |
36645 | D(fprintf(stderr, "%*c> _tmp_207[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36646 | Token * _keyword; |
36647 | expr_ty name_var; |
36648 | if ( |
36649 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' Branch (36649:13): [True: 12, False: 17]
|
36650 | && |
36651 | (name_var = _PyPegen_name_token(p))12 // NAME |
36652 | ) |
36653 | { |
36654 | D(fprintf(stderr, "%*c+ _tmp_207[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36655 | _res = _PyPegen_dummy_name(p, _keyword, name_var); |
36656 | goto done; |
36657 | } |
36658 | p->mark = _mark; |
36659 | D(fprintf(stderr, "%*c%s _tmp_207[%d-%d]: %s failed!\n", p->level, ' ', |
36660 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
36661 | } |
36662 | _res = NULL; |
36663 | done: |
36664 | p->level--; |
36665 | return _res; |
36666 | } |
36667 | |
36668 | // _tmp_208: NEWLINE | ':' |
36669 | static void * |
36670 | _tmp_208_rule(Parser *p) |
36671 | { |
36672 | if (p->level++ == MAXSTACK) { Branch (36672:9): [True: 0, False: 23]
|
36673 | p->error_indicator = 1; |
36674 | PyErr_NoMemory(); |
36675 | } |
36676 | if (p->error_indicator) { Branch (36676:9): [True: 0, False: 23]
|
36677 | p->level--; |
36678 | return NULL; |
36679 | } |
36680 | void * _res = NULL; |
36681 | int _mark = p->mark; |
36682 | { // NEWLINE |
36683 | if (p->error_indicator) { |
36684 | p->level--; |
36685 | return NULL; |
36686 | } |
36687 | D(fprintf(stderr, "%*c> _tmp_208[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
36688 | Token * newline_var; |
36689 | if ( |
36690 | (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' |
36691 | ) |
36692 | { |
36693 | D(fprintf(stderr, "%*c+ _tmp_208[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); |
36694 | _res = newline_var; |
36695 | goto done; |
36696 | } |
36697 | p->mark = _mark; |
36698 | D(fprintf(stderr, "%*c%s _tmp_208[%d-%d]: %s failed!\n", p->level, ' ', |
36699 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); |
36700 | } |
36701 | { // ':' |
36702 | if (p->error_indicator) { |
36703 | p->level--; |
36704 | return NULL; |
36705 | } |
36706 | D(fprintf(stderr, "%*c> _tmp_208[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); |
36707 | Token * _literal; |
36708 | if ( |
36709 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
36710 | ) |
36711 | { |
36712 | D(fprintf(stderr, "%*c+ _tmp_208[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); |
36713 | _res = _literal; |
36714 | goto done; |
36715 | } |
36716 | p->mark = _mark; |
36717 | D(fprintf(stderr, "%*c%s _tmp_208[%d-%d]: %s failed!\n", p->level, ' ', |
36718 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); |
36719 | } |
36720 | _res = NULL; |
36721 | done: |
36722 | p->level--; |
36723 | return _res; |
36724 | } |
36725 | |
36726 | // _tmp_209: 'as' NAME |
36727 | static void * |
36728 | _tmp_209_rule(Parser *p) |
36729 | { |
36730 | if (p->level++ == MAXSTACK) { Branch (36730:9): [True: 0, False: 21]
|
36731 | p->error_indicator = 1; |
36732 | PyErr_NoMemory(); |
36733 | } |
36734 | if (p->error_indicator) { Branch (36734:9): [True: 0, False: 21]
|
36735 | p->level--; |
36736 | return NULL; |
36737 | } |
36738 | void * _res = NULL; |
36739 | int _mark = p->mark; |
36740 | { // 'as' NAME |
36741 | if (p->error_indicator) { |
36742 | p->level--; |
36743 | return NULL; |
36744 | } |
36745 | D(fprintf(stderr, "%*c> _tmp_209[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36746 | Token * _keyword; |
36747 | expr_ty name_var; |
36748 | if ( |
36749 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
36750 | && |
36751 | (name_var = _PyPegen_name_token(p))4 // NAME |
36752 | ) |
36753 | { |
36754 | D(fprintf(stderr, "%*c+ _tmp_209[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36755 | _res = _PyPegen_dummy_name(p, _keyword, name_var); |
36756 | goto done; |
36757 | } |
36758 | p->mark = _mark; |
36759 | D(fprintf(stderr, "%*c%s _tmp_209[%d-%d]: %s failed!\n", p->level, ' ', |
36760 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
36761 | } |
36762 | _res = NULL; |
36763 | done: |
36764 | p->level--; |
36765 | return _res; |
36766 | } |
36767 | |
36768 | // _tmp_210: 'as' NAME |
36769 | static void * |
36770 | _tmp_210_rule(Parser *p) |
36771 | { |
36772 | if (p->level++ == MAXSTACK) { Branch (36772:9): [True: 0, False: 18]
|
36773 | p->error_indicator = 1; |
36774 | PyErr_NoMemory(); |
36775 | } |
36776 | if (p->error_indicator) { Branch (36776:9): [True: 0, False: 18]
|
36777 | p->level--; |
36778 | return NULL; |
36779 | } |
36780 | void * _res = NULL; |
36781 | int _mark = p->mark; |
36782 | { // 'as' NAME |
36783 | if (p->error_indicator) { |
36784 | p->level--; |
36785 | return NULL; |
36786 | } |
36787 | D(fprintf(stderr, "%*c> _tmp_210[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36788 | Token * _keyword; |
36789 | expr_ty name_var; |
36790 | if ( |
36791 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
36792 | && |
36793 | (name_var = _PyPegen_name_token(p))5 // NAME |
36794 | ) |
36795 | { |
36796 | D(fprintf(stderr, "%*c+ _tmp_210[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); |
36797 | _res = _PyPegen_dummy_name(p, _keyword, name_var); |
36798 | goto done; |
36799 | } |
36800 | p->mark = _mark; |
36801 | D(fprintf(stderr, "%*c%s _tmp_210[%d-%d]: %s failed!\n", p->level, ' ', |
36802 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); |
36803 | } |
36804 | _res = NULL; |
36805 | done: |
36806 | p->level--; |
36807 | return _res; |
36808 | } |
36809 | |
36810 | // _tmp_211: positional_patterns ',' |
36811 | static void * |
36812 | _tmp_211_rule(Parser *p) |
36813 | { |
36814 | if (p->level++ == MAXSTACK) { Branch (36814:9): [True: 0, False: 4]
|
36815 | p->error_indicator = 1; |
36816 | PyErr_NoMemory(); |
36817 | } |
36818 | if (p->error_indicator) { Branch (36818:9): [True: 0, False: 4]
|
36819 | p->level--; |
36820 | return NULL; |
36821 | } |
36822 | void * _res = NULL; |
36823 | int _mark = p->mark; |
36824 | { // positional_patterns ',' |
36825 | if (p->error_indicator) { |
36826 | p->level--; |
36827 | return NULL; |
36828 | } |
36829 | D(fprintf(stderr, "%*c> _tmp_211[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); |
36830 | Token * _literal; |
36831 | asdl_pattern_seq* positional_patterns_var; |
36832 | if ( |
36833 | (positional_patterns_var = positional_patterns_rule(p)) // positional_patterns |
36834 | && |
36835 | (_literal = _PyPegen_expect_token(p, 12))1 // token=',' |
36836 | ) |
36837 | { |
36838 | D(fprintf(stderr, "%*c+ _tmp_211[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); |
36839 | _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal); |
36840 | goto done; |
36841 | } |
36842 | p->mark = _mark; |
36843 | D(fprintf(stderr, "%*c%s _tmp_211[%d-%d]: %s failed!\n", p->level, ' ', |
36844 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); |
36845 | } |
36846 | _res = NULL; |
36847 | done: |
36848 | p->level--; |
36849 | return _res; |
36850 | } |
36851 | |
36852 | // _tmp_212: '->' expression |
36853 | static void * |
36854 | _tmp_212_rule(Parser *p) |
36855 | { |
36856 | if (p->level++ == MAXSTACK) { Branch (36856:9): [True: 0, False: 65]
|
36857 | p->error_indicator = 1; |
36858 | PyErr_NoMemory(); |
36859 | } |
36860 | if (p->error_indicator) { Branch (36860:9): [True: 0, False: 65]
|
36861 | p->level--; |
36862 | return NULL; |
36863 | } |
36864 | void * _res = NULL; |
36865 | int _mark = p->mark; |
36866 | { // '->' expression |
36867 | if (p->error_indicator) { |
36868 | p->level--; |
36869 | return NULL; |
36870 | } |
36871 | D(fprintf(stderr, "%*c> _tmp_212[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); |
36872 | Token * _literal; |
36873 | expr_ty expression_var; |
36874 | if ( |
36875 | (_literal = _PyPegen_expect_token(p, 51)) // token='->' |
36876 | && |
36877 | (expression_var = expression_rule(p))0 // expression |
36878 | ) |
36879 | { |
36880 | D(fprintf(stderr, "%*c+ _tmp_212[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression")); |
36881 | _res = _PyPegen_dummy_name(p, _literal, expression_var); |
36882 | goto done; |
36883 | } |
36884 | p->mark = _mark; |
36885 | D(fprintf(stderr, "%*c%s _tmp_212[%d-%d]: %s failed!\n", p->level, ' ', |
36886 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); |
36887 | } |
36888 | _res = NULL; |
36889 | done: |
36890 | p->level--; |
36891 | return _res; |
36892 | } |
36893 | |
36894 | // _tmp_213: '(' arguments? ')' |
36895 | static void * |
36896 | _tmp_213_rule(Parser *p) |
36897 | { |
36898 | if (p->level++ == MAXSTACK) { Branch (36898:9): [True: 0, False: 6]
|
36899 | p->error_indicator = 1; |
36900 | PyErr_NoMemory(); |
36901 | } |
36902 | if (p->error_indicator) { Branch (36902:9): [True: 0, False: 6]
|
36903 | p->level--; |
36904 | return NULL; |
36905 | } |
36906 | void * _res = NULL; |
36907 | int _mark = p->mark; |
36908 | { // '(' arguments? ')' |
36909 | if (p->error_indicator) { |
36910 | p->level--; |
36911 | return NULL; |
36912 | } |
36913 | D(fprintf(stderr, "%*c> _tmp_213[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); |
36914 | Token * _literal; |
36915 | Token * _literal_1; |
36916 | void *_opt_var; |
36917 | UNUSED(_opt_var); // Silence compiler warnings |
36918 | if ( |
36919 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' |
36920 | && |
36921 | (_opt_var = arguments_rule(p), !p->error_indicator)2 // arguments? |
36922 | && |
36923 | (_literal_1 = _PyPegen_expect_token(p, 8))2 // token=')' |
36924 | ) |
36925 | { |
36926 | D(fprintf(stderr, "%*c+ _tmp_213[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); |
36927 | _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1); |
36928 | goto done; |
36929 | } |
36930 | p->mark = _mark; |
36931 | D(fprintf(stderr, "%*c%s _tmp_213[%d-%d]: %s failed!\n", p->level, ' ', |
36932 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); |
36933 | } |
36934 | _res = NULL; |
36935 | done: |
36936 | p->level--; |
36937 | return _res; |
36938 | } |
36939 | |
36940 | // _tmp_214: '(' arguments? ')' |
36941 | static void * |
36942 | _tmp_214_rule(Parser *p) |
36943 | { |
36944 | if (p->level++ == MAXSTACK) { Branch (36944:9): [True: 0, False: 5]
|
36945 | p->error_indicator = 1; |
36946 | PyErr_NoMemory(); |
36947 | } |
36948 | if (p->error_indicator) { Branch (36948:9): [True: 0, False: 5]
|
36949 | p->level--; |
36950 | return NULL; |
36951 | } |
36952 | void * _res = NULL; |
36953 | int _mark = p->mark; |
36954 | { // '(' arguments? ')' |
36955 | if (p->error_indicator) { |
36956 | p->level--; |
36957 | return NULL; |
36958 | } |
36959 | D(fprintf(stderr, "%*c> _tmp_214[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); |
36960 | Token * _literal; |
36961 | Token * _literal_1; |
36962 | void *_opt_var; |
36963 | UNUSED(_opt_var); // Silence compiler warnings |
36964 | if ( |
36965 | (_literal = _PyPegen_expect_token(p, 7)) // token='(' |
36966 | && |
36967 | (_opt_var = arguments_rule(p), !p->error_indicator)2 // arguments? |
36968 | && |
36969 | (_literal_1 = _PyPegen_expect_token(p, 8))2 // token=')' |
36970 | ) |
36971 | { |
36972 | D(fprintf(stderr, "%*c+ _tmp_214[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); |
36973 | _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1); |
36974 | goto done; |
36975 | } |
36976 | p->mark = _mark; |
36977 | D(fprintf(stderr, "%*c%s _tmp_214[%d-%d]: %s failed!\n", p->level, ' ', |
36978 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); |
36979 | } |
36980 | _res = NULL; |
36981 | done: |
36982 | p->level--; |
36983 | return _res; |
36984 | } |
36985 | |
36986 | // _loop0_216: ',' double_starred_kvpair |
36987 | static asdl_seq * |
36988 | _loop0_216_rule(Parser *p) |
36989 | { |
36990 | if (p->level++ == MAXSTACK) { Branch (36990:9): [True: 0, False: 377]
|
36991 | p->error_indicator = 1; |
36992 | PyErr_NoMemory(); |
36993 | } |
36994 | if (p->error_indicator) { Branch (36994:9): [True: 0, False: 377]
|
36995 | p->level--; |
36996 | return NULL; |
36997 | } |
36998 | void *_res = NULL; |
36999 | int _mark = p->mark; |
37000 | int _start_mark = p->mark; |
37001 | void **_children = PyMem_Malloc(sizeof(void *)); |
37002 | if (!_children) { Branch (37002:9): [True: 0, False: 377]
|
37003 | p->error_indicator = 1; |
37004 | PyErr_NoMemory(); |
37005 | p->level--; |
37006 | return NULL; |
37007 | } |
37008 | Py_ssize_t _children_capacity = 1; |
37009 | Py_ssize_t _n = 0; |
37010 | { // ',' double_starred_kvpair |
37011 | if (p->error_indicator) { Branch (37011:13): [True: 0, False: 377]
|
37012 | p->level--; |
37013 | return NULL; |
37014 | } |
37015 | D(fprintf(stderr, "%*c> _loop0_216[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); |
37016 | Token * _literal; |
37017 | KeyValuePair* elem; |
37018 | while ( |
37019 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (37019:13): [True: 11, False: 374]
|
37020 | && |
37021 | (elem = double_starred_kvpair_rule(p))11 // double_starred_kvpair |
37022 | ) |
37023 | { |
37024 | _res = elem; |
37025 | if (_res == NULL && PyErr_Occurred()0 ) { |
37026 | p->error_indicator = 1; |
37027 | PyMem_Free(_children); |
37028 | p->level--; |
37029 | return NULL; |
37030 | } |
37031 | if (_n == _children_capacity) { |
37032 | _children_capacity *= 2; |
37033 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
37034 | if (!_new_children) { |
37035 | p->error_indicator = 1; |
37036 | PyErr_NoMemory(); |
37037 | p->level--; |
37038 | return NULL; |
37039 | } |
37040 | _children = _new_children; |
37041 | } |
37042 | _children[_n++] = _res; |
37043 | _mark = p->mark; |
37044 | } |
37045 | p->mark = _mark; |
37046 | D(fprintf(stderr, "%*c%s _loop0_216[%d-%d]: %s failed!\n", p->level, ' ', |
37047 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); |
37048 | } |
37049 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
37050 | if (!_seq) { Branch (37050:9): [True: 0, False: 377]
|
37051 | PyMem_Free(_children); |
37052 | p->error_indicator = 1; |
37053 | PyErr_NoMemory(); |
37054 | p->level--; |
37055 | return NULL; |
37056 | } |
37057 | for (int i = 0; 377 i < _n; i++8 ) asdl_seq_SET_UNTYPED377 (_seq, i, _children[i]); Branch (37057:21): [True: 8, False: 377]
|
37058 | PyMem_Free(_children); |
37059 | _PyPegen_insert_memo(p, _start_mark, _loop0_216_type, _seq); |
37060 | p->level--; |
37061 | return _seq; |
37062 | } |
37063 | |
37064 | // _gather_215: double_starred_kvpair _loop0_216 |
37065 | static asdl_seq * |
37066 | _gather_215_rule(Parser *p) |
37067 | { |
37068 | if (p->level++ == MAXSTACK) { Branch (37068:9): [True: 0, False: 1.81k]
|
37069 | p->error_indicator = 1; |
37070 | PyErr_NoMemory(); |
37071 | } |
37072 | if (p->error_indicator) { Branch (37072:9): [True: 0, False: 1.81k]
|
37073 | p->level--; |
37074 | return NULL; |
37075 | } |
37076 | asdl_seq * _res = NULL; |
37077 | int _mark = p->mark; |
37078 | { // double_starred_kvpair _loop0_216 |
37079 | if (p->error_indicator) { Branch (37079:13): [True: 0, False: 1.81k]
|
37080 | p->level--; |
37081 | return NULL; |
37082 | } |
37083 | D(fprintf(stderr, "%*c> _gather_215[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_216")); |
37084 | KeyValuePair* elem; |
37085 | asdl_seq * seq; |
37086 | if ( |
37087 | (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair Branch (37087:13): [True: 377, False: 1.44k]
|
37088 | && |
37089 | (seq = _loop0_216_rule(p))377 // _loop0_216 Branch (37089:13): [True: 377, False: 0]
|
37090 | ) |
37091 | { |
37092 | D(fprintf(stderr, "%*c+ _gather_215[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_216")); |
37093 | _res = _PyPegen_seq_insert_in_front(p, elem, seq); |
37094 | goto done; |
37095 | } |
37096 | p->mark = _mark; |
37097 | D(fprintf(stderr, "%*c%s _gather_215[%d-%d]: %s failed!\n", p->level, ' ', |
37098 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_216")); |
37099 | } |
37100 | _res = NULL; |
37101 | done: |
37102 | p->level--; |
37103 | return _res; |
37104 | } |
37105 | |
37106 | // _tmp_217: '}' | ',' |
37107 | static void * |
37108 | _tmp_217_rule(Parser *p) |
37109 | { |
37110 | if (p->level++ == MAXSTACK) { Branch (37110:9): [True: 0, False: 384]
|
37111 | p->error_indicator = 1; |
37112 | PyErr_NoMemory(); |
37113 | } |
37114 | if (p->error_indicator) { Branch (37114:9): [True: 0, False: 384]
|
37115 | p->level--; |
37116 | return NULL; |
37117 | } |
37118 | void * _res = NULL; |
37119 | int _mark = p->mark; |
37120 | { // '}' |
37121 | if (p->error_indicator) { Branch (37121:13): [True: 0, False: 384]
|
37122 | p->level--; |
37123 | return NULL; |
37124 | } |
37125 | D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); |
37126 | Token * _literal; |
37127 | if ( |
37128 | (_literal = _PyPegen_expect_token(p, 26)) // token='}' Branch (37128:13): [True: 1, False: 383]
|
37129 | ) |
37130 | { |
37131 | D(fprintf(stderr, "%*c+ _tmp_217[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); |
37132 | _res = _literal; |
37133 | goto done; |
37134 | } |
37135 | p->mark = _mark; |
37136 | D(fprintf(stderr, "%*c%s _tmp_217[%d-%d]: %s failed!\n", p->level, ' ', |
37137 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); |
37138 | } |
37139 | { // ',' |
37140 | if (p->error_indicator) { Branch (37140:13): [True: 0, False: 383]
|
37141 | p->level--; |
37142 | return NULL; |
37143 | } |
37144 | D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
37145 | Token * _literal; |
37146 | if ( |
37147 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (37147:13): [True: 0, False: 383]
|
37148 | ) |
37149 | { |
37150 | D(fprintf(stderr, "%*c+ _tmp_217[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
37151 | _res = _literal; |
37152 | goto done; |
37153 | } |
37154 | p->mark = _mark; |
37155 | D(fprintf(stderr, "%*c%s _tmp_217[%d-%d]: %s failed!\n", p->level, ' ', |
37156 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
37157 | } |
37158 | _res = NULL; |
37159 | done: |
37160 | p->level--; |
37161 | return _res; |
37162 | } |
37163 | |
37164 | // _tmp_218: '}' | ',' |
37165 | static void * |
37166 | _tmp_218_rule(Parser *p) |
37167 | { |
37168 | if (p->level++ == MAXSTACK) { Branch (37168:9): [True: 0, False: 1]
|
37169 | p->error_indicator = 1; |
37170 | PyErr_NoMemory(); |
37171 | } |
37172 | if (p->error_indicator) { Branch (37172:9): [True: 0, False: 1]
|
37173 | p->level--; |
37174 | return NULL; |
37175 | } |
37176 | void * _res = NULL; |
37177 | int _mark = p->mark; |
37178 | { // '}' |
37179 | if (p->error_indicator) { |
37180 | p->level--; |
37181 | return NULL; |
37182 | } |
37183 | D(fprintf(stderr, "%*c> _tmp_218[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); |
37184 | Token * _literal; |
37185 | if ( |
37186 | (_literal = _PyPegen_expect_token(p, 26)) // token='}' |
37187 | ) |
37188 | { |
37189 | D(fprintf(stderr, "%*c+ _tmp_218[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); |
37190 | _res = _literal; |
37191 | goto done; |
37192 | } |
37193 | p->mark = _mark; |
37194 | D(fprintf(stderr, "%*c%s _tmp_218[%d-%d]: %s failed!\n", p->level, ' ', |
37195 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); |
37196 | } |
37197 | { // ',' |
37198 | if (p->error_indicator) { |
37199 | p->level--; |
37200 | return NULL; |
37201 | } |
37202 | D(fprintf(stderr, "%*c> _tmp_218[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); |
37203 | Token * _literal; |
37204 | if ( |
37205 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' |
37206 | ) |
37207 | { |
37208 | D(fprintf(stderr, "%*c+ _tmp_218[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); |
37209 | _res = _literal; |
37210 | goto done; |
37211 | } |
37212 | p->mark = _mark; |
37213 | D(fprintf(stderr, "%*c%s _tmp_218[%d-%d]: %s failed!\n", p->level, ' ', |
37214 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); |
37215 | } |
37216 | _res = NULL; |
37217 | done: |
37218 | p->level--; |
37219 | return _res; |
37220 | } |
37221 | |
37222 | // _tmp_219: star_targets '=' |
37223 | static void * |
37224 | _tmp_219_rule(Parser *p) |
37225 | { |
37226 | if (p->level++ == MAXSTACK) { Branch (37226:9): [True: 0, False: 566k]
|
37227 | p->error_indicator = 1; |
37228 | PyErr_NoMemory(); |
37229 | } |
37230 | if (p->error_indicator) { Branch (37230:9): [True: 0, False: 566k]
|
37231 | p->level--; |
37232 | return NULL; |
37233 | } |
37234 | void * _res = NULL; |
37235 | int _mark = p->mark; |
37236 | { // star_targets '=' |
37237 | if (p->error_indicator) { Branch (37237:13): [True: 0, False: 566k]
|
37238 | p->level--; |
37239 | return NULL; |
37240 | } |
37241 | D(fprintf(stderr, "%*c> _tmp_219[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); |
37242 | Token * _literal; |
37243 | expr_ty z; |
37244 | if ( |
37245 | (z = star_targets_rule(p)) // star_targets Branch (37245:13): [True: 392k, False: 173k]
|
37246 | && |
37247 | (_literal = _PyPegen_expect_token(p, 22))392k // token='=' Branch (37247:13): [True: 85.1k, False: 307k]
|
37248 | ) |
37249 | { |
37250 | D(fprintf(stderr, "%*c+ _tmp_219[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); |
37251 | _res = z; |
37252 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37252:17): [True: 0, False: 85.1k]
Branch (37252:33): [True: 0, False: 0]
|
37253 | p->error_indicator = 1; |
37254 | p->level--; |
37255 | return NULL; |
37256 | } |
37257 | goto done; |
37258 | } |
37259 | p->mark = _mark; |
37260 | D(fprintf(stderr, "%*c%s _tmp_219[%d-%d]: %s failed!\n", p->level, ' ', |
37261 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); |
37262 | } |
37263 | _res = NULL; |
37264 | done: |
37265 | p->level--; |
37266 | return _res; |
37267 | } |
37268 | |
37269 | // _tmp_220: '.' | '...' |
37270 | static void * |
37271 | _tmp_220_rule(Parser *p) |
37272 | { |
37273 | if (p->level++ == MAXSTACK) { Branch (37273:9): [True: 0, False: 2.22k]
|
37274 | p->error_indicator = 1; |
37275 | PyErr_NoMemory(); |
37276 | } |
37277 | if (p->error_indicator) { Branch (37277:9): [True: 0, False: 2.22k]
|
37278 | p->level--; |
37279 | return NULL; |
37280 | } |
37281 | void * _res = NULL; |
37282 | int _mark = p->mark; |
37283 | { // '.' |
37284 | if (p->error_indicator) { Branch (37284:13): [True: 0, False: 2.22k]
|
37285 | p->level--; |
37286 | return NULL; |
37287 | } |
37288 | D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); |
37289 | Token * _literal; |
37290 | if ( |
37291 | (_literal = _PyPegen_expect_token(p, 23)) // token='.' Branch (37291:13): [True: 145, False: 2.08k]
|
37292 | ) |
37293 | { |
37294 | D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); |
37295 | _res = _literal; |
37296 | goto done; |
37297 | } |
37298 | p->mark = _mark; |
37299 | D(fprintf(stderr, "%*c%s _tmp_220[%d-%d]: %s failed!\n", p->level, ' ', |
37300 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); |
37301 | } |
37302 | { // '...' |
37303 | if (p->error_indicator) { Branch (37303:13): [True: 0, False: 2.08k]
|
37304 | p->level--; |
37305 | return NULL; |
37306 | } |
37307 | D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); |
37308 | Token * _literal; |
37309 | if ( |
37310 | (_literal = _PyPegen_expect_token(p, 52)) // token='...' Branch (37310:13): [True: 2, False: 2.07k]
|
37311 | ) |
37312 | { |
37313 | D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); |
37314 | _res = _literal; |
37315 | goto done; |
37316 | } |
37317 | p->mark = _mark; |
37318 | D(fprintf(stderr, "%*c%s _tmp_220[%d-%d]: %s failed!\n", p->level, ' ', |
37319 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); |
37320 | } |
37321 | _res = NULL; |
37322 | done: |
37323 | p->level--; |
37324 | return _res; |
37325 | } |
37326 | |
37327 | // _tmp_221: '.' | '...' |
37328 | static void * |
37329 | _tmp_221_rule(Parser *p) |
37330 | { |
37331 | if (p->level++ == MAXSTACK) { Branch (37331:9): [True: 0, False: 126]
|
37332 | p->error_indicator = 1; |
37333 | PyErr_NoMemory(); |
37334 | } |
37335 | if (p->error_indicator) { Branch (37335:9): [True: 0, False: 126]
|
37336 | p->level--; |
37337 | return NULL; |
37338 | } |
37339 | void * _res = NULL; |
37340 | int _mark = p->mark; |
37341 | { // '.' |
37342 | if (p->error_indicator) { Branch (37342:13): [True: 0, False: 126]
|
37343 | p->level--; |
37344 | return NULL; |
37345 | } |
37346 | D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); |
37347 | Token * _literal; |
37348 | if ( |
37349 | (_literal = _PyPegen_expect_token(p, 23)) // token='.' Branch (37349:13): [True: 54, False: 72]
|
37350 | ) |
37351 | { |
37352 | D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); |
37353 | _res = _literal; |
37354 | goto done; |
37355 | } |
37356 | p->mark = _mark; |
37357 | D(fprintf(stderr, "%*c%s _tmp_221[%d-%d]: %s failed!\n", p->level, ' ', |
37358 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); |
37359 | } |
37360 | { // '...' |
37361 | if (p->error_indicator) { |
37362 | p->level--; |
37363 | return NULL; |
37364 | } |
37365 | D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); |
37366 | Token * _literal; |
37367 | if ( |
37368 | (_literal = _PyPegen_expect_token(p, 52)) // token='...' |
37369 | ) |
37370 | { |
37371 | D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); |
37372 | _res = _literal; |
37373 | goto done; |
37374 | } |
37375 | p->mark = _mark; |
37376 | D(fprintf(stderr, "%*c%s _tmp_221[%d-%d]: %s failed!\n", p->level, ' ', |
37377 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); |
37378 | } |
37379 | _res = NULL; |
37380 | done: |
37381 | p->level--; |
37382 | return _res; |
37383 | } |
37384 | |
37385 | // _tmp_222: '@' named_expression NEWLINE |
37386 | static void * |
37387 | _tmp_222_rule(Parser *p) |
37388 | { |
37389 | if (p->level++ == MAXSTACK) { Branch (37389:9): [True: 0, False: 41.1k]
|
37390 | p->error_indicator = 1; |
37391 | PyErr_NoMemory(); |
37392 | } |
37393 | if (p->error_indicator) { Branch (37393:9): [True: 0, False: 41.1k]
|
37394 | p->level--; |
37395 | return NULL; |
37396 | } |
37397 | void * _res = NULL; |
37398 | int _mark = p->mark; |
37399 | { // '@' named_expression NEWLINE |
37400 | if (p->error_indicator) { Branch (37400:13): [True: 0, False: 41.1k]
|
37401 | p->level--; |
37402 | return NULL; |
37403 | } |
37404 | D(fprintf(stderr, "%*c> _tmp_222[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); |
37405 | Token * _literal; |
37406 | expr_ty f; |
37407 | Token * newline_var; |
37408 | if ( |
37409 | (_literal = _PyPegen_expect_token(p, 49)) // token='@' Branch (37409:13): [True: 2.94k, False: 38.2k]
|
37410 | && |
37411 | (f = named_expression_rule(p))2.94k // named_expression Branch (37411:13): [True: 2.92k, False: 19]
|
37412 | && |
37413 | (newline_var = _PyPegen_expect_token(p, 2.92k NEWLINE2.92k )) // token='NEWLINE' Branch (37413:13): [True: 2.91k, False: 10]
|
37414 | ) |
37415 | { |
37416 | D(fprintf(stderr, "%*c+ _tmp_222[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); |
37417 | _res = f; |
37418 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37418:17): [True: 0, False: 2.91k]
Branch (37418:33): [True: 0, False: 0]
|
37419 | p->error_indicator = 1; |
37420 | p->level--; |
37421 | return NULL; |
37422 | } |
37423 | goto done; |
37424 | } |
37425 | p->mark = _mark; |
37426 | D(fprintf(stderr, "%*c%s _tmp_222[%d-%d]: %s failed!\n", p->level, ' ', |
37427 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE")); |
37428 | } |
37429 | _res = NULL; |
37430 | done: |
37431 | p->level--; |
37432 | return _res; |
37433 | } |
37434 | |
37435 | // _tmp_223: ',' expression |
37436 | static void * |
37437 | _tmp_223_rule(Parser *p) |
37438 | { |
37439 | if (p->level++ == MAXSTACK) { Branch (37439:9): [True: 0, False: 36.8k]
|
37440 | p->error_indicator = 1; |
37441 | PyErr_NoMemory(); |
37442 | } |
37443 | if (p->error_indicator) { Branch (37443:9): [True: 0, False: 36.8k]
|
37444 | p->level--; |
37445 | return NULL; |
37446 | } |
37447 | void * _res = NULL; |
37448 | int _mark = p->mark; |
37449 | { // ',' expression |
37450 | if (p->error_indicator) { Branch (37450:13): [True: 0, False: 36.8k]
|
37451 | p->level--; |
37452 | return NULL; |
37453 | } |
37454 | D(fprintf(stderr, "%*c> _tmp_223[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); |
37455 | Token * _literal; |
37456 | expr_ty c; |
37457 | if ( |
37458 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (37458:13): [True: 207, False: 36.6k]
|
37459 | && |
37460 | (c = expression_rule(p))207 // expression Branch (37460:13): [True: 207, False: 0]
|
37461 | ) |
37462 | { |
37463 | D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression")); |
37464 | _res = c; |
37465 | if (_res == NULL && PyErr_Occurred()0 ) { |
37466 | p->error_indicator = 1; |
37467 | p->level--; |
37468 | return NULL; |
37469 | } |
37470 | goto done; |
37471 | } |
37472 | p->mark = _mark; |
37473 | D(fprintf(stderr, "%*c%s _tmp_223[%d-%d]: %s failed!\n", p->level, ' ', |
37474 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); |
37475 | } |
37476 | _res = NULL; |
37477 | done: |
37478 | p->level--; |
37479 | return _res; |
37480 | } |
37481 | |
37482 | // _tmp_224: ',' star_expression |
37483 | static void * |
37484 | _tmp_224_rule(Parser *p) |
37485 | { |
37486 | if (p->level++ == MAXSTACK) { Branch (37486:9): [True: 0, False: 440k]
|
37487 | p->error_indicator = 1; |
37488 | PyErr_NoMemory(); |
37489 | } |
37490 | if (p->error_indicator) { Branch (37490:9): [True: 0, False: 440k]
|
37491 | p->level--; |
37492 | return NULL; |
37493 | } |
37494 | void * _res = NULL; |
37495 | int _mark = p->mark; |
37496 | { // ',' star_expression |
37497 | if (p->error_indicator) { Branch (37497:13): [True: 0, False: 440k]
|
37498 | p->level--; |
37499 | return NULL; |
37500 | } |
37501 | D(fprintf(stderr, "%*c> _tmp_224[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); |
37502 | Token * _literal; |
37503 | expr_ty c; |
37504 | if ( |
37505 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (37505:13): [True: 2.55k, False: 438k]
|
37506 | && |
37507 | (c = star_expression_rule(p))2.55k // star_expression Branch (37507:13): [True: 2.53k, False: 25]
|
37508 | ) |
37509 | { |
37510 | D(fprintf(stderr, "%*c+ _tmp_224[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); |
37511 | _res = c; |
37512 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37512:17): [True: 0, False: 2.53k]
Branch (37512:33): [True: 0, False: 0]
|
37513 | p->error_indicator = 1; |
37514 | p->level--; |
37515 | return NULL; |
37516 | } |
37517 | goto done; |
37518 | } |
37519 | p->mark = _mark; |
37520 | D(fprintf(stderr, "%*c%s _tmp_224[%d-%d]: %s failed!\n", p->level, ' ', |
37521 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression")); |
37522 | } |
37523 | _res = NULL; |
37524 | done: |
37525 | p->level--; |
37526 | return _res; |
37527 | } |
37528 | |
37529 | // _tmp_225: 'or' conjunction |
37530 | static void * |
37531 | _tmp_225_rule(Parser *p) |
37532 | { |
37533 | if (p->level++ == MAXSTACK) { Branch (37533:9): [True: 0, False: 1.74M]
|
37534 | p->error_indicator = 1; |
37535 | PyErr_NoMemory(); |
37536 | } |
37537 | if (p->error_indicator) { Branch (37537:9): [True: 0, False: 1.74M]
|
37538 | p->level--; |
37539 | return NULL; |
37540 | } |
37541 | void * _res = NULL; |
37542 | int _mark = p->mark; |
37543 | { // 'or' conjunction |
37544 | if (p->error_indicator) { Branch (37544:13): [True: 0, False: 1.74M]
|
37545 | p->level--; |
37546 | return NULL; |
37547 | } |
37548 | D(fprintf(stderr, "%*c> _tmp_225[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); |
37549 | Token * _keyword; |
37550 | expr_ty c; |
37551 | if ( |
37552 | (_keyword = _PyPegen_expect_token(p, 574)) // token='or' Branch (37552:13): [True: 2.87k, False: 1.73M]
|
37553 | && |
37554 | (c = conjunction_rule(p))2.87k // conjunction Branch (37554:13): [True: 2.87k, False: 0]
|
37555 | ) |
37556 | { |
37557 | D(fprintf(stderr, "%*c+ _tmp_225[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); |
37558 | _res = c; |
37559 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37559:17): [True: 0, False: 2.87k]
Branch (37559:33): [True: 0, False: 0]
|
37560 | p->error_indicator = 1; |
37561 | p->level--; |
37562 | return NULL; |
37563 | } |
37564 | goto done; |
37565 | } |
37566 | p->mark = _mark; |
37567 | D(fprintf(stderr, "%*c%s _tmp_225[%d-%d]: %s failed!\n", p->level, ' ', |
37568 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction")); |
37569 | } |
37570 | _res = NULL; |
37571 | done: |
37572 | p->level--; |
37573 | return _res; |
37574 | } |
37575 | |
37576 | // _tmp_226: 'and' inversion |
37577 | static void * |
37578 | _tmp_226_rule(Parser *p) |
37579 | { |
37580 | if (p->level++ == MAXSTACK) { Branch (37580:9): [True: 0, False: 1.74M]
|
37581 | p->error_indicator = 1; |
37582 | PyErr_NoMemory(); |
37583 | } |
37584 | if (p->error_indicator) { Branch (37584:9): [True: 0, False: 1.74M]
|
37585 | p->level--; |
37586 | return NULL; |
37587 | } |
37588 | void * _res = NULL; |
37589 | int _mark = p->mark; |
37590 | { // 'and' inversion |
37591 | if (p->error_indicator) { Branch (37591:13): [True: 0, False: 1.74M]
|
37592 | p->level--; |
37593 | return NULL; |
37594 | } |
37595 | D(fprintf(stderr, "%*c> _tmp_226[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); |
37596 | Token * _keyword; |
37597 | expr_ty c; |
37598 | if ( |
37599 | (_keyword = _PyPegen_expect_token(p, 575)) // token='and' Branch (37599:13): [True: 4.74k, False: 1.74M]
|
37600 | && |
37601 | (c = inversion_rule(p))4.74k // inversion Branch (37601:13): [True: 4.74k, False: 0]
|
37602 | ) |
37603 | { |
37604 | D(fprintf(stderr, "%*c+ _tmp_226[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); |
37605 | _res = c; |
37606 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37606:17): [True: 0, False: 4.74k]
Branch (37606:33): [True: 0, False: 0]
|
37607 | p->error_indicator = 1; |
37608 | p->level--; |
37609 | return NULL; |
37610 | } |
37611 | goto done; |
37612 | } |
37613 | p->mark = _mark; |
37614 | D(fprintf(stderr, "%*c%s _tmp_226[%d-%d]: %s failed!\n", p->level, ' ', |
37615 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion")); |
37616 | } |
37617 | _res = NULL; |
37618 | done: |
37619 | p->level--; |
37620 | return _res; |
37621 | } |
37622 | |
37623 | // _tmp_227: slice | starred_expression |
37624 | static void * |
37625 | _tmp_227_rule(Parser *p) |
37626 | { |
37627 | if (p->level++ == MAXSTACK) { Branch (37627:9): [True: 0, False: 5.74k]
|
37628 | p->error_indicator = 1; |
37629 | PyErr_NoMemory(); |
37630 | } |
37631 | if (p->error_indicator) { Branch (37631:9): [True: 0, False: 5.74k]
|
37632 | p->level--; |
37633 | return NULL; |
37634 | } |
37635 | void * _res = NULL; |
37636 | int _mark = p->mark; |
37637 | { // slice |
37638 | if (p->error_indicator) { Branch (37638:13): [True: 0, False: 5.74k]
|
37639 | p->level--; |
37640 | return NULL; |
37641 | } |
37642 | D(fprintf(stderr, "%*c> _tmp_227[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); |
37643 | expr_ty slice_var; |
37644 | if ( |
37645 | (slice_var = slice_rule(p)) // slice Branch (37645:13): [True: 4.07k, False: 1.66k]
|
37646 | ) |
37647 | { |
37648 | D(fprintf(stderr, "%*c+ _tmp_227[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); |
37649 | _res = slice_var; |
37650 | goto done; |
37651 | } |
37652 | p->mark = _mark; |
37653 | D(fprintf(stderr, "%*c%s _tmp_227[%d-%d]: %s failed!\n", p->level, ' ', |
37654 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice")); |
37655 | } |
37656 | { // starred_expression |
37657 | if (p->error_indicator) { Branch (37657:13): [True: 2, False: 1.66k]
|
37658 | p->level--; |
37659 | return NULL; |
37660 | } |
37661 | D(fprintf(stderr, "%*c> _tmp_227[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); |
37662 | expr_ty starred_expression_var; |
37663 | if ( |
37664 | (starred_expression_var = starred_expression_rule(p)) // starred_expression Branch (37664:13): [True: 1.47k, False: 189]
|
37665 | ) |
37666 | { |
37667 | D(fprintf(stderr, "%*c+ _tmp_227[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); |
37668 | _res = starred_expression_var; |
37669 | goto done; |
37670 | } |
37671 | p->mark = _mark; |
37672 | D(fprintf(stderr, "%*c%s _tmp_227[%d-%d]: %s failed!\n", p->level, ' ', |
37673 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); |
37674 | } |
37675 | _res = NULL; |
37676 | done: |
37677 | p->level--; |
37678 | return _res; |
37679 | } |
37680 | |
37681 | // _tmp_228: 'if' disjunction |
37682 | static void * |
37683 | _tmp_228_rule(Parser *p) |
37684 | { |
37685 | if (p->level++ == MAXSTACK) { Branch (37685:9): [True: 0, False: 218]
|
37686 | p->error_indicator = 1; |
37687 | PyErr_NoMemory(); |
37688 | } |
37689 | if (p->error_indicator) { Branch (37689:9): [True: 0, False: 218]
|
37690 | p->level--; |
37691 | return NULL; |
37692 | } |
37693 | void * _res = NULL; |
37694 | int _mark = p->mark; |
37695 | { // 'if' disjunction |
37696 | if (p->error_indicator) { Branch (37696:13): [True: 0, False: 218]
|
37697 | p->level--; |
37698 | return NULL; |
37699 | } |
37700 | D(fprintf(stderr, "%*c> _tmp_228[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); |
37701 | Token * _keyword; |
37702 | expr_ty z; |
37703 | if ( |
37704 | (_keyword = _PyPegen_expect_token(p, 634)) // token='if' Branch (37704:13): [True: 0, False: 218]
|
37705 | && |
37706 | (z = disjunction_rule(p))0 // disjunction |
37707 | ) |
37708 | { |
37709 | D(fprintf(stderr, "%*c+ _tmp_228[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); |
37710 | _res = z; |
37711 | if (_res == NULL && PyErr_Occurred()) { |
37712 | p->error_indicator = 1; |
37713 | p->level--; |
37714 | return NULL; |
37715 | } |
37716 | goto done; |
37717 | } |
37718 | p->mark = _mark; |
37719 | D(fprintf(stderr, "%*c%s _tmp_228[%d-%d]: %s failed!\n", p->level, ' ', |
37720 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); |
37721 | } |
37722 | _res = NULL; |
37723 | done: |
37724 | p->level--; |
37725 | return _res; |
37726 | } |
37727 | |
37728 | // _tmp_229: 'if' disjunction |
37729 | static void * |
37730 | _tmp_229_rule(Parser *p) |
37731 | { |
37732 | if (p->level++ == MAXSTACK) { Branch (37732:9): [True: 0, False: 6.34k]
|
37733 | p->error_indicator = 1; |
37734 | PyErr_NoMemory(); |
37735 | } |
37736 | if (p->error_indicator) { Branch (37736:9): [True: 0, False: 6.34k]
|
37737 | p->level--; |
37738 | return NULL; |
37739 | } |
37740 | void * _res = NULL; |
37741 | int _mark = p->mark; |
37742 | { // 'if' disjunction |
37743 | if (p->error_indicator) { Branch (37743:13): [True: 0, False: 6.34k]
|
37744 | p->level--; |
37745 | return NULL; |
37746 | } |
37747 | D(fprintf(stderr, "%*c> _tmp_229[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); |
37748 | Token * _keyword; |
37749 | expr_ty z; |
37750 | if ( |
37751 | (_keyword = _PyPegen_expect_token(p, 634)) // token='if' Branch (37751:13): [True: 1.16k, False: 5.18k]
|
37752 | && |
37753 | (z = disjunction_rule(p))1.16k // disjunction Branch (37753:13): [True: 1.16k, False: 0]
|
37754 | ) |
37755 | { |
37756 | D(fprintf(stderr, "%*c+ _tmp_229[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); |
37757 | _res = z; |
37758 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37758:17): [True: 0, False: 1.16k]
Branch (37758:33): [True: 0, False: 0]
|
37759 | p->error_indicator = 1; |
37760 | p->level--; |
37761 | return NULL; |
37762 | } |
37763 | goto done; |
37764 | } |
37765 | p->mark = _mark; |
37766 | D(fprintf(stderr, "%*c%s _tmp_229[%d-%d]: %s failed!\n", p->level, ' ', |
37767 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); |
37768 | } |
37769 | _res = NULL; |
37770 | done: |
37771 | p->level--; |
37772 | return _res; |
37773 | } |
37774 | |
37775 | // _tmp_230: starred_expression | (assignment_expression | expression !':=') !'=' |
37776 | static void * |
37777 | _tmp_230_rule(Parser *p) |
37778 | { |
37779 | if (p->level++ == MAXSTACK) { Branch (37779:9): [True: 0, False: 467k]
|
37780 | p->error_indicator = 1; |
37781 | PyErr_NoMemory(); |
37782 | } |
37783 | if (p->error_indicator) { Branch (37783:9): [True: 0, False: 467k]
|
37784 | p->level--; |
37785 | return NULL; |
37786 | } |
37787 | void * _res = NULL; |
37788 | int _mark = p->mark; |
37789 | { // starred_expression |
37790 | if (p->error_indicator) { Branch (37790:13): [True: 0, False: 467k]
|
37791 | p->level--; |
37792 | return NULL; |
37793 | } |
37794 | D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); |
37795 | expr_ty starred_expression_var; |
37796 | if ( |
37797 | (starred_expression_var = starred_expression_rule(p)) // starred_expression Branch (37797:13): [True: 1.09k, False: 466k]
|
37798 | ) |
37799 | { |
37800 | D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); |
37801 | _res = starred_expression_var; |
37802 | goto done; |
37803 | } |
37804 | p->mark = _mark; |
37805 | D(fprintf(stderr, "%*c%s _tmp_230[%d-%d]: %s failed!\n", p->level, ' ', |
37806 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); |
37807 | } |
37808 | { // (assignment_expression | expression !':=') !'=' |
37809 | if (p->error_indicator) { Branch (37809:13): [True: 10, False: 466k]
|
37810 | p->level--; |
37811 | return NULL; |
37812 | } |
37813 | D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); |
37814 | void *_tmp_243_var; |
37815 | if ( |
37816 | (_tmp_243_var = _tmp_243_rule(p)) // assignment_expression | expression !':=' Branch (37816:13): [True: 141k, False: 324k]
|
37817 | && |
37818 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)141k // token='=' Branch (37818:13): [True: 136k, False: 5.35k]
|
37819 | ) |
37820 | { |
37821 | D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); |
37822 | _res = _tmp_243_var; |
37823 | goto done; |
37824 | } |
37825 | p->mark = _mark; |
37826 | D(fprintf(stderr, "%*c%s _tmp_230[%d-%d]: %s failed!\n", p->level, ' ', |
37827 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='")); |
37828 | } |
37829 | _res = NULL; |
37830 | done: |
37831 | p->level--; |
37832 | return _res; |
37833 | } |
37834 | |
37835 | // _tmp_231: ',' star_target |
37836 | static void * |
37837 | _tmp_231_rule(Parser *p) |
37838 | { |
37839 | if (p->level++ == MAXSTACK) { Branch (37839:9): [True: 0, False: 14.0k]
|
37840 | p->error_indicator = 1; |
37841 | PyErr_NoMemory(); |
37842 | } |
37843 | if (p->error_indicator) { Branch (37843:9): [True: 0, False: 14.0k]
|
37844 | p->level--; |
37845 | return NULL; |
37846 | } |
37847 | void * _res = NULL; |
37848 | int _mark = p->mark; |
37849 | { // ',' star_target |
37850 | if (p->error_indicator) { Branch (37850:13): [True: 0, False: 14.0k]
|
37851 | p->level--; |
37852 | return NULL; |
37853 | } |
37854 | D(fprintf(stderr, "%*c> _tmp_231[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); |
37855 | Token * _literal; |
37856 | expr_ty c; |
37857 | if ( |
37858 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (37858:13): [True: 9.81k, False: 4.25k]
|
37859 | && |
37860 | (c = star_target_rule(p))9.81k // star_target Branch (37860:13): [True: 9.67k, False: 132]
|
37861 | ) |
37862 | { |
37863 | D(fprintf(stderr, "%*c+ _tmp_231[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); |
37864 | _res = c; |
37865 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37865:17): [True: 0, False: 9.67k]
Branch (37865:33): [True: 0, False: 0]
|
37866 | p->error_indicator = 1; |
37867 | p->level--; |
37868 | return NULL; |
37869 | } |
37870 | goto done; |
37871 | } |
37872 | p->mark = _mark; |
37873 | D(fprintf(stderr, "%*c%s _tmp_231[%d-%d]: %s failed!\n", p->level, ' ', |
37874 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); |
37875 | } |
37876 | _res = NULL; |
37877 | done: |
37878 | p->level--; |
37879 | return _res; |
37880 | } |
37881 | |
37882 | // _tmp_232: ',' star_target |
37883 | static void * |
37884 | _tmp_232_rule(Parser *p) |
37885 | { |
37886 | if (p->level++ == MAXSTACK) { Branch (37886:9): [True: 0, False: 3.03k]
|
37887 | p->error_indicator = 1; |
37888 | PyErr_NoMemory(); |
37889 | } |
37890 | if (p->error_indicator) { Branch (37890:9): [True: 0, False: 3.03k]
|
37891 | p->level--; |
37892 | return NULL; |
37893 | } |
37894 | void * _res = NULL; |
37895 | int _mark = p->mark; |
37896 | { // ',' star_target |
37897 | if (p->error_indicator) { Branch (37897:13): [True: 0, False: 3.03k]
|
37898 | p->level--; |
37899 | return NULL; |
37900 | } |
37901 | D(fprintf(stderr, "%*c> _tmp_232[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); |
37902 | Token * _literal; |
37903 | expr_ty c; |
37904 | if ( |
37905 | (_literal = _PyPegen_expect_token(p, 12)) // token=',' Branch (37905:13): [True: 1.95k, False: 1.07k]
|
37906 | && |
37907 | (c = star_target_rule(p))1.95k // star_target Branch (37907:13): [True: 1.76k, False: 190]
|
37908 | ) |
37909 | { |
37910 | D(fprintf(stderr, "%*c+ _tmp_232[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); |
37911 | _res = c; |
37912 | if (_res == NULL && PyErr_Occurred()0 ) { Branch (37912:17): [True: 0, False: 1.76k]
Branch (37912:33): [True: 0, False: 0]
|
37913 | p->error_indicator = 1; |
37914 | p->level--; |
37915 | return NULL; |
37916 | } |
37917 | goto done; |
37918 | } |
37919 | p->mark = _mark; |
37920 | D(fprintf(stderr, "%*c%s _tmp_232[%d-%d]: %s failed!\n", p->level, ' ', |
37921 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); |
37922 | } |
37923 | _res = NULL; |
37924 | done: |
37925 | p->level--; |
37926 | return _res; |
37927 | } |
37928 | |
37929 | // _tmp_233: star_targets '=' |
37930 | static void * |
37931 | _tmp_233_rule(Parser *p) |
37932 | { |
37933 | if (p->level++ == MAXSTACK) { Branch (37933:9): [True: 0, False: 792]
|
37934 | p->error_indicator = 1; |
37935 | PyErr_NoMemory(); |
37936 | } |
37937 | if (p->error_indicator) { Branch (37937:9): [True: 0, False: 792]
|
37938 | p->level--; |
37939 | return NULL; |
37940 | } |
37941 | void * _res = NULL; |
37942 | int _mark = p->mark; |
37943 | { // star_targets '=' |
37944 | if (p->error_indicator) { Branch (37944:13): [True: 0, False: 792]
|
37945 | p->level--; |
37946 | return NULL; |
37947 | } |
37948 | D(fprintf(stderr, "%*c> _tmp_233[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); |
37949 | Token * _literal; |
37950 | expr_ty star_targets_var; |
37951 | if ( |
37952 | (star_targets_var = star_targets_rule(p)) // star_targets Branch (37952:13): [True: 105, False: 687]
|
37953 | && |
37954 | (_literal = _PyPegen_expect_token(p, 22))105 // token='=' |
37955 | ) |
37956 | { |
37957 | D(fprintf(stderr, "%*c+ _tmp_233[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); |
37958 | _res = _PyPegen_dummy_name(p, star_targets_var, _literal); |
37959 | goto done; |
37960 | } |
37961 | p->mark = _mark; |
37962 | D(fprintf(stderr, "%*c%s _tmp_233[%d-%d]: %s failed!\n", p->level, ' ', |
37963 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); |
37964 | } |
37965 | _res = NULL; |
37966 | done: |
37967 | p->level--; |
37968 | return _res; |
37969 | } |
37970 | |
37971 | // _tmp_234: star_targets '=' |
37972 | static void * |
37973 | _tmp_234_rule(Parser *p) |
37974 | { |
37975 | if (p->level++ == MAXSTACK) { Branch (37975:9): [True: 0, False: 768]
|
37976 | p->error_indicator = 1; |
37977 | PyErr_NoMemory(); |
37978 | } |
37979 | if (p->error_indicator) { Branch (37979:9): [True: 0, False: 768]
|
37980 | p->level--; |
37981 | return NULL; |
37982 | } |
37983 | void * _res = NULL; |
37984 | int _mark = p->mark; |
37985 | { // star_targets '=' |
37986 | if (p->error_indicator) { Branch (37986:13): [True: 0, False: 768]
|
37987 | p->level--; |
37988 | return NULL; |
37989 | } |
37990 | D(fprintf(stderr, "%*c> _tmp_234[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); |
37991 | Token * _literal; |
37992 | expr_ty star_targets_var; |
37993 | if ( |
37994 | (star_targets_var = star_targets_rule(p)) // star_targets Branch (37994:13): [True: 102, False: 666]
|
37995 | && |
37996 | (_literal = _PyPegen_expect_token(p, 22))102 // token='=' |
37997 | ) |
37998 | { |
37999 | D(fprintf(stderr, "%*c+ _tmp_234[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); |
38000 | _res = _PyPegen_dummy_name(p, star_targets_var, _literal); |
38001 | goto done; |
38002 | } |
38003 | p->mark = _mark; |
38004 | D(fprintf(stderr, "%*c%s _tmp_234[%d-%d]: %s failed!\n", p->level, ' ', |
38005 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); |
38006 | } |
38007 | _res = NULL; |
38008 | done: |
38009 | p->level--; |
38010 | return _res; |
38011 | } |
38012 | |
38013 | // _tmp_235: ')' | '**' |
38014 | static void * |
38015 | _tmp_235_rule(Parser *p) |
38016 | { |
38017 | if (p->level++ == MAXSTACK) { Branch (38017:9): [True: 0, False: 9]
|
38018 | p->error_indicator = 1; |
38019 | PyErr_NoMemory(); |
38020 | } |
38021 | if (p->error_indicator) { Branch (38021:9): [True: 0, False: 9]
|
38022 | p->level--; |
38023 | return NULL; |
38024 | } |
38025 | void * _res = NULL; |
38026 | int _mark = p->mark; |
38027 | { // ')' |
38028 | if (p->error_indicator) { |
38029 | p->level--; |
38030 | return NULL; |
38031 | } |
38032 | D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); |
38033 | Token * _literal; |
38034 | if ( |
38035 | (_literal = _PyPegen_expect_token(p, 8)) // token=')' |
38036 | ) |
38037 | { |
38038 | D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); |
38039 | _res = _literal; |
38040 | goto done; |
38041 | } |
38042 | p->mark = _mark; |
38043 | D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ', |
38044 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); |
38045 | } |
38046 | { // '**' |
38047 | if (p->error_indicator) { |
38048 | p->level--; |
38049 | return NULL; |
38050 | } |
38051 | D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); |
38052 | Token * _literal; |
38053 | if ( |
38054 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
38055 | ) |
38056 | { |
38057 | D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); |
38058 | _res = _literal; |
38059 | goto done; |
38060 | } |
38061 | p->mark = _mark; |
38062 | D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ', |
38063 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); |
38064 | } |
38065 | _res = NULL; |
38066 | done: |
38067 | p->level--; |
38068 | return _res; |
38069 | } |
38070 | |
38071 | // _tmp_236: ':' | '**' |
38072 | static void * |
38073 | _tmp_236_rule(Parser *p) |
38074 | { |
38075 | if (p->level++ == MAXSTACK) { Branch (38075:9): [True: 0, False: 0]
|
38076 | p->error_indicator = 1; |
38077 | PyErr_NoMemory(); |
38078 | } |
38079 | if (p->error_indicator) { Branch (38079:9): [True: 0, False: 0]
|
38080 | p->level--; |
38081 | return NULL; |
38082 | } |
38083 | void * _res = NULL; |
38084 | int _mark = p->mark; |
38085 | { // ':' |
38086 | if (p->error_indicator) { |
38087 | p->level--; |
38088 | return NULL; |
38089 | } |
38090 | D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); |
38091 | Token * _literal; |
38092 | if ( |
38093 | (_literal = _PyPegen_expect_token(p, 11)) // token=':' |
38094 | ) |
38095 | { |
38096 | D(fprintf(stderr, "%*c+ _tmp_236[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); |
38097 | _res = _literal; |
38098 | goto done; |
38099 | } |
38100 | p->mark = _mark; |
38101 | D(fprintf(stderr, "%*c%s _tmp_236[%d-%d]: %s failed!\n", p->level, ' ', |
38102 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); |
38103 | } |
38104 | { // '**' |
38105 | if (p->error_indicator) { |
38106 | p->level--; |
38107 | return NULL; |
38108 | } |
38109 | D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); |
38110 | Token * _literal; |
38111 | if ( |
38112 | (_literal = _PyPegen_expect_token(p, 35)) // token='**' |
38113 | ) |
38114 | { |
38115 | D(fprintf(stderr, "%*c+ _tmp_236[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); |
38116 | _res = _literal; |
38117 | goto done; |
38118 | } |
38119 | p->mark = _mark; |
38120 | D(fprintf(stderr, "%*c%s _tmp_236[%d-%d]: %s failed!\n", p->level, ' ', |
38121 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); |
38122 | } |
38123 | _res = NULL; |
38124 | done: |
38125 | p->level--; |
38126 | return _res; |
38127 | } |
38128 | |
38129 | // _tmp_237: expression ['as' star_target] |
38130 | static void * |
38131 | _tmp_237_rule(Parser *p) |
38132 | { |
38133 | if (p->level++ == MAXSTACK) { Branch (38133:9): [True: 0, False: 14]
|
38134 | p->error_indicator = 1; |
38135 | PyErr_NoMemory(); |
38136 | } |
38137 | if (p->error_indicator) { Branch (38137:9): [True: 0, False: 14]
|
38138 | p->level--; |
38139 | return NULL; |
38140 | } |
38141 | void * _res = NULL; |
38142 | int _mark = p->mark; |
38143 | { // expression ['as' star_target] |
38144 | if (p->error_indicator) { |
38145 | p->level--; |
38146 | return NULL; |
38147 | } |
38148 | D(fprintf(stderr, "%*c> _tmp_237[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); |
38149 | void *_opt_var; |
38150 | UNUSED(_opt_var); // Silence compiler warnings |
38151 | expr_ty expression_var; |
38152 | if ( |
38153 | (expression_var = expression_rule(p)) // expression |
38154 | && |
38155 | (_opt_var = _tmp_244_rule(p), !p->error_indicator)10 // ['as' star_target] |
38156 | ) |
38157 | { |
38158 | D(fprintf(stderr, "%*c+ _tmp_237[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); |
38159 | _res = _PyPegen_dummy_name(p, expression_var, _opt_var); |
38160 | goto done; |
38161 | } |
38162 | p->mark = _mark; |
38163 | D(fprintf(stderr, "%*c%s _tmp_237[%d-%d]: %s failed!\n", p->level, ' ', |
38164 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]")); |
38165 | } |
38166 | _res = NULL; |
38167 | done: |
38168 | p->level--; |
38169 | return _res; |
38170 | } |
38171 | |
38172 | // _tmp_238: expressions ['as' star_target] |
38173 | static void * |
38174 | _tmp_238_rule(Parser *p) |
38175 | { |
38176 | if (p->level++ == MAXSTACK) { Branch (38176:9): [True: 0, False: 4]
|
38177 | p->error_indicator = 1; |
38178 | PyErr_NoMemory(); |
38179 | } |
38180 | if (p->error_indicator) { Branch (38180:9): [True: 0, False: 4]
|
38181 | p->level--; |
38182 | return NULL; |
38183 | } |
38184 | void * _res = NULL; |
38185 | int _mark = p->mark; |
38186 | { // expressions ['as' star_target] |
38187 | if (p->error_indicator) { |
38188 | p->level--; |
38189 | return NULL; |
38190 | } |
38191 | D(fprintf(stderr, "%*c> _tmp_238[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); |
38192 | void *_opt_var; |
38193 | UNUSED(_opt_var); // Silence compiler warnings |
38194 | expr_ty expressions_var; |
38195 | if ( |
38196 | (expressions_var = expressions_rule(p)) // expressions |
38197 | && |
38198 | (_opt_var = _tmp_245_rule(p), !p->error_indicator) // ['as' star_target] |
38199 | ) |
38200 | { |
38201 | D(fprintf(stderr, "%*c+ _tmp_238[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); |
38202 | _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); |
38203 | goto done; |
38204 | } |
38205 | p->mark = _mark; |
38206 | D(fprintf(stderr, "%*c%s _tmp_238[%d-%d]: %s failed!\n", p->level, ' ', |
38207 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]")); |
38208 | } |
38209 | _res = NULL; |
38210 | done: |
38211 | p->level--; |
38212 | return _res; |
38213 | } |
38214 | |
38215 | // _tmp_239: expression ['as' star_target] |
38216 | static void * |
38217 | _tmp_239_rule(Parser *p) |
38218 | { |
38219 | if (p->level++ == MAXSTACK) { Branch (38219:9): [True: 0, False: 35]
|
38220 | p->error_indicator = 1; |
38221 | PyErr_NoMemory(); |
38222 | } |
38223 | if (p->error_indicator) { Branch (38223:9): [True: 0, False: 35]
|
38224 | p->level--; |
38225 | return NULL; |
38226 | } |
38227 | void * _res = NULL; |
38228 | int _mark = p->mark; |
38229 | { // expression ['as' star_target] |
38230 | if (p->error_indicator) { |
38231 | p->level--; |
38232 | return NULL; |
38233 | } |
38234 | D(fprintf(stderr, "%*c> _tmp_239[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); |
38235 | void *_opt_var; |
38236 | UNUSED(_opt_var); // Silence compiler warnings |
38237 | expr_ty expression_var; |
38238 | if ( |
38239 | (expression_var = expression_rule(p)) // expression |
38240 | && |
38241 | (_opt_var = _tmp_246_rule(p), !p->error_indicator)28 // ['as' star_target] |
38242 | ) |
38243 | { |
38244 | D(fprintf(stderr, "%*c+ _tmp_239[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); |
38245 | _res = _PyPegen_dummy_name(p, expression_var, _opt_var); |
38246 | goto done; |
38247 | } |
38248 | p->mark = _mark; |
38249 | D(fprintf(stderr, "%*c%s _tmp_239[%d-%d]: %s failed!\n", p->level, ' ', |
38250 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]")); |
38251 | } |
38252 | _res = NULL; |
38253 | done: |
38254 | p->level--; |
38255 | return _res; |
38256 | } |
38257 | |
38258 | // _tmp_240: expressions ['as' star_target] |
38259 | static void * |
38260 | _tmp_240_rule(Parser *p) |
38261 | { |
38262 | if (p->level++ == MAXSTACK) { Branch (38262:9): [True: 0, False: 9]
|
38263 | p->error_indicator = 1; |
38264 | PyErr_NoMemory(); |
38265 | } |
38266 | if (p->error_indicator) { Branch (38266:9): [True: 0, False: 9]
|
38267 | p->level--; |
38268 | return NULL; |
38269 | } |
38270 | void * _res = NULL; |
38271 | int _mark = p->mark; |
38272 | { // expressions ['as' star_target] |
38273 | if (p->error_indicator) { |
38274 | p->level--; |
38275 | return NULL; |
38276 | } |
38277 | D(fprintf(stderr, "%*c> _tmp_240[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); |
38278 | void *_opt_var; |
38279 | UNUSED(_opt_var); // Silence compiler warnings |
38280 | expr_ty expressions_var; |
38281 | if ( |
38282 | (expressions_var = expressions_rule(p)) // expressions |
38283 | && |
38284 | (_opt_var = _tmp_247_rule(p), !p->error_indicator) // ['as' star_target] |
38285 | ) |
38286 | { |
38287 | D(fprintf(stderr, "%*c+ _tmp_240[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); |
38288 | _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); |
38289 | goto done; |
38290 | } |
38291 | p->mark = _mark; |
38292 | D(fprintf(stderr, "%*c%s _tmp_240[%d-%d]: %s failed!\n", p->level, ' ', |
38293 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]")); |
38294 | } |
38295 | _res = NULL; |
38296 | done: |
38297 | p->level--; |
38298 | return _res; |
38299 | } |
38300 | |
38301 | // _tmp_241: except_block+ except_star_block |
38302 | static void * |
38303 | _tmp_241_rule(Parser *p) |
38304 | { |
38305 | if (p->level++ == MAXSTACK) { Branch (38305:9): [True: 0, False: 49]
|
38306 | p->error_indicator = 1; |
38307 | PyErr_NoMemory(); |
38308 | } |
38309 | if (p->error_indicator) { Branch (38309:9): [True: 0, False: 49]
|
38310 | p->level--; |
38311 | return NULL; |
38312 | } |
38313 | void * _res = NULL; |
38314 | int _mark = p->mark; |
38315 | { // except_block+ except_star_block |
38316 | if (p->error_indicator) { |
38317 | p->level--; |
38318 | return NULL; |
38319 | } |
38320 | D(fprintf(stderr, "%*c> _tmp_241[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block+ except_star_block")); |
38321 | asdl_seq * _loop1_248_var; |
38322 | excepthandler_ty except_star_block_var; |
38323 | if ( |
38324 | (_loop1_248_var = _loop1_248_rule(p)) // except_block+ |
38325 | && |
38326 | (except_star_block_var = except_star_block_rule(p))6 // except_star_block |
38327 | ) |
38328 | { |
38329 | D(fprintf(stderr, "%*c+ _tmp_241[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "except_block+ except_star_block")); |
38330 | _res = _PyPegen_dummy_name(p, _loop1_248_var, except_star_block_var); |
38331 | goto done; |
38332 | } |
38333 | p->mark = _mark; |
38334 | D(fprintf(stderr, "%*c%s _tmp_241[%d-%d]: %s failed!\n", p->level, ' ', |
38335 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block+ except_star_block")); |
38336 | } |
38337 | _res = NULL; |
38338 | done: |
38339 | p->level--; |
38340 | return _res; |
38341 | } |
38342 | |
38343 | // _tmp_242: except_star_block+ except_block |
38344 | static void * |
38345 | _tmp_242_rule(Parser *p) |
38346 | { |
38347 | if (p->level++ == MAXSTACK) { Branch (38347:9): [True: 0, False: 30]
|
38348 | p->error_indicator = 1; |
38349 | PyErr_NoMemory(); |
38350 | } |
38351 | if (p->error_indicator) { Branch (38351:9): [True: 0, False: 30]
|
38352 | p->level--; |
38353 | return NULL; |
38354 | } |
38355 | void * _res = NULL; |
38356 | int _mark = p->mark; |
38357 | { // except_star_block+ except_block |
38358 | if (p->error_indicator) { |
38359 | p->level--; |
38360 | return NULL; |
38361 | } |
38362 | D(fprintf(stderr, "%*c> _tmp_242[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block+ except_block")); |
38363 | asdl_seq * _loop1_249_var; |
38364 | excepthandler_ty except_block_var; |
38365 | if ( |
38366 | (_loop1_249_var = _loop1_249_rule(p)) // except_star_block+ |
38367 | && |
38368 | (except_block_var = except_block_rule(p))7 // except_block |
38369 | ) |
38370 | { |
38371 | D(fprintf(stderr, "%*c+ _tmp_242[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "except_star_block+ except_block")); |
38372 | _res = _PyPegen_dummy_name(p, _loop1_249_var, except_block_var); |
38373 | goto done; |
38374 | } |
38375 | p->mark = _mark; |
38376 | D(fprintf(stderr, "%*c%s _tmp_242[%d-%d]: %s failed!\n", p->level, ' ', |
38377 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block+ except_block")); |
38378 | } |
38379 | _res = NULL; |
38380 | done: |
38381 | p->level--; |
38382 | return _res; |
38383 | } |
38384 | |
38385 | // _tmp_243: assignment_expression | expression !':=' |
38386 | static void * |
38387 | _tmp_243_rule(Parser *p) |
38388 | { |
38389 | if (p->level++ == MAXSTACK) { Branch (38389:9): [True: 0, False: 466k]
|
38390 | p->error_indicator = 1; |
38391 | PyErr_NoMemory(); |
38392 | } |
38393 | if (p->error_indicator) { Branch (38393:9): [True: 0, False: 466k]
|
38394 | p->level--; |
38395 | return NULL; |
38396 | } |
38397 | void * _res = NULL; |
38398 | int _mark = p->mark; |
38399 | { // assignment_expression |
38400 | if (p->error_indicator) { Branch (38400:13): [True: 0, False: 466k]
|
38401 | p->level--; |
38402 | return NULL; |
38403 | } |
38404 | D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); |
38405 | expr_ty assignment_expression_var; |
38406 | if ( |
38407 | (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression Branch (38407:13): [True: 3, False: 466k]
|
38408 | ) |
38409 | { |
38410 | D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); |
38411 | _res = assignment_expression_var; |
38412 | goto done; |
38413 | } |
38414 | p->mark = _mark; |
38415 | D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ', |
38416 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); |
38417 | } |
38418 | { // expression !':=' |
38419 | if (p->error_indicator) { Branch (38419:13): [True: 6, False: 466k]
|
38420 | p->level--; |
38421 | return NULL; |
38422 | } |
38423 | D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); |
38424 | expr_ty expression_var; |
38425 | if ( |
38426 | (expression_var = expression_rule(p)) // expression Branch (38426:13): [True: 141k, False: 324k]
|
38427 | && |
38428 | _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)141k // token=':=' Branch (38428:13): [True: 141k, False: 0]
|
38429 | ) |
38430 | { |
38431 | D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); |
38432 | _res = expression_var; |
38433 | goto done; |
38434 | } |
38435 | p->mark = _mark; |
38436 | D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ', |
38437 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); |
38438 | } |
38439 | _res = NULL; |
38440 | done: |
38441 | p->level--; |
38442 | return _res; |
38443 | } |
38444 | |
38445 | // _tmp_244: 'as' star_target |
38446 | static void * |
38447 | _tmp_244_rule(Parser *p) |
38448 | { |
38449 | if (p->level++ == MAXSTACK) { Branch (38449:9): [True: 0, False: 10]
|
38450 | p->error_indicator = 1; |
38451 | PyErr_NoMemory(); |
38452 | } |
38453 | if (p->error_indicator) { Branch (38453:9): [True: 0, False: 10]
|
38454 | p->level--; |
38455 | return NULL; |
38456 | } |
38457 | void * _res = NULL; |
38458 | int _mark = p->mark; |
38459 | { // 'as' star_target |
38460 | if (p->error_indicator) { |
38461 | p->level--; |
38462 | return NULL; |
38463 | } |
38464 | D(fprintf(stderr, "%*c> _tmp_244[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38465 | Token * _keyword; |
38466 | expr_ty star_target_var; |
38467 | if ( |
38468 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
38469 | && |
38470 | (star_target_var = star_target_rule(p))4 // star_target |
38471 | ) |
38472 | { |
38473 | D(fprintf(stderr, "%*c+ _tmp_244[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38474 | _res = _PyPegen_dummy_name(p, _keyword, star_target_var); |
38475 | goto done; |
38476 | } |
38477 | p->mark = _mark; |
38478 | D(fprintf(stderr, "%*c%s _tmp_244[%d-%d]: %s failed!\n", p->level, ' ', |
38479 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); |
38480 | } |
38481 | _res = NULL; |
38482 | done: |
38483 | p->level--; |
38484 | return _res; |
38485 | } |
38486 | |
38487 | // _tmp_245: 'as' star_target |
38488 | static void * |
38489 | _tmp_245_rule(Parser *p) |
38490 | { |
38491 | if (p->level++ == MAXSTACK) { Branch (38491:9): [True: 0, False: 4]
|
38492 | p->error_indicator = 1; |
38493 | PyErr_NoMemory(); |
38494 | } |
38495 | if (p->error_indicator) { Branch (38495:9): [True: 0, False: 4]
|
38496 | p->level--; |
38497 | return NULL; |
38498 | } |
38499 | void * _res = NULL; |
38500 | int _mark = p->mark; |
38501 | { // 'as' star_target |
38502 | if (p->error_indicator) { |
38503 | p->level--; |
38504 | return NULL; |
38505 | } |
38506 | D(fprintf(stderr, "%*c> _tmp_245[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38507 | Token * _keyword; |
38508 | expr_ty star_target_var; |
38509 | if ( |
38510 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
38511 | && |
38512 | (star_target_var = star_target_rule(p))3 // star_target |
38513 | ) |
38514 | { |
38515 | D(fprintf(stderr, "%*c+ _tmp_245[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38516 | _res = _PyPegen_dummy_name(p, _keyword, star_target_var); |
38517 | goto done; |
38518 | } |
38519 | p->mark = _mark; |
38520 | D(fprintf(stderr, "%*c%s _tmp_245[%d-%d]: %s failed!\n", p->level, ' ', |
38521 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); |
38522 | } |
38523 | _res = NULL; |
38524 | done: |
38525 | p->level--; |
38526 | return _res; |
38527 | } |
38528 | |
38529 | // _tmp_246: 'as' star_target |
38530 | static void * |
38531 | _tmp_246_rule(Parser *p) |
38532 | { |
38533 | if (p->level++ == MAXSTACK) { Branch (38533:9): [True: 0, False: 28]
|
38534 | p->error_indicator = 1; |
38535 | PyErr_NoMemory(); |
38536 | } |
38537 | if (p->error_indicator) { Branch (38537:9): [True: 0, False: 28]
|
38538 | p->level--; |
38539 | return NULL; |
38540 | } |
38541 | void * _res = NULL; |
38542 | int _mark = p->mark; |
38543 | { // 'as' star_target |
38544 | if (p->error_indicator) { |
38545 | p->level--; |
38546 | return NULL; |
38547 | } |
38548 | D(fprintf(stderr, "%*c> _tmp_246[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38549 | Token * _keyword; |
38550 | expr_ty star_target_var; |
38551 | if ( |
38552 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
38553 | && |
38554 | (star_target_var = star_target_rule(p))20 // star_target |
38555 | ) |
38556 | { |
38557 | D(fprintf(stderr, "%*c+ _tmp_246[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38558 | _res = _PyPegen_dummy_name(p, _keyword, star_target_var); |
38559 | goto done; |
38560 | } |
38561 | p->mark = _mark; |
38562 | D(fprintf(stderr, "%*c%s _tmp_246[%d-%d]: %s failed!\n", p->level, ' ', |
38563 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); |
38564 | } |
38565 | _res = NULL; |
38566 | done: |
38567 | p->level--; |
38568 | return _res; |
38569 | } |
38570 | |
38571 | // _tmp_247: 'as' star_target |
38572 | static void * |
38573 | _tmp_247_rule(Parser *p) |
38574 | { |
38575 | if (p->level++ == MAXSTACK) { Branch (38575:9): [True: 0, False: 9]
|
38576 | p->error_indicator = 1; |
38577 | PyErr_NoMemory(); |
38578 | } |
38579 | if (p->error_indicator) { Branch (38579:9): [True: 0, False: 9]
|
38580 | p->level--; |
38581 | return NULL; |
38582 | } |
38583 | void * _res = NULL; |
38584 | int _mark = p->mark; |
38585 | { // 'as' star_target |
38586 | if (p->error_indicator) { |
38587 | p->level--; |
38588 | return NULL; |
38589 | } |
38590 | D(fprintf(stderr, "%*c> _tmp_247[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38591 | Token * _keyword; |
38592 | expr_ty star_target_var; |
38593 | if ( |
38594 | (_keyword = _PyPegen_expect_token(p, 632)) // token='as' |
38595 | && |
38596 | (star_target_var = star_target_rule(p))7 // star_target |
38597 | ) |
38598 | { |
38599 | D(fprintf(stderr, "%*c+ _tmp_247[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); |
38600 | _res = _PyPegen_dummy_name(p, _keyword, star_target_var); |
38601 | goto done; |
38602 | } |
38603 | p->mark = _mark; |
38604 | D(fprintf(stderr, "%*c%s _tmp_247[%d-%d]: %s failed!\n", p->level, ' ', |
38605 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); |
38606 | } |
38607 | _res = NULL; |
38608 | done: |
38609 | p->level--; |
38610 | return _res; |
38611 | } |
38612 | |
38613 | // _loop1_248: except_block |
38614 | static asdl_seq * |
38615 | _loop1_248_rule(Parser *p) |
38616 | { |
38617 | if (p->level++ == MAXSTACK) { Branch (38617:9): [True: 0, False: 49]
|
38618 | p->error_indicator = 1; |
38619 | PyErr_NoMemory(); |
38620 | } |
38621 | if (p->error_indicator) { Branch (38621:9): [True: 0, False: 49]
|
38622 | p->level--; |
38623 | return NULL; |
38624 | } |
38625 | void *_res = NULL; |
38626 | int _mark = p->mark; |
38627 | int _start_mark = p->mark; |
38628 | void **_children = PyMem_Malloc(sizeof(void *)); |
38629 | if (!_children) { Branch (38629:9): [True: 0, False: 49]
|
38630 | p->error_indicator = 1; |
38631 | PyErr_NoMemory(); |
38632 | p->level--; |
38633 | return NULL; |
38634 | } |
38635 | Py_ssize_t _children_capacity = 1; |
38636 | Py_ssize_t _n = 0; |
38637 | { // except_block |
38638 | if (p->error_indicator) { |
38639 | p->level--; |
38640 | return NULL; |
38641 | } |
38642 | D(fprintf(stderr, "%*c> _loop1_248[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block")); |
38643 | excepthandler_ty except_block_var; |
38644 | while ( |
38645 | (except_block_var = except_block_rule(p)) // except_block |
38646 | ) |
38647 | { |
38648 | _res = except_block_var; |
38649 | if (_n == _children_capacity) { |
38650 | _children_capacity *= 2; |
38651 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
38652 | if (!_new_children) { |
38653 | p->error_indicator = 1; |
38654 | PyErr_NoMemory(); |
38655 | p->level--; |
38656 | return NULL; |
38657 | } |
38658 | _children = _new_children; |
38659 | } |
38660 | _children[_n++] = _res; |
38661 | _mark = p->mark; |
38662 | } |
38663 | p->mark = _mark; |
38664 | D(fprintf(stderr, "%*c%s _loop1_248[%d-%d]: %s failed!\n", p->level, ' ', |
38665 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block")); |
38666 | } |
38667 | if (_n == 0 || p->error_indicator7 ) { Branch (38667:9): [True: 42, False: 7]
Branch (38667:20): [True: 1, False: 6]
|
38668 | PyMem_Free(_children); |
38669 | p->level--; |
38670 | return NULL; |
38671 | } |
38672 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
38673 | if (!_seq) { Branch (38673:9): [True: 0, False: 6]
|
38674 | PyMem_Free(_children); |
38675 | p->error_indicator = 1; |
38676 | PyErr_NoMemory(); |
38677 | p->level--; |
38678 | return NULL; |
38679 | } |
38680 | for (int i = 0; 6 i < _n; i++7 ) asdl_seq_SET_UNTYPED6 (_seq, i, _children[i]); |
38681 | PyMem_Free(_children); |
38682 | _PyPegen_insert_memo(p, _start_mark, _loop1_248_type, _seq); |
38683 | p->level--; |
38684 | return _seq; |
38685 | } |
38686 | |
38687 | // _loop1_249: except_star_block |
38688 | static asdl_seq * |
38689 | _loop1_249_rule(Parser *p) |
38690 | { |
38691 | if (p->level++ == MAXSTACK) { Branch (38691:9): [True: 0, False: 30]
|
38692 | p->error_indicator = 1; |
38693 | PyErr_NoMemory(); |
38694 | } |
38695 | if (p->error_indicator) { Branch (38695:9): [True: 0, False: 30]
|
38696 | p->level--; |
38697 | return NULL; |
38698 | } |
38699 | void *_res = NULL; |
38700 | int _mark = p->mark; |
38701 | int _start_mark = p->mark; |
38702 | void **_children = PyMem_Malloc(sizeof(void *)); |
38703 | if (!_children) { Branch (38703:9): [True: 0, False: 30]
|
38704 | p->error_indicator = 1; |
38705 | PyErr_NoMemory(); |
38706 | p->level--; |
38707 | return NULL; |
38708 | } |
38709 | Py_ssize_t _children_capacity = 1; |
38710 | Py_ssize_t _n = 0; |
38711 | { // except_star_block |
38712 | if (p->error_indicator) { |
38713 | p->level--; |
38714 | return NULL; |
38715 | } |
38716 | D(fprintf(stderr, "%*c> _loop1_249[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block")); |
38717 | excepthandler_ty except_star_block_var; |
38718 | while ( |
38719 | (except_star_block_var = except_star_block_rule(p)) // except_star_block |
38720 | ) |
38721 | { |
38722 | _res = except_star_block_var; |
38723 | if (_n == _children_capacity) { |
38724 | _children_capacity *= 2; |
38725 | void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); |
38726 | if (!_new_children) { |
38727 | p->error_indicator = 1; |
38728 | PyErr_NoMemory(); |
38729 | p->level--; |
38730 | return NULL; |
38731 | } |
38732 | _children = _new_children; |
38733 | } |
38734 | _children[_n++] = _res; |
38735 | _mark = p->mark; |
38736 | } |
38737 | p->mark = _mark; |
38738 | D(fprintf(stderr, "%*c%s _loop1_249[%d-%d]: %s failed!\n", p->level, ' ', |
38739 | p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block")); |
38740 | } |
38741 | if (_n == 0 || p->error_indicator8 ) { Branch (38741:9): [True: 22, False: 8]
Branch (38741:20): [True: 1, False: 7]
|
38742 | PyMem_Free(_children); |
38743 | p->level--; |
38744 | return NULL; |
38745 | } |
38746 | asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); |
38747 | if (!_seq) { Branch (38747:9): [True: 0, False: 7]
|
38748 | PyMem_Free(_children); |
38749 | p->error_indicator = 1; |
38750 | PyErr_NoMemory(); |
38751 | p->level--; |
38752 | return NULL; |
38753 | } |
38754 | for (int i = 0; 7 i < _n; i++8 ) asdl_seq_SET_UNTYPED7 (_seq, i, _children[i]); |
38755 | PyMem_Free(_children); |
38756 | _PyPegen_insert_memo(p, _start_mark, _loop1_249_type, _seq); |
38757 | p->level--; |
38758 | return _seq; |
38759 | } |
38760 | |
38761 | void * |
38762 | _PyPegen_parse(Parser *p) |
38763 | { |
38764 | // Initialize keywords |
38765 | p->keywords = reserved_keywords; |
38766 | p->n_keyword_lists = n_keyword_lists; |
38767 | p->soft_keywords = soft_keywords; |
38768 | |
38769 | // Run parser |
38770 | void *result = NULL; |
38771 | if (p->start_rule == Py_file_input) { Branch (38771:9): [True: 18.2k, False: 115k]
|
38772 | result = file_rule(p); |
38773 | } else if (p->start_rule == Py_single_input) { Branch (38773:16): [True: 5.01k, False: 110k]
|
38774 | result = interactive_rule(p); |
38775 | } else if (p->start_rule == Py_eval_input) { Branch (38775:16): [True: 37.4k, False: 73.1k]
|
38776 | result = eval_rule(p); |
38777 | } else if (p->start_rule == Py_func_type_input) { Branch (38777:16): [True: 18, False: 73.0k]
|
38778 | result = func_type_rule(p); |
38779 | } else if (p->start_rule == Py_fstring_input) { Branch (38779:16): [True: 73.0k, False: 0]
|
38780 | result = fstring_rule(p); |
38781 | } |
38782 | |
38783 | return result; |
38784 | } |